首页 > 代码库 > Tomcat源码解读：我们发起的HTTP请求如何到达Servlet的
Tomcat源码解读：我们发起的HTTP请求如何到达Servlet的
在上一节中，了解了Tomcat服务器启动的整个过程，现在来了解一下Tomcat如何接收到HTTP请求，并将请求送达至Servlet，Servlet处理后，响应信息又是如何返回给浏览器的呢？这两个问题是接下来要研究的课题，本节先研究第一个问题。
了解一点点网络知识的人，都会知道TCP连接通信是基于Socket的，上一节也有提到这点。通过上一节的说明，可以了解到Tomcat服务器在内部已经使用Endpoint类封装了Socket。
本篇会包含大量的源码解读说，由于篇幅原因，就将源码折叠起来，如果想了解其过程，简易打开折叠的源码看看。
猜想流程
在查看源码之前，建议大家自己想一想，如果是你来设计，会怎么处理请求。我先自己想了一下请求处理过程：
1） ServerSocket accept客户端的请求得到Socket对象，这一部分肯定要与Connector关联起来，因为只有Connector上配置了与TCP相关的东西，例如：port, protocol等。
2） Tomcat中的某个组件（在Connector范围内）解析Socket对象，封装成一个Request对象
3） Tomcat中某个组件（在Connector范围内）根据Request对象在服务器上找出于这个连接器关联的Container，也就是Engine。因为Connector和Engine都是Service范围内的，并且一个Service内可以有多个Connector，只能有一个Engine，所以在Connector确定的情况下，Engine就是确定的。接下来只需要找到所在的虚拟主机Host就行了。
4） 找到请求所属的主机Host，根据HTTP请求的URL就可以了。这是因为URL由遵循下面的结构：Protocol://host:port/context/path
5）找到请求所属的context，也就是说找到请求那个web app的。
6）根据请求的path部分找到所在的Web app的资源处理Servlet
因为在web.xml中配置了Servlet的url-pattern，也就是那个Servlet处理哪些路径下的资源请求。
7）如果有filter，先filter处理。
8）调用Servlet#doService()方法。这是在做Java Web开发时了解到的。然后根据请求的method（GET、POST、PUT等），自动的解析为doXxx（doGet, doPost）
简易类图
在了解这一部分前，我简单的看了一下源码，做了一个简单的类图：
接下来，就通过调试说明这个处理过程：
调试前，先看看系统中已有的线程：
从这个线程列表里可以看出来，这些线程都是各个Endpoint内部的属性（Acceptor、CometPoller、Poller）的线程。所以我们发送的请求肯定是这几类线程中的一个来处理的。
真实流程解读
1）使用AprEndpoint$Acceptor#run()来接收TCP连接
通过类图知道，在AprEndpoint内部有很多的Acceptor，应该是用于接收不同端口的TCP连接的吧。
猜想不能解决问题，经过调试，确实发现这里开始接收TCP连接请求了：
public void run() { // Loop until we receive a shutdown command while (running) { // Loop if endpoint is paused while (paused && running) { try { Thread.sleep(1000); } catch (InterruptedException e) { // Ignore } } if (!running) { break; } try { // Accept the next incoming connection from the server socket long socket = Socket.accept(serverSock); /* * In the case of a deferred accept unlockAccept needs to * send data. This data will be rubbish, so destroy the * socket and don‘t process it. */ if (deferAccept && (paused || !running)) { destroySocket(socket); continue; } // Hand this socket off to an appropriate processor if (!processSocketWithOptions(socket)) { // Close socket and pool right away destroySocket(socket); } } catch (Throwable t) { if (running) { String msg = sm.getString("endpoint.accept.fail"); if (t instanceof Error) { Error e = (Error) t; if (e.getError() == 233) { // Not an error on HP-UX so log as a warning // so it can be filtered out on that platform // See bug 50273 log.warn(msg, t); } else { log.error(msg, t); } } else { log.error(msg, t); } } } // The processor will recycle itself when it finishes } }
这里附加一些Java的基本知识：它只用接收请求就行了，别的什么也不用做。
它并没有拿到一个Socket，也没有将socket传递给其他的类，但是却能够完成请求的处理，这是为什么呢？
上面的代码中Socket.acccpt(serverSocket)，就是接收一个Socket请求，标示是serverSocket 。
因为使用了内部类，这样的好处是内部类方法和属性对于外部类是可见的，外部类的方法属性对内部类也是可见的。其实内部类的方法可以认为是对于外部类的扩充，只是在其他的类中不能使用这些方法而已，只能在外部类，内部类本身里使用而已（当然了，如果内部类是public，方法也是public情况下，第三方类还是可以使用的）。
2）使用AprEndpoint$Worker#run()来做启动TCP连接处理流程
public void run() { // Process requests until we receive a shutdown signal while (running) { // Wait for the next socket to be assigned// 拿到Acceptor接收到的请求 long socket = await(); if (socket == 0) continue; if (!deferAccept && options) { if (setSocketOptions(socket)) { getPoller().add(socket); } else { // Close socket and pool destroySocket(socket); socket = 0; } } else { // Process the request from this socket if ((status != null) && (handler.event(socket, status) == Handler.SocketState.CLOSED)) { // Close socket and pool destroySocket(socket); socket = 0;// 调用Handler.process处理Socket// 在Handler对象内部，会找到一个HTTP11AprProcessor处理器，用于处理Socket请求// 然后在HTTP11AprProcessor处理过程中，又会转给 } else if ((status == null) && ((options && !setSocketOptions(socket)) || handler.process(socket) == Handler.SocketState.CLOSED)) { // Close socket and pool destroySocket(socket); socket = 0; } } // Finish up this request recycleWorkerThread(this); } }
3）根据Socket解析HTTP Header封装成Request
由于方法比较长，就不粘了，只粘出主要代码：
inputBuffer.setSocket(socket);inputBuffer.parseHeaders();而inputBuffer#parseHeader():
/** * Parse the HTTP headers. */ public void parseHeaders() throws IOException {// 每一次调用parseHeader()，就是解析HTTP Header中的一条。 这个是基于HTTP Header的格式来解析的，这个不明白，可以先了解一下HTTP协议while (parseHeader()) { } parsingHeader = false; end = pos; }
InputBuffer# parseHeader()，这个过程比较复杂，就不贴了。下面贴出来解析后的消息头：
4）根据消息头解析出Container相关信息
准备Request，其实就是做一些额外的处理，例如根据消息头解析host, port,context,path等等，将其封装为StandardContext对象，然后放在Request对象里。
5）调用adapter#service()，请求转给Container（Engine）
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 = (Request) connector.createRequest(); request.setCoyoteRequest(req); response = (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 comet = false; try { // Parse and set Catalina and configuration specific // request parameters req.getRequestProcessor().setWorkerThreadName(Thread.currentThread().getName()); if (postParseRequest(req, request, res, response)) { // Calling the container// 通过这一步，获取到与Connector关联的Container【也就是Engine】，如此就将流程转给了Tomcat容器处理了。//这也是这个CoyoteApapter的作用// 这里connector.getContainer()得到的是一个Engine// engine.getPipeline().getFirst()得到的其实是Engine的pipeliene中的一个StandardEngineValue。Tomcat中的Value是用于执行一些任务的。至于为什么起名为Value，就不太清楚了。只需要知道这段代码执行的是StandardEngineValue#invoke()就可以了。 connector.getContainer().getPipeline().getFirst().invoke(request, response); if (request.isComet()) { if (!response.isClosed() && !response.isError()) { if (request.getAvailable() || (request.getContentLength() > 0 && (!request.isParametersParsed()))) { // Invoke a read event right away if there are available bytes if (event(req, res, SocketStatus.OPEN)) { comet = true; res.action(ActionCode.ACTION_COMET_BEGIN, null); } } else { comet = true; res.action(ActionCode.ACTION_COMET_BEGIN, null); } } else { // Clear the filter chain, as otherwise it will not be reset elsewhere // since this is a Comet request request.setFilterChain(null); } } } if (!comet) { response.finishResponse(); req.action(ActionCode.ACTION_POST_REQUEST , null); } } catch (IOException e) { ; } finally { req.getRequestProcessor().setWorkerThreadName(null); // Recycle the wrapper request and response if (!comet) { request.recycle(); response.recycle(); } else { // Clear converters so that the minimum amount of memory // is used by this processor request.clearEncoders(); response.clearEncoders(); } } }
6）在Engine》Host》Context之间通过Pipeline传递请求
6.1）StandarEngineValue#invoke()从将Request转给Host处理
下面是StandardEngineValue#invoke()的源码：
/** * Select the appropriate child Host to process this request, * based on the requested server name. If no matching Host can * be found, return an appropriate HTTP error. * */ 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) { response.sendError (HttpServletResponse.SC_BAD_REQUEST, sm.getString("standardEngine.noHost", request.getServerName())); return; } // Ask this Host to process this request// 这个设计与之前的设计思路是一致的，调用的是StandardHostValue#invoke() host.getPipeline().getFirst().invoke(request, response); }
从invoke方法的注释就可以知道，是要从engine范围内，根据第3）步找到的HOST信息，将请求交给host处理。
6.2）StandardHostValue#invoke()将Request转给Context处理
这一步与上面是类似的，将请求交给了StandardContextValue处理。
/** * Select the appropriate child Context to process this request, * based on the specified request URI. If no matching Context can * be found, return an appropriate HTTP error. */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; } // Bind the context CL to the current thread if( context.getLoader() != null ) { // Not started - it should check for availability first // This should eventually move to Engine, it‘s generic. Thread.currentThread().setContextClassLoader (context.getLoader().getClassLoader()); } // Ask this Context to process this request context.getPipeline().getFirst().invoke(request, response); // Access a session (if present) to update last accessed time, based on a // strict interpretation of the specification if (Globals.STRICT_SERVLET_COMPLIANCE) { request.getSession(false); } // Error page processing response.setSuspended(false); Throwable t = (Throwable) request.getAttribute(Globals.EXCEPTION_ATTR); if (t != null) { throwable(request, response, t); } else { status(request, response); } // Restore the context classloader Thread.currentThread().setContextClassLoader (StandardHostValve.class.getClassLoader()); }
至此，请求终于到达处理它的WEB应用程序了。
7）启动监听器处理，接着在Context找到Wrapper，让Wrapper处理
/** * Select the appropriate child Wrapper to process this request, * based on the specified request URI. If no matching Wrapper can * be found, return an appropriate HTTP error. * * @param request Request to be processed * @param response Response to be produced * @param valveContext Valve context used to forward to the next Valve * * @exception IOException if an input/output error occurred * @exception ServletException if a servlet error occurred */ public final void invoke(Request request, Response response) throws IOException, ServletException { // Disallow any direct access to resources under WEB-INF or META-INF// META-INF 和WEB-INF目录是应用程序内部的专属空间，是不允许直接这两个目录下的内容的。所以如果你的请求URL上包含着两个目录，都不会被处理。// 在应用程序内部，例如Servlet里，可以处理这两个目录下的文件。譬如JSP文件放在WEB-INF目录下，直接访问是不可见的，但是通过Servlet进行forward就可以。但是这都是请求到达Servlet之后的事了，现在请求还没到Servlet呢，别急。 MessageBytes requestPathMB = request.getRequestPathMB(); if ((requestPathMB.startsWithIgnoreCase("/META-INF/", 0)) || (requestPathMB.equalsIgnoreCase("/META-INF")) || (requestPathMB.startsWithIgnoreCase("/WEB-INF/", 0)) || (requestPathMB.equalsIgnoreCase("/WEB-INF"))) { notFound(response); return; } // Wait if we are reloading// 软重启应用程序，前提是Web应用程序下有资源改变，一般情况下，不会重启的。 boolean reloaded = false; while (context.getPaused()) { reloaded = true; try { Thread.sleep(1000); } catch (InterruptedException e) { ; } } // Reloading will have stopped the old webappclassloader and // created a new one// 要是重启过，就得重新设置类加载器 if (reloaded && context.getLoader() != null && context.getLoader().getClassLoader() != null) { Thread.currentThread().setContextClassLoader( context.getLoader().getClassLoader()); } // Select the Wrapper to be used for this Request Wrapper wrapper = request.getWrapper(); if (wrapper == null) { notFound(response); return; } else if (wrapper.isUnavailable()) { // May be as a result of a reload, try and find the new wrapper wrapper = (Wrapper) container.findChild(wrapper.getName()); if (wrapper == null) { notFound(response); return; } } // Normal request processing// 取得所有的监听器，这些监听器都是我们在web.xml中配置的（有ServletContext(application)、Session、Request 级别的监听器）不管属于哪个级别的，全部查出来。 Object instances[] = context.getApplicationEventListeners(); ServletRequestEvent event = null; if ((instances != null) && (instances.length > 0)) {// 封装一个request级别的Event event = new ServletRequestEvent (((StandardContext) container).getServletContext(), request.getRequest()); // create pre-service event// 轮询前面取到所有的listener，处理RequestListener for (int i = 0; i < instances.length; i++) { if (instances[i] == null) continue; if (!(instances[i] instanceof ServletRequestListener)) continue; ServletRequestListener listener = (ServletRequestListener) instances[i]; try {// listener处理 listener.requestInitialized(event); } catch (Throwable t) { container.getLogger().error(sm.getString("standardContext.requestListener.requestInit", instances[i].getClass().getName()), t); ServletRequest sreq = request.getRequest(); sreq.setAttribute(Globals.EXCEPTION_ATTR,t); return; } } }// 同之前的设计一样，找到StandardWrapperValue，处理Request wrapper.getPipeline().getFirst().invoke(request, response); // 监听器结束生命周期 if ((instances !=null ) && (instances.length > 0)) { // create post-service event for (int i = 0; i < instances.length; i++) { if (instances[i] == null) continue; if (!(instances[i] instanceof ServletRequestListener)) continue; ServletRequestListener listener = (ServletRequestListener) instances[i]; try { listener.requestDestroyed(event); } catch (Throwable t) { container.getLogger().error(sm.getString("standardContext.requestListener.requestDestroy", instances[i].getClass().getName()), t); ServletRequest sreq = request.getRequest(); sreq.setAttribute(Globals.EXCEPTION_ATTR,t); } } } }
8）Servlet处理请求
请求并不是直接就让Servlet处理的，这点做过Web开发的人都知道，至少中间还有个Filter要处理吧。
下面是StandardWrapperValue#invoke()的源码，就来了解一下它是咋处理的。
这点代码包含了很多内容，解析来会一一说明：
/** * Invoke the servlet we are managing, respecting the rules regarding * servlet lifecycle and SingleThreadModel support. * */ 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++; StandardWrapper wrapper = (StandardWrapper) getContainer(); Servlet servlet = null; Context context = (Context) wrapper.getParent(); // 检查context是否可用，就是检查web应用程序是否可用，因为可能出现应用程序挂了，或者软重启了 if (!context.getAvailable()) { response.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE, sm.getString("standardContext.isUnavailable")); unavailable = true; } // 检查要处理请求的Servlet是否可用，如果Servlet被删除，然后也重启Context了，servlet就没有了，所以又必要检查一下。 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; } // 分配一个Servlet对象来处理请求,下面8.1会详细说明如何分配的 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); servlet = null; } catch (Throwable e) { container.getLogger().error(sm.getString("standardWrapper.allocateException", wrapper.getName()), e); throwable = e; exception(request, response, e); servlet = null; } // Identify if the request is Comet related now that the servlet has been allocated boolean comet = false; if (servlet instanceof CometProcessor && request.getAttribute("org.apache.tomcat.comet.support") == Boolean.TRUE) { comet = true; request.setComet(true); } // 告诉Connector：已经拿到处理的Servlet了。 try { response.sendAcknowledgement(); } catch (IOException e) { request.removeAttribute(Globals.JSP_FILE_ATTR); container.getLogger().warn(sm.getString("standardWrapper.acknowledgeException", wrapper.getName()), e); throwable = e; exception(request, response, e); } catch (Throwable e) { container.getLogger().error(sm.getString("standardWrapper.acknowledgeException", wrapper.getName()), e); throwable = e; exception(request, response, e); servlet = null; } MessageBytes requestPathMB = null; if (request != null) { requestPathMB = request.getRequestPathMB(); } request.setAttribute (ApplicationFilterFactory.DISPATCHER_TYPE_ATTR, ApplicationFilterFactory.REQUEST_INTEGER); request.setAttribute (ApplicationFilterFactory.DISPATCHER_REQUEST_PATH_ATTR, requestPathMB); // 为request创建Filter链，是创建，是为每一个请求创建过滤器链，不是获取已有的。 ApplicationFilterFactory factory = ApplicationFilterFactory.getInstance(); ApplicationFilterChain filterChain = factory.createFilterChain(request, wrapper, servlet); // Reset comet flag value after creating the filter chain request.setComet(false); //调用filter chain处理请求，这个过程我还有一篇文章专门讲述 try { String jspFile = wrapper.getJspFile(); if (jspFile != null) request.setAttribute(Globals.JSP_FILE_ATTR, jspFile); else request.removeAttribute(Globals.JSP_FILE_ATTR); if ((servlet != null) && (filterChain != null)) { // Swallow output if needed if (context.getSwallowOutput()) { try { SystemLogHandler.startCapture(); if (comet) { filterChain.doFilterEvent(request.getEvent()); request.setComet(true); } else { filterChain.doFilter(request.getRequest(), response.getResponse()); } } finally { String log = SystemLogHandler.stopCapture(); if (log != null && log.length() > 0) { context.getLogger().info(log); } } } else { if (comet) { request.setComet(true); filterChain.doFilterEvent(request.getEvent()); } else { filterChain.doFilter (request.getRequest(), response.getResponse()); } } } request.removeAttribute(Globals.JSP_FILE_ATTR); } catch (ClientAbortException e) { request.removeAttribute(Globals.JSP_FILE_ATTR); throwable = e; exception(request, response, e); } catch (IOException e) { request.removeAttribute(Globals.JSP_FILE_ATTR); container.getLogger().error(sm.getString("standardWrapper.serviceException", wrapper.getName()), e); throwable = e; exception(request, response, e); } catch (UnavailableException e) { request.removeAttribute(Globals.JSP_FILE_ATTR); container.getLogger().error(sm.getString("standardWrapper.serviceException", wrapper.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) { request.removeAttribute(Globals.JSP_FILE_ATTR); Throwable rootCause = StandardWrapper.getRootCause(e); if (!(rootCause instanceof ClientAbortException)) { container.getLogger().error(sm.getString("standardWrapper.serviceException", wrapper.getName()), rootCause); } throwable = e; exception(request, response, e); } catch (Throwable e) { request.removeAttribute(Globals.JSP_FILE_ATTR); container.getLogger().error(sm.getString("standardWrapper.serviceException", wrapper.getName()), e); throwable = e; exception(request, response, e); } // 释放过滤器链，此时Servlet已经执行完毕。 if (filterChain != null) { if (request.isComet()) { // If this is a Comet request, then the same chain will be used for the // processing of all subsequent events. filterChain.reuse(); } else { filterChain.release(); } } // 回收servlet try { if (servlet != null) { wrapper.deallocate(servlet); } } catch (Throwable e) { container.getLogger().error(sm.getString("standardWrapper.deallocateException", wrapper.getName()), e); if (throwable == null) { throwable = e; exception(request, response, e); } } // If this servlet has been marked permanently unavailable, // unload it and release this instance try { if ((servlet != null) && (wrapper.getAvailable() == Long.MAX_VALUE)) { wrapper.unload(); } } catch (Throwable e) { container.getLogger().error(sm.getString("standardWrapper.unloadException", wrapper.getName()), e); if (throwable == null) { throwable = e; exception(request, response, e); } } long t2=System.currentTimeMillis(); long time=t2-t1; processingTime += time; if( time > maxTime) maxTime=time; if( time < minTime) minTime=time; }
8.1）分配Servlet
要让Servlet处理请求，得先分配Servlet，分配Servlet对象也是有讲究的，因为Servlet有两种运行模式，单线程运行模式和多线程运行模式。
public Servlet allocate() throws ServletException { // If we are currently unloading this servlet, throw an exception if (unloading) throw new ServletException (sm.getString("standardWrapper.unloading", getName())); boolean newInstance = false; // If not SingleThreadedModel, return the same instance every time if (!singleThreadModel) { // 如果是第一次请求这个Servlet，Servlet肯定还没有创建，这时就要创建一个Servlet实例，并初始化。这一点，我想有的面试官会问到的。 if (instance == null) { synchronized (this) { if (instance == null) { try { if (log.isDebugEnabled()) log.debug("Allocating non-STM instance");// loadServlet()过程也做了很多事：// 如果是jsp请求：解析JSP成一个Servlet类，编译，加载（解析，编译过程只在第一次请求该JSP文件时进行）// 如果是html，img,css，js等就返回DefaultServlet instance = loadServlet(); // For non-STM, increment here to prevent a race // condition with unload. Bug 43683, test case #3 if (!singleThreadModel) { newInstance = true; countAllocated.incrementAndGet(); } } catch (ServletException e) { throw e; } catch (Throwable e) { throw new ServletException (sm.getString("standardWrapper.allocate"), e); } } } }// 返回Servlet实例。 if (!singleThreadModel) { if (log.isTraceEnabled()) log.trace(" Returning non-STM instance"); // For new instances, count will have been incremented at the // time of creation if (!newInstance) { countAllocated.incrementAndGet(); } return (instance); } } // 要是单线程模式下运行的Sevlet，就得等Servlet执行完毕，被回收后，再分配给你这个请求 synchronized (instancePool) { while (countAllocated.get() >= nInstances) { // Allocate a new instance if possible, or else wait if (nInstances < maxInstances) { try { instancePool.push(loadServlet()); nInstances++; } catch (ServletException e) { throw e; } catch (Throwable e) { throw new ServletException (sm.getString("standardWrapper.allocate"), e); } } else { try { instancePool.wait(); } catch (InterruptedException e) { ; } } } if (log.isTraceEnabled()) log.trace(" Returning allocated STM instance"); countAllocated.incrementAndGet(); return (Servlet) instancePool.pop(); } }
8.2）过滤器链处理
参考博客：Filter
8.3）Servlet.service() ，Servlet执行
过滤器对象里有个属性就是servelt，在过滤器链处理完毕，就直接调用了Servlet了。
官方的说法
官方说法中前三步中涉及到的类，可能有我调试时不同，这是因为采用的协议不同，协议不同，与protocol相关的processor也就不同。但是整个流程就是这个样子的。
Tomcat源码解读：我们发起的HTTP请求如何到达Servlet的
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。