tomcat8.5源码学习三之Endpoit
Healthy Mind Lv3
 2021-05-28 14:08:15    

本篇主要学习tomcat 是如何把Connector线程池里的请求数据转发到servlet的

上一篇 我们已经可能到了 org.apache.tomcat.util.net.NioEndpoint 的 ***bind()***方法

bind方法其实就是nio端口绑定的方法

真正启动线程池的方法是 startInternal() 方法，源码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
/**
    * Start the NIO endpoint, creating acceptor, poller threads.
    */
   @Override
   public void startInternal() throws Exception {

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

           processorCache = new SynchronizedStack<>(SynchronizedStack.DEFAULT_SIZE,
                   socketProperties.getProcessorCache());
           eventCache = new SynchronizedStack<>(SynchronizedStack.DEFAULT_SIZE,
                           socketProperties.getEventCache());
           nioChannels = new SynchronizedStack<>(SynchronizedStack.DEFAULT_SIZE,
                   socketProperties.getBufferPool());

           // Create worker collection
           if ( getExecutor() == null ) {
               createExecutor();
           }

           initializeConnectionLatch();

           // Start poller threads
           pollers = new Poller[getPollerThreadCount()];
           for (int i=0; i<pollers.length; i++) {
               pollers[i] = new Poller();
               Thread pollerThread = new Thread(pollers[i], getName() + "-ClientPoller-"+i);
               pollerThread.setPriority(threadPriority);
               pollerThread.setDaemon(true);
               pollerThread.start();
           }

           startAcceptorThreads();
       }
   }

这里主要查看 Poller的类的run 方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
/**
       * The background thread that adds sockets to the Poller, checks the
       * poller for triggered events and hands the associated socket off to an
       * appropriate processor as events occur.
       */
      @Override
      public void run() {
          // Loop until destroy() is called
          while (true) {

              boolean hasEvents = false;

              try {
                  if (!close) {
                      hasEvents = events();
                      if (wakeupCounter.getAndSet(-1) > 0) {
                          //if we are here, means we have other stuff to do
                          //do a non blocking select
                          keyCount = selector.selectNow();
                      } else {
                          keyCount = selector.select(selectorTimeout);
                      }
                      wakeupCounter.set(0);
                  }
                  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());

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

              //process timeouts
              timeout(keyCount,hasEvents);
          }//while

          getStopLatch().countDown();
      }

这段代码大部分就是状态修改，唯一可以看到的 就是

1
processKey(sk, attachment);

接下来就看 这个方法

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

主要方法就是 processSocket 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/**
   * Process the given SocketWrapper with the given status. Used to trigger
   * processing as if the Poller (for those endpoints that have one)
   * selected the socket.
   *
   * @param socketWrapper The socket wrapper to process
   * @param event         The socket event to be processed
   * @param dispatch      Should the processing be performed on a new
   *                          container thread
   *
   * @return if processing was triggered successfully
   */
  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.execute(sc);
          } else {
              sc.run();
          }
      } catch (RejectedExecutionException ree) {
          getLog().warn(sm.getString("endpoint.executor.fail", socketWrapper) , ree);
          return false;
      } catch (Throwable t) {
          ExceptionUtils.handleThrowable(t);
          // This means we got an OOM or similar creating a thread, or that
          // the pool and its queue are full
          getLog().error(sm.getString("endpoint.process.fail"), t);
          return false;
      }
      return true;
  }

这里调用 SocketProcessorBase 的 run方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Override
   public final void run() {
       synchronized (socketWrapper) {
           // It is possible that processing may be triggered for read and
           // write at the same time. The sync above makes sure that processing
           // does not occur in parallel. The test below ensures that if the
           // first event to be processed results in the socket being closed,
           // the subsequent events are not processed.
           if (socketWrapper.isClosed()) {
               return;
           }
           doRun();
       }
   }

我们查看 NioEndpoint 这个类的 doRun方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
@Override
     protected void doRun() {
         NioChannel socket = socketWrapper.getSocket();
         SelectionKey key = socket.getIOChannel().keyFor(socket.getPoller().getSelector());

         try {
             int handshake = -1;

          ....
             if (handshake == 0) {
                 SocketState state = SocketState.OPEN;
                 // Process the request from this socket
                 if (event == null) {
                     state = getHandler().process(socketWrapper, SocketEvent.OPEN_READ);
                 } else {
                     state = getHandler().process(socketWrapper, event);
                 }
                 if (state == SocketState.CLOSED) {
                     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);
         } catch (VirtualMachineError vme) {
             ExceptionUtils.handleThrowable(vme);
         } catch (Throwable t) {
             log.error("", t);
             socket.getPoller().cancelledKey(key);
         } finally {
             socketWrapper = null;
             event = null;
             //return to cache
             if (running && !paused) {
                 processorCache.push(this);
             }
         }
     }
 }

这里省略了部分代码 看到代码就我们就可以很确定核心代码就是

1
2
3
4
5
6
// Process the request from this socket
                  if (event == null) {
                      state = getHandler().process(socketWrapper, SocketEvent.OPEN_READ);
                  } else {
                      state = getHandler().process(socketWrapper, event);
                  }

进入process方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
@Override
   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) {
                   // There may be pipe-lined data to read. If the data isn't
                   // processed now, execution will exit this loop and call
                   // release() which will recycle the processor (and input
                   // buffer) deleting any pipe-lined data. To avoid this,
                   // process it now.
                   state = service(socketWrapper);
               }
           } else if (status == SocketEvent.OPEN_WRITE) {
               // Extra write event likely after async, ignore
               state = SocketState.LONG;
           } else if (status == SocketEvent.OPEN_READ){
               state = service(socketWrapper);
           } else {
               // Default to closing the socket if the SocketEvent passed in
               // is not consistent with the current state of the Processor
               state = SocketState.CLOSED;
           }

           if (getLog().isDebugEnabled()) {
               getLog().debug("Socket: [" + socketWrapper +
                       "], Status in: [" + status +
                       "], State out: [" + state + "]");
           }

           if (state != SocketState.CLOSED && isAsync()) {
               state = asyncPostProcess();
               if (getLog().isDebugEnabled()) {
                   getLog().debug("Socket: [" + socketWrapper +
                           "], State after async post processing: [" + state + "]");
               }
           }

           if (dispatches == null || !dispatches.hasNext()) {
               // Only returns non-null iterator if there are
               // dispatches to process.
               dispatches = getIteratorAndClearDispatches();
           }
       } while (state == SocketState.ASYNC_END ||
               dispatches != null && state != SocketState.CLOSED);

       return state;
   }

这里面 有dispatch、service、asyncPostProcess这几个核心方法调用，最终跟踪到最后其实都会看到如下样板代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
....  
    // Process the request in the adapter
            if (!getErrorState().isError()) {
                try {
                    rp.setStage(org.apache.coyote.Constants.STAGE_SERVICE);
                    getAdapter().service(request, response);
                    // Handle when the response was committed before a serious
                    // error occurred.  Throwing a ServletException should both
                    // set the status to 500 and set the errorException.
                    // If we fail here, then the response is likely already
                    // committed, so we can't try and set headers.
                    if(keepAlive && !getErrorState().isError() && !isAsync() &&
                            statusDropsConnection(response.getStatus())) {
                        setErrorState(ErrorState.CLOSE_CLEAN, null);
                    }
                } catch (InterruptedIOException e) {
                    setErrorState(ErrorState.CLOSE_CONNECTION_NOW, e);
                } catch (HeadersTooLargeException e) {
                    log.error(sm.getString("http11processor.request.process"), e);
                    // The response should not have been committed but check it
                    // anyway to be safe
                    if (response.isCommitted()) {
                        setErrorState(ErrorState.CLOSE_NOW, e);
                    } else {
                        response.reset();
                        response.setStatus(500);
                        setErrorState(ErrorState.CLOSE_CLEAN, e);
                        response.setHeader("Connection", "close"); // TODO: Remove
                    }
                } catch (Throwable t) {
                    ...

以上代码是org.apache.coyote.http11.Http11Processor service（）方法的部分内容

主要查看 getAdapter().service(request, response);这段内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
@Override
  public void service(org.apache.coyote.Request req, org.apache.coyote.Response res)
          throws Exception {

     ....

      try {
          // Parse and set Catalina and configuration specific
          // request parameters
          postParseSuccess = postParseRequest(req, request, res, response);
          if (postParseSuccess) {
              //check valves if we support async
              request.setAsyncSupported(
                      connector.getService().getContainer().getPipeline().isAsyncSupported());
              // Calling the container
              //这个是这段方法的核心代码
              connector.getService().getContainer().getPipeline().getFirst().invoke(
                      request, response);
          }
          if (request.isAsync()) {
              async = true;
              ReadListener readListener = req.getReadListener();
              if (readListener != null && request.isFinished()) {
                  // Possible the all data may have been read during service()
                  // method so this needs to be checked here
                  ClassLoader oldCL = null;
                  try {
                      oldCL = request.getContext().bind(false, null);
                      if (req.sendAllDataReadEvent()) {
                          req.getReadListener().onAllDataRead();
                      }
                  } finally {
                      request.getContext().unbind(false, oldCL);
                  }
              }

              Throwable throwable =
                      (Throwable) request.getAttribute(RequestDispatcher.ERROR_EXCEPTION);

              // If an async request was started, is not going to end once
              // this container thread finishes and an error occurred, trigger
              // the async error process
              if (!request.isAsyncCompleting() && throwable != null) {
                  request.getAsyncContextInternal().setErrorState(throwable, true);
              }
          } else {
              request.finishRequest();
              response.finishResponse();
          }

      } catch (IOException e) {
          // Ignore
      } finally {
          AtomicBoolean error = new AtomicBoolean(false);
          res.action(ActionCode.IS_ERROR, error);

          if (request.isAsyncCompleting() && error.get()) {
              // Connection will be forcibly closed which will prevent
              // completion happening at the usual point. Need to trigger
              // call to onComplete() here.
              res.action(ActionCode.ASYNC_POST_PROCESS,  null);
              async = false;
          }

          // Access log
          if (!async && postParseSuccess) {
              // Log only if processing was invoked.
              // If postParseRequest() failed, it has already logged it.
              Context context = request.getContext();
              // If the context is null, it is likely that the endpoint was
              // shutdown, this connection closed and the request recycled in
              // a different thread. That thread will have updated the access
              // log so it is OK not to update the access log here in that
              // case.
              if (context != null) {
                  context.logAccess(request, response,
                          System.currentTimeMillis() - req.getStartTime(), false);
              }
          }

          req.getRequestProcessor().setWorkerThreadName(null);

          // Recycle the wrapper request and response
          if (!async) {
              request.recycle();
              response.recycle();
          }
      }
  }

connector.getService().getContainer().getPipeline().getFirst().invoke(request, response);

这句代码就是获取在pipeline管道的的第一个Value的实现 ，在tomcat中 Value实现比较多

这里有26个 这里的Value有点像Servlet里面的Filter 一样 我们直接看org.apache.catalina.core.StandardWrapperValve 在tomcat中servlet都被包装成里 Wrapper

在 invoke方法里面 比较长

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

/**
 * Invoke the servlet we are managing, respecting the rules regarding
 * servlet lifecycle and SingleThreadModel support.
 *
 * @param request Request to be processed
 * @param response Response to be produced
 *
 * @exception IOException if an input/output error occurred
 * @exception ServletException if a servlet error occurred
 */
@Override
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 {
                        filterChain.doFilter(request.getRequest(),
                                response.getResponse());
                    }
                } finally {
                    String log = SystemLogHandler.stopCapture();
                    if (log != null && log.length() > 0) {
                        context.getLogger().info(log);
                    }
                }
            } else {
                if (request.isAsyncDispatching()) {
                    request.getAsyncContextInternal().doInternalDispatch();
                } else {
                    filterChain.doFilter
                        (request.getRequest(), response.getResponse());
                }
            }

        }
    } catch (ClientAbortException | CloseNowException e) {
        if (container.getLogger().isDebugEnabled()) {
            container.getLogger().debug(sm.getString(
                    "standardWrapper.serviceException", wrapper.getName(),
                    context.getName()), e);
        }
        throwable = e;
        exception(request, response, e);
    } ...
}

这里我们可以看到 tomcat 是如何把wrapper转成 Servlet的已经处理Servlet3 提供的异步处理请求的实现，

在这里的核心方法是

1
filterChain.doFilter(request.getRequest(),response.getResponse());

在 **org.apache.catalina.core.ApplicationFilterChain ** doFilter方法有一个内部 方法 internalDoFilter

这个方法的代码如下 前半部分是处理flter的后半部分是调用Servlet.Service方法的 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
private void internalDoFilter(ServletRequest request,
                                 ServletResponse response)
       throws IOException, ServletException {

       // Call the next filter if there is one
       if (pos < n) {
           ApplicationFilterConfig filterConfig = filters[pos++];
           try {
               Filter filter = filterConfig.getFilter();

               if (request.isAsyncSupported() && "false".equalsIgnoreCase(
                       filterConfig.getFilterDef().getAsyncSupported())) {
                   request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR, Boolean.FALSE);
               }
               if( Globals.IS_SECURITY_ENABLED ) {
                   final ServletRequest req = request;
                   final ServletResponse res = response;
                   Principal principal =
                       ((HttpServletRequest) req).getUserPrincipal();

                   Object[] args = new Object[]{req, res, this};
                   SecurityUtil.doAsPrivilege ("doFilter", filter, classType, args, principal);
               } else {
                   filter.doFilter(request, response, this);
               }
           } catch (IOException | ServletException | RuntimeException e) {
               throw e;
           } catch (Throwable e) {
               e = ExceptionUtils.unwrapInvocationTargetException(e);
               ExceptionUtils.handleThrowable(e);
               throw new ServletException(sm.getString("filterChain.filter"), e);
           }
           return;
       }

       // We fell off the end of the chain -- call the servlet instance
       try {
           if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
               lastServicedRequest.set(request);
               lastServicedResponse.set(response);
           }

           if (request.isAsyncSupported() && !servletSupportsAsync) {
               request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR,
                       Boolean.FALSE);
           }
           // Use potentially wrapped request from this point
           if ((request instanceof HttpServletRequest) &&
                   (response instanceof HttpServletResponse) &&
                   Globals.IS_SECURITY_ENABLED ) {
               final ServletRequest req = request;
               final ServletResponse res = response;
               Principal principal =
                   ((HttpServletRequest) req).getUserPrincipal();
               Object[] args = new Object[]{req, res};
               SecurityUtil.doAsPrivilege("service",
                                          servlet,
                                          classTypeUsedInService,
                                          args,
                                          principal);
           } else {
               servlet.service(request, response);
           }
       } catch (IOException | ServletException | RuntimeException e) {
           throw e;
       } catch (Throwable e) {
           e = ExceptionUtils.unwrapInvocationTargetException(e);
           ExceptionUtils.handleThrowable(e);
           throw new ServletException(sm.getString("filterChain.servlet"), e);
       } finally {
           if (ApplicationDispatcher.WRAP_SAME_OBJECT) {
               lastServicedRequest.set(null);
               lastServicedResponse.set(null);
           }
       }
   }


至此 Servlet的 service方法就传入到了我们ServletRequesst,ServletResponse