how tomcat works 笔记
1 tomcat是模块化的服务器，由两大模块：connector和container。
connector主要用来处理网络通讯，接收tcp请求，构造httprequest和httpresponse对象，然后传递给container。
容器的主要任务是触发Servlet.service(ServletRequest?arg0,?ServletResponse?arg1)，响应用户请求。
connector和container是解耦的，通过接口规范协作。
?
org.apache.catalina.Container是一个接口，按照范围从大到小，他的实现类有四个，这几个实现类的关系类似于组合模式的树结构。范围最大的是Engine，他表示整个catalina servlet引擎，他包含一个或者多个Host、Context；Host表示一个虚拟主机，包含一个或多个Context（好比在一个tomacat服务器下部署多个应用）；Context表示一个独立的ServletContext（也就是一个应用，对应的部署描述符是web.xml），他包含一个或多个Wrapper（当需要多个不同的servlet的时候，就会引用多个wrapper子容器）。wraper表示web应用中部署描述符定义的一个servlet，他控制这个servlet的生命周期，负责创建和销毁servlet。wraper不能再有子容器。要部署一个web应用，不一定需要所有的容器。
?
一般来说，一个connector会引用一个容器，这个容器可能是层级结构的。当接受到客户端请求的时候，connector会调用容器的invoke，容器引用一个pipeline，把请求传递给pipeline，、在pipeline里面顺序执行valve链。如果容器是层级结构的，那么父容器的某个valve会根据某种映射选择一个子容器，子容器执行和父容器类似的过程，请求会横向或者纵向的传递下去。例如，当context接受到一个请求时，他会调用自身的pipeline，执行StandardContextValve，这个value会根据规则找到合适的子容器wrapper，再由wrapper处理请求。
?
何时需要engine呢？当需要监控到整个engine的请求或者使用独立的connector却需要支持多个host的时候；
用host的时机类似。当和web server 如apache结合使用的时候，一般不需要engine或者host，因为连接器会利用web server的功能确定合适的context或者wrapper.
?
?
?
2 http 服务器实现的主体是Connector.start()（基于server socket），connector.CoyoteAdapter.service(Request req, Response res)内部实现http的处理逻辑。?
?
3 官方网站的学习资料十分重要。不可不看
?
4
核心类图
?
从类图结构可以看出，tomcat具有良好的模块化结构，注重针对接口编程，类的设计具有充分的可扩展性。抽象和实现分离，在通信层面支持bio,nio,apr。
?
5 处理流程
?
7.0.27版本的http请求处理流程
Connector.initInternal()-》Connector.startInternal()
?-》AbstractProtocol.start()-》AbstractEndpoint.start()此处采用了模板方法，AbstractEndpoint.startInternal()具体实现由子类定义?-》以http11为例子进行推演JIoEndpoint.startInternal()-》AbstractEndpoint.startAcceptorThreads启动接收器-》JIoEndpoint.Acceptor.run()-》当有连接请求进来时处理请求，JIoEndpoint.processSocket(Socket socket)，以线程池的方式处理getExecutor().execute(new SocketProcessor(wrapper))-》JIoEndpoint.Handler.process(SocketWrapper<Socket> socket, SocketStatus status)，此处handler的具体实现类对应Http11ConnectionHandler?extends AbstractConnectionHandler-》
AbstractProtocol.AbstractConnectionHandler.process(SocketWrapper<S> socket, SocketStatus status)对请求进行处理-》AbstractHttp11Processor.process(SocketWrapper<S> socketWrapper)构造http请求和http响应，触发servlet的service-》CoyoteAdapter.service(Request req, Response res)，CoyoteAdapter类作为请求处理器-》coyoteAdapter关联着一个org.apache.catalina.connector.Connector，由connector调用?connector.getService().getContainer().getPipeline().getFirst().invoke(request, response)，委托容器处理请求（webx的pipeline借鉴此处）-》pipeline执行至StandardWrapperValve.invoke(Request request, Response response)-》ApplicationFilterChain.doFilter(ServletRequest request, ServletResponse response)，在这个filter里面进入我们熟悉的Servlet.service(ServletRequest arg0, ServletResponse arg1)过程。
?
（小记，在分析代码过程中state = handler.process(socket,status);，直接在eclipse下面用ctrl+鼠标，没有直接显示出handler的实现类，而实际上是有实现类的，需要先点击到接口里面，在按F4）
?
6 tomcat的通讯层的实现主要在Endpoint，例如JIoEndpoint，在JIoEndpoint.Acceptor接受连接，拿到套接字后转交给线程池，由线程池执行SocketProcessor。
acceptor接受一个请求的处理逻辑
?
int errorDelay = 0; // Loop until we receive a shutdown command while (running) { // Loop if endpoint is paused while (paused && running) { state = AcceptorState.PAUSED; try { Thread.sleep(50); } catch (InterruptedException e) { // Ignore } } if (!running) { break; } state = AcceptorState.RUNNING; try { //if we have reached max connections, wait countUpOrAwaitConnection(); Socket socket = null; try { // Accept the next incoming connection from the server // socket socket = serverSocketFactory.acceptSocket(serverSocket); } catch (IOException ioe) { // Introduce delay if necessary errorDelay = handleExceptionWithDelay(errorDelay); // re-throw throw ioe; } // Successful accept, reset the error delay errorDelay = 0; // Configure the socket if (running && !paused && setSocketOptions(socket)) { // Hand this socket off to an appropriate processor if (!processSocket(socket)) { // Close socket right away closeSocket(socket); } } else { // Close socket right away closeSocket(socket); } } catch (IOException x) { if (running) { log.error(sm.getString("endpoint.accept.fail"), x); } } catch (NullPointerException npe) { if (running) { log.error(sm.getString("endpoint.accept.fail"), npe); } } catch (Throwable t) { ExceptionUtils.handleThrowable(t); log.error(sm.getString("endpoint.accept.fail"), t); } } state = AcceptorState.ENDED; ? // Process the request from this socket try { SocketWrapper<Socket> wrapper = new SocketWrapper<Socket>(socket); wrapper.setKeepAliveLeft(getMaxKeepAliveRequests()); // During shutdown, executor may be null - avoid NPE if (!running) { return false; } getExecutor().execute(new SocketProcessor(wrapper)); } catch (RejectedExecutionException x) { log.warn("Socket processing request was rejected for:"+socket,x); 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 log.error(sm.getString("endpoint.process.fail"), t); return false; } return true; ?最后由协议处理器AbstractHttp11Processor.process(SocketWrapper<S> socketWrapper)，去进行底层io操作，读取输入流构造http请求。
?
RequestInfo rp = request.getRequestProcessor(); rp.setStage(org.apache.coyote.Constants.STAGE_PARSE); // Setting up the I/O setSocketWrapper(socketWrapper); getInputBuffer().init(socketWrapper, endpoint); getOutputBuffer().init(socketWrapper, endpoint);?
Http协议的解码由http11.InternalInputBuffer实现
?
8 为了提供服务器性能，tomcat还提供基于java nio的NioEndpoint，还有基于APR（Apache Portable Runtime）技术，直接和操作系统交互，更好的集成一些现有的本地服务器技术。web 服务器通过ajp协议和应用服务器通信。
?
参考（jni?http://baike.baidu.com/view/1272329.htm;
http://hi.baidu.com/ugo5/blog/item/96710efe34aa7e5cd7887de2.html
http://www.itpub.net/thread-1064918-1-1.html
http://guojuanjun.blog.51cto.com/277646/688559
http://tomcat.apache.org/connectors-doc/ajp/ajpv13a.html）
?
9 tomcat使用自定义的classloader加载servlet，是出于安全考虑。如果采用系统类加载器统一加载，那么运行的恶意servlet就可以访问到classpath中所有的类库。而使用自定义class loader加载servlet类就可以做到代码访问的隔离，除非应用允许，否则一个类只能访问到同一命名空间的类（即同一个类加载器加载的class）。
另外一个原因是为了支持动态类加载，例如reload功能，支持热部署。可以感知到web lib下的class文件修改，自动重新加载，这是系统类加载器做不到的。
?
?
? ?To specify certain rules in loading classes.?
? ?To cache the previously loaded classes.?
? ?To pre-load classes so they are ready to use.
?
tomcat控制一个webapp只能访问到它自己的WEB-INF/lib 下面的class，不能访问tomcat所运行的jvm下面的classpath(由系统类加载器加载的)。
它的默认class loader是WebappLoader，由下面步骤完成隔离加载和自动热部署的效果
?
? ?Creating a class loader?
? ?Setting repositories?
? ?Setting the class path?
? ?Setting permissions?
? ?Starting a new thread for auto-reload.
?
?
?
10 servlet依据是否实现SingleThreadModel，分为单线程模型和多线程模型。实现SingleThreadModel(该模型的含义具有一定误导性，已经被废弃)的servlet的，容器会做同步，保证任意时刻只会有一个线程访问servlet(为了保证性能，容器会创建一个servlet实例池)。相反，另一种servlet的，容器将允许多线程访问，如果有需要，业务要自己做好同步。
由于servlet具有两种含义的线程，所以wrapper需要根据自己所表示的servlet的线程安全性，在分配servlet的时候做更多的处理逻辑。
StandardWrapper.allocate() ?
?
@Override public Servlet allocate() throws ServletException { // If we are currently unloading this servlet, throw an exception if (unloading) throw new ServletException (sm.getString("standardWrapper.unloading", getName())); boolean newInstance = false; // If not SingleThreadedModel, return the same instance every time if (!singleThreadModel) { // Load and initialize our instance if necessary if (instance == null) { synchronized (this) { if (instance == null) { try { if (log.isDebugEnabled()) log.debug("Allocating non-STM instance"); instance = loadServlet(); if (!singleThreadModel) { // For non-STM, increment here to prevent a race // condition with unload. Bug 43683, test case // #3 newInstance = true; countAllocated.incrementAndGet(); } } catch (ServletException e) { throw e; } catch (Throwable e) { ExceptionUtils.handleThrowable(e); throw new ServletException (sm.getString("standardWrapper.allocate"), e); } } } } if (!instanceInitialized) { initServlet(instance); } if (singleThreadModel) { if (newInstance) { // Have to do this outside of the sync above to prevent a // possible deadlock synchronized (instancePool) { instancePool.push(instance); nInstances++; } } } else { if (log.isTraceEnabled()) log.trace(" Returning non-STM instance"); // For new instances, count will have been incremented at the // time of creation if (!newInstance) { countAllocated.incrementAndGet(); } return (instance); } } synchronized (instancePool) { while (countAllocated.get() >= nInstances) { // Allocate a new instance if possible, or else wait if (nInstances < maxInstances) { try { instancePool.push(loadServlet()); nInstances++; } catch (ServletException e) { throw e; } catch (Throwable e) { ExceptionUtils.handleThrowable(e); throw new ServletException (sm.getString("standardWrapper.allocate"), e); } } else { try { instancePool.wait(); } catch (InterruptedException e) { // Ignore } } } if (log.isTraceEnabled()) log.trace(" Returning allocated STM instance"); countAllocated.incrementAndGet(); return instancePool.pop(); } }11 tomcat的启动类位于stratup包下面，有Bootstrap创建一个Catalina实例，并调用Catalina的处理方法。之所以分为2个类，是因为在不同的系统下面，会有多个Bootstrap的实现。bin目录下面的shell程序就是用来启动tomcat.
?
12 StringManager，当tomcat发生异常行为时，需要记录错误信息。tomcat采用properties文件来维护错误文案，每个package下面都有自己的一个properties文件。当需要获取错误文案时，直接调用StringManager.getManager(String packageName)即可，这边使用了单例模式，每个package下面共享一个manager.
?
/** * Get the StringManager for a particular package. If a manager for * a package already exists, it will be reused, else a new * StringManager will be created and returned. * * @param packageName The package name */ public static final synchronized StringManager getManager(String packageName) { StringManager mgr = managers.get(packageName); if (mgr == null) { mgr = new StringManager(packageName); managers.put(packageName, mgr); } return mgr; }??
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?