Tomcat 9.0 源码分析(4)-网络请求处理

蔚落 2023-10-03 12:32 9阅读 0赞

#### 文章目录 ####

*  1. Tomcat 网络请求处理流程
 *  2. 源码分析
 *   *   *  2.1 连接轮询器 Poller 处理
         *  2.2 协议解析器 Processor 读取 socket
         *  2.3 适配器 Adapter 的 Request 对象转换
         *  2.4 容器 Container 的处理

## 1. Tomcat 网络请求处理流程 ##

在 [Tomcat源码分析(1)-结构组成与核心组件][Tomcat_1_-] 中笔者分析了 Tomcat 的核心组成，由此也可以将 Tomcat 的网络请求处理分为以下几个步骤：

> 1.  Poller 分发 socket 连接读写事件
> 2.  Processor 读取 socket 数据，按照协议类型构建底层 Request/Response 对象
> 3.  Adapter 适配转换上层 ServletRequest/ServletResponse 对象，并将请求投入容器 Container
> 4.  容器 Container 针对请求完成业务处理

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUwNTMxMw_size_16_color_FFFFFF_t_70_pic_center]

## 2. 源码分析 ##

#### 2.1 连接轮询器 Poller 处理 ####

1.  本文以 `NioEndpoint` 为例分析 Tomcat 的底层连接处理，而在 [Tomcat源码分析(2)-连接器 Connector 的启动][Tomcat_2_-_ Connector] 中笔者已经提到作为轮询器 `Poller#run()` 会在子线程 while 循环中不断轮询就绪连接，其实现如下，关键逻辑是通过 Selector 获取可读写的连接，然后调用 `Poller#processKey()` 处理连接
    
        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);
                         }
                         if (close) {
              
                             events();
                             timeout(0, false);
                             try {
              
                                 selector.close();
                             } catch (IOException ioe) {
              
                                 log.error(sm.getString("endpoint.nio.selectorCloseFail"), ioe);
                             }
                             break;
                         }
                     } catch (Throwable x) {
              
                         ExceptionUtils.handleThrowable(x);
                         log.error(sm.getString("endpoint.nio.selectorLoopError"), x);
                         continue;
                     }
                     // Either we timed out or we woke up, process events first
                     if (keyCount == 0) {
              
                         hasEvents = (hasEvents | events());
                     }
        
                     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();
                         NioSocketWrapper socketWrapper = (NioSocketWrapper) sk.attachment();
                         // Attachment may be null if another thread has called
                         // cancelledKey()
                         if (socketWrapper == null) {
              
                             iterator.remove();
                         } else {
              
                             iterator.remove();
                             processKey(sk, socketWrapper);
                         }
                     }
        
                     // Process timeouts
                     timeout(keyCount,hasEvents);
                 }
        
                 getStopLatch().countDown();
             }
2.  `Poller#processKey()` 的核心逻辑分为以下几步：
    
    > 1.  首先判断是否是发送文件的操作，是的话调用 `Poller#processSendfile()` 借助 `FileChannel#transferTo()` 实现零拷贝发送数据
    > 2.  普通的读写操作调用 `AbstractEndpoint#processSocket()` 方法统一处理，只不过二者的 SocketEvent 不同
    
        protected void processKey(SelectionKey sk, NioSocketWrapper socketWrapper) {
              
                 try {
              
                     if (close) {
              
                         cancelledKey(sk, socketWrapper);
                     } else if (sk.isValid() && socketWrapper != null) {
              
                         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 (!processSocket(socketWrapper, SocketEvent.OPEN_READ, true)) {
              
                                         closeSocket = true;
                                     }
                                 }
                                 if (!closeSocket && sk.isWritable()) {
              
                                     if (socketWrapper.writeOperation != null) {
              
                                         if (!socketWrapper.writeOperation.process()) {
              
                                             closeSocket = true;
                                         }
                                     } 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);
                 }
         }
3.  `AbstractEndpoint#processSocket()` 方法的核心逻辑其实是调用子类的方法实现 `NioEndpoint#createSocketProcessor()` 创建出 `SocketProcessorBase` 异步任务对象，然后将这个任务扔进线程池执行。本例中，创建出的异步任务对象为 `NioEndpoint` 内部类 `SocketProcessor` 对象
    
        public boolean processSocket(SocketWrapperBase<S> socketWrapper,
                 SocketEvent event, boolean dispatch) {
              
             try {
              
                 if (socketWrapper == null) {
              
                     return false;
                 }
                 SocketProcessorBase<S> sc = null;
                 if (processorCache != null) {
              
                     sc = processorCache.pop();
                 }
                 if (sc == null) {
              
                     sc = createSocketProcessor(socketWrapper, event);
                 } else {
              
                     sc.reset(socketWrapper, event);
                 }
                 Executor executor = getExecutor();
                 if (dispatch && executor != null) {
              
                     executor.execute(sc);
                 } else {
              
                     sc.run();
                 }
             } 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;
         }
4.  `NioEndpoint.SocketProcessor#doRun()` 方法将在任务执行过程中触发，这里的重要逻辑是通过 `getHandler().process()` 调用到 `ConnectionHandler#process()` 将 socket 连接交给 `Processor` 进行数据处理
    
        protected void doRun() {
              
                 NioChannel socket = socketWrapper.getSocket();
                 SelectionKey key = socket.getIOChannel().keyFor(socket.getSocketWrapper().getPoller().getSelector());
                 Poller poller = NioEndpoint.this.poller;
                 if (poller == null) {
              
                     socketWrapper.close();
                     return;
                 }
        
                 try {
              
                     int handshake = -1;
        
                     try {
              
                         if (key != null) {
              
                             if (socket.isHandshakeComplete()) {
              
                                 // No TLS handshaking required. Let the handler
                                 // process this socket / event combination.
                                 handshake = 0;
                             } else if (event == SocketEvent.STOP || event == SocketEvent.DISCONNECT ||
                                     event == SocketEvent.ERROR) {
              
                                 // Unable to complete the TLS handshake. Treat it as
                                 // if the handshake failed.
                                 handshake = -1;
                             } else {
              
                                 handshake = socket.handshake(key.isReadable(), key.isWritable());
                                 // The handshake process reads/writes from/to the
                                 // socket. status may therefore be OPEN_WRITE once
                                 // the handshake completes. However, the handshake
                                 // happens when the socket is opened so the status
                                 // must always be OPEN_READ after it completes. It
                                 // is OK to always set this as it is only used if
                                 // the handshake completes.
                                 event = SocketEvent.OPEN_READ;
                             }
                         }
                     } catch (IOException x) {
              
                         handshake = -1;
                         if (log.isDebugEnabled()) log.debug("Error during SSL handshake",x);
                     } catch (CancelledKeyException ckx) {
              
                         handshake = -1;
                     }
                     if (handshake == 0) {
              
                         SocketState state = SocketState.OPEN;
                         // Process the request from this socket
                         if (event == null) {
              
                             state = getHandler().process(socketWrapper, SocketEvent.OPEN_READ);
                         } else {
              
                             state = getHandler().process(socketWrapper, event);
                         }
                         if (state == SocketState.CLOSED) {
              
                             poller.cancelledKey(key, socketWrapper);
                         }
                     } else if (handshake == -1 ) {
              
                         getHandler().process(socketWrapper, SocketEvent.CONNECT_FAIL);
                         poller.cancelledKey(key, socketWrapper);
                     } else if (handshake == SelectionKey.OP_READ){
              
                         socketWrapper.registerReadInterest();
                     } else if (handshake == SelectionKey.OP_WRITE){
              
                         socketWrapper.registerWriteInterest();
                     }
                 } catch (CancelledKeyException cx) {
              
                     poller.cancelledKey(key, socketWrapper);
                 } catch (VirtualMachineError vme) {
              
                     ExceptionUtils.handleThrowable(vme);
                 } catch (Throwable t) {
              
                     log.error(sm.getString("endpoint.processing.fail"), t);
                     poller.cancelledKey(key, socketWrapper);
                 } finally {
              
                     socketWrapper = null;
                     event = null;
                     //return to cache
                     if (running && !paused && processorCache != null) {
              
                         processorCache.push(this);
                     }
                 }
             }
         }
5.  `ConnectionHandler#process()` 方法的关键处理如下：
    
    > 1.  如果从各级缓存都没有获得 `Processor` 对象，则通过 `getProtocol().createProcessor()` 新建一个 `Processor`，本例中将调用 `AbstractHttp11Protocol#createProcessor()` 创建一个 `Http11Processor` 对象
    > 2.  通过 `processor.process()` 调用到 `AbstractProcessorLight#process()` 方法处理 socket 中的数据，此处进入 `Processor` 处理流程，将在下节分析
    > 3.  根据 socket 的处理状态做进一步处理，此处不作深入分析。不过需注意，如果状态为 `SocketState.LONG` 且`Processor`对象为异步模式，则会将其通过 `getProtocol().addWaitingProcessor()` 加入到等待队列中，此处是 [Connector 连接器启动][Connector] 中提到的异步请求超时检测实现的数据基础
    
        public SocketState process(SocketWrapperBase<S> wrapper, SocketEvent status) {
              
                 if (getLog().isDebugEnabled()) {
              
                     getLog().debug(sm.getString("abstractConnectionHandler.process",
                             wrapper.getSocket(), status));
                 }
                 if (wrapper == null) {
              
                     // Nothing to do. Socket has been closed.
                     return SocketState.CLOSED;
                 }
        
                 S socket = wrapper.getSocket();
        
                 Processor processor = (Processor) wrapper.getCurrentProcessor();
                 if (getLog().isDebugEnabled()) {
              
                     getLog().debug(sm.getString("abstractConnectionHandler.connectionsGet",
                             processor, socket));
                 }
        
                 // Timeouts are calculated on a dedicated thread and then
                 // dispatched. Because of delays in the dispatch process, the
                 // timeout may no longer be required. Check here and avoid
                 // unnecessary processing.
                 if (SocketEvent.TIMEOUT == status &&
                         (processor == null ||
                         !processor.isAsync() && !processor.isUpgrade() ||
                         processor.isAsync() && !processor.checkAsyncTimeoutGeneration())) {
              
                     // This is effectively a NO-OP
                     return SocketState.OPEN;
                 }
        
                 if (processor != null) {
              
                     // Make sure an async timeout doesn't fire
                     getProtocol().removeWaitingProcessor(processor);
                 } else if (status == SocketEvent.DISCONNECT || status == SocketEvent.ERROR) {
              
                     // Nothing to do. Endpoint requested a close and there is no
                     // longer a processor associated with this socket.
                     return SocketState.CLOSED;
                 }
        
                 ContainerThreadMarker.set();
        
                 try {
              
                     
                     ......
        
                     if (processor == null) {
              
                         processor = getProtocol().createProcessor();
                         register(processor);
                         if (getLog().isDebugEnabled()) {
              
                             getLog().debug(sm.getString("abstractConnectionHandler.processorCreate", processor));
                         }
                     }
        
                     processor.setSslSupport(
                             wrapper.getSslSupport(getProtocol().getClientCertProvider()));
        
                     // Associate the processor with the connection
                     wrapper.setCurrentProcessor(processor);
        
                     SocketState state = SocketState.CLOSED;
                     do {
              
                         state = processor.process(wrapper, status);
        
                         ......
        
                     } while ( state == SocketState.UPGRADING);
        
                     if (state == SocketState.LONG) {
              
                         // In the middle of processing a request/response. Keep the
                         // socket associated with the processor. Exact requirements
                         // depend on type of long poll
                         longPoll(wrapper, processor);
                         if (processor.isAsync()) {
              
                             getProtocol().addWaitingProcessor(processor);
                         }
                     } 
        
                     ......
        
                 // Make sure socket/processor is removed from the list of current
                 // connections
                 wrapper.setCurrentProcessor(null);
                 release(processor);
                 return SocketState.CLOSED;
             }

#### 2.2 协议解析器 Processor 读取 socket ####

1.  `AbstractProcessorLight#process()` 方法会按照 SocketEvent 进行不同处理，对于 `SocketEvent.OPEN_READ` 将调用到 `Http11Processor#service()` 方法
    
        public SocketState process(SocketWrapperBase<?> socketWrapper, SocketEvent status)
                 throws IOException {
              
        
             SocketState state = SocketState.CLOSED;
             Iterator<DispatchType> dispatches = null;
             do {
              
                 if (dispatches != null) {
              
                     DispatchType nextDispatch = dispatches.next();
                     if (getLog().isDebugEnabled()) {
              
                         getLog().debug("Processing dispatch type: [" + nextDispatch + "]");
                     }
                     state = dispatch(nextDispatch.getSocketStatus());
                     if (!dispatches.hasNext()) {
              
                         state = checkForPipelinedData(state, socketWrapper);
                     }
                 } else if (status == SocketEvent.DISCONNECT) {
              
                     // Do nothing here, just wait for it to get recycled
                 } else if (isAsync() || isUpgrade() || state == SocketState.ASYNC_END) {
              
                     state = dispatch(status);
                     state = checkForPipelinedData(state, socketWrapper);
                 } else if (status == SocketEvent.OPEN_WRITE) {
              
                     // Extra write event likely after async, ignore
                     state = SocketState.LONG;
                 } else if (status == SocketEvent.OPEN_READ) {
              
                     state = service(socketWrapper);
                 } else if (status == SocketEvent.CONNECT_FAIL) {
              
                     logAccess(socketWrapper);
                 } else {
              
                     // Default to closing the socket if the SocketEvent passed in
                     // is not consistent with the current state of the Processor
                     state = SocketState.CLOSED;
                 }
        
                 if (getLog().isDebugEnabled()) {
              
                     getLog().debug("Socket: [" + socketWrapper +
                             "], Status in: [" + status +
                             "], State out: [" + state + "]");
                 }
        
                 if (isAsync()) {
              
                     state = asyncPostProcess();
                     if (getLog().isDebugEnabled()) {
              
                         getLog().debug("Socket: [" + socketWrapper +
                                 "], State after async post processing: [" + state + "]");
                     }
                 }
        
                 if (dispatches == null || !dispatches.hasNext()) {
              
                     // Only returns non-null iterator if there are
                     // dispatches to process.
                     dispatches = getIteratorAndClearDispatches();
                 }
             } while (state == SocketState.ASYNC_END ||
                     dispatches != null && state != SocketState.CLOSED);
        
             return state;
         }
2.  `Http11Processor#service()` 方法的关键逻辑分为以下几个步骤：
    
    > 1.  调用 `Http11Processor#setSocketWrapper()` 方法初始化内部代表 socket 输入输出的 `Http11InputBuffer/Http11OutputBuffer` 对象
    > 2.  读取 socket 数据，解析出 HTTP 报文的请求行和请求头，构建 Adapter 层次的 Request/Response 对象，请求体的解析将推迟到业务处理需要使用请求参数时进行，读者如对 HTTP 请求报文的结构不清楚可参考 [HTTP 请求消息的结构][HTTP]。本例中`Http11InputBuffer#parseRequestLine()` 方法将解析 HTTP 请求行，`Http11InputBuffer#parseHeaders()` 方法将解析请求头
    > 3.  通过 `getAdapter().service(request, response)` 将请求/响应对象投进 Adapter 中进一步转化，至此进入了 `CoyoteAdapter#service()` 方法的处理，下节分析
    
        public SocketState service(SocketWrapperBase<?> socketWrapper)
             throws IOException {
              
             RequestInfo rp = request.getRequestProcessor();
             rp.setStage(org.apache.coyote.Constants.STAGE_PARSE);
        
             // Setting up the I/O
             setSocketWrapper(socketWrapper);
        
             // Flags
             keepAlive = true;
             openSocket = false;
             readComplete = true;
             boolean keptAlive = false;
             SendfileState sendfileState = SendfileState.DONE;
        
             while (!getErrorState().isError() && keepAlive && !isAsync() && upgradeToken == null &&
                     sendfileState == SendfileState.DONE && !protocol.isPaused()) {
              
        
                 // Parsing the request header
                 try {
              
                     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();
        
                     if (protocol.isPaused()) {
              
                         // 503 - Service unavailable
                         response.setStatus(503);
                         setErrorState(ErrorState.CLOSE_CLEAN, null);
                     } else {
              
                         keptAlive = true;
                         // Set this every time in case limit has been changed via JMX
                         request.getMimeHeaders().setLimit(protocol.getMaxHeaderCount());
                         // Don't parse headers for HTTP/0.9
                         if (!http09 && !inputBuffer.parseHeaders()) {
              
                             // We've read part of the request, don't recycle it
                             // instead associate it with the socket
                             openSocket = true;
                             readComplete = false;
                             break;
                         }
                         if (!protocol.getDisableUploadTimeout()) {
              
                             socketWrapper.setReadTimeout(protocol.getConnectionUploadTimeout());
                         }
                     }
                 } catch (IOException e) {
              
                     if (log.isDebugEnabled()) {
              
                         log.debug(sm.getString("http11processor.header.parse"), e);
                     }
                     setErrorState(ErrorState.CLOSE_CONNECTION_NOW, e);
                     break;
                 } catch (Throwable t) {
              
                     ExceptionUtils.handleThrowable(t);
                     UserDataHelper.Mode logMode = userDataHelper.getNextMode();
                     if (logMode != null) {
              
                         String message = sm.getString("http11processor.header.parse");
                         switch (logMode) {
              
                             case INFO_THEN_DEBUG:
                                 message += sm.getString("http11processor.fallToDebug");
                                 //$FALL-THROUGH$
                             case INFO:
                                 log.info(message, t);
                                 break;
                             case DEBUG:
                                 log.debug(message, t);
                         }
                     }
                     // 400 - Bad Request
                     response.setStatus(400);
                     setErrorState(ErrorState.CLOSE_CLEAN, t);
                 }
        
                 ......
        
                 // Process the request in the adapter
                 if (getErrorState().isIoAllowed()) {
              
                     try {
              
                         rp.setStage(org.apache.coyote.Constants.STAGE_SERVICE);
                         getAdapter().service(request, response);
                         // Handle when the response was committed before a serious
                         // error occurred.  Throwing a ServletException should both
                         // set the status to 500 and set the errorException.
                         // If we fail here, then the response is likely already
                         // committed, so we can't try and set headers.
                         if(keepAlive && !getErrorState().isError() && !isAsync() &&
                                 statusDropsConnection(response.getStatus())) {
              
                             setErrorState(ErrorState.CLOSE_CLEAN, null);
                         }
                     } catch (InterruptedIOException e) {
              
                         setErrorState(ErrorState.CLOSE_CONNECTION_NOW, e);
                     } catch (HeadersTooLargeException e) {
              
                         log.error(sm.getString("http11processor.request.process"), e);
                         // The response should not have been committed but check it
                         // anyway to be safe
                         if (response.isCommitted()) {
              
                             setErrorState(ErrorState.CLOSE_NOW, e);
                         } else {
              
                             response.reset();
                             response.setStatus(500);
                             setErrorState(ErrorState.CLOSE_CLEAN, e);
                             response.setHeader("Connection", "close"); // TODO: Remove
                         }
                     } catch (Throwable t) {
              
                         ExceptionUtils.handleThrowable(t);
                         log.error(sm.getString("http11processor.request.process"), t);
                         // 500 - Internal Server Error
                         response.setStatus(500);
                         setErrorState(ErrorState.CLOSE_CLEAN, t);
                         getAdapter().log(request, response, 0);
                     }
                 }
        
             ......
         }
3.  `Http11InputBuffer#parseRequestLine()` 方法实现较长，比较关键的是调用 `Http11InputBuffer#fill()` 方法从 socket 中读取数据到字节缓冲中，后续的处理其实就是从字节缓冲中取数据进行解析
    
        boolean parseRequestLine(boolean keptAlive, int connectionTimeout, int keepAliveTimeout)
                 throws IOException {
              
        
             // check state
             if (!parsingRequestLine) {
              
                 return true;
             }
             //
             // Skipping blank lines
             //
             if (parsingRequestLinePhase < 2) {
              
                 do {
              
                     // Read new bytes if needed
                     if (byteBuffer.position() >= byteBuffer.limit()) {
              
                         if (keptAlive) {
              
                             // Haven't read any request data yet so use the keep-alive
                             // timeout.
                             wrapper.setReadTimeout(keepAliveTimeout);
                         }
                         if (!fill(false)) {
              
                             // A read is pending, so no longer in initial state
                             parsingRequestLinePhase = 1;
                             return false;
                         }
                         // At least one byte of the request has been received.
                         // Switch to the socket timeout.
                         wrapper.setReadTimeout(connectionTimeout);
                     }
                     if (!keptAlive && byteBuffer.position() == 0 && byteBuffer.limit() >= CLIENT_PREFACE_START.length - 1) {
              
                         boolean prefaceMatch = true;
                         for (int i = 0; i < CLIENT_PREFACE_START.length && prefaceMatch; i++) {
              
                             if (CLIENT_PREFACE_START[i] != byteBuffer.get(i)) {
              
                                 prefaceMatch = false;
                             }
                         }
                         if (prefaceMatch) {
              
                             // HTTP/2 preface matched
                             parsingRequestLinePhase = -1;
                             return false;
                         }
                     }
                     // Set the start time once we start reading data (even if it is
                     // just skipping blank lines)
                     if (request.getStartTime() < 0) {
              
                         request.setStartTime(System.currentTimeMillis());
                     }
                     chr = byteBuffer.get();
                 } while ((chr == Constants.CR) || (chr == Constants.LF));
                 byteBuffer.position(byteBuffer.position() - 1);
        
                 parsingRequestLineStart = byteBuffer.position();
                 parsingRequestLinePhase = 2;
                 if (log.isDebugEnabled()) {
              
                     log.debug("Received ["
                             + new String(byteBuffer.array(), byteBuffer.position(), byteBuffer.remaining(), StandardCharsets.ISO_8859_1) + "]");
                 }
             }
             
             ......
         }
4.  `Http11InputBuffer#fill()` 方法的关键步骤是通过 `socketWrapper.read()` 从 socket 中读取数据，本例中将调用到 `NioSocketWrapper#read()` 方法，此后就是使用 Java 提供的相关接口读取数据的流程，此处不再赘述
    
        private boolean fill(boolean block) throws IOException {
              
        
             if (parsingHeader) {
              
                 if (byteBuffer.limit() >= headerBufferSize) {
              
                     if (parsingRequestLine) {
              
                         // Avoid unknown protocol triggering an additional error
                         request.protocol().setString(Constants.HTTP_11);
                     }
                     throw new IllegalArgumentException(sm.getString("iib.requestheadertoolarge.error"));
                 }
             } else {
              
                 byteBuffer.limit(end).position(end);
             }
        
             byteBuffer.mark();
             if (byteBuffer.position() < byteBuffer.limit()) {
              
                 byteBuffer.position(byteBuffer.limit());
             }
             byteBuffer.limit(byteBuffer.capacity());
             SocketWrapperBase<?> socketWrapper = this.wrapper;
             int nRead = -1;
             if (socketWrapper != null) {
              
                 nRead = socketWrapper.read(block, byteBuffer);
             } else {
              
                 throw new CloseNowException(sm.getString("iib.eof.error"));
             }
             byteBuffer.limit(byteBuffer.position()).reset();
             if (nRead > 0) {
              
                 return true;
             } else if (nRead == -1) {
              
                 throw new EOFException(sm.getString("iib.eof.error"));
             } else {
              
                 return false;
             }
        
         }
5.  `Http11InputBuffer#parseHeaders()` 方法的核心是调用内部重载的 `Http11InputBuffer#parseHeaders()` 方法，此处的重要处理分为两步：
    
    > 1.  调用 `Http11InputBuffer#fill()` 方法读取 socket 数据到字节缓冲区
    > 2.  通过 `headers.addValue()` 调用 `MimeHeaders#addValue()` 方法，将请求头数据塞入到 Adapter 层次 Request 对象的 headers 属性，后续将在 `Http11Processor#prepareRequest()` 方法中使用，不再赘述
    
        boolean parseHeaders() throws IOException {
              
             if (!parsingHeader) {
              
                 throw new IllegalStateException(sm.getString("iib.parseheaders.ise.error"));
             }
        
             HeaderParseStatus status = HeaderParseStatus.HAVE_MORE_HEADERS;
        
             do {
              
                 status = parseHeader();
                 // Checking that
                 // (1) Headers plus request line size does not exceed its limit
                 // (2) There are enough bytes to avoid expanding the buffer when
                 // reading body
                 // Technically, (2) is technical limitation, (1) is logical
                 // limitation to enforce the meaning of headerBufferSize
                 // From the way how buf is allocated and how blank lines are being
                 // read, it should be enough to check (1) only.
                 if (byteBuffer.position() > headerBufferSize || byteBuffer.capacity() - byteBuffer.position() < socketReadBufferSize) {
              
                     throw new IllegalArgumentException(sm.getString("iib.requestheadertoolarge.error"));
                 }
             } while (status == HeaderParseStatus.HAVE_MORE_HEADERS);
             if (status == HeaderParseStatus.DONE) {
              
                 parsingHeader = false;
                 end = byteBuffer.position();
                 return true;
             } else {
              
                 return false;
             }
         }
        
         private HeaderParseStatus parseHeader() throws IOException {
              
        
             while (headerParsePos == HeaderParsePosition.HEADER_START) {
              
        
                 // Read new bytes if needed
                 if (byteBuffer.position() >= byteBuffer.limit()) {
              
                     if (!fill(false)) {
              // parse header
                         headerParsePos = HeaderParsePosition.HEADER_START;
                         return HeaderParseStatus.NEED_MORE_DATA;
                     }
                 }
        
                 prevChr = chr;
                 chr = byteBuffer.get();
        
                 if (chr == Constants.CR && prevChr != Constants.CR) {
              
                     // Possible start of CRLF - process the next byte.
                 } else if (prevChr == Constants.CR && chr == Constants.LF) {
              
                     return HeaderParseStatus.DONE;
                 } else {
              
                     if (prevChr == Constants.CR) {
              
                         // Must have read two bytes (first was CR, second was not LF)
                         byteBuffer.position(byteBuffer.position() - 2);
                     } else {
              
                         // Must have only read one byte
                         byteBuffer.position(byteBuffer.position() - 1);
                     }
                     break;
                 }
             }
        
             if (headerParsePos == HeaderParsePosition.HEADER_START) {
              
                 // Mark the current buffer position
                 headerData.start = byteBuffer.position();
                 headerData.lineStart = headerData.start;
                 headerParsePos = HeaderParsePosition.HEADER_NAME;
             }
        
             //
             // Reading the header name
             // Header name is always US-ASCII
             //
        
             while (headerParsePos == HeaderParsePosition.HEADER_NAME) {
              
        
                 // Read new bytes if needed
                 if (byteBuffer.position() >= byteBuffer.limit()) {
              
                     if (!fill(false)) {
               // parse header
                         return HeaderParseStatus.NEED_MORE_DATA;
                     }
                 }
        
                 int pos = byteBuffer.position();
                 chr = byteBuffer.get();
                 if (chr == Constants.COLON) {
              
                     headerParsePos = HeaderParsePosition.HEADER_VALUE_START;
                     headerData.headerValue = headers.addValue(byteBuffer.array(), headerData.start,
                             pos - headerData.start);
                     pos = byteBuffer.position();
                     // Mark the current buffer position
                     headerData.start = pos;
                     headerData.realPos = pos;
                     headerData.lastSignificantChar = pos;
                     break;
                 } 
                 
                 ......
        
             return HeaderParseStatus.HAVE_MORE_HEADERS;
         }

#### 2.3 适配器 Adapter 的 Request 对象转换 ####

`CoyoteAdapter#service()` 方法源码如下，重点处理总结如下：

> 1.  通过 `connector.createRequest()` 调用 `Connector#createRequest()` 方法创建提供给上层容器的 `HttpServletRequest` 对象
> 2.  通过 `connector.getService().getContainer().getPipeline().getFirst().invoke(request, response)` 链式调用将 `HttpServletRequest` 对象投进容器中处理。此处完整体现了 Tomcat 中 service 的组成结构，组件轨迹为 `Connector -> Service -> Engine -> Pipeline -> Valve`，不记得的读者可以再次参考 [Tomcat源码分析(1)-结构组成与核心组件][Tomcat_1_-]

public void service(org.apache.coyote.Request req, org.apache.coyote.Response res)
                throws Exception {
        
    
            Request request = (Request) req.getNote(ADAPTER_NOTES);
            Response response = (Response) res.getNote(ADAPTER_NOTES);
    
            if (request == null) {
        
                // Create objects
                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());
            }
    
            if (connector.getXpoweredBy()) {
        
                response.addHeader("X-Powered-By", POWERED_BY);
            }
    
            boolean async = false;
            boolean postParseSuccess = false;
    
            req.getRequestProcessor().setWorkerThreadName(THREAD_NAME.get());
    
            try {
        
                // Parse and set Catalina and configuration specific
                // request parameters
                postParseSuccess = postParseRequest(req, request, res, response);
                if (postParseSuccess) {
        
                    //check valves if we support async
                    request.setAsyncSupported(
                            connector.getService().getContainer().getPipeline().isAsyncSupported());
                    // Calling the container
                    connector.getService().getContainer().getPipeline().getFirst().invoke(
                            request, response);
                }
                if (request.isAsync()) {
        
                    async = true;
                    ReadListener readListener = req.getReadListener();
                    if (readListener != null && request.isFinished()) {
        
                        // Possible the all data may have been read during service()
                        // method so this needs to be checked here
                        ClassLoader oldCL = null;
                        try {
        
                            oldCL = request.getContext().bind(false, null);
                            if (req.sendAllDataReadEvent()) {
        
                                req.getReadListener().onAllDataRead();
                            }
                        } finally {
        
                            request.getContext().unbind(false, oldCL);
                        }
                    }
    
                    Throwable throwable =
                            (Throwable) request.getAttribute(RequestDispatcher.ERROR_EXCEPTION);
    
                    // If an async request was started, is not going to end once
                    // this container thread finishes and an error occurred, trigger
                    // the async error process
                    if (!request.isAsyncCompleting() && throwable != null) {
        
                        request.getAsyncContextInternal().setErrorState(throwable, true);
                    }
                } else {
        
                    request.finishRequest();
                    response.finishResponse();
                }
    
            } catch (IOException e) {
        
                // Ignore
            } finally {
        
                AtomicBoolean error = new AtomicBoolean(false);
                res.action(ActionCode.IS_ERROR, error);
    
                if (request.isAsyncCompleting() && error.get()) {
        
                    // Connection will be forcibly closed which will prevent
                    // completion happening at the usual point. Need to trigger
                    // call to onComplete() here.
                    res.action(ActionCode.ASYNC_POST_PROCESS,  null);
                    async = false;
                }
    
                // Access log
                if (!async && postParseSuccess) {
        
                    // Log only if processing was invoked.
                    // If postParseRequest() failed, it has already logged it.
                    Context context = request.getContext();
                    Host host = request.getHost();
                    // If the context is null, it is likely that the endpoint was
                    // shutdown, this connection closed and the request recycled in
                    // a different thread. That thread will have updated the access
                    // log so it is OK not to update the access log here in that
                    // case.
                    // The other possibility is that an error occurred early in
                    // processing and the request could not be mapped to a Context.
                    // Log via the host or engine in that case.
                    long time = System.currentTimeMillis() - req.getStartTime();
                    if (context != null) {
        
                        context.logAccess(request, response, time, false);
                    } else if (response.isError()) {
        
                        if (host != null) {
        
                            host.logAccess(request, response, time, false);
                        } else {
        
                            connector.getService().getContainer().logAccess(
                                    request, response, time, false);
                        }
                    }
                }
    
                req.getRequestProcessor().setWorkerThreadName(null);
    
                // Recycle the wrapper request and response
                if (!async) {
        
                    updateWrapperErrorCount(request, response);
                    request.recycle();
                    response.recycle();
                }
            }
        }

#### 2.4 容器 Container 的处理 ####

1.  经过 2.3 节 的处理，供上层使用的 `HttpServletRequest` 进入了容器处理的环节，它要经过的第一个 `Valve` 就是 `StandardEngineValve#invoke()`，可以看到该方法的主要逻辑是从 `Request对象`中取出协议解析过程中根据 HTTP 请求头确定的 `Host 容器`，将请求投递到该容器中，最终将调用到 `StandardHostValve#invoke()`
    
        public final void invoke(Request request, Response response)
             throws IOException, ServletException {
              
        
             // Select the Host to be used for this Request
             Host host = request.getHost();
             if (host == null) {
              
                 // HTTP 0.9 or HTTP 1.0 request without a host when no default host
                 // is defined. This is handled by the CoyoteAdapter.
                 return;
             }
             if (request.isAsyncSupported()) {
              
                 request.setAsyncSupported(host.getPipeline().isAsyncSupported());
             }
        
             // Ask this Host to process this request
             host.getPipeline().getFirst().invoke(request, response);
         }
2.  `StandardHostValve#invoke()` 的核心逻辑也是将请求向下一级容器投递，最后会调到 `StandardContextValve#invoke()` 方法
    
        public final void invoke(Request request, Response response)
             throws IOException, ServletException {
              
        
             // Select the Context to be used for this Request
             Context context = request.getContext();
             if (context == null) {
              
                 return;
             }
        
             if (request.isAsyncSupported()) {
              
                 request.setAsyncSupported(context.getPipeline().isAsyncSupported());
             }
        
             boolean asyncAtStart = request.isAsync();
        
             try {
              
                 context.bind(Globals.IS_SECURITY_ENABLED, MY_CLASSLOADER);
        
                 if (!asyncAtStart && !context.fireRequestInitEvent(request.getRequest())) {
              
                     // Don't fire listeners during async processing (the listener
                     // fired for the request that called startAsync()).
                     // If a request init listener throws an exception, the request
                     // is aborted.
                     return;
                 }
        
                 // Ask this Context to process this request. Requests that are
                 // already in error must have been routed here to check for
                 // application defined error pages so DO NOT forward them to the the
                 // application for processing.
                 try {
              
                     if (!response.isErrorReportRequired()) {
              
                         context.getPipeline().getFirst().invoke(request, response);
                     }
                 } catch (Throwable t) {
              
                     ExceptionUtils.handleThrowable(t);
                     container.getLogger().error("Exception Processing " + request.getRequestURI(), t);
                     // If a new error occurred while trying to report a previous
                     // error allow the original error to be reported.
                     if (!response.isErrorReportRequired()) {
              
                         request.setAttribute(RequestDispatcher.ERROR_EXCEPTION, t);
                         throwable(request, response, t);
                     }
                 }
        
                 // Now that the request/response pair is back under container
                 // control lift the suspension so that the error handling can
                 // complete and/or the container can flush any remaining data
                 response.setSuspended(false);
        
                 Throwable t = (Throwable) request.getAttribute(RequestDispatcher.ERROR_EXCEPTION);
        
                 // Protect against NPEs if the context was destroyed during a
                 // long running request.
                 if (!context.getState().isAvailable()) {
              
                     return;
                 }
        
                 // Look for (and render if found) an application level error page
                 if (response.isErrorReportRequired()) {
              
                     // If an error has occurred that prevents further I/O, don't waste time
                     // producing an error report that will never be read
                     AtomicBoolean result = new AtomicBoolean(false);
                     response.getCoyoteResponse().action(ActionCode.IS_IO_ALLOWED, result);
                     if (result.get()) {
              
                         if (t != null) {
              
                             throwable(request, response, t);
                         } else {
              
                             status(request, response);
                         }
                     }
                 }
        
                 if (!request.isAsync() && !asyncAtStart) {
              
                     context.fireRequestDestroyEvent(request.getRequest());
                 }
             } finally {
              
                 // Access a session (if present) to update last accessed time, based
                 // on a strict interpretation of the specification
                 if (ACCESS_SESSION) {
              
                     request.getSession(false);
                 }
        
                 context.unbind(Globals.IS_SECURITY_ENABLED, MY_CLASSLOADER);
             }
         }
3.  `StandardContextValve#invoke()` 方法终于将请求投递到层级最低的容器 `Wrapper`，`StandardWrapperValve#invoke()` 将被调用
    
        public final void invoke(Request request, Response response)
             throws IOException, ServletException {
              
        
             // Disallow any direct access to resources under WEB-INF or META-INF
             MessageBytes requestPathMB = request.getRequestPathMB();
             if ((requestPathMB.startsWithIgnoreCase("/META-INF/", 0))
                     || (requestPathMB.equalsIgnoreCase("/META-INF"))
                     || (requestPathMB.startsWithIgnoreCase("/WEB-INF/", 0))
                     || (requestPathMB.equalsIgnoreCase("/WEB-INF"))) {
              
                 response.sendError(HttpServletResponse.SC_NOT_FOUND);
                 return;
             }
        
             // Select the Wrapper to be used for this Request
             Wrapper wrapper = request.getWrapper();
             if (wrapper == null || wrapper.isUnavailable()) {
              
                 response.sendError(HttpServletResponse.SC_NOT_FOUND);
                 return;
             }
        
             // Acknowledge the request
             try {
              
                 response.sendAcknowledgement();
             } catch (IOException ioe) {
              
                 container.getLogger().error(sm.getString(
                         "standardContextValve.acknowledgeException"), ioe);
                 request.setAttribute(RequestDispatcher.ERROR_EXCEPTION, ioe);
                 response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                 return;
             }
        
             if (request.isAsyncSupported()) {
              
                 request.setAsyncSupported(wrapper.getPipeline().isAsyncSupported());
             }
             wrapper.getPipeline().getFirst().invoke(request, response);
         }
4.  `StandardWrapperValve#invoke()` 的重要处理分为以下几个步骤：
    
    > 1.  首先通过 `wrapper.allocate()` 调用 `StandardWrapper#allocate()` 方法使用反射创建 `Servlet` 实例
    > 2.  调用 `ApplicationFilterFactory.createFilterChain()` 将 `Servlet` 和相关的 `Filter` 封装为 `ApplicationFilterChain` 执行链对象
    > 3.  调用 `ApplicationFilterChain#doFilter()` 方法使执行链得到执行
    
        public final void invoke(Request request, Response response)
             throws IOException, ServletException {
              
        
             // Initialize local variables we may need
             boolean unavailable = false;
             Throwable throwable = null;
             // This should be a Request attribute...
             long t1=System.currentTimeMillis();
             requestCount.incrementAndGet();
             StandardWrapper wrapper = (StandardWrapper) getContainer();
             Servlet servlet = null;
             Context context = (Context) wrapper.getParent();
        
             // Check for the application being marked unavailable
             if (!context.getState().isAvailable()) {
              
                 response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                                sm.getString("standardContext.isUnavailable"));
                 unavailable = true;
             }
        
             // Check for the servlet being marked unavailable
             if (!unavailable && wrapper.isUnavailable()) {
              
                 container.getLogger().info(sm.getString("standardWrapper.isUnavailable",
                         wrapper.getName()));
                 long available = wrapper.getAvailable();
                 if ((available > 0L) && (available < Long.MAX_VALUE)) {
              
                     response.setDateHeader("Retry-After", available);
                     response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                             sm.getString("standardWrapper.isUnavailable",
                                     wrapper.getName()));
                 } else if (available == Long.MAX_VALUE) {
              
                     response.sendError(HttpServletResponse.SC_NOT_FOUND,
                             sm.getString("standardWrapper.notFound",
                                     wrapper.getName()));
                 }
                 unavailable = true;
             }
        
             // Allocate a servlet instance to process this request
             try {
              
                 if (!unavailable) {
              
                     servlet = wrapper.allocate();
                 }
             } catch (UnavailableException e) {
              
                 container.getLogger().error(
                         sm.getString("standardWrapper.allocateException",
                                 wrapper.getName()), e);
                 long available = wrapper.getAvailable();
                 if ((available > 0L) && (available < Long.MAX_VALUE)) {
              
                     response.setDateHeader("Retry-After", available);
                     response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                                sm.getString("standardWrapper.isUnavailable",
                                             wrapper.getName()));
                 } else if (available == Long.MAX_VALUE) {
              
                     response.sendError(HttpServletResponse.SC_NOT_FOUND,
                                sm.getString("standardWrapper.notFound",
                                             wrapper.getName()));
                 }
             } catch (ServletException e) {
              
                 container.getLogger().error(sm.getString("standardWrapper.allocateException",
                                  wrapper.getName()), StandardWrapper.getRootCause(e));
                 throwable = e;
                 exception(request, response, e);
             } catch (Throwable e) {
              
                 ExceptionUtils.handleThrowable(e);
                 container.getLogger().error(sm.getString("standardWrapper.allocateException",
                                  wrapper.getName()), e);
                 throwable = e;
                 exception(request, response, e);
                 servlet = null;
             }
        
             MessageBytes requestPathMB = request.getRequestPathMB();
             DispatcherType dispatcherType = DispatcherType.REQUEST;
             if (request.getDispatcherType()==DispatcherType.ASYNC) dispatcherType = DispatcherType.ASYNC;
             request.setAttribute(Globals.DISPATCHER_TYPE_ATTR,dispatcherType);
             request.setAttribute(Globals.DISPATCHER_REQUEST_PATH_ATTR,
                     requestPathMB);
             // Create the filter chain for this request
             ApplicationFilterChain filterChain =
                     ApplicationFilterFactory.createFilterChain(request, wrapper, servlet);
        
             // Call the filter chain for this request
             // NOTE: This also calls the servlet's service() method
             Container container = this.container;
             try {
              
                 if ((servlet != null) && (filterChain != null)) {
              
                     // Swallow output if needed
                     if (context.getSwallowOutput()) {
              
                         try {
              
                             SystemLogHandler.startCapture();
                             if (request.isAsyncDispatching()) {
              
                                 request.getAsyncContextInternal().doInternalDispatch();
                             } else {
              
                                 filterChain.doFilter(request.getRequest(),
                                         response.getResponse());
                             }
                         } finally {
              
                             String log = SystemLogHandler.stopCapture();
                             if (log != null && log.length() > 0) {
              
                                 context.getLogger().info(log);
                             }
                         }
                     } else {
              
                         if (request.isAsyncDispatching()) {
              
                             request.getAsyncContextInternal().doInternalDispatch();
                         } else {
              
                             filterChain.doFilter
                                 (request.getRequest(), response.getResponse());
                         }
                     }
        
                 }
             } catch (ClientAbortException | CloseNowException e) {
              
                
                ......
             
             }
         }
5.  `ApplicationFilterChain#doFilter()` 方法实现如下，可以看到核心的逻辑是调用 `ApplicationFilterChain#internalDoFilter()` 方法首先执行完 Filter 过滤器，最后再调用 `servlet.service(request, response)` 调用 `GenericServlet#service()` 方法
    
        public void doFilter(ServletRequest request, ServletResponse response)
             throws IOException, ServletException {
              
        
             if( Globals.IS_SECURITY_ENABLED ) {
              
                 final ServletRequest req = request;
                 final ServletResponse res = response;
                 try {
              
                     java.security.AccessController.doPrivileged(
                         new java.security.PrivilegedExceptionAction<Void>() {
              
                             @Override
                             public Void run()
                                 throws ServletException, IOException {
              
                                 internalDoFilter(req,res);
                                 return null;
                             }
                         }
                     );
                 } catch( PrivilegedActionException pe) {
              
                     Exception e = pe.getException();
                     if (e instanceof ServletException)
                         throw (ServletException) e;
                     else if (e instanceof IOException)
                         throw (IOException) e;
                     else if (e instanceof RuntimeException)
                         throw (RuntimeException) e;
                     else
                         throw new ServletException(e.getMessage(), e);
                 }
             } else {
              
                 internalDoFilter(request,response);
             }
         }
        
         private void internalDoFilter(ServletRequest request,
                                       ServletResponse response)
             throws IOException, ServletException {
              
        
             // Call the next filter if there is one
             if (pos < n) {
              
                 ApplicationFilterConfig filterConfig = filters[pos++];
                 try {
              
                     Filter filter = filterConfig.getFilter();
        
                     if (request.isAsyncSupported() && "false".equalsIgnoreCase(
                             filterConfig.getFilterDef().getAsyncSupported())) {
              
                         request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR, Boolean.FALSE);
                     }
                     if( Globals.IS_SECURITY_ENABLED ) {
              
                         final ServletRequest req = request;
                         final ServletResponse res = response;
                         Principal principal =
                             ((HttpServletRequest) req).getUserPrincipal();
        
                         Object[] args = new Object[]{
              req, res, this};
                         SecurityUtil.doAsPrivilege ("doFilter", filter, classType, args, principal);
                     } else {
              
                         filter.doFilter(request, response, this);
                     }
                 } catch (IOException | ServletException | RuntimeException e) {
              
                     throw e;
                 } catch (Throwable e) {
              
                     e = ExceptionUtils.unwrapInvocationTargetException(e);
                     ExceptionUtils.handleThrowable(e);
                     throw new ServletException(sm.getString("filterChain.filter"), e);
                 }
                 return;
             }
        
             // We fell off the end of the chain -- call the servlet instance
             try {
              
                 if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
              
                     lastServicedRequest.set(request);
                     lastServicedResponse.set(response);
                 }
        
                 if (request.isAsyncSupported() && !servletSupportsAsync) {
              
                     request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR,
                             Boolean.FALSE);
                 }
                 // Use potentially wrapped request from this point
                 if ((request instanceof HttpServletRequest) &&
                         (response instanceof HttpServletResponse) &&
                         Globals.IS_SECURITY_ENABLED ) {
              
                     final ServletRequest req = request;
                     final ServletResponse res = response;
                     Principal principal =
                         ((HttpServletRequest) req).getUserPrincipal();
                     Object[] args = new Object[]{
              req, res};
                     SecurityUtil.doAsPrivilege("service",
                                                servlet,
                                                classTypeUsedInService,
                                                args,
                                                principal);
                 } else {
              
                     servlet.service(request, response);
                 }
             } catch (IOException | ServletException | RuntimeException e) {
              
                 throw e;
             } catch (Throwable e) {
              
                 e = ExceptionUtils.unwrapInvocationTargetException(e);
                 ExceptionUtils.handleThrowable(e);
                 throw new ServletException(sm.getString("filterChain.servlet"), e);
             } finally {
              
                 if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
              
                     lastServicedRequest.set(null);
                     lastServicedResponse.set(null);
                 }
             }
         }
6.  `GenericServlet#service()` 是接口方法其实现为 `HttpServlet#service()` 方法，而`HttpServlet#service()` 方法实际会调用子类重写的 `HttpServlet#service()` 方法。此处可以看到 `Spring WebMVC` 框架中的 `FrameworkServlet` 重写了这个方法，至此进入到了 `Spring WebMVC` 框架层
    
        public void service(ServletRequest req, ServletResponse res)
             throws ServletException, IOException {
              
        
             HttpServletRequest  request;
             HttpServletResponse response;
        
             try {
              
                 request = (HttpServletRequest) req;
                 response = (HttpServletResponse) res;
             } catch (ClassCastException e) {
              
                 throw new ServletException(lStrings.getString("http.non_http"));
             }
             service(request, response);
         }
7.  `FrameworkServlet#service()` 的核心逻辑是调用 `FrameworkServlet#processRequest()` 方法，并在该方法中调用子类实现的 `doService()` 方法，也就是调用 `DispatcherServlet#doService()`。在此终于看到了 `Spring WebMVC` 框架中绕不过的 `DispatcherServlet`，请求从此处分发进入了我们编写的各个处理方法，读者如有兴趣可参考[Spring WebMVC 源码分析(1)-请求处理主流程][Spring WebMVC _1_-]，Tomcat 请求处理流程基本结束
    
        protected void service(HttpServletRequest request, HttpServletResponse response)
         		throws ServletException, IOException {
              
        
         	HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
         	if (httpMethod == HttpMethod.PATCH || httpMethod == null) {
              
         		processRequest(request, response);
         	}
         	else {
              
         		super.service(request, response);
         	}
         }
        
         protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
         		throws ServletException, IOException {
              
        
         	long startTime = System.currentTimeMillis();
         	Throwable failureCause = null;
        
         	LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
         	LocaleContext localeContext = buildLocaleContext(request);
        
         	RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
         	ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);
        
         	WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
         	asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());
        
         	initContextHolders(request, localeContext, requestAttributes);
        
         	try {
              
         		doService(request, response);
         	}
         	catch (ServletException | IOException ex) {
              
         		failureCause = ex;
         		throw ex;
         	}
         	catch (Throwable ex) {
              
         		failureCause = ex;
         		throw new NestedServletException("Request processing failed", ex);
         	}
        
         	finally {
              
         		resetContextHolders(request, previousLocaleContext, previousAttributes);
         		if (requestAttributes != null) {
              
         			requestAttributes.requestCompleted();
         		}
         		logResult(request, response, failureCause, asyncManager);
         		publishRequestHandledEvent(request, response, startTime, failureCause);
         	}
         }
        
        ```

[Tomcat_1_-]: https://blog.csdn.net/weixin_45505313/article/details/118631533
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUwNTMxMw_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/7b3c4fd4f2cb465bb8894e38544fbdc5.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUwNTMxMw==,size_16,color_FFFFFF,t_70#pic_center
[Tomcat_2_-_ Connector]: https://blog.csdn.net/weixin_45505313/article/details/118855200
[Connector]: https://blog.csdn.net/weixin_45505313/article/details/118855200#t5
[HTTP]: https://blog.csdn.net/weixin_45505313/article/details/102219831#t3
[Spring WebMVC _1_-]: https://blog.csdn.net/weixin_45505313/article/details/100782887