tomcat连接器

      Connector是Tomcat最核心的组件之一，负责处理一个WebServer最核心的连接管理、Net IO、线程（可选）、协议解析和处理的工作。
一、连接器介绍
在开始Connector探索之路之前，先看看Connector几个关键字

  • NIO：Tomcat可以利用Java比较新的NIO技术，提升高并发下的Socket性能
  • AJP：Apache JServ Protocol，AJP的提出当然还是为了解决java亘古不变的问题——性能，AJP协议是基于包的长连接协议，以减少前端Proxy与Tomcat连接Socket连接创建的代价，目前Apache通过JK和AJP_ROXY的方式支持AJP协议，需要注意的是，虽然Nginx作为代理服务器性能强劲，但其只能通过HTTP PROXY的方式与后端的Tomcat联系，因此如果从作为代理服务器的角度上讲，在这种情况下Nginx未必会比Apache体现出更优的性能
  • APR/Native：Apache Portable Runtime，还是一个词，性能。APR的提出利用Native代码更好地解决性能问题，更好地与本地服务器(linux)打交道。让我们看看Tomcat文档对APR的介绍
Tomcat6文档 写道
Tomcat can use the Apache Portable Runtime to provide superior scalability, performance, and better integration with native server technologies. The Apache Portable Runtime is a highly portable library that is at the heart of Apache HTTP Server 2.x. APR has many uses, including access to advanced IO functionality (such as sendfile, epoll and OpenSSL), OS level functionality (random number generation, system status, etc), and native process handling (shared memory, NT pipes and Unix sockets).
These features allows making Tomcat a general purpose webserver, will enable much better integration with other native web technologies, and overall make Java much more viable as a full fledged webserver platform rather than simply a backend focused technology.

通过对如上名词的组合，Tomcat组成了如下的Connector系列：

  • Http11Protocol：支持HTTP1.1协议的连接器
  • Http11NioProtocol：支持HTTP1.1 协议+ NIO的连接器
  • Http11AprProtocol：使用APR技术处理连接的连接器
  • AjpProtocol：支持AJP协议的连接器
  • AjpAprProtocol：使用APR技术处理连接的连接器

二、范例
      我们以最简单的Http11Protocol为例，看看从请求进来到处理完毕，连接器部件是处理处理的。首先我们利用Tomcat组件组成我们一个最简单的WebServer，其具备如下功能：

  • 监停某个端口，接受客户端的请求，并将请求分配给处理线程
  • 处理线程处理请求，分析HTTP1.1请求，封装Request/Response对象，并将请求由请求处理器处理
  • 实现最简单的请求处理器，向客户端打印Hello World

代码非常简单，首先是主功能（这里，我们利用JDK5.0的线程池，连接器不再管理线程功能）：

Java代码  收藏代码
  1. package ray.tomcat.test;  
  2.   
  3. import java.util.concurrent.BlockingQueue;  
  4. import java.util.concurrent.LinkedBlockingQueue;  
  5. import java.util.concurrent.ThreadPoolExecutor;  
  6. import java.util.concurrent.TimeUnit;  
  7.   
  8. import org.apache.coyote.http11.Http11Protocol;  
  9.   
  10. public class TomcatMainV2  
  11. {  
  12.     public static void main(String[] args) throws Exception  
  13.     {  
  14.         Http11Protocol protocol = new Http11Protocol();  
  15.         protocol.setPort(8000);  
  16.         ThreadPoolExecutor threadPoolExecutor = createThreadPoolExecutor();  
  17.         threadPoolExecutor.prestartCoreThread();  
  18.         protocol.setExecutor(threadPoolExecutor);  
  19.         protocol.setAdapter(new MyHandler());  
  20.         protocol.init();  
  21.         protocol.start();  
  22.     }  
  23.   
  24.     public static ThreadPoolExecutor createThreadPoolExecutor()  
  25.     {  
  26.         int corePoolSize = 2;  
  27.         int maximumPoolSize = 10;  
  28.         long keepAliveTime = 60;  
  29.         TimeUnit unit = TimeUnit.SECONDS;  
  30.         BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>();  
  31.         ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(  
  32.                 corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);  
  33.         return threadPoolExecutor;  
  34.     }  
  35. }  
 

请求处理器向客户端打引Hello World，代码如下

Java代码  收藏代码
  1. package ray.tomcat.test;  
  2.   
  3. import java.io.ByteArrayOutputStream;  
  4. import java.io.OutputStreamWriter;  
  5. import java.io.PrintWriter;  
  6.   
  7. import org.apache.coyote.Adapter;  
  8. import org.apache.coyote.Request;  
  9. import org.apache.coyote.Response;  
  10. import org.apache.tomcat.util.buf.ByteChunk;  
  11. import org.apache.tomcat.util.net.SocketStatus;  
  12.   
  13. public class MyHandler implements Adapter  
  14. {  
  15.     //支持Comet，Servlet3.0将对Comet提供支持，Tomcat6目前是非标准的实现  
  16.     public boolean event(Request req, Response res, SocketStatus status)  
  17.             throws Exception  
  18.     {  
  19.         System.out.println("event");  
  20.         return false;  
  21.     }  
  22.   
  23.     //请求处理  
  24.     public void service(Request req, Response res) throws Exception  
  25.     {  
  26.         System.out.println("service");  
  27.   
  28.         ByteArrayOutputStream baos = new ByteArrayOutputStream();  
  29.         PrintWriter writer = new PrintWriter(new OutputStreamWriter(baos));  
  30.         writer.println("Hello World");  
  31.         writer.flush();  
  32.   
  33.         ByteChunk byteChunk = new ByteChunk();  
  34.         byteChunk.append(baos.toByteArray(), 0, baos.size());  
  35.         res.doWrite(byteChunk);  
  36.     }     
  37. }  
 

     运行主程序，在浏览器中输入http://127.0.0.1:8000，我们可以看到打印”Hello World”
三、分析
     以如上Http11Protocol为例，我们可以看到，Tomcat实现一个最简单的处理Web请求的代码其实非常简单，其主要包括如下核心处理类：

  • Http11Protocol：Http1.1协议处理入口类，其本身没有太多逻辑，对请求主要由JIoEndPoint类处理
  • Http11Protocol$Http11ConnectionHandler：连接管理器，管理连接处理队列，并分配Http11Processor对请求进行处理
  • Http11Processor：请求处理器，负责HTTP1.0协议相关的工作，包括解析请求和处理响应信息，并调用Adapter做实际的处理工作，如上我们看到了我们自定义的Adapter实现响应”Hello World”
  • JIoEndPoint：监停端口，启动接受线程准备接收请求，在请求接受后转给工作线程处理
  • JIoEndPoint$Acceptor：请求接收器，接收后将Socket分配给工作线程继续后续处理
  • JIoEndPoint$Worker：工作线程，使用Handler来处理请求，对于我们的HTTP1.1协议来说，其实现是Http11Protocol$Http11ConnectionHandler。这部分不是必须的，也可以选择JDK的concurrent包的线程池

      实际上各种连接器实现基本大同小异，基本上都是由如上部分组合而成

      1.初始化：首先，还是从入口开始，先看看初始化init

Java代码  收藏代码
  1. public void init() throws Exception {  
  2.         endpoint.setName(getName());  
  3.         endpoint.setHandler(cHandler); //请求处理器，对于HTTP1.1协议，是Http11Protocol$Http11ConnectionHandler  
  4.   
  5.          
  6. // 初始化ServerSocket工厂类，如果需SSL/TLS支持，使用JSSESocketFactory/PureTLSSocketFactory  
  7. . . . (略)         
  8.               //主要的初始化过程实际是在endpoint(JIoEndpoint)  
  9.         endpoint.init();  
  10.         . . . (略)  
  11.     }  

      Http11Protocol的初始化非常简单，准备好ServerSocket工厂，调用JIoEndPoint的初始化。让我们接下来看看JIoEndPoint的初始化过程

Java代码  收藏代码
  1. public void init()  
  2.         throws Exception {  
  3.   
  4.         if (initialized)  
  5.             return;  
  6.          
  7.         // Initialize thread count defaults for acceptor  
  8.         // 请求接收处理线程，这个值实际1已经足够  
  9.         if (acceptorThreadCount == 0) {  
  10.             acceptorThreadCount = 1;  
  11.         }  
  12.         if (serverSocketFactory == null) {  
  13.             serverSocketFactory = ServerSocketFactory.getDefault();  
  14.         }  
  15.          
  16.         //创建监停ServerSocket，port为监听端口，address为监停地址  
  17.         // backlog为连接请求队列容量(@param backlog how many connections are queued)  
  18.         if (serverSocket == null) {  
  19.             try {  
  20.                 if (address == null) {  
  21.                     serverSocket = serverSocketFactory.createSocket(port, backlog);  
  22.                 } else {  
  23.                     serverSocket = serverSocketFactory.createSocket(port, backlog, address);  
  24.                 }  
  25.             } catch (BindException be) {  
  26.                 throw new BindException(be.getMessage() + ":" + port);  
  27.             }  
  28.         }  
  29.         //if( serverTimeout >= 0 )  
  30.         //    serverSocket.setSoTimeout( serverTimeout );  
  31.          
  32.         initialized = true;    
  33.     }  

        可以看到，监停端口在此处准备就绪

Java代码  收藏代码
  1. public void start()  
  2.      throws Exception {  
  3.      // Initialize socket if not done before  
  4.      if (!initialized) {  
  5.          init();  
  6.      }  
  7.      if (!running) {  
  8.          running = true;  
  9.          paused = false;  
  10.   
  11.          // Create worker collection  
  12.          // 初始化工作线程池，有WorkerStack(Tomcat自实现)和Executor(JDK concurrent包)两种实现  
  13.          if (executor == null) {  
  14.              workers = new WorkerStack(maxThreads);  
  15.          }  
  16.   
  17.          // Start acceptor threads  
  18.          // 启动请求连接接收处理线程  
  19.          for (int i = 0; i < acceptorThreadCount; i++) {  
  20.              Thread acceptorThread = new Thread(new Acceptor(), getName() + "-Acceptor-" + i);  
  21.              acceptorThread.setPriority(threadPriority);  
  22.              acceptorThread.setDaemon(daemon); //设置是否daemon参数，默认为true  
  23.              acceptorThread.start();  
  24.          }  
  25.      }  
  26.  }  
 


      2．准备好连接处理：初始化完毕，准备好连接处理，准备接收连接上来，同样的，Http11Protocol的start基本没干啥事，调用一下JIoEndPoint的start，我们来看看JIoEndPoint的start

Java代码  收藏代码
  1. public void start()  
  2.      throws Exception {  
  3.      // Initialize socket if not done before  
  4.      if (!initialized) {  
  5.          init();  
  6.      }  
  7.      if (!running) {  
  8.          running = true;  
  9.          paused = false;  
  10.   
  11.          // Create worker collection  
  12.          // 初始化工作线程池，有WorkerStack(Tomcat自实现)和Executor(JDK concurrent包)两种实现  
  13.          if (executor == null) {  
  14.              workers = new WorkerStack(maxThreads);  
  15.          }  
  16.   
  17.          // Start acceptor threads  
  18.          // 启动请求连接接收处理线程  
  19.          for (int i = 0; i < acceptorThreadCount; i++) {  
  20.              Thread acceptorThread = new Thread(new Acceptor(), getName() + "-Acceptor-" + i);  
  21.              acceptorThread.setPriority(threadPriority);  
  22.              acceptorThread.setDaemon(daemon); //设置是否daemon参数，默认为true  
  23.              acceptorThread.start();  
  24.          }  
  25.      }  
  26.  }  

      主要处理的事情无非就是准备和工作线程（处理具体请求的线程度池，可选，也可以使用JDK5.0的线程池），连接请求接收处理线程（代码中，一般acceptorThreadCount=1）

      3．连接请求接收处理：准备就绪，可以连接入请求了。现在工作已经转到了Acceptor(JIoEndPoint$Acceptor)这里，我们看看Acceptor到底做了些啥

Java代码  收藏代码
  1. public void run() {  
  2.   
  3.             // Loop until we receive a shutdown command  
  4.             while (running) {  
  5.                 . . . (略)  
  6.                     //阻塞等待客户端连接  
  7.                     Socket socket = serverSocketFactory.acceptSocket(serverSocket);  
  8.                     serverSocketFactory.initSocket(socket);  
  9.                     // Hand this socket off to an appropriate processor  
  10.                     if (!processSocket(socket)) {  
  11.                         // Close socket right away  
  12.                         try {  
  13.                             socket.close();  
  14.                         } catch (IOException e) {  
  15.                             // Ignore  
  16.                         }  
  17.                     }  
  18.                   . . . (略)  
  19.             }  
  20.  }  
  21. . . . (略)  
  22.     protected boolean processSocket(Socket socket) {  
  23.         try {  
  24.             //由工作线程继续后续的处理  
  25.             if (executor == null) {  
  26.                 getWorkerThread().assign(socket);  
  27.             } else {  
  28.                 executor.execute(new SocketProcessor(socket));  
  29.             }  
  30.         } catch (Throwable t) {  
  31.             . . . (略)             
  32. return false;  
  33.         }  
  34.         return true;  
  35.     }  

       实际上也没有什么复杂的工作，无非就是有连接上来之后，将连接转交给工作线程(SocketProcessor)去处理

       4.工作线程：SocketProcessor

Java代码  收藏代码
  1. public void run() {  
  2.             // Process the request from this socket  
  3.             if (!setSocketOptions(socket) || !handler.process(socket)) {  
  4.                 // Close socket  
  5.                 try {  
  6.                     socket.close();  
  7.                 } catch (IOException e) {  
  8.                 }  
  9.             }  
  10.             // Finish up this request  
  11.             socket = null;  
  12.         }     

    工作线程主要是设置一下Socket参数，然后将请求转交给handler去处理，需要注意一下如下几个连接参数的意义：

  • SO_LINGER：若设置了SO_LINGER并确定了非零的超时间隔，则closesocket()调用阻塞进程，直到所剩数据发送完毕或超时。这种关闭称为“优雅的”关 闭。请注意如果套接口置为非阻塞且SO_LINGER设为非零超时，则closesocket()调用将以WSAEWOULDBLOCK错误返回。若在一个流类套接口上设置了SO_DONTLINGER，则closesocket()调用立即返回。但是，如果可能，排队的数据将在套接口关闭前发送。请注意，在这种情况下WINDOWS套接口实现将在 一段不确定的时间内保留套接口以及其他资源(TIME_WAIT)，这对于想用所以套接口的应用程序来说有一定影响。默认此参数不打开
  • TCP_NODELAY：是否打开Nagle，默认打开，使用Nagle算法是为了避免多次发送小的分组，而是累计到一定程度或者超过一定时间后才一起发送。对于AJP连接，可能需要关注一下这个选项。
  • SO_TIMEOUT：JDK API注释如下，With this option set to a non-zero timeout,a read() call on the InputStream associated with this Socket will block for only this amount of time.  If the timeout expires, a java.net.SocketTimeoutException is raised, though the Socket is still valid. The option must be enabled prior to entering the blocking operation to have effect. The timeout must be > 0。默认设置的是60秒

        关于默认的设置，可以参见org.apache.coyote.http11.Constants定义
      5．最终请求终于回到了Handler，此处的Handler实现是org.apache.coyote.http11.Http11Processor，其主要处理一些HTTP协议性细节的东西，此处代码不再列出，有兴趣可以自行读代码。最终请求终于回到了我们的Adapter对象，一个请求处理完毕，功德圆满。

posted @ 2014-07-19 13:57  永志  阅读(818)  评论(0)  编辑  收藏  举报