Tomcat卷二---请求流程源码分析

转x33g5p2x  于2022-02-07 转载在 其他  
字(20.3k)|赞(0)|评价(0)|浏览(455)

Tomcat 请求处理流程

请求流程

设计了这么多层次的容器，Tomcat是怎么确定每一个请求应该由哪个Wrapper容器里的 Servlet来处理的呢？

答案是，Tomcat是用Mapper组件来完成这个任务的。

Mapper组件的功能就是将用户请求的URL定位到一个Servlet，它的工作原理是：

Mapper组件里保存了Web应用的配置信息，其实就是容器组件与访问路径的映射关系， 比如Host容器里配置的域名、Context容器里的Web应用路径，以及Wrapper容器里 Servlet映射的路径，你可以想象这些配置信息就是一个多层次的Map。

当一个请求到来时，Mapper组件通过解析请求URL里的域名和路径，再到自己保存的 Map里去查找，就能定位到一个Servlet。请你注意，一个请求URL最后只会定位到一个 Wrapper容器，也就是一个Servlet。

下面的示意图中 ， 就描述了 当用户请求链接 http://www.itcast.cn/bbs/findAll 之 后, 是如何找到最终处理业务逻辑的servlet 。

那上面这幅图只是描述了根据请求的URL如何查找到需要执行的Servlet ， 那么下面我们 再来解析一下 ， 从Tomcat的设计架构层面来分析Tomcat的请求处理

步骤如下:

  1. Connector组件Endpoint中的Acceptor监听客户端套接字连接并接收Socket。
  2. 将连接交给线程池Executor处理，开始执行请求响应任务。
  3. Processor组件读取消息报文，解析请求行、请求体、请求头，封装成Request对象。
  4. Mapper组件根据请求行的URL值和请求头的Host值匹配由哪个Host容器、Context容器、Wrapper容器处理请求。
  5. CoyoteAdaptor组件负责将Connector组件和Engine容器关联起来，把生成的 Request对象和响应对象Response传递到Engine容器中，调用 Pipeline。
  6. Engine容器的管道开始处理，管道中包含若干个Valve、每个Valve负责部分处理逻 辑。执行完Valve后会执行基础的 Valve–StandardEngineValve，负责调用Host容器的 Pipeline。
  7. Host容器的管道开始处理，流程类似，最后执行 Context容器的Pipeline。
  8. Context容器的管道开始处理，流程类似，最后执行 Wrapper容器的Pipeline。
  9. Wrapper容器的管道开始处理，流程类似，最后执行 Wrapper容器对应的Servlet对象 的 处理方法。

请求流程源码解析

在前面所讲解的Tomcat的整体架构中，我们发现Tomcat中的各个组件各司其职，组件 之间松耦合，确保了整体架构的可伸缩性和可拓展性，那么在组件内部，如何增强组件 的灵活性和拓展性呢？ 在Tomcat中，每个Container组件采用责任链模式来完成具体的 请求处理。

在Tomcat中定义了Pipeline 和 Valve 两个接口，Pipeline 用于构建责任链， 后者代表责 任链上的每个处理器。Pipeline 中维护了一个基础的Valve，它始终位于Pipeline的末端 （最后执行），封装了具体的请求处理和输出响应的过程。当然，我们也可以调用 addValve()方法， 为Pipeline 添加其他的Valve， 后添加的Valve 位于基础的Valve之 前，并按照添加顺序执行。Pipiline通过获得首个Valve来启动整合链条的执行 。

源码研究

建议看源码流程前先去回顾一下责任链模式，因为tomcat的请求流程中主要使用了责任链模式

责任链模式

我们把请求过程的源码分为两部分来进行分析:
第一部分: 请求由Endpoint捕获,并转交给Processor处理.

1.Acceptor.run()

请求的流程由NioEndpoint中的Accepter类的run方法开始.

首先一个浏览器的请求会由tomcat中的Endpoint中的Accepter所捕获并开启会话.

  1. protected class Acceptor extends AbstractEndpoint.Acceptor {
  2.  
  3.         @Override
  4.         public void run() {
  5.             int errorDelay = 0;
  6.             while (running) {
  7.                 while (paused && running) {
  8.                     state = AcceptorState.PAUSED;
  9.                     try {
  10.                         Thread.sleep(50);
  11.                     } catch (InterruptedException e) {
  12.                         // Ignore
  13.                     }
  14.                 }
  15.                 if (!running) {
  16.                     break;
  17.                 }
  18.                 state = AcceptorState.RUNNING;
  19.                 try {
  20.                     //if we have reached max connections, wait
  21.                     countUpOrAwaitConnection();
  22.                     SocketChannel socket = null;
  23.                     try {
  24.                         //接受客户端请求
  25.                         socket = serverSock.accept();
  26.                     } catch (IOException ioe) {
  27.                         // We didn't get a socket
  28.                         countDownConnection();
  29.                         if (running) {
  30.                             // Introduce delay if necessary
  31.                             errorDelay = handleExceptionWithDelay(errorDelay);
  32.                             // re-throw
  33.                             throw ioe;
  34.                         } else {
  35.                             break;
  36.                         }
  37.                     }
  38.                     // Successful accept, reset the error delay
  39.                     errorDelay = 0;
  40.  
  41.                     // Configure the socket
  42.                     if (running && !paused) {
  43.                         // setSocketOptions() will hand the socket off to
  44.                         // an appropriate processor if successful
  45.                         if (!setSocketOptions(socket)) {
  46.                             closeSocket(socket);
  47.                         }
  48.                     } else {
  49.                         closeSocket(socket);
  50.                     }
  51.                 } catch (Throwable t) {
  52.                     ExceptionUtils.handleThrowable(t);
  53.                     log.error(sm.getString("endpoint.accept.fail"), t);
  54.                 }
  55.             }
  56.             state = AcceptorState.ENDED;
  57.         }

2.Poller.run()

当接收客户端请求时,NioEndpoint.Poller会获取事件并开始迭代执行.(一下省略部分代码)

  1. public void run() {
  2.             
  3.             while (true) {
  4.                 .......
  5.                 while (iterator != null && iterator.hasNext()) {
  6.                     SelectionKey sk = iterator.next();
  7.                     NioSocketWrapper attachment = (NioSocketWrapper)sk.attachment();
  8.                     // Attachment may be null if another thread has called
  9.                     // cancelledKey()
  10.                     if (attachment == null) {
  11.                         iterator.remove();
  12.                     } else {
  13.                         iterator.remove();
  14.                         //开始正式执行请求流程
  15.                         processKey(sk, attachment);
  16.                     }
  17.                 }//while
  18.  
  19.                 //process timeouts
  20.                 timeout(keyCount,hasEvents);
  21.             }//while
  22.  
  23.             getStopLatch().countDown();
  24.         }
2.1 Poller.processKey()

processKey方法继续调用其中的processSocket方法,并开始处理会话.

  1. protected void processKey(SelectionKey sk, NioSocketWrapper attachment) {
  2.             try {
  3.                 if ( close ) {
  4.                     cancelledKey(sk);
  5.                 } else if ( sk.isValid() && attachment != null ) {
  6.                     if (sk.isReadable() || sk.isWritable() ) {
  7.                         if ( attachment.getSendfileData() != null ) {
  8.                             processSendfile(sk,attachment, false);
  9.                         } else {
  10.                             unreg(sk, attachment, sk.readyOps());
  11.                             boolean closeSocket = false;
  12.                             // Read goes before write
  13.                             if (sk.isReadable()) {
  14.                                 //开始处理会话
  15.                                 if (!processSocket(attachment, SocketEvent.OPEN_READ, true)) {
  16.                                     closeSocket = true;
  17.                                 }
  18.                             }
  19.                             if (!closeSocket && sk.isWritable()) {
  20.                                 if (!processSocket(attachment, SocketEvent.OPEN_WRITE, true)) {
  21.                                     closeSocket = true;
  22.                                 }
  23.                             }
  24.                             if (closeSocket) {
  25.                                 cancelledKey(sk);
  26.                             }
  27.                         }
  28.                     }
  29.                 } else {
  30.                     //invalid key
  31.                     cancelledKey(sk);
  32.                 }
  33.             } catch ( CancelledKeyException ckx ) {
  34.                 cancelledKey(sk);
  35.             } catch (Throwable t) {
  36.                 ExceptionUtils.handleThrowable(t);
  37.                 log.error("",t);
  38.             }
  39.         }
2.2 AbstractEndpoint.processSocket()

当跟踪进processSocket时会发现调用的是AbstractEndpoint的processSocket方法.

他会首先获取Socket的处理器,并获取线程池为处理Socket单独开启一个线程.

  1. public boolean processSocket(SocketWrapperBase<S> socketWrapper,
  2.             SocketEvent event, boolean dispatch) {
  3.         try {
  4.             if (socketWrapper == null) {
  5.                 return false;
  6.             }
  7.             //获取socket的处理器
  8.             SocketProcessorBase<S> sc = processorCache.pop();
  9.             if (sc == null) {
  10.                 sc = createSocketProcessor(socketWrapper, event);
  11.             } else {
  12.                 sc.reset(socketWrapper, event);
  13.             }
  14.             //获取到线程池
  15.             Executor executor = getExecutor();
  16.             if (dispatch && executor != null) {
  17.                 //由线程池调用一个线程来执行Socket处理器
  18.                 executor.execute(sc);
  19.             } else {
  20.                 sc.run();
  21.             }
  22.         } catch (RejectedExecutionException ree) {
  23.             getLog().warn(sm.getString("endpoint.executor.fail", socketWrapper) , ree);
  24.             return false;
  25.         } catch (Throwable t) {
  26.             ExceptionUtils.handleThrowable(t);
  27.             // This means we got an OOM or similar creating a thread, or that
  28.             // the pool and its queue are full
  29.             getLog().error(sm.getString("endpoint.process.fail"), t);
  30.             return false;
  31.         }
  32.         return true;
  33.     }

3. NioEndpoint.SocketProcessor.doRun()

经过跟踪会最终发现,sc.run()方法实际上是在调用NioEndpoint.SocketProcessor.doRun();

  1. protected void doRun() {
  2.             NioChannel socket = socketWrapper.getSocket();
  3.             SelectionKey key = socket.getIOChannel().keyFor(socket.getPoller().getSelector());
  4.  
  5.             ....
  6.                 if (handshake == 0) {
  7.                     SocketState state = SocketState.OPEN;
  8.                     // Process the request from this socket
  9.                     if (event == null) {
  10.                         //获取Handler处理器:Servlet(处理器),调度处理器的处理方法
  11.                         state = getHandler().process(socketWrapper, SocketEvent.OPEN_READ);
  12.                     } else {
  13.                         state = getHandler().process(socketWrapper, event);
  14.                     }
  15.                     if (state == SocketState.CLOSED) {
  16.                         close(socket, key);
  17.                     }
  18.                 } 
  19.               ....
  20.         }
  21.     }

4. AbstractProtocol.ConnectionHandler.process

在doRun的方法中最后会交给AbstractProtocol.ConnectionHandler.process方法执行.

  1. @Override
  2.         public SocketState process(SocketWrapperBase<S> wrapper, SocketEvent status) {
  3.             if (getLog().isDebugEnabled()) {
  4.                 getLog().debug(sm.getString("abstractConnectionHandler.process",
  5.                         wrapper.getSocket(), status));
  6.             }
  7.             if (wrapper == null) {
  8.                 // Nothing to do. Socket has been closed.
  9.                 return SocketState.CLOSED;
  10.             }
  11.  
  12.             //获取Socket
  13.             S socket = wrapper.getSocket();
  14.             //交给Processor处理 -> 真正开始处理请求
  15.             Processor processor = connections.get(socket);
  16.             ....
  17.              do {
  18.                     //开始解析请求
  19.                     state = processor.process(wrapper, status);
  20.  
  21.                     .....
  22.                     }
  23.                 } while ( state == SocketState.UPGRADING);
  24. }

至此,请求由Endpoint组件正式转交给Processor进行处理.

主要内容为在请求转交给Coyote适配器后的流程分析,紧接上文中请求交由Processor处理.

5.AbstractProcessorLight.process()

当请求由Endpoint交由Processor处理时,首先经过的就是AbstractProcessorLight.process()

  1. public SocketState process(SocketWrapperBase<?> socketWrapper, SocketEvent status)
  2.             throws IOException {
  3.  
  4.         SocketState state = SocketState.CLOSED;
  5.         Iterator<DispatchType> dispatches = null;
  6.         do {
  7.             if (dispatches != null) {
  8.                 DispatchType nextDispatch = dispatches.next();
  9.                 if (getLog().isDebugEnabled()) {
  10.                     getLog().debug("Processing dispatch type: [" + nextDispatch + "]");
  11.                 }
  12.                 state = dispatch(nextDispatch.getSocketStatus());
  13.                 if (!dispatches.hasNext()) {
  14.                     state = checkForPipelinedData(state, socketWrapper);
  15.                 }
  16.             } else if (status == SocketEvent.DISCONNECT) {
  17.             } else if (isAsync() || isUpgrade() || state == SocketState.ASYNC_END) {
  18.                 state = dispatch(status);
  19.                 state = checkForPipelinedData(state, socketWrapper);
  20.             } else if (status == SocketEvent.OPEN_WRITE) {
  21.                 // Extra write event likely after async, ignore
  22.                 state = SocketState.LONG;
  23.             } else if (status == SocketEvent.OPEN_READ) {
  24.                 //调度Http11Processor.service方法
  25.                 state = service(socketWrapper);
  26.             } else if (status == SocketEvent.CONNECT_FAIL) {
  27.                 logAccess(socketWrapper);
  28.             } else {
  29.                 state = SocketState.CLOSED;
  30.             }
  31.  
  32.             ....
  33.             }
  34.         } while (state == SocketState.ASYNC_END ||
  35.                 dispatches != null && state != SocketState.CLOSED);
  36.  
  37.         return state;
  38.     }

6.Http11Processor的service方法

  1. @Override
  2.     public SocketState service(SocketWrapperBase<?> socketWrapper)
  3.         
  4.           ....    
  5.         while (!getErrorState().isError() && keepAlive && !isAsync() && upgradeToken == null &&
  6.                 sendfileState == SendfileState.DONE && !endpoint.isPaused()) {
  8.             // Parsing the request header
  9.             try {
  10.             //解析socket请求数据中每一行,按照http协议解析请求头----只负责解析请求头
  11.                 if (!inputBuffer.parseRequestLine(keptAlive)) {
  12.                     if (inputBuffer.getParsingRequestLinePhase() == -1) {
  13.                         return SocketState.UPGRADING;
  14.                     } else if (handleIncompleteRequestLineRead()) {
  15.                         break;
  16.                     }
  17.                 }
  19.                 if (endpoint.isPaused()) {
  20.                     // 503 - Service unavailable
  21.                     response.setStatus(503);
  22.                     setErrorState(ErrorState.CLOSE_CLEAN, null);
  23.                 } else {
  24.                     keptAlive = true;
  25.                     // Set this every time in case limit has been changed via JMX
  26.                     request.getMimeHeaders().setLimit(endpoint.getMaxHeaderCount());
  27.                     if (!inputBuffer.parseHeaders()) {
  28.                         // We've read part of the request, don't recycle it
  29.                         // instead associate it with the socket
  30.                         openSocket = true;
  31.                         readComplete = false;
  32.                         break;
  33.                     }
  34.                     if (!disableUploadTimeout) {
  35.                         socketWrapper.setReadTimeout(connectionUploadTimeout);
  36.                     }
  37.                 }
  38.             } catch (IOException e) {
  39.                 if (log.isDebugEnabled()) {
  40.                     log.debug(sm.getString("http11processor.header.parse"), e);
  41.                 }
  42.                 setErrorState(ErrorState.CLOSE_CONNECTION_NOW, e);
  43.                 break;
  44.             } catch (Throwable t) {
  45.                    ....
  46.                 }
  47.                 // 400 - Bad Request
  48.                 response.setStatus(400);
  49.                 setErrorState(ErrorState.CLOSE_CLEAN, t);
  50.             }
  52.             // Has an upgrade been requested?
  53.             Enumeration<String> connectionValues = request.getMimeHeaders().values("Connection");
  54.             boolean foundUpgrade = false;
  55.             while (connectionValues.hasMoreElements() && !foundUpgrade) {
  56.                 foundUpgrade = connectionValues.nextElement().toLowerCase(
  57.                         Locale.ENGLISH).contains("upgrade");
  58.             }
  60.             if (foundUpgrade) {
  61.                 // Check the protocol
  62.                 String requestedProtocol = request.getHeader("Upgrade");
  64.                 UpgradeProtocol upgradeProtocol = httpUpgradeProtocols.get(requestedProtocol);
  65.                 if (upgradeProtocol != null) {
  66.                     if (upgradeProtocol.accept(request)) {
  67.                         // TODO Figure out how to handle request bodies at this
  68.                         // point.
  69.                         response.setStatus(HttpServletResponse.SC_SWITCHING_PROTOCOLS);
  70.                         response.setHeader("Connection", "Upgrade");
  71.                         response.setHeader("Upgrade", requestedProtocol);
  72.                         action(ActionCode.CLOSE,  null);
  73.                         getAdapter().log(request, response, 0);
  75.                         InternalHttpUpgradeHandler upgradeHandler =
  76.                                 upgradeProtocol.getInternalUpgradeHandler(
  77.                                         getAdapter(), cloneRequest(request));
  78.                         UpgradeToken upgradeToken = new UpgradeToken(upgradeHandler, null, null);
  79.                         action(ActionCode.UPGRADE, upgradeToken);
  80.                         return SocketState.UPGRADING;
  81.                     }
  82.                 }
  83.             }
  85.             if (getErrorState().isIoAllowed()) {
  86.                 // Setting up filters, and parse some request headers
  87.                 rp.setStage(org.apache.coyote.Constants.STAGE_PREPARE);
  88.                 try {
  89.                 //After reading the request headers, we have to setup the request filters.
  90.                     prepareRequest();
  91.                 } catch (Throwable t) {
  92.                     ExceptionUtils.handleThrowable(t);
  93.                     if (log.isDebugEnabled()) {
  94.                         log.debug(sm.getString("http11processor.request.prepare"), t);
  95.                     }
  96.                     // 500 - Internal Server Error
  97.                     response.setStatus(500);
  98.                     setErrorState(ErrorState.CLOSE_CLEAN, t);
  99.                 }
  100.             }
  101.               ...
  102.             // Process the request in the adapter
  103.             if (getErrorState().isIoAllowed()) {
  104.                 try {
  105.                     rp.setStage(org.apache.coyote.Constants.STAGE_SERVICE);
  106.                     //将上面socket请求封装而成的request和response对象，再交给适配器进行处理
  107.                   //获取Coyote适配器,并调用其service方法
  108.                     getAdapter().service(request, response);
  109.                     ...

7.CoyoteAdapter.service()

至此请求就即将被发送给Engine引擎.

在CoyoteAdapter中将Request和Response装换成Servlet容器中处理的Request和Response，然后从service中获取容器，再调用管道Pipeline的阀门Valve的invoke方法

在Coyote适配器中,会获取Engine容器的第一个Valve,即StandardEngineValve,并执行.

  1. @Override
  2.     public void service(org.apache.coyote.Request req, org.apache.coyote.Response res)
  3.             throws Exception {
  5.         Request request = (Request) req.getNote(ADAPTER_NOTES);
  6.         Response response = (Response) res.getNote(ADAPTER_NOTES);
  7.          
  8.          .......   
  9.          
  10.         if (connector.getXpoweredBy()) {
  11.             response.addHeader("X-Powered-By", POWERED_BY);
  12.         }
  14.         boolean async = false;
  15.         boolean postParseSuccess = false;
  17.         req.getRequestProcessor().setWorkerThreadName(THREAD_NAME.get());
  19.         try {
  20.             // Parse and set Catalina and configuration specific
  21.             // request parameters
  22.             //解析和设置 Catalina 和特定配置,包括session的查找
  23.             //在这里将Request和Response装换成Servlet容器中处理的Request和Response
  24.             postParseSuccess = postParseRequest(req, request, res, response);
  25.             if (postParseSuccess) {
  26.                 //check valves if we support async
  27.                 request.setAsyncSupported(
  28.                         connector.getService().getContainer().getPipeline().isAsyncSupported());
  29.                 // Calling the container
  30.                 //获取Engine容器的第一个Valve,即StandardEngineValve,并执行.
  31.                 connector.getService().getContainer().getPipeline().getFirst().invoke(
  32.                         request, response);
  33.             }
  34.             .......

整个容器中执行的链路如图：

8.StandardEngineValve#invoke

因为这里默认只有一个标准的Engine value实现:

  1. @Override
  2.     public final void invoke(Request request, Response response)
  3.         throws IOException, ServletException {
  5.         // Select the Host to be used for this Request
  6.         Host host = request.getHost();
  7.         if (host == null) {
  8.             response.sendError
  9.                 (HttpServletResponse.SC_BAD_REQUEST,
  10.                  sm.getString("standardEngine.noHost",
  11.                               request.getServerName()));
  12.             return;
  13.         }
  14.         if (request.isAsyncSupported()) {
  15.             request.setAsyncSupported(host.getPipeline().isAsyncSupported());
  16.         }
  18.         // Ask this Host to process this request
  19.         //这里调用Host管道中的每个pipeline
  20.         host.getPipeline().getFirst().invoke(request, response);
  22.     }
9.StandardHostValve#invoke

说明一下:在Host管道中,默认还会加入两个Value，一个是accessLogValue，一个是errorLogValue后者用来处理请求处理过程中发生的错误

接下来依次调用context,wrapper的valve并执行.

10.StandardContextValve#invoke

获取当前请求对应的wrapper

  1. // Select the Wrapper to be used for this Request
  2.         Wrapper wrapper = request.getWrapper();

调用wrapper管道中所有value

  1. wrapper.getPipeline().getFirst().invoke(request, response);
10.StandardWrapperValve#invoke

重点代码一:分配一个servlet实例对象，来处理当前请求，这里的servlet其实就是我们自己定义的

  1. // Allocate a servlet instance to process this request
  2.         try {
  3.             if (!unavailable) {
  4.                 servlet = wrapper.allocate();
  5.             }

这里的allocate就是从mapped中获取到当前请求映射的servlet，联系初始化时,扫描web.xml和相关注解

  1. // Create the filter chain for this request
  2.         ApplicationFilterChain filterChain =
  3.                 ApplicationFilterFactory.createFilterChain(request, wrapper, servlet);

给当前请求创建一个过滤器链

  1. /**
  2.      * Construct a FilterChain implementation that will wrap the execution of
  3.      * the specified servlet instance.
  4.      *
  5.      * @param request The servlet request we are processing
  6.      * @param wrapper The wrapper managing the servlet instance
  7.      * @param servlet The servlet instance to be wrapped
  8.      *
  9.      * @return The configured FilterChain instance or null if none is to be
  10.      *         executed.
  11.      */
  12.     public static ApplicationFilterChain createFilterChain(ServletRequest request,
  13.             Wrapper wrapper, Servlet servlet) {
  15.         // If there is no servlet to execute, return null
  16.         if (servlet == null)
  17.             return null;
  19.         // Create and initialize a filter chain object
  20.         ApplicationFilterChain filterChain = null;
  21.         if (request instanceof Request) {
  22.             Request req = (Request) request;
  23.             if (Globals.IS_SECURITY_ENABLED) {
  24.                 // Security: Do not recycle
  25.                 filterChain = new ApplicationFilterChain();
  26.             } else {
  27.                 filterChain = (ApplicationFilterChain) req.getFilterChain();
  28.                 if (filterChain == null) {
  29.                     filterChain = new ApplicationFilterChain();
  30.                     req.setFilterChain(filterChain);
  31.                 }
  32.             }
  33.         } else {
  34.             // Request dispatcher in use
  35.             filterChain = new ApplicationFilterChain();
  36.         }
  38.         filterChain.setServlet(servlet);
  39.         filterChain.setServletSupportsAsync(wrapper.isAsyncSupported());
  41.         // Acquire the filter mappings for this Context
  42.         StandardContext context = (StandardContext) wrapper.getParent();
  43.         //wrapper的父容器context中的过滤器集合
  44.         FilterMap filterMaps[] = context.findFilterMaps();
  46.         // If there are no filter mappings, we are done
  47.         if ((filterMaps == null) || (filterMaps.length == 0))
  48.             return (filterChain);
  50.         // Acquire the information we will need to match filter mappings
  51.         DispatcherType dispatcher =
  52.                 (DispatcherType) request.getAttribute(Globals.DISPATCHER_TYPE_ATTR);
  54.         String requestPath = null;
  55.         Object attribute = request.getAttribute(Globals.DISPATCHER_REQUEST_PATH_ATTR);
  56.         if (attribute != null){
  57.             requestPath = attribute.toString();
  58.         }
  60.         String servletName = wrapper.getName();
  62.         // Add the relevant path-mapped filters to this filter chain
  63.         for (int i = 0; i < filterMaps.length; i++) {
  64.             if (!matchDispatcher(filterMaps[i] ,dispatcher)) {
  65.                 continue;
  66.             }
  67.             if (!matchFiltersURL(filterMaps[i], requestPath))
  68.                 continue;
  69.             ApplicationFilterConfig filterConfig = (ApplicationFilterConfig)
  70.                 context.findFilterConfig(filterMaps[i].getFilterName());
  71.             if (filterConfig == null) {
  72.                 // FIXME - log configuration problem
  73.                 continue;
  74.             }
  75.             //将集合中符合要求当前请求的过滤器都加入过滤器链中
  76.             filterChain.addFilter(filterConfig);
  77.         }
  79.         // Add filters that match on servlet name second
  80.         for (int i = 0; i < filterMaps.length; i++) {
  81.             if (!matchDispatcher(filterMaps[i] ,dispatcher)) {
  82.                 continue;
  83.             }
  84.             if (!matchFiltersServlet(filterMaps[i], servletName))
  85.                 continue;
  86.             ApplicationFilterConfig filterConfig = (ApplicationFilterConfig)
  87.                 context.findFilterConfig(filterMaps[i].getFilterName());
  88.             if (filterConfig == null) {
  89.                 // FIXME - log configuration problem
  90.                 continue;
  91.             }
  92.             //将集合中符合要求当前请求的过滤器都加入过滤器链中
  93.             filterChain.addFilter(filterConfig);
  94.         }
  96.         // Return the completed filter chain
  97.         //返回构建好的过滤器链
  98.         return filterChain;
  99.     }

调用完创建过滤器的方法后,回到invoke方法中

正式对当前请求调用过滤器链

  1. filterChain.doFilter
  2.                             (request.getRequest(), response.getResponse());
11.ApplicationFilterChain#doFilter

重点代码:

  1. internalDoFilter(request,response);

开始真正执行过滤流程

12.ApplicationFilterChain#internalDoFilter
  1. private void internalDoFilter(ServletRequest request,
  2.                                   ServletResponse response)
  3.         throws IOException, ServletException {
  5.         // Call the next filter if there is one
  6.         if (pos < n) {
  7.             ApplicationFilterConfig filterConfig = filters[pos++];
  8.             try {
  9.                 Filter filter = filterConfig.getFilter();
  11.                 if (request.isAsyncSupported() && "false".equalsIgnoreCase(
  12.                         filterConfig.getFilterDef().getAsyncSupported())) {
  13.                     request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR, Boolean.FALSE);
  14.                 }
  15.                 if( Globals.IS_SECURITY_ENABLED ) {
  16.                     final ServletRequest req = request;
  17.                     final ServletResponse res = response;
  18.                     Principal principal =
  19.                         ((HttpServletRequest) req).getUserPrincipal();
  21.                     Object[] args = new Object[]{req, res, this};
  22.                     SecurityUtil.doAsPrivilege ("doFilter", filter, classType, args, principal);
  23.                 } else {
  24.                     //重点代码---第三个参数是当前过滤器链对象--ApplicationFilterChain
  25.                     filter.doFilter(request, response, this);
  26.                 }
  27.             } catch (IOException | ServletException | RuntimeException e) {
  28.                 throw e;
  29.             } catch (Throwable e) {
  30.                 e = ExceptionUtils.unwrapInvocationTargetException(e);
  31.                 ExceptionUtils.handleThrowable(e);
  32.                 throw new ServletException(sm.getString("filterChain.filter"), e);
  33.             }
  34.             return;
  35.         }
  37.         // We fell off the end of the chain -- call the servlet instance
  38.         try {
  39.             if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
  40.                 lastServicedRequest.set(request);
  41.                 lastServicedResponse.set(response);
  42.             }
  44.             if (request.isAsyncSupported() && !servletSupportsAsync) {
  45.                 request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR,
  46.                         Boolean.FALSE);
  47.             }
  48.             // Use potentially wrapped request from this point
  49.             if ((request instanceof HttpServletRequest) &&
  50.                     (response instanceof HttpServletResponse) &&
  51.                     Globals.IS_SECURITY_ENABLED ) {
  52.                 final ServletRequest req = request;
  53.                 final ServletResponse res = response;
  54.                 Principal principal =
  55.                     ((HttpServletRequest) req).getUserPrincipal();
  56.                 Object[] args = new Object[]{req, res};
  57.                 SecurityUtil.doAsPrivilege("service",
  58.                                            servlet,
  59.                                            classTypeUsedInService,
  60.                                            args,
  61.                                            principal);
  62.             } else {
  63.             //过滤器链调用完毕,真正调用servlet的方法
  64.                 servlet.service(request, response);
  65.             }
  66.         } catch (IOException | ServletException | RuntimeException e) {
  67.             throw e;
  68.         } catch (Throwable e) {
  69.             e = ExceptionUtils.unwrapInvocationTargetException(e);
  70.             ExceptionUtils.handleThrowable(e);
  71.             throw new ServletException(sm.getString("filterChain.servlet"), e);
  72.         } finally {
  73.             if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
  74.                 lastServicedRequest.set(null);
  75.                 lastServicedResponse.set(null);
  76.             }
  77.         }
  78.     }

这是过滤器的原理

下面看sevlet的调用,下面演示的是正常流程:

13.HttpServlet#service
  1. protected void service(HttpServletRequest req, HttpServletResponse resp)
  2.         throws ServletException, IOException {
  4.         String method = req.getMethod();
  6.         if (method.equals(METHOD_GET)) {
  7.             long lastModified = getLastModified(req);
  8.             if (lastModified == -1) {
  9.                 // servlet doesn't support if-modified-since, no reason
  10.                 // to go through further expensive logic
  11.                 doGet(req, resp);
  12.             } else {
  13.                 long ifModifiedSince;
  14.                 try {
  15.                     ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
  16.                 } catch (IllegalArgumentException iae) {
  17.                     // Invalid date header - proceed as if none was set
  18.                     ifModifiedSince = -1;
  19.                 }
  20.                 if (ifModifiedSince < (lastModified / 1000 * 1000)) {
  21.                     // If the servlet mod time is later, call doGet()
  22.                     // Round down to the nearest second for a proper compare
  23.                     // A ifModifiedSince of -1 will always be less
  24.                     maybeSetLastModified(resp, lastModified);
  25.                     doGet(req, resp);
  26.                 } else {
  27.                     resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
  28.                 }
  29.             }
  31.         } else if (method.equals(METHOD_HEAD)) {
  32.             long lastModified = getLastModified(req);
  33.             maybeSetLastModified(resp, lastModified);
  34.             doHead(req, resp);
  36.         } else if (method.equals(METHOD_POST)) {
  37.             doPost(req, resp);
  39.         } else if (method.equals(METHOD_PUT)) {
  40.             doPut(req, resp);
  42.         } else if (method.equals(METHOD_DELETE)) {
  43.             doDelete(req, resp);
  45.         } else if (method.equals(METHOD_OPTIONS)) {
  46.             doOptions(req,resp);
  48.         } else if (method.equals(METHOD_TRACE)) {
  49.             doTrace(req,resp);
  51.         } else {
  52.             //
  53.             // Note that this means NO servlet supports whatever
  54.             // method was requested, anywhere on this server.
  55.             //
  57.             String errMsg = lStrings.getString("http.method_not_implemented");
  58.             Object[] errArgs = new Object[1];
  59.             errArgs[0] = method;
  60.             errMsg = MessageFormat.format(errMsg, errArgs);
  62.             resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
  63.         }
  64.     }

这里的doGet和doPost等方法的调用就是在我们自己的servlet中调用了，因为我们自己的servlet没有重写service方法，所以这里service是调用父类的，而重写的doGet等方法，是调用对应子类的实现

13.DefaultServlet#service

如果没有找到对应的请求映射servlet，会返回DefaultServlet

  1. @Override
  2.     protected void service(HttpServletRequest req, HttpServletResponse resp)
  3.             throws ServletException, IOException {
  5.         if (req.getDispatcherType() == DispatcherType.ERROR) {
  6.             doGet(req, resp);
  7.         } else {
  8.             super.service(req, resp);
  9.         }
  10.     }

最终走的是HttpSerlvet的最后一个else分支,因为DefaultServlet是HttpServlet的子类

  1. else {
  2.             //
  3.             // Note that this means NO servlet supports whatever
  4.             // method was requested, anywhere on this server.
  5.             //
  7.             String errMsg = lStrings.getString("http.method_not_implemented");
  8.             Object[] errArgs = new Object[1];
  9.             errArgs[0] = method;
  10.             errMsg = MessageFormat.format(errMsg, errArgs);
  12.             resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
  13.         }

到此请求流程代码分析完毕

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://cjdhy.blog.csdn.net/article/details/122784459

内容来源于网络，如有侵权，请联系作者删除！

Javatomcat前端

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com