Tomcat请求处理(三) -- coyote请求处理

在上一篇文章文章中，Tomcat的请求处理到了JIoEndpoint$Worker#run()方法的handler.process(socket)这个调用中。 

这个handler在JIoEndpoint中是这样定义的： 

 protected Handler handler = null;

这个Handler是在JIoEndpoint内部定义的一个接口，它的内部只有public boolean process(Socket socket);这一个方法。 

那么这个handler到底在哪里实现的呢？ 

这个还要从org.apache.coyote.http11.Http11Protocol#init()中处理的，也就是在Tomcat的初始化过程中设置的。 

 endpoint.setHandler(cHandler);

这个cHandler就是设置的handler，它的定义如下： 

 protected Http11ConnectionHandler cHandler = new Http11ConnectionHandler(this);

这个Http11ConnectionHandler是一个Http11Protocol的内部类，它的process()方法如下所示： 

 public boolean process(Socket socket) {
             // 获取processor
             Http11Processor processor = recycledProcessors.poll();
             try {
                 if (processor == null) {
                     // 如果为空创建一个
                     processor = createProcessor();
                 }

                 if (processor instanceof ActionHook) {
                     // 设置Http11Processor的一个成员变量started为true
                     ((ActionHook) processor).action(ActionCode.ACTION_START, null);
                 }
                 // 设置SSL支持
                 if (proto.secure && (proto.sslImplementation != null)) {
                     processor.setSSLSupport(proto.sslImplementation.getSSLSupport(socket));
                 } else {
                     processor.setSSLSupport(null);
                 }
                 // 继续处理
                 processor.process(socket);
                 return false;

             } catch (java.net.SocketException e) {
                 Http11Protocol.log.debug(
                         sm.getString("http11protocol.proto.socketexception.debug"), e);
             } catch (java.io.IOException e) {
                 Http11Protocol.log.debug(sm.getString("http11protocol.proto.ioexception.debug"), e);
             } catch (Throwable e) {
                 Http11Protocol.log.error(sm.getString("http11protocol.proto.error"), e);
             } finally {
                 if (processor instanceof ActionHook) {
                     // 设置Http11Processor的一个成员变量started为false
                     ((ActionHook) processor).action(ActionCode.ACTION_STOP, null);
                 }
                 // 回收processor
                 recycledProcessors.offer(processor);
             }
             return false;
         }

首先，程序要创建一个Http11Processor对象，然后将它内部的一个标志started设为true，然后将socket对象传给Http11Processor#process()去继续请求流程。 

最后请求结束后，程序会确保started设为false，并且会回收前面使用的Http11Processor对象。 

于是，接下来请求就到了Http11Processor#process()这个方法了。 

 public void process(Socket socket) throws IOException {
         // 请求信息，request对象
         RequestInfo rp = request.getRequestProcessor();
         // 设定请求的状态为STAGE_PARSE
         rp.setStage(org.apache.coyote.Constants.STAGE_PARSE);

         // 设定远端地址
         remoteAddr = null;
         remoteHost = null;
         localAddr = null;
         localName = null;
         remotePort = -1;
         localPort = -1;

         // IO设定
         this.socket = socket;
         // 输入
         inputBuffer.setInputStream(socket.getInputStream());
         // 输出
         outputBuffer.setOutputStream(socket.getOutputStream());

         // 错误标志
         error = false;
         keepAlive = true;

         // 保持连接的计数器
         int keepAliveLeft = maxKeepAliveRequests;
         // 超时设置
         int soTimeout = socket.getSoTimeout();
         int oldSoTimeout = soTimeout;

         // 当前JIoEndpoint中的已经使用的Worker与总Worker的比例
         int threadRatio = (endpoint.getCurrentThreadsBusy() * 100) / endpoint.getMaxThreads();
         if (threadRatio > 75) {// 如果使用中的Worker比例高于75%，只保持连接1次
             keepAliveLeft = 1;
         }

         if (soTimeout != oldSoTimeout) {
             try {
                 socket.setSoTimeout(soTimeout);
             } catch (Throwable t) {
                 log.debug(sm.getString("http11processor.socket.timeout"), t);
                 error = true;
             }
         }
         // 是否被保持着连接
         boolean keptAlive = false;

         while (started && !error && keepAlive) {// 循环处理请求

             // Parsing the request header
             // 解析请求Header
             try {
                 if (!disableUploadTimeout && keptAlive) {
                     if (keepAliveTimeout > 0) {
                         socket.setSoTimeout(keepAliveTimeout);
                     } else if (soTimeout > 0) {
                         socket.setSoTimeout(soTimeout);
                     }
                 }
                 // 读取请求行
                 inputBuffer.parseRequestLine();
                 // 请求开始时间
                 request.setStartTime(System.currentTimeMillis());
                 keptAlive = true;

                 if (!disableUploadTimeout) {
                     socket.setSoTimeout(timeout);
                 }
                 // 读取Header
                 inputBuffer.parseHeaders();
             } catch (IOException e) {
                 // 设置错误标志，跳出循环
                 error = true;
                 break;
             } catch (Throwable t) {
                 if (log.isDebugEnabled()) {
                     log.debug(sm.getString("http11processor.header.parse"), t);
                 }
                 // 400 - 错误的请求
                 response.setStatus(400);
                 error = true;
             }

             rp.setStage(org.apache.coyote.Constants.STAGE_PREPARE);
             try {
                 // 准备请求
                 prepareRequest();
             } catch (Throwable t) {
                 if (log.isDebugEnabled()) {
                     log.debug(sm.getString("http11processor.request.prepare"), t);
                 }
                 response.setStatus(400);
                 error = true;
             }

             // 设置是否请求存活
             if (maxKeepAliveRequests > 0 && --keepAliveLeft == 0)
                 keepAlive = false;

             if (!error) {
                 try {
                     rp.setStage(org.apache.coyote.Constants.STAGE_SERVICE);
                     // adapter是org.apache.catalina.connector.CoyoteAdapter类的对象
                     adapter.service(request, response);

                     if (keepAlive && !error) {
                         // 判断是否有异常
                         error = response.getErrorException() != null
                                 || statusDropsConnection(response.getStatus());
                     }

                 } catch (InterruptedIOException e) {
                     error = true;
                 } catch (Throwable t) {
                     log.error(sm.getString("http11processor.request.process"), t);
                     response.setStatus(500);
                     error = true;
                 }
             }

             // 结束请求
             try {
                 rp.setStage(org.apache.coyote.Constants.STAGE_ENDINPUT);
                 inputBuffer.endRequest();
             } catch (IOException e) {
                 error = true;
             } catch (Throwable t) {
                 log.error(sm.getString("http11processor.request.finish"), t);
                 response.setStatus(500);
                 error = true;
             }
             try {
                 rp.setStage(org.apache.coyote.Constants.STAGE_ENDOUTPUT);
                 outputBuffer.endRequest();
             } catch (IOException e) {
                 error = true;
             } catch (Throwable t) {
                 log.error(sm.getString("http11processor.response.finish"), t);
                 error = true;
             }

             if (error) {
                 response.setStatus(500);
             }
             request.updateCounters();

             rp.setStage(org.apache.coyote.Constants.STAGE_KEEPALIVE);

             inputBuffer.nextRequest();
             outputBuffer.nextRequest();

         }

         rp.setStage(org.apache.coyote.Constants.STAGE_ENDED);

         // 回收
         inputBuffer.recycle();
         outputBuffer.recycle();

         sslSupport = null;
     }

这里面需要重点说的是adapter.service(request, response);这一句，它对请求进行了进一步处理。这里的adapter是org.apache.catalina.connector.CoyoteAdapter类的对象，至于是哪里设定的这里就不详细介绍了，主要来看一下它的#service(org.apache.coyote.Request req, org.apache.coyote.Response res)方法。 

 public void service(org.apache.coyote.Request req, org.apache.coyote.Response res) throws Exception {
         // 对Coyote Request和Response进行封装
         Request request = (Request) req.getNote(ADAPTER_NOTES);
         Response response = (Response) res.getNote(ADAPTER_NOTES);

         if (request == null) {
             // 重新创建封装的Coyote Request和Response对象
             request = (Request) connector.createRequest();
             request.setCoyoteRequest(req);
             response = (Response) connector.createResponse();
             response.setCoyoteResponse(res);

             // 互相引用
             request.setResponse(response);
             response.setRequest(request);

             req.setNote(ADAPTER_NOTES, request);
             res.setNote(ADAPTER_NOTES, response);

             req.getParameters().setQueryStringEncoding(connector.getURIEncoding());

         }

         if (connector.getXpoweredBy()) {
             response.addHeader("X-Powered-By", "Servlet/2.5");
         }

         boolean comet = false;

         try {
             req.getRequestProcessor().setWorkerThreadName(Thread.currentThread().getName());
             if (postParseRequest(req, request, res, response)) {

                 // 调用Container继续请求
                 connector.getContainer().getPipeline().getFirst().invoke(request, response);

                 if (request.isComet()) {
                     if (!response.isClosed() && !response.isError()) {
                         if (request.getAvailable()) {
                             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 {
                         request.setFilterChain(null);
                     }
                 }

             }

             if (!comet) {
                 response.finishResponse();
                 req.action(ActionCode.ACTION_POST_REQUEST, null);
             }

         } catch (IOException e) {
             ;
         } catch (Throwable t) {
             log.error(sm.getString("coyoteAdapter.service"), t);
         } finally {
             req.getRequestProcessor().setWorkerThreadName(null);
             // 回收
             if (!comet) {
                 request.recycle();
                 response.recycle();
             } else {
                 request.clearEncoders();
                 response.clearEncoders();
             }
         }

     }

下面准备总结下之前的Tomcat请求处理过程，总结出一些宏观性的东西。