How Tomcat Works 读书笔记(第四章)

How Tomcat Works 读书笔记(第四章)
2011年07月01日
　　 Tomcat的连接器是一个单独的模块，它可以插入到一个servlet容器里面，现在一些比较常见的连接器有Coyote,mod_jk, mod_jk2,和mod_webapp.一个Tomcat的连接器必须要满足下面的要求：
　　1． 它必须实现org.apache.catalina.Connector接口
　　2． 它必须要创建一个实现org.apache.catalina.Request对象的request
　　3． 它必须要创建一个实现org.apache.catalina.Response对象的response
　　Tomcat 4的连接器和第三章的差不多，它也是等待HTTP请求，创建reqeust和response对象，而后把request和response对象传给container容器。它是调用container的invoker方法来实现传递的：
　　Public void invoke (org.apache.catalina.Reqeust request, org.apache.catalina.Response response);
　　在invoke方法里面，container加载servlet类，调用它的service方法，管理session，并使用log等组件。这个connector对第三章的connector做了一些优化，第一点就是提供了一个池，避免了对象创建的开销，第二点，在很多地方用char数组代替了string。
　　HTTP 1.1 新特性：
　　1. 持久连接：这个我们比较熟悉，就是复用Connection，来下载多个资源；
　　2. 块编码： 在content-length没有准备好的情况下，每块数据都会提供一个length， 用来指示块长度；
　　3. 100状态码的使用， 这个一般用作client来确定服务器状态用的，这个一般用作客户端准备传送一个大的request body，但无法确定服务器是否接受它，如果服务器此刻是down的，那么客户端传送一个大的request body是一个资源浪费。
　　Connector接口：
　　1. Tomcat的连接器都是实现org.apache.catalina.Connector接口，它的主要的方法是getContainer, setContainer, createRequest,createResponse. setContainer会使一个Connector和一个Container联系起来，其他的createRequest和createResponse比较容易理解，就是创建一个Request和Response对象。
　　2. Org.apache.catalina.http.HttpConnector是它的实现类。下面我们看一下类图:
　　
　　我们来看HttpConnector类 的实现吧：
　　首先在它的open方法里面调用ServerSocketFactory创建一个ServerSocket，DefaultServerSocketFactory实现ServerSocketFactory，这个很好理解，就是创建一个ServerSocket。
　　在第三章里面，我们的HttpConnector只有一个HttpProcessor实例，它一次只能请求一个Http请求，在Tomcat连接器里面，它有一个HttpProcessor对象池，每个HttpProcessor都在独自的线程里面运行，所以HttpProcessor可以同时处理多个Http请求。
　　HttpConnector维护了一个HttpProcessor池来避免HttpProcessor的创建， HttpProcessor实例是维护在一个栈中的，
　　Private Stack processors = new Stack();
　　在HttpConnector中有个minProcessors和maxProcessors两个变量，HttpConnector会创建minProcessors个HttpProcessor，它会创建HtttpProcessor，直到maxProcessors达到后。 变量curProcessor保存着HttpProcessor创建的数量。
　　在HttpConnector的start方法里面会调用下面的代码来创建初始的Processor。
　　While(curProcessors 0 && curProcessor >= maxProcessors){ Break; } HttpProcessor processor = newProcessor(); Recycle(processor); }
　　Recycle方法是将HttpProcessor压入到栈中去的。
　　HttpProcessor是负责解析HTTP Request请求头和Header的，一个HttpProcessor和一个request和一个response对象关联。 在HttpProcessor的构造函数里面会调用createRequest和createResponse方法来创建Request对象和Response对象。
　　当有一个请求来临时，HttpProcessor会从对象池中取得一个HttpProcessor对象，如果到达maxProcessors的时候，HttpConnector直接关闭socket，Http request将不会被处理。获得一个HttpProcessor方法后，将会调用HttpProcessor的assign方法：
　　Processor.assing(socket);
　　HttpProcessor对象是利用SocketInputStream读取请求头，解析Http Request。我们现在就来看一下assign方法吧。
　　/** * Process an incoming TCP/IP connection on the specified socket. Any * exception that occurs during processing must be logged and swallowed. * NOTE: This method is called from our Connector's thread. We * must assign it to our own thread so that multiple simultaneous * requests can be handled. * * @param socket TCP socket to process */ synchronized void assign(Socket socket) { // Wait for the Processor to get the previous Socket // 在创建的时候，available是false的，所以这个while循环将被跳过 while (available) { try { wait(); } catch (InterruptedException e) { } } // Store the newly available Socket and notify our thread // 我们将available设置成true，调用notifyAll来唤醒等待当前对象的锁 this.socket = socket; available = true; notifyAll(); if ((debug >= 1) && (socket != null)) log(" An incoming request is being assigned"); // 这个方法就可以返回了，HttpConnector就可以相应下一个请求了。 }
　　对了，我们要完全理解这个HttpProcessor线程，我们应该先看一下HttpConnector的newProcessor方法。
　　/** * Create and return a new processor suitable for processing HTTP * requests and returning the corresponding responses. */ private HttpProcessor newProcessor() { // if (debug >= 2) // log("newProcessor: Creating new processor"); // 首先会创建一个HttpProcessor对象 HttpProcessor processor = new HttpProcessor(this, curProcessors++); if (processor instanceof Lifecycle) { try { // 在这里调用了processor的start方法 ((Lifecycle) processor).start(); } catch (LifecycleException e) { log("newProcessor", e); return (null); } } created.addElement(processor); return (processor); }
　　其实HttpProcessor的构造函数很简单，主要会调用HttpConnector的createRequest和createResponse方法。
　　我们看到在创建HttpProcessor的时候会调用start方法，在start方法里面调用threadStart方法，在start线程里面将该线程设置成守护线程，然后调用start方法，实际上会执行现场的run方法，我们就重点看一下run方法吧。其实run方法很简单，就是得到一个socket，然后处理该socket，处理完毕之后调用HttpConnector的recycle方法，将该对象压入processors栈中。
　　/** * The background thread that listens for incoming TCP/IP connections and * hands them off to an appropriate processor. */ public void run() { // Process requests until we receive a shutdown signal while (!stopped) { // Wait for the next socket to be assigned Socket socket = await(); if (socket == null) continue; // Process the request from this socket try { process(socket); } catch (Throwable t) { log("process.invoke", t); } // Finish up this request connector.recycle(this); } // Tell threadStop() we have shut ourselves down successfully synchronized (threadSync) { threadSync.notifyAll(); } }
　　下面最重要的就是await方法了，这个方法写的很巧妙。我们来看一下吧：
　　/** * Await a newly assigned Socket from our Connector, or null * if we are supposed to shut down. */ private synchronized Socket await() { // 在初始化的时候availabe是false，所以会调用wait方法 // Wait for the Connector to provide a new Socket while (!available) { try { wait(); } catch (InterruptedException e) { } } // 其实我们刚才也看到了，调用了assign方法后，available的值会变成true， // 然后将socket返回，我们可以看到在这里将socket赋给了一个局部变量 // 这一点非常高明，使得HttpProcessor可以复用了。 // Notify the Connector that we have received this Socket Socket socket = this.socket; available = false; notifyAll(); if ((debug >= 1) && (socket != null)) log(" The incoming request has been awaited"); return (socket); }