二、Connector在Tomcat中所处的位置

1. Tomcat架构

>>>Server(服务器)是Tomcat构成的顶级构成元素，所有一切均包含在Serv    erz中，Server的实现类StandardServer可以包含一个到多个Services;>>>>Service的实现类为StandardService调用了容器(Container)     接口，其实是调用了Servlet Engine(引擎)，而且StandardService类中也   指明了该Service归属的Server;

• >>>Container，引擎(Engine)、主机(Host)  上下文(Context)和Wraper均继承自Container接口，所以它们都是容器       但是，它们是有父子关系的，在主机(Host)、上下文(Context)和引擎(En      gine)这三类容器中，引擎是顶级容器，直接包含是主机容器，而主机容       器又包含上下文容器，所以引擎、主机和上下文从大小上来说又构成父子     关系,虽然它们都继承自Container接口。
• >>>连接器(Connector)将Service和Container连接起来，首先它需要注册到一个Service，它的作用就是把来自客户端的请求转发到Container(容器)，这就是它为什么称作连接器的原因。

故我们从功能的角度将Tomcat源代码分成5个子模块，它们分别是：

Jsper子模块：这个子模块负责jsp页面的解析、jsp属性的验证，同时也负责将jsp页面动态转换为java代码并编译成class文件。在Tomcat源代码中，凡是属于org.apache.jasper包及其子包中的源代码都属于这个子模块;

Servlet和Jsp规范的实现模块：这个子模块的源代码属于javax.servlet包及其子包，如我们非常熟悉的javax.servlet.Servlet接口、javax.servet.http.HttpServlet类及javax.servlet.jsp.HttpJspPage就位于这个子模块中;

Catalina子模块：这个子模块包含了所有以org.apache.catalina开头的java源代码。该子模块的任务是规范了Tomcat的总体架构，定义了Server、Service、Host、Connector、Context、Session及Cluster等关键组件及这些组件的实现，这个子模块大量运用了Composite设计模式。同时也规范了Catalina的启动及停止等事件的执行流程。从代码阅读的角度看，这个子模块应该是我们阅读和学习的重点。

Connector子模块：如果说上面三个子模块实现了Tomcat应用服务器的话，那么这个子模块就是Web服务器的实现。所谓连接器(Connector)就是一个连接客户和应用服务器的桥梁，它接收用户的请求，并把用户请求包装成标准的Http请求(包含协议名称，请求头Head，请求方法是Get还是Post等等)。同时，这个子模块还按照标准的Http协议，负责给客户端发送响应页面，比如在请求页面未发现时，connector就会给客户端浏览器发送标准的Http 404错误响应页面。

Resource子模块：这个子模块包含一些资源文件，如Server.xml及Web.xml配置文件。严格说来，这个子模块不包含java源代码，但是它还是Tomcat编译运行所必需的。

2.Tomcat运行流程

• Connector把该请求交给它所在的Service的Engine来处理，并等待Engine的回应
• Engine获得请求localhost:8080/test/index.jsp，匹配它所有虚拟主机Host
• Engine匹配到名为localhost的Host(即使匹配不到也把请求交给该Host处理，因为该Host被定义为该Engine的默认主机)
• localhost Host获得请求/test/index.jsp，匹配它所拥有的所有Context
• Host匹配到路径为/test的Context(如果匹配不到就把该请求交给路径名为""的Context去处理)
• path="/test"的Context获得请求/index.jsp，在它的mapping table中寻找对应的servlet
• Context匹配到URL PATTERN为*.jsp的servlet，对应于JspServlet类，构造HttpServletRequest对象和HttpServletResponse对象，作为参数调用JspServlet的doGet或doPost方法
• Context把执行完了之后的HttpServletResponse对象返回给Host
• Host把HttpServletResponse对象返回给Engine
• Engine把HttpServletResponse对象返回给Connector
• Connector把HttpServletResponse对象返回给客户browser

三、Connector源码分析

1 Tomcat的启动分析与集成设想

我们知道，启动tomcat有两种方式：双击bin/startup.bat、运行bin/catalina.bat run。它们对应于Bootstrap与Catalina两个类，我们现在只关心Catalina这个类，这个类使用Apache Digester解析conf/server.xml文件生成tomcat组件，然后再调用Embedded类的start方法启动tomcat。

所以，集成Tomcat的方式就有以下两种了：

①沿用tomcat自身的server.xml

②自己定义一个xml格式来配置tocmat的各参数，自己再写解析这段xml，然后使用tomcat提供的API根据这些xml来生成Tomcat组件，最后调用Embedded类的start方法启动tomcat

个人觉得第一种方式要优越，给开发者比较好的用户体验，如果使用这种，直接模仿Catalina类的方法即可实现集成。

目前，JOnAS就使用了这种集成方式，JBoss、GlassFish使用的第二种自定义XML的方式。

2. Connector类图与顺序图

从上面二图中我们可以得到如下信息：

Tomcat中有四种容器(Context、Engine、Host、Wrapper)，前三者常见，第四个不常见但它也是实现了Container接口的容器

如果要自定义一个Connector的话，只需要实现org.apache.coyote.ProtocolHander接口,该接口定义如下：

/**  Licensed to the Apache Software Foundation (ASF) under one or more*  contributor license agreements.  See the NOTICE file distributed with*  this work for additional information regarding copyright ownership.*  The ASF licenses this file to You under the Apache License, Version 2.0*  (the "License"); you may not use this file except in compliance with*  the License.  You may obtain a copy of the License at**      http://www.apache.org/licenses/LICENSE-2.0**  Unless required by applicable law or agreed to in writing, software*  distributed under the License is distributed on an "AS IS" BASIS,*  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.*  See the License for the specific language governing permissions and*  limitations under the License.*/package org.apache.coyote;import java.util.concurrent.Executor;/*** Abstract the protocol implementation, including threading, etc.* Processor is single threaded and specific to stream-based protocols,* will not fit Jk protocols like JNI.** This is the main interface to be implemented by a coyote connector.* Adapter is the main interface to be implemented by a coyote servlet* container.** @author Remy Maucherat* @author Costin Manolache* @see Adapter*/
public interface ProtocolHandler {   //Tomcat 中的Connector实现了这个接口/*** The adapter, used to call the connector.*/public void setAdapter(Adapter adapter);public Adapter getAdapter();/*** The executor, provide access to the underlying thread pool.*/public Executor getExecutor();/*** Initialise the protocol.*/public void init() throws Exception;/*** Start the protocol.*/public void start() throws Exception;/*** Pause the protocol (optional).*/public void pause() throws Exception;/*** Resume the protocol (optional).*/public void resume() throws Exception;/*** Stop the protocol.*/public void stop() throws Exception;/*** Destroy the protocol (optional).*/public void destroy() throws Exception;/*** Requires APR/native library*/public boolean isAprRequired();
}

Tomcat以HTTP(包括BIO与NIO)、AJP、APR、内存四种协议实现了该接口(它们分别是：AjpAprProtocol、AjpProtocol、Http11AprProtocol、Http11NioProtocol、Http11Protocal、JkCoyoteHandler、MemoryProtocolHandler)，要使用哪种Connector就在conf/server.xml中配置，在Connector的构造函数中会通过反射实例化所配置的实现类：

    public Http11AprProtocol() {endpoint = new AprEndpoint();                    // 主要工作由AprEndpoint来完成cHandler = new Http11ConnectionHandler(this);    // inner class((AprEndpoint) endpoint).setHandler(cHandler);

②在AprEndpoint.Acceptor类中的run()方法会接收一个客户端新的连接请求.

    /*** The background thread that listens for incoming TCP/IP connections and* hands them off to an appropriate processor.*/protected class Acceptor extends AbstractEndpoint.Acceptor {private final Log log = LogFactory.getLog(AprEndpoint.Acceptor.class);@Overridepublic void run() {int errorDelay = 0;// Loop until we receive a shutdown commandwhile (running) {

③在AprEndpoint类中，有一个内部接口Handler，该接口定义如下：

/*** Bare bones interface used for socket processing. Per thread data is to be* stored in the ThreadWithAttributes extra folders, or alternately in* thread local fields.*/public interface Handler extends AbstractEndpoint.Handler {public SocketState process(SocketWrapper socket,SocketStatus status);}

④在Http11AprProtocol类中实现了AprEndpoint中的Handler接口，

 protected static class Http11ConnectionHandlerextends AbstractConnectionHandler implements Handler {

       @Override

        protected Http11AprProcessor createProcessor() {Http11AprProcessor processor = new Http11AprProcessor(

package myConnector;import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;import org.apache.coyote.http11.Http11Protocol;/*** 基于Http11Protocol实现一个简单的服务器* @author bingduanLin**/
public class MyServer {/*** @param args*/public static void main(String[] args) throws Exception{Http11Protocol hp = new Http11Protocol();hp.setPort(9000);ThreadPoolExecutor threadPoolExecutor = createThreadPoolExecutor();threadPoolExecutor.prestartCoreThread();hp.setExecutor(threadPoolExecutor);hp.setAdapter(new myHandler());hp.init();hp.start();System.out.println("My Server has started successfully!");}public static ThreadPoolExecutor createThreadPoolExecutor() {int corePoolSite = 2 ;int maxPoolSite = 10 ;long keepAliveTime = 60 ;TimeUnit unit = TimeUnit.SECONDS;BlockingQueue workQueue = new LinkedBlockingQueue();ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(corePoolSite, maxPoolSite,keepAliveTime, unit, workQueue);return threadPoolExecutor;}}

package myConnector;import java.io.ByteArrayOutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;import org.apache.coyote.Adapter;
import org.apache.coyote.Request;
import org.apache.coyote.Response;
import org.apache.tomcat.util.buf.ByteChunk;
import org.apache.tomcat.util.net.SocketStatus;public class myHandler implements Adapter {@Overridepublic void service(Request req, Response res) throws Exception {// 请求处理System.out.println("Hi, Boss. I am handling the reuqest!");ByteArrayOutputStream baos = new ByteArrayOutputStream();   PrintWriter writer = new PrintWriter(new OutputStreamWriter(baos));   writer.println("Not Hello World");   writer.flush();   ByteChunk byteChunk = new ByteChunk();   byteChunk.append(baos.toByteArray(), 0, baos.size());   res.doWrite(byteChunk);  }@Overridepublic boolean event(Request req, Response res, SocketStatus status)throws Exception {System.out.println("Event-Event");return false;}@Overridepublic boolean asyncDispatch(Request req, Response res, SocketStatus status)throws Exception {// TODO Auto-generated method stubreturn false;}@Overridepublic void log(Request req, Response res, long time) {// TODO Auto-generated method stub}@Overridepublic String getDomain() {// TODO Auto-generated method stubreturn null;}}