Tomcat源碼分析（二）請求過程分析

    通過前面幾篇文章的分析，咱們對Tomcat的框架有了必定得掌握，對於各個模塊的功能也有了大體瞭解，這篇文章主要分析Connector如何將請求分發到Engine，以及最後到Servlet處理。
    從Tomcat類結構中咱們知道，真正和Socket打交道的是EndPoint，EndPoint負責監聽端口、接收鏈接、讀取數據等，因此咱們從EndPoint着手研究請求分發過程，本文以NioEndPoint爲例。

1. 主要類結構：
   
    
2. 請求分發過程
   1）NioEndPoint循環處理Selector上的事件

   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("",x);
               continue;
           }
           //either we timed out or we woke up, process events first
           if ( keyCount == 0 ) hasEvents = (hasEvents | events());
   
           // Selector事件觸發，將事件放到SelectionKey中返回
           Iterator<SelectionKey> iterator = keyCount > 0 ? selector.selectedKeys().iterator() : null;
           while (iterator != null && iterator.hasNext()) {
               SelectionKey sk = iterator.next();
               NioSocketWrapper attachment = (NioSocketWrapper)sk.attachment();
               // Attachment may be null if another thread has called
               // cancelledKey()
               if (attachment == null) {
                   iterator.remove();
               } else {
                   iterator.remove();
                   // 處理SelectionKey上的事件
                   processKey(sk, attachment);
               }
           }//while
   
           //process timeouts
           timeout(keyCount,hasEvents);
       }//while
   
       stopLatch.countDown();
   }

   
   2) AbstractEndPoint調用Executor執行SocketProcessor

   public boolean processSocket(SocketWrapperBase<S> socketWrapper, SocketEvent event, boolean dispatch) {
       try {
           if (socketWrapper == null) {
               return false;
           }
           SocketProcessorBase<S> sc = processorCache.pop();
           if (sc == null) {
               sc = createSocketProcessor(socketWrapper, event);
           } else {
               sc.reset(socketWrapper, event);
           }
           Executor executor = getExecutor();
           if (dispatch && executor != null) {
               // Executor執行SocketProcessor
               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);
           getLog().error(sm.getString("endpoint.process.fail"), t);
           return false;
       }
       return true;
   }

   
   3) ThreadPoolExecutor執行Runnable任務，SocketProcessor繼承SocketProcessorBase，SocketProcessorBase繼承Runnable，最終執行Runnable是SocketProcessor

   public void execute(Runnable command, long timeout, TimeUnit unit) {
       submittedCount.incrementAndGet();
       try {
           // 將Runnable加入到線程池執行
           super.execute(command);
       } catch (RejectedExecutionException rx) {
           if (super.getQueue() instanceof TaskQueue) {
               final TaskQueue queue = (TaskQueue)super.getQueue();
               try {
                   if (!queue.force(command, timeout, unit)) {
                       submittedCount.decrementAndGet();
                       throw new RejectedExecutionException("Queue capacity is full.");
                   }
               } catch (InterruptedException x) {
                   submittedCount.decrementAndGet();
                   throw new RejectedExecutionException(x);
               }
           } else {
               submittedCount.decrementAndGet();
               throw rx;
           }
       }
   }

   
   4) SocketProcessor的doRun方法被線程調用，SocketProcessor加入Executor後會被一個線程執行，SocketProcessorBase的run方法會調用doRun方法，而SocketProcessorBase將doRun方法保留給子類擴展

   protected void doRun() {
       NioChannel socket = socketWrapper.getSocket();
       SelectionKey key = socket.getIOChannel().keyFor(socket.getPoller().getSelector());
   
       try {
           int handshake = -1;
   
           try {
               if (key != null) {
                   if (socket.isHandshakeComplete()) {
                       handshake = 0;
                   } else if (event == SocketEvent.STOP || event == SocketEvent.DISCONNECT || event == SocketEvent.ERROR) {
                       handshake = -1;
                   } else {
                       handshake = socket.handshake(key.isReadable(), key.isWritable());
                       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 {
                   // 調用AbstractProtocol.ConnectionHandler處理事件，
                   // AbstractProtocol.ConnectionHandler繼承了AbstractEndPoint.Handler
                   state = getHandler().process(socketWrapper, event);
               }
               if (state == SocketState.CLOSED) {
                   close(socket, key);
               }
           } else if (handshake == -1 ) {
               close(socket, key);
           } else if (handshake == SelectionKey.OP_READ){
               socketWrapper.registerReadInterest();
           } else if (handshake == SelectionKey.OP_WRITE){
               socketWrapper.registerWriteInterest();
           }
       } catch (CancelledKeyException cx) {
           socket.getPoller().cancelledKey(key);
       }
       /* 省略部分代碼 */
   }

   
   5) AbstractProtocol.ConnectionHandler處理請求，調用Processor進行處理

   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 = connections.get(socket);
       if ((status == SocketEvent.DISCONNECT || status == SocketEvent.ERROR) && processor == null) {
           // 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) {
               /* 省略部分代碼 */
           }
           if (processor == null) {
               processor = recycledProcessors.pop();
           }
           if (processor == null) {
               processor = getProtocol().createProcessor();
               register(processor);
           }
   
           processor.setSslSupport(wrapper.getSslSupport(getProtocol().getClientCertProvider()));
   
           // Associate the processor with the connection
           connections.put(socket, processor);
           // Make sure an async timeout doesn't fire
           getProtocol().removeWaitingProcessor(processor);
   
           SocketState state = SocketState.CLOSED;
           do {
               // Processor處理請求
               state = processor.process(wrapper, status);
   
               if (state == SocketState.UPGRADING) {
                   // Get the HTTP upgrade handler
                   UpgradeToken upgradeToken = processor.getUpgradeToken();
                   // Retrieve leftover input
                   ByteBuffer leftOverInput = processor.getLeftoverInput();
                   if (upgradeToken == null) {
                       // Assume direct HTTP/2 connection
                       UpgradeProtocol upgradeProtocol = getProtocol().getUpgradeProtocol("h2c");
                       if (upgradeProtocol != null) {
                           processor = upgradeProtocol.getProcessor(wrapper, getProtocol().getAdapter());
                           wrapper.unRead(leftOverInput);
                           // Associate with the processor with the connection
                           connections.put(socket, processor);
                       } else {
                           if (getLog().isDebugEnabled()) {
                               getLog().debug(sm.getString(
                                   "abstractConnectionHandler.negotiatedProcessor.fail",
                                   "h2c"));
                           }
                           return SocketState.CLOSED;
                       }
                   } else {
                       HttpUpgradeHandler httpUpgradeHandler = upgradeToken.getHttpUpgradeHandler();
                       // Release the Http11 processor to be re-used
                       release(processor);
                       // Create the upgrade processor
                       processor = getProtocol().createUpgradeProcessor(wrapper, upgradeToken);
                       wrapper.unRead(leftOverInput);
                       // Mark the connection as upgraded
                       wrapper.setUpgraded(true);
                       // Associate with the processor with the connection
                       connections.put(socket, processor);
   
                       if (upgradeToken.getInstanceManager() == null) {
                           httpUpgradeHandler.init((WebConnection) processor);
                       } else {
                           ClassLoader oldCL = upgradeToken.getContextBind().bind(false, null);
                           try {
                               httpUpgradeHandler.init((WebConnection) processor);
                           } finally {
                               upgradeToken.getContextBind().unbind(false, oldCL);
                           }
                       }
                   }
               }
           } while ( state == SocketState.UPGRADING);
   
           /* 省略部分代碼 */
   
           return state;
       } catch(java.net.SocketException e) {
           /* 省略部分代碼 */
       } finally {
           ContainerThreadMarker.clear();
       }
   
       // Make sure socket/processor is removed from the list of current
       // connections
       connections.remove(socket);
       release(processor);
       return SocketState.CLOSED;
   }

   
   6) AbstractProcessorLight處理請求，AbstractProcessorLight中service方法爲抽象方法，由子類提供實現，AbstractProcessorLight經過調用子類的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();
               state = dispatch(nextDispatch.getSocketStatus());
           } 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);
               if (state == SocketState.OPEN) {
                   state = service(socketWrapper);
               }
           } else if (status == SocketEvent.OPEN_WRITE) {
               // Extra write event likely after async, ignore
               state = SocketState.LONG;
           } else {
               // 調用子類的service方法處理請求
               state = service(socketWrapper);
           }
   
           if (state != SocketState.CLOSED && isAsync()) {
               state = asyncPostProcess();
           }
   
           if (getLog().isDebugEnabled()) {
               getLog().debug("Socket: [" + socketWrapper + "], Status in: [" + status + "], State out: [" + state + "]");
           }
   
           if (dispatches == null || !dispatches.hasNext()) {
               dispatches = getIteratorAndClearDispatches();
           }
       } while (state == SocketState.ASYNC_END || dispatches != null && state != SocketState.CLOSED);
   
       return state;
   }

   
   7) Http11Processor實現AbstractProcessorLight的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);
       inputBuffer.init(socketWrapper);
       outputBuffer.init(socketWrapper);
   
       // Flags
       keepAlive = true;
       openSocket = false;
       readComplete = true;
       boolean keptAlive = false;
   
       while (!getErrorState().isError() && keepAlive && !isAsync() &&
               upgradeToken == null && !endpoint.isPaused()) {
   
           // Parsing the request header
           try {
               if (!inputBuffer.parseRequestLine(keptAlive)) {
                   if (inputBuffer.getParsingRequestLinePhase() == -1) {
                       return SocketState.UPGRADING;
                   } else if (handleIncompleteRequestLineRead()) {
                       break;
                   }
               }
   
               if (endpoint.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(endpoint.getMaxHeaderCount());
                   if (!inputBuffer.parseHeaders()) {
                       openSocket = true;
                       readComplete = false;
                       break;
                   }
                   if (!disableUploadTimeout) {
                       socketWrapper.setReadTimeout(connectionUploadTimeout);
                   }
               }
           } 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);
               getAdapter().log(request, response, 0);
           }
   
           // Has an upgrade been requested?
           Enumeration<String> connectionValues = request.getMimeHeaders().values("Connection");
           boolean foundUpgrade = false;
           while (connectionValues.hasMoreElements() && !foundUpgrade) {
               foundUpgrade = connectionValues.nextElement().toLowerCase(
                       Locale.ENGLISH).contains("upgrade");
           }
   
           if (foundUpgrade) {
               // Check the protocol
               String requestedProtocol = request.getHeader("Upgrade");
   
               UpgradeProtocol upgradeProtocol = httpUpgradeProtocols.get(requestedProtocol);
               if (upgradeProtocol != null) {
                   if (upgradeProtocol.accept(request)) {
                       // TODO Figure out how to handle request bodies at this
                       // point.
                       response.setStatus(HttpServletResponse.SC_SWITCHING_PROTOCOLS);
                       response.setHeader("Connection", "Upgrade");
                       response.setHeader("Upgrade", requestedProtocol);
                       action(ActionCode.CLOSE,  null);
                       getAdapter().log(request, response, 0);
   
                       InternalHttpUpgradeHandler upgradeHandler = upgradeProtocol.getInternalUpgradeHandler(
                                       getAdapter(), cloneRequest(request));
                       UpgradeToken upgradeToken = new UpgradeToken(upgradeHandler, null, null);
                       action(ActionCode.UPGRADE, upgradeToken);
                       return SocketState.UPGRADING;
                   }
               }
           }
   
           if (!getErrorState().isError()) {
               // Setting up filters, and parse some request headers
               rp.setStage(org.apache.coyote.Constants.STAGE_PREPARE);
               try {
                   prepareRequest();
               } catch (Throwable t) {
                   ExceptionUtils.handleThrowable(t);
                   if (log.isDebugEnabled()) {
                       log.debug(sm.getString("http11processor.request.prepare"), t);
                   }
                   // 500 - Internal Server Error
                   response.setStatus(500);
                   setErrorState(ErrorState.CLOSE_CLEAN, t);
                   getAdapter().log(request, response, 0);
               }
           }
   
           if (maxKeepAliveRequests == 1) {
               keepAlive = false;
           } else if (maxKeepAliveRequests > 0 &&
                   socketWrapper.decrementKeepAlive() <= 0) {
               keepAlive = false;
           }
   
           // Process the request in the adapter
           if (!getErrorState().isError()) {
               try {
                   rp.setStage(org.apache.coyote.Constants.STAGE_SERVICE);
                   // 使用CoyoteAdapter處理請求
                   getAdapter().service(request, response);
   
                   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);
               }
           }
   
           // Finish the handling of the request
           rp.setStage(org.apache.coyote.Constants.STAGE_ENDINPUT);
           if (!isAsync()) {
               // If this is an async request then the request ends when it has
               // been completed. The AsyncContext is responsible for calling
               // endRequest() in that case.
               endRequest();
           }
           rp.setStage(org.apache.coyote.Constants.STAGE_ENDOUTPUT);
   
           // If there was an error, make sure the request is counted as
           // and error, and update the statistics counter
           if (getErrorState().isError()) {
               response.setStatus(500);
           }
   
           if (!isAsync() || getErrorState().isError()) {
               request.updateCounters();
               if (getErrorState().isIoAllowed()) {
                   inputBuffer.nextRequest();
                   outputBuffer.nextRequest();
               }
           }
   
           if (!disableUploadTimeout) {
               int soTimeout = endpoint.getSoTimeout();
               if(soTimeout > 0) {
                   socketWrapper.setReadTimeout(soTimeout);
               } else {
                   socketWrapper.setReadTimeout(0);
               }
           }
   
           rp.setStage(org.apache.coyote.Constants.STAGE_KEEPALIVE);
   
           if (breakKeepAliveLoop(socketWrapper)) {
               break;
           }
       }
   
       rp.setStage(org.apache.coyote.Constants.STAGE_ENDED);
   
       if (getErrorState().isError() || endpoint.isPaused()) {
           return SocketState.CLOSED;
       } else if (isAsync()) {
           return SocketState.LONG;
       } else if (isUpgrade()) {
           return SocketState.UPGRADING;
       } else {
           if (sendfileData != null) {
               return SocketState.SENDFILE;
           } else {
               if (openSocket) {
                   if (readComplete) {
                       return SocketState.OPEN;
                   } else {
                       return SocketState.LONG;
                   }
               } else {
                   return SocketState.CLOSED;
               }
           }
       }
   }

   
   8) CoyoteAdapter處理請求

   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().setQueryStringEncoding(connector.getURIEncoding());
   
       }
   
       if (connector.getXpoweredBy()) {
           response.addHeader("X-Powered-By", POWERED_BY);
       }
   
       boolean async = false;
       boolean postParseSuccess = false;
   
       try {
           // Parse and set Catalina and configuration specific
           // request parameters
           req.getRequestProcessor().setWorkerThreadName(THREAD_NAME.get());
           // 解析Url，獲取對應的Host, Context, Wrapper等
           postParseSuccess = postParseRequest(req, request, res, response);
           if (postParseSuccess) {
               //check valves if we support async
               request.setAsyncSupported(connector.getService().getContainer().getPipeline().isAsyncSupported());
               // connector經過Service調用Engine的Pipline來處理請求
               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 {
          /* 省略部分代碼 */
       }
   }

   
   9) StandardEngineValve invoke處理請求

   public final void invoke(Request request, Response response)throws IOException, ServletException {
   
       // 獲取對應的Url對應的Host
       Host host = request.getHost();
       if (host == null) {
           response.sendError(HttpServletResponse.SC_BAD_REQUEST,
                sm.getString("standardEngine.noHost", request.getServerName()));
           return;
       }
       if (request.isAsyncSupported()) {
           request.setAsyncSupported(host.getPipeline().isAsyncSupported());
       }
   
       // 調用Host的Pipeline處理請求
       host.getPipeline().getFirst().invoke(request, response);
   }

   
   10) StandardHostValve invoke處理請求，Host的Pipeline上有三個Valve分別是AbstractAccessLogValve, ErrorReportValve和StandardHostValve，StandardHostValve最後被調用

   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) {
           response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
                sm.getString("standardHost.noContext"));
           return;
       }
   
       if (request.isAsyncSupported()) {
           request.setAsyncSupported(context.getPipeline().isAsyncSupported());
       }
   
       boolean asyncAtStart = request.isAsync();
       boolean asyncDispatching = request.isAsyncDispatching();
   
       try {
           context.bind(Globals.IS_SECURITY_ENABLED, MY_CLASSLOADER);
   
           if (!asyncAtStart && !context.fireRequestInitEvent(request)) {
               // 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;
           }
   
           try {
               if (!asyncAtStart || asyncDispatching) {
                   // 調用Context的Pipeline處理請求
                   context.getPipeline().getFirst().invoke(request, response);
               } else {
                   // Make sure this request/response is here because an error
                   // report is required.
                   if (!response.isErrorReportRequired()) {
                       throw new IllegalStateException(sm.getString("standardHost.asyncStateError"));
                   }
               }
           } 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);
               }
           }
   
           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 (t != null) {
                   throwable(request, response, t);
               } else {
                   status(request, response);
               }
           }
   
           if (!request.isAsync() && (!asyncAtStart || !response.isErrorReportRequired())) {
               context.fireRequestDestroyEvent(request);
           }
       } 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);
       }
   }

   
   11) StandardContextValve invoke處理請求，Context的Pipeline上有兩個Valve分別是AuthenticatorBase和StandardContextValve，StandardContextValve被最後調用

   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的Pipeline處理請求
       wrapper.getPipeline().getFirst().invoke(request, response);
   }

   
   12) StandardWrapperValve invoke處理請求

   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
       try {
           if ((servlet != null) && (filterChain != null)) {
               // Swallow output if needed
               if (context.getSwallowOutput()) {
                   try {
                       SystemLogHandler.startCapture();
                       if (request.isAsyncDispatching()) {
                           request.getAsyncContextInternal().doInternalDispatch();
                       } else {
                           // 使用ApplicationFilterChain處理請求，ApplicationFilterChain添加了一系列Filter操做
                           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 e) {
           throwable = e;
           exception(request, response, e);
       } catch (IOException e) {
           container.getLogger().error(sm.getString( "standardWrapper.serviceException", wrapper.getName(), context.getName()), e);
           throwable = e;
           exception(request, response, e);
       } catch (UnavailableException e) {
           container.getLogger().error(sm.getString(
                   "standardWrapper.serviceException", wrapper.getName(),
                   context.getName()), e);
           //            throwable = e;
           //            exception(request, response, e);
           wrapper.unavailable(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()));
           }
           // Do not save exception in 'throwable', because we
           // do not want to do exception(request, response, e) processing
       } catch (ServletException e) {
           Throwable rootCause = StandardWrapper.getRootCause(e);
           if (!(rootCause instanceof ClientAbortException)) {
               container.getLogger().error(sm.getString(
                       "standardWrapper.serviceExceptionRoot",
                       wrapper.getName(), context.getName(), e.getMessage()),
                       rootCause);
           }
           throwable = e;
           exception(request, response, e);
       } catch (Throwable e) {
           ExceptionUtils.handleThrowable(e);
           container.getLogger().error(sm.getString(
                   "standardWrapper.serviceException", wrapper.getName(),
                   context.getName()), e);
           throwable = e;
           exception(request, response, e);
       }
   
       // Release the filter chain (if any) for this request
       if (filterChain != null) {
           filterChain.release();
       }
   
       /* 省略部分代碼 */
   }

   
   13) ApplicationFilterChain最終調用Servlet的service方法處理請求

   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最後處理請求
               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);
           }
       }
   }

   
    
3. 總結 雖然Tomcat的請求分發過程很長，可是結合Tomcat的框架其實也很好把握。EndPoint做爲與Socket直接打交道的類，將接收到的Socket事件並交給ProtocolHandler處理請求，Executor則爲ProtocolHandler處理請求提供線程支持，ProtocolHandler經過Connector將請求交由Engine處理，請求通過Engine, Host, Context, Wrapper，最終由Servlet處理。