很多開源應用服務器都是集成tomcat作為web container的，而且對於tomcat的servlet container這部分代碼很少改動。這樣，這些應用服務器的性能基本上就取決於Tomcat處理HTTP請求的connector模塊的性能。本文首先從應用層次分析了tomcat所有的connector種類及用法，接着從架構上分析了connector模塊在整個tomcat中所處的位置，最后對connector做了詳細的源代碼分析。並且我們以Http11NioProtocol為例詳細說明了tomcat是如何通過實現ProtocolHandler接口而構建connector的。
一、Connector介紹
1. Connector
在Tomcat架構中，Connector主要負責處理與客戶端的通信。Connector的實例用於監聽端口，接受來自客戶端的請求並將請求轉交給Engine處理。同時將來自Engine的答復返回給客戶端。
2. Connector的種類
Tomcat源碼中與connector相關的類位於org.apache.coyote包中，Connector分為以下幾類：
Http Connector, 基於HTTP協議，負責建立HTTP連接。它又分為BIO Http Connector與NIO Http Connector兩種，后者提供非阻塞IO與長連接Comet支持。默認情況下，Tomcat使用的就是這個Connector。
AJP Connector, 基於AJP協議，AJP是專門設計用來為tomcat與http服務器之間通信專門定制的協議，能提供較高的通信速度和效率。如與Apache服務器集成時，采用這個協議。
APR HTTP Connector, 用C實現，通過JNI調用的。主要提升對靜態資源(如HTML、圖片、CSS、JS等)的訪問性能。現在這個庫已獨立出來可用在任何項目中。Tomcat在配置APR之后性能非常強勁。
具體地，Tomcat7中實現了以下幾種Connector：
org.apache.coyote.http11.Http11Protocol : 支持HTTP/1.1 協議的連接器。
org.apache.coyote.http11.Http11NioProtocol : 支持HTTP/1.1 協議+New IO的連接器。
org.apache.coyote.http11.Http11AprProtocol : 使用APR（Apache portable runtime)技術的連接器,利用Native代碼與本地服務器（如linux）來提高性能。
（以上三種Connector實現都是直接處理來自客戶端Http請求，加上NIO或者APR）
org.apache.coyote.ajp.AjpProtocol：使用AJP協議的連接器，實現與web server（如Apache httpd）之間的通信
org.apache.coyote.ajp.AjpNioProtocol：SJP協議+ New IO
org.apache.coyote.ajp.AjpAprProtocol：AJP + APR
（這三種實現方法則是與web server打交道，同樣加上NIO和APR）
當然，我們可以通過實現ProtocolHandler接口來定義自己的Connector。詳細的實現過程請看文章后文。
3. Connector的配置
對Connector的配置位於conf/server.xml文件中，內嵌在Service元素中，可以有多個Connector元素。
(1) BIO HTTP/1.1 Connector配置
一個典型的配置如下：
如果是SSL配置，如下：
其中，keystoreFile為證書位置，keystorePass為證書密碼
(2) NIO HTTP/1.1 Connector配置
(3) Native APR Connector配置
- ARP是用C/C++寫的，對靜態資源(HTML，圖片等)進行了優化。所以要下載本地庫tcnative-1.dll與openssl.exe，將其放在%tomcat%\bin目錄下。
下載地址是：http://tomcat.heanet.ie/native/1.1.10/binaries/win32/
-
在server.xml中要配置一個Listener,如下圖。這個配置tomcat是默認配好的。<!--APR library loader. Documentation at /docs/apr.html --><Listener className="org.apache.catalina.core.AprLifecycleListener" SSLEngine="on" />
-
配置使用APR connector<Connector port=”8080” protocol=”org.apache.coyote.http11.Http11AprProtocol”maxThreads=”150” connectionTimeout=”20000” redirectPort=”8443”
-
二、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接口,該接口定義如下：
- <span style="font-size:14px;">/*
- * 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();
- }
- </span>
自定義Connector時需實現的ProtoclHandler接口
Tomcat以HTTP(包括BIO與NIO)、AJP、APR、內存四種協議實現了該接口(它們分別是：AjpAprProtocol、AjpProtocol、Http11AprProtocol、Http11NioProtocol、Http11Protocal、JkCoyoteHandler、MemoryProtocolHandler)，要使用哪種Connector就在conf/server.xml中配置，在Connector的構造函數中會通過反射實例化所配置的實現類：
- <span style="font-size:14px;"> public Http11AprProtocol() {
- endpoint = new AprEndpoint(); // 主要工作由AprEndpoint來完成
- cHandler = new Http11ConnectionHandler(this); // inner class
- ((AprEndpoint) endpoint).setHandler(cHandler);</span>
②在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);
- @Override
- public void run() {
- int errorDelay = 0;
- // Loop until we receive a shutdown command
- while (running) {
③在AprEndpoint類中，有一個內部接口Handler，該接口定義如下：
- <span style="font-size:14px;">/**
- * 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<Long> socket,
- SocketStatus status);
- }</span>
④在Http11AprProtocol類中實現了AprEndpoint中的Handler接口，
- protected static class Http11ConnectionHandler
- extends AbstractConnectionHandler<Long,Http11AprProcessor> implements Handler {
並調用Http11AprProcessor類(該類實現了ActionHook回調接口)。
@Override
- <span style="font-size:14px;"> protected Http11AprProcessor createProcessor() {
- Http11AprProcessor processor = new Http11AprProcessor(</span>
- 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<Runnable> workQueue = new LinkedBlockingQueue<Runnable>();
- ThreadPoolExecutor threadPoolExecutor =
- new ThreadPoolExecutor(corePoolSite, maxPoolSite,
- keepAliveTime, unit, workQueue);
- return threadPoolExecutor;
- }
- }
上面這個類用到的MyHandler類代碼如下：
- 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 {
- @Override
- public 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);
- }
- @Override
- public boolean event(Request req, Response res, SocketStatus status)
- throws Exception {
- System.out.println("Event-Event");
- return false;
- }
- @Override
- public boolean asyncDispatch(Request req, Response res, SocketStatus status)
- throws Exception {
- // TODO Auto-generated method stub
- return false;
- }
- @Override
- public void log(Request req, Response res, long time) {
- // TODO Auto-generated method stub
- }
- @Override
- public String getDomain() {
- // TODO Auto-generated method stub
- return null;
- }
- }
注意，必須導入相關的tomcat源碼文件。完成之后運行主程序即：MyServer。然后在瀏覽器中輸入：localhost:9000就可以看到“Not Hello World”。
INFO: Initializing ProtocolHandler ["http-bio-9000"]
十二月 20, 2012 8:46:13 下午 org.apache.coyote.AbstractProtocol start
INFO: Starting ProtocolHandler ["http-bio-9000"]
My Server has started successfully!
Hi, Boss. I am handling the reuqest!
Hi, Boss. I am handling the reuqest!
Hi, Boss. I am handling the reuqest!
Hi, Boss. I am handling the reuqest!