Scenario: Receive and Process HTTP Request

Given the system is running
When a valid HTTP request is received
Then the system should successfully parse the HTTP request
And extract the request path, parameters, method, and body if present
And generate an appropriate HTTP response
And include the correct HTTP status code indicating successful processing
And include the expected response body format and data if applicable
And include the appropriate HTTP headers in the response (e.g., Content-Type)

GET /sample HTTP/1.1 
Host: www.example.com
Accept: application/json

val socket = Socket("google.com", 443)
println(socket.isConnected)

# 写入一个字节数组
socket.getOutputStream().write("Ping!".toByteArray())
#也可以写入单个字节
socket.getOutputStream().write(71)

val serverSocket = ServerSocket(8080)
println("Server started successfully, listening on port: 8080")

# 建立ServerSocket后调用accept 方法来接收请求，在有请求到来之前这个方法会一直阻塞，并且为了处理多次请求，一般会循环调用
val socket = serverSocket.accept()
# 上述方法返回了Socket, 这和我们从客户端建立链接时看到的Socket 是一样的，因为说了，网络上的通信我们都是面向Socket
val bytes = socket.getInputStream().let {
    val bytes = ByteArray(it.available())
    it.read(bytes)
    bytes
}
println(bytes.decodeToString())

GET /sample HTTP/1.1 
Host: www.example.com
Accept: application/json

socket.getOutputStream().write(
    ("HTTP/1.1 200 OK\r\n" +
            "Content-Type: text/plain\r\n" +
            "Content-Length: 25\r\n" +
            "\r\n" +
            "Hello, World and /sample!"
            ).toByteArray()
)

@Test
fun `should successfully process valid HTTP request`() {
    // Given
    MyHttpServer(TEST_PORT).start()

    // When
    // 发起HTTP 请求
    val socket = sendRequest()

    // Then
    assertEquals(
        "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n" + "Content-Length: 25\r\n\r\nHello, World and /sample!",
        decodeResponse(socket)
    )

}

/**
 * 1.建立socket连接
 * 2.向socket中写入符合HTTP规范的数据
 * 3.返回socket
 */
private fun sendRequest(
    httpRequest: String = "GET /sample HTTP/1.1\r\n" + "Host: localhost\r\n" + "Accept: application/json\r\n\r\n"
): Socket {
    val socket = Socket(Constants.LOCAL_HOST, Constants.TEST_PORT)
    socket.getOutputStream().write(httpRequest.toByteArray(Charset.defaultCharset()))
    return socket
}

package com.fan

import java.net.ServerSocket
import java.net.Socket
import java.net.SocketException
import java.nio.charset.StandardCharsets


class SampleHttpServer(private val port: Int) {

    private lateinit var serverSocket: ServerSocket

    private var isRunning = true

    fun start() {
        createServerSocket(port)
        println("${currentThreadName()}Server started successfully, listening on port $port")
        Thread {
            while (isRunning) {
                val clientSocket = acceptClientConnection(serverSocket)
                clientSocket?.let {
                    try {
                        handleClientRequest(clientSocket)
                    } catch (e: Exception) {
                        e.printStackTrace()
                    } finally {
                        closeSocket(clientSocket)
                    }
                }
            }
        }.start()
    }

    private fun closeSocket(clientSocket: Socket) {
        checkIfSocketClosed(clientSocket)
        if (!clientSocket.isClosed) {
            clientSocket.close()
            checkIfSocketClosed(clientSocket)
        }
    }

    private fun checkIfSocketClosed(clientSocket: Socket) {
        println("${currentThreadName()}client socket closed? ${clientSocket.isClosed}")
    }

    private fun createServerSocket(port: Int) {
        this.serverSocket = ServerSocket(port)
    }

    private fun acceptClientConnection(serverSocket: ServerSocket): Socket? {
        try {
            val clientSocket = serverSocket.accept()
            println("${currentThreadName()}Accepted client connection from: ${clientSocket.inetAddress}")
            return clientSocket
        } catch (e: SocketException) {
            //socket maybe closed from client, ignore
            println("${currentThreadName()} ${e.message}")
        }
        return null
    }

    private fun handleClientRequest(clientSocket: Socket) {
        val requestBytes = readBytesFromSocketInputStream(clientSocket)
        println("${currentThreadName()}Received bytes from client:${requestBytes.contentToString()}")
        val httpRequest = parseBytesToHttpRequest(requestBytes)
        val httpResponse = buildResponse(httpRequest)
        sendResponseToClient(httpResponse, clientSocket)
    }

    private fun readBytesFromSocketInputStream(socket: Socket): ByteArray {
        return socket.getInputStream().let {
            val bytes = ByteArray(it.available())
            it.read(bytes)
            bytes
        }
    }

    private fun parseBytesToHttpRequest(bytes: ByteArray): Request {
        val plainRequest = String(bytes, StandardCharsets.UTF_8)
        println("${currentThreadName()}Received request:\r\n--------------\r\n$plainRequest\r\n--------------")
        val httpMethod = extractHttpMethod(plainRequest)
        val uri = extractUri(plainRequest)
        val protocol = extractProtocol(plainRequest)
        return Request(httpMethod, protocol, uri)
    }


    private fun extractHttpMethod(plainRequest: String): String {
        return plainRequest.substring(0, plainRequest.indexOf(" "))
    }

    private fun extractUri(plainRequest: String): String {
        val start = plainRequest.indexOf(" ") + 1
        val end = plainRequest.indexOf("HTTP") - 1
        return plainRequest.substring(start, end)
    }

    private fun extractProtocol(plainRequest: String): String {
        val start = plainRequest.indexOf("HTTP") + 5
        val end = plainRequest.indexOf("\r\n")
        return plainRequest.substring(start, end)
    }

    private fun buildResponse(request: Request): Response {
        val body = "Hello, World and ${request.uri}!"
        return Response(
            statusLine = "HTTP/1.1 200 OK",
            headers = "Content-Type: text/plain\r\nContent-Length: ${body.length}",
            body = body
        )
    }


    private fun sendResponseToClient(response: Response, socket: Socket) {
        val responseBytes = response.toString().toByteArray()
        socket.getOutputStream().write(responseBytes)
        println("${currentThreadName()}Response sent to client.")
    }

    private fun currentThreadName() = "[${Thread.currentThread().name}] "

    fun stop() {
        isRunning = false
        if (::serverSocket.isInitialized) {
            serverSocket.close()
        }
    }
}

package com.fan

data class Request(
    val method: String,
    val protocol: String,
    val uri: String
)

data class Response(
    val statusLine: String,
    val headers: String,
    val body: String
) {
    override fun toString(): String {
        return statusLine + "\r\n" + headers + "\r\n\r\n" + body
    }
}

curl https://dlcdn.apache.org/tomcat/tomcat-10/v10.1.18/bin/apache-tomcat-10.1.18.zip -o apache-tomcat-10.1.18.zip

public final class StandardServer extends LifecycleMBeanBase implements Server {
  ...
  private Catalina catalina = null;
  /**
   * The set of Services associated with this Server.
   */
  private Service services[] = new Service[0];
  ...
    
   @Override
    public void addService(Service service) {
        ...
        synchronized (servicesLock) {
            Service results[] = new Service[services.length + 1];
            // 将services 中的值拷贝到results
            System.arraycopy(services, 0, results, 0, services.length);
            results[services.length] = service;
            services = results;
            ...
        }

    }
  
    @Override
    public void addConnector(Connector connector) {
        synchronized (connectorsLock) {
            connector.setService(this);
            Connector results[] = new Connector[connectors.length + 1];
            System.arraycopy(connectors, 0, results, 0, connectors.length);
            results[connectors.length] = connector;
            connectors = results;
        }

        ...
    }
  
    @Override
    public void setCatalina(Catalina catalina) {
        this.catalina = catalina;
    }
  ...
}

public class StandardService extends LifecycleMBeanBase implements Service {
    ...
    private Engine engine = null;
    /**
     * The <code>Server</code> that owns this Service, if any.
     */
    private Server server = null;
    /**
     * The set of Connectors associated with this Service.
     */
    protected Connector connectors[] = new Connector[0];
    ...
      
    @Override
    public void setContainer(Engine engine) {
        ... 
        this.engine = engine;
        if (this.engine != null) {
            this.engine.setService(this);
        }
        ...
    }
    
    @Override
    public void setServer(Server server) {
        this.server = server;
    }
  
    @Override
    public void addConnector(Connector connector) {

        synchronized (connectorsLock) {
            connector.setService(this);
            Connector results[] = new Connector[connectors.length + 1];
            System.arraycopy(connectors, 0, results, 0, connectors.length);
            results[connectors.length] = connector;
            connectors = results;
        }

       ...
    }
   
   ...
}  

public class StandardEngine extends ContainerBase implements Engine {
  
  /**
     * The <code>Service</code> that owns this Engine, if any.
     */
    private Service service = null;
  
    ...
    @Override
    public void addChild(Container child) {
        // Engine的Child 必须是Host
        if (!(child instanceof Host)) {
            throw new IllegalArgumentException
                (sm.getString("standardEngine.notHost"));
        }
        // 调用父类ContainerBase中的实现
        super.addChild(child);
    }
    ...
}  

public class StandardHost extends ContainerBase implements Host {
    ...
      
    @Override
    public void addChild(Container child) {
      // Host的Child必须是Context
       if (!(child instanceof Context)) {
            throw new IllegalArgumentException
                (sm.getString("standardHost.notContext"));
        }
        ...
        // 调用父类ContainerBase中的实现
        super.addChild(child);
    }
    
    ...
}  

public class StandardContext extends ContainerBase
        implements Context, NotificationEmitter {
   
    ...
      
    @Override
    public void addChild(Container child) {

        // Global JspServlet
        Wrapper oldJspServlet = null;

        if (!(child instanceof Wrapper)) {
            throw new IllegalArgumentException
                (sm.getString("standardContext.notWrapper"));
        }

        ...
        // 调用父类ContainerBase中的实现
        super.addChild(child);
        ...
    }
    
    ...
}  

public class StandardWrapper extends ContainerBase
    implements ServletConfig, Wrapper, NotificationEmitter {
  ...
  /**
   * Refuse to add a child Container, because Wrappers are the lowest level
   * of the Container hierarchy.
   *
   * @param child Child container to be added
   */
  @Override
  public void addChild(Container child) {
		  // StandardWrapper是层级的最底层，拒绝添加child
      throw new IllegalStateException
          (sm.getString("standardWrapper.notChild"));

  }
  ...  
}

public abstract class ContainerBase extends LifecycleMBeanBase implements Container {
   ...
   /**
    * The parent Container to which this Container is a child.
    */
   protected Container parent = null;
   protected final HashMap<String, Container> children = new HashMap<>();
   ...
     
   @Override
    public void addChild(Container child) {
        ...
        addChildInternal(child);
        ...
    }

    private void addChildInternal(Container child) {

        ...

        synchronized(children) {
            if (children.get(child.getName()) != null) {
                throw new IllegalArgumentException(
                        sm.getString("containerBase.child.notUnique", child.getName()));
            }
            child.setParent(this);  // May throw IAE
            children.put(child.getName(), child);
        }

        ...
    }
    ...
}

<?xml version="1.0" encoding="UTF-8"?>
<Server port="8005" shutdown="SHUTDOWN">
  <Service name="Catalina">
    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />
    <Engine name="Catalina" defaultHost="localhost">

      <Host name="localhost"  appBase="webapps"
            unpackWARs="true" autoDeploy="true">

      </Host>
    </Engine>
  </Service>
</Server>

 <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />

// 在开始解析xml文件之前会给Digister添加一个Rule来告诉Digister遇到<Connector>标签时的处理逻辑
digester.addRule("Server/Service/Connector",
    new ConnectorCreateRule());

 public Http11NioProtocol() {
        super(new NioEndpoint());
    }

public abstract class AbstractProtocol<S> implements ProtocolHandler,
        MBeanRegistration {
    ...
    /**
     * Endpoint that provides low-level network I/O - must be matched to the
     * ProtocolHandler implementation (ProtocolHandler using NIO, requires NIO
     * Endpoint etc.).
     */
    private final AbstractEndpoint<S,?> endpoint;
    ...
}

public class StandardService extends LifecycleMBeanBase implements Service {
  
    ...
    @Override
    protected void startInternal() throws LifecycleException {

        ...
        // Start our defined Connectors second
        synchronized (connectorsLock) {
            for (Connector connector: connectors) {
                // If it has already failed, don't try and start it
                if (connector.getState() != LifecycleState.FAILED) {
                    connector.start();
                }
            }
        }
   }
   ...
}

public class Connector extends LifecycleMBeanBase  {
    ...
    /**
      * Coyote protocol handler.
      */
    protected final ProtocolHandler protocolHandler;
  
    ...
    @Override
    protected void startInternal() throws LifecycleException {

        ...
        try {
            protocolHandler.start();
        } catch (Exception e) {
            throw new LifecycleException(
                    sm.getString("coyoteConnector.protocolHandlerStartFailed"), e);
        }
    }
    ...
 
}

public abstract class AbstractProtocol<S> implements ProtocolHandler,
        MBeanRegistration {
    ...      
    @Override
    public void start() throws Exception {
        ...
        endpoint.start();
        ...
    }
    ...
}

public class NioEndpoint extends AbstractJsseEndpoint<NioChannel,SocketChannel> {
   @Override
    public void startInternal() throws Exception {

        if (!running) {
            running = true;
            paused = false;

            ...
            // Start poller thread
            poller = new Poller();
            Thread pollerThread = new Thread(poller, getName() + "-Poller");
            pollerThread.setPriority(threadPriority);
            pollerThread.setDaemon(true);
            pollerThread.start();

            startAcceptorThread();
        }
    }
}

public abstract class AbstractEndpoint<S,U> {
  protected void startAcceptorThread() {
        acceptor = new Acceptor<>(this);
        String threadName = getName() + "-Acceptor";
        acceptor.setThreadName(threadName);
        Thread t = new Thread(acceptor, threadName);
        t.setPriority(getAcceptorThreadPriority());
        t.setDaemon(getDaemon());
        t.start();
    }
  
}  

// Acceptor 类
@Override
public void run() {
   ...
   while (!stopCalled) {
      socket = endpoint.serverSocketAccept();
      ...
      if (!stopCalled && !endpoint.isPaused()) {
          if (!endpoint.setSocketOptions(socket)) {
              endpoint.closeSocket(socket);
          }
      } else {
          endpoint.destroySocket(socket);
      }
      ...
   }
   ....
}

//NioEndpoint类
@Override
protected SocketChannel serverSocketAccept() throws Exception {

    // serverSocketChannel 是在catalina load 阶段通过初始化
    // 如果设置了blocking 所以此处会阻塞，例如 serverSocketChannel.configureBlocking(true)，否则立即返回
    SocketChannel result = serverSocketChannel.accept();
    ...

    return result;
}

@Override
protected boolean setSocketOptions(SocketChannel socket) {
    NioSocketWrapper socketWrapper = null;
    try {
        // 分配NioChannel
        NioChannel channel = null;
        if (nioChannels != null) {
            channel = nioChannels.pop();
        }
        if (channel == null) {
            SocketBufferHandler bufhandler = new SocketBufferHandler(
                    socketProperties.getAppReadBufSize(),
                    socketProperties.getAppWriteBufSize(),
                    socketProperties.getDirectBuffer());
            if (isSSLEnabled()) {
                channel = new SecureNioChannel(bufhandler, this);
            } else {
                channel = new NioChannel(bufhandler);
            }
        }
      
        //封装SocketWrapper
        NioSocketWrapper newWrapper = new NioSocketWrapper(channel, this);
        channel.reset(socket, newWrapper);
        connections.put(socket, newWrapper);
        socketWrapper = newWrapper;

        // Set socket properties
        // Disable blocking, polling will be used
        socket.configureBlocking(false);
        if (getUnixDomainSocketPath() == null) {
            socketProperties.setProperties(socket.socket());
        }

        socketWrapper.setReadTimeout(getConnectionTimeout());
        socketWrapper.setWriteTimeout(getConnectionTimeout());
        socketWrapper.setKeepAliveLeft(NioEndpoint.this.getMaxKeepAliveRequests());
        // 将socketWrapper交给poller
        poller.register(socketWrapper);
        return true;
    } catch (Throwable t) {
        ExceptionUtils.handleThrowable(t);
        try {
            log.error(sm.getString("endpoint.socketOptionsError"), t);
        } catch (Throwable tt) {
            ExceptionUtils.handleThrowable(tt);
        }
        if (socketWrapper == null) {
            destroySocket(socket);
        }
    }
    // Tell to close the socket if needed
    return false;
}

// Poller类
public void register(final NioSocketWrapper socketWrapper) {
    socketWrapper.interestOps(SelectionKey.OP_READ);//this is what OP_REGISTER turns into.
    PollerEvent pollerEvent = createPollerEvent(socketWrapper, OP_REGISTER);
    addEvent(pollerEvent);
}

   /**
     * The background thread that adds sockets to the Poller, checks the
     * poller for triggered events and hands the associated socket off to an
     * appropriate processor as events occur.
     */
    @Override
    public void run() {
        // Loop until destroy() is called
        while (true) {

            boolean hasEvents = false;

            try {
                if (!close) {
                    hasEvents = events();
                    if (wakeupCounter.getAndSet(-1) > 0) {
                        // If we are here, means we have other stuff to do
                        // Do a non blocking select
                        keyCount = selector.selectNow();
                    } else {
                        keyCount = selector.select(selectorTimeout);
                    }
                    wakeupCounter.set(0);
                }
                ...
            } catch (Throwable x) {
                ExceptionUtils.handleThrowable(x);
                log.error(sm.getString("endpoint.nio.selectorLoopError"), x);
                continue;
            }

            Iterator<SelectionKey> iterator =
                keyCount > 0 ? selector.selectedKeys().iterator() : null;
            // Walk through the collection of ready keys and dispatch
            // any active event.
            while (iterator != null && iterator.hasNext()) {
                SelectionKey sk = iterator.next();
                iterator.remove();
                NioSocketWrapper socketWrapper = (NioSocketWrapper) sk.attachment();
                // Attachment may be null if another thread has called
                // cancelledKey()
                if (socketWrapper != null) {
                    processKey(sk, socketWrapper);
                }
            }

            // Process timeouts
            timeout(keyCount,hasEvents);
        }

        getStopLatch().countDown();
    }

 protected void processKey(SelectionKey sk, NioSocketWrapper socketWrapper) {
    try {
        if (close) {
            cancelledKey(sk, socketWrapper);
        } else if (sk.isValid()) {
            if (sk.isReadable() || sk.isWritable()) {
                if (socketWrapper.getSendfileData() != null) {
                    processSendfile(sk, socketWrapper, false);
                } else {
                    unreg(sk, socketWrapper, sk.readyOps());
                    boolean closeSocket = false;
                    // Read goes before write
                    if (sk.isReadable()) {
                        if (socketWrapper.readOperation != null) {
                            if (!socketWrapper.readOperation.process()) {
                                closeSocket = true;
                            }
                        } else if (socketWrapper.readBlocking) {
                            synchronized (socketWrapper.readLock) {
                                socketWrapper.readBlocking = false;
                                socketWrapper.readLock.notify();
                            }
                        } else if (!processSocket(socketWrapper, SocketEvent.OPEN_READ, true)) {
                            closeSocket = true;
                        }
                    }
                    if (!closeSocket && sk.isWritable()) {
                        if (socketWrapper.writeOperation != null) {
                            if (!socketWrapper.writeOperation.process()) {
                                closeSocket = true;
                            }
                        } else if (socketWrapper.writeBlocking) {
                            synchronized (socketWrapper.writeLock) {
                                socketWrapper.writeBlocking = false;
                                socketWrapper.writeLock.notify();
                            }
                        } else if (!processSocket(socketWrapper, SocketEvent.OPEN_WRITE, true)) {
                            closeSocket = true;
                        }
                    }
                    if (closeSocket) {
                        cancelledKey(sk, socketWrapper);
                    }
                }
            }
        } else {
            // Invalid key
            cancelledKey(sk, socketWrapper);
        }
    } catch (CancelledKeyException ckx) {
        cancelledKey(sk, socketWrapper);
    } catch (Throwable t) {
        ExceptionUtils.handleThrowable(t);
        log.error(sm.getString("endpoint.nio.keyProcessingError"), t);
    }
}

public boolean processSocket(SocketWrapperBase<S> socketWrapper,
            SocketEvent event, boolean dispatch) {
        try {
            ...
            // 创建SocketProcessor， SocketProcessor是EndPoint 的内部类
            sc = createSocketProcessor(socketWrapper, event);
            ...
            Executor executor = getExecutor();
            // 交给线程池来处理
            executor.execute(sc);
           ...
        } catch (RejectedExecutionException ree) {
            getLog().warn(sm.getString("endpoint.executor.fail", socketWrapper) , ree);
            return false;
        } catch (Throwable t) {
            ExceptionUtils.handleThrowable(t);
            // This means we got an OOM or similar creating a thread, or that
            // the pool and its queue are full
            getLog().error(sm.getString("endpoint.process.fail"), t);
            return false;
        }
        return true;
    }

@Override
protected void doRun() {
    Poller poller = NioEndpoint.this.poller;
    ...   
    // getHandler 返回的就是ConnectionHandler， 是AbstractProtocol的一个内部类
    state = getHandler().process(socketWrapper, event);
    ...        
}

@Override
public SocketState process(SocketWrapperBase<S> wrapper, SocketEvent status) {
    ...
    try {
        ...
        if (processor == null) {
            processor = recycledProcessors.pop();
            ...
        }
        if (processor == null) {
            // 返回Processor
            processor = getProtocol().createProcessor();
            register(processor);
            ...
        }

        ...
        do {
            state = processor.process(wrapper, status);
            ...
        } while ( state == SocketState.UPGRADING);

        ...
        return state;
    } catch(Exception e){}

    // Make sure socket/processor is removed from the list of current
    // connections
    release(processor);
    return SocketState.CLOSED;
}

// AbstactHttp11Protocol 中createProcessor 的实现
// 注意此处传入了一个Adapter, 它在Connector初始化时创建
//  adapter = new CoyoteAdapter(this);
//  protocolHandler.setAdapter(adapter);
@Override
protected Processor createProcessor() {
    Http11Processor processor = new Http11Processor(this, adapter);
    return processor;
}

@Override
public SocketState process(SocketWrapperBase<?> socketWrapper, SocketEvent status)
        throws IOException {

     ...
    do {
        ...
        if(condition)
            // service 是抽象方法
            state = service(socketWrapper);
        } 
        ...
    } while (state == SocketState.ASYNC_END ||
            dispatches != null && state != SocketState.CLOSED);

    return state;
}

@Override
public SocketState service(SocketWrapperBase<?> socketWrapper)
    throws IOException {
    ....
    // Parsing the request header
    if (!inputBuffer.parseRequestLine(keptAlive, protocol.getConnectionTimeout(),
            protocol.getKeepAliveTimeout())) {
        if (inputBuffer.getParsingRequestLinePhase() == -1) {
            return SocketState.UPGRADING;
        } else if (handleIncompleteRequestLineRead()) {
            break;
        }
    }

    // Process the Protocol component of the request line
    // Need to know if this is an HTTP 0.9 request before trying to
    // parse headers.
    prepareRequestProtocol();
    ...
    //解析完后会调用adaptor 的service 方法
    getAdapter().service(request, response);
}

//Adapter 是在connector初始化的时候创建的
@Override
protected void initInternal() throws LifecycleException {
    ...
    // Initialize adapter
    adapter = new CoyoteAdapter(this);
    protocolHandler.setAdapter(adapter);
    ...
    try {
        protocolHandler.init();
    } catch (Exception e) {
        throw new LifecycleException(
                sm.getString("coyoteConnector.protocolHandlerInitializationFailed"), e);
    }
}

@Override
public void service(org.apache.coyote.Request req, org.apache.coyote.Response res)
        throws Exception {
    ...
    if (request == null) {
          // 此处创建的是org.apache.catalina.connector.Request
          request = connector.createRequest();
          request.setCoyoteRequest(req);
          response = connector.createResponse();
          response.setCoyoteResponse(res);

          // Link objects
          request.setResponse(response);
          response.setRequest(request);

          // Set as notes
          req.setNote(ADAPTER_NOTES, request);
          res.setNote(ADAPTER_NOTES, response);

          // Set query string encoding
          req.getParameters().setQueryStringCharset(connector.getURICharset());
    }
    ...
    try {
        // Parse and set Catalina and configuration specific
        // request parameters
        postParseSuccess = postParseRequest(req, request, res, response);
        if (postParseSuccess) {
            ...
            // Calling the container
            connector.getService().getContainer().getPipeline().getFirst().invoke(
                    request, response);
        }
        if (request.isAsync()) {
            ...
        } else {
            request.finishRequest();
            response.finishResponse();
        }

    } catch (IOException e) {
        // Ignore
    } finally {
       ...
    }
}

@Override
    public final void invoke(Request request, Response response)
        throws IOException, ServletException {

        // Select the Host to be used for this Request
        Host host = request.getHost();
        ...

        // Ask this Host to process this request
        host.getPipeline().getFirst().invoke(request, response);
    }

@Override
public final void invoke(Request request, Response response)
    throws IOException, ServletException {

    ...
    Servlet servlet = null;
    ...
    servlet = wrapper.allocate();
    ...
    // Create the filter chain for this request
    // 大名鼎鼎的Tomcat Filter 接口
    ApplicationFilterChain filterChain =
            ApplicationFilterFactory.createFilterChain(request, wrapper, servlet);
    ...
    filterChain.doFilter(request.getRequest(), response.getResponse());
    ...
}