Tomcat服務器配置參考

Tomcat服務器配置參考 

 

 

Coyote HTTP/1.1 Connector

 

概述

Coyote HTTP/1.1 Connector元素是一個支持HTTP/1.1協議的Connector組件。它使Catalina除了能夠執行servlet和JSP頁面外，還能夠作為一個單獨的web server運行。Connector對象的實例在服務器上監聽特定的TCP端口。一個Service可以配置一個或多個這樣的Connector，每個Connector都把請求轉發給對應Engine進行處理，並產生響應。

在 服務器啟動的時候，Connector會創建一些請求處理線程（基於minProcessors屬性值）。每個請求需要一個線程為其服務，直到服務完成。 如果同一時刻的請求數多於可用的請求處理線程，會創建額外的處理線程，線程數的上限是maxProcessors。如果已經到達了最大請求數，仍然有請求 發生，它們被緩存在由Connector創建的server socket中，直到緩存的上限（由acceptCount屬性的值定義）。這以后所有的請求都會收到“拒絕連接”的錯誤，直到有資源能夠處理它們。

屬性

公共屬性

所有Connector的實現支持如下屬性：

屬性	描述
enableLookups	如果希望調用request.getRemoteHost()進行DNS查詢，以返回遠程客戶的實際主機名，將enableLookups設為true。如果希望忽略DNS查詢，僅僅返回IP地址，設為false（這樣提高了性能）。缺省情況下，DNS查詢是使能的。
redirectPort	如果Connector支持非SSL請求，在收到一個要求使用SSL傳輸的請求以后，Catalina會自動將該請求重定向到這里指定的端口號。
scheme	調用request.getScheme()時返回的協議名稱。比如，在SSL Connector上可能將這個屬性設為“https”。缺省值為“http”，更多信息，參考SSL支持
secure	如果希望在該Connector接收到的請求上調用request.isSecure()返回true，設置該屬性為true。缺省值為false。

標准實現

Coyote HTTP/1.1 Connector的標准實現是org.apache.coyote.tomcat5.CoyoteConnector。它還支持如下的附加屬性

屬性	描述
acceptCount	當所有可能的請求處理線程都被使用的時候，連接請求隊列的最大長度。如果該隊列為滿，所有的請求都被拒絕，缺省值為10。
address	對於具有多個IP地址的server，這個屬性指定了用於監聽特定端口的地址。缺省情況下，端口作用於server的所有IP地址。
bufferSize	connector創建的輸入流緩沖區的大小（以字節為單位）。缺省情況下，bufferSize=2048。
compression	為 了節省服務器帶寬，Connector可能使用HTTP/1.1GZIP壓縮。這個參數的可接受值為“off”（不使用壓縮），“on”（壓縮文本數據），“force”（在所有的情況下強制壓縮），或者使用一個數值 整數（等價於“on”，但是指定了輸出被壓縮是的最小的數據數）。如果content-length未知， 而compression設置成“on”或者 更強，輸出也會被壓縮。如果沒有指定，這個屬性被設成“off”
connectionLinger	當Connector使用的socket被關閉的時候，保留該socket的時間，以毫秒為單位。缺省值為－1（不使用socket linger）
connectionTimeout	在Connector接受一個連接以后，等待發生第一個請求的時間，以毫秒為單位。缺省值為60000（60秒）
debug	日志消息的詳細程度，數字越大，輸出越詳細，如果沒有指定，使用缺省值0。
disableUploadTimeout	這個標志允許servlet container在一個servlet執行的時候，使用一個不同的，更長的連接超時。最終的結果是給servlet更長的時間以便完成其執行，或者在數據上載的時候更長的超時時間。如果沒有指定，設為false。
maxKeepAliveRequests	在server關閉連接之前，接受的HTTP請求的最大數目。如果該值設為1，會禁止HTTP/1.0保活，同時也會禁止HTTP/1.1保活和pipelining。如果沒有指定，設為100。
maxSpareThreads	在線程池開始停止不必要的線程之前，允許存在的最大未使用的請求處理線程。缺省值為50。
maxThreads	Connector能夠創建的最大請求處理線程數，這個值決定了同時能夠處理的最大請求數。如果沒有指定，缺省值為200。
minSpareThreads	當Connector第一次啟動時，創建的請求處理線程數。connector同時必須保證指定數目的空閑處理線程。這個值應該設置成比maxThreads小的數值，缺省值為4。
port	Connector創建server socket並等待連接的TCP端口號。操作系統在特定的IP地址上只允許一個服務器應用程序監聽特定的端口。
protocol	為了使用HTTP處理器，該屬性值必須為HTTP/1.1（缺省值）
proxyName	如果connector在代理配置中使用，將這個屬性設置成調用request.getServerName()時返回的服務器名稱。更多信息參考代理支持。
proxyPort	如果Connector在代理配置中使用，這個屬性指定了調用request.getServerPort()返回的端口值。更多信息參考代理支持。
socketBuffer	socket輸出緩沖區的大小。如果為－1，不使用緩沖。缺省值為9000字節。
tcpNoDelay	如果為true，服務器socket會設置TCP_NO_DELAY選項，在大多數情況下可以提高性能。缺省情況下設為true。

嵌套組件

可以嵌套在Connector中的唯一元素是Factory，用來配置服務器套接口工廠組件。這個組件從來都不需要，現在支持這個組件是為了與Tomcat的早期版本兼容。

專有特征

HTTP/1.1 和HTTP/1.0 支持

Connector 支持HTTP/1.1協議的所有必需特征（如RFC2616所描述的），包括永久性連接，流水線，expectations and chunked encoding。如果客戶端（通常是一個瀏覽器）只支持HTTP/1.0，Connector會自動跳回到HTTP/1.0。不需要特殊的配置來使能這 個支持。Connector也支持HTTP/1.0保活機制。

RFC2616要求HTTP服務器的響應總是以它們宣稱支持的最高HTTP版本開始。因此，這個Connector在它的響應的開始總是返回HTTP/1.1。

 

日志輸出

Connector產生的任何調試或者異常信息都會被自動路由到與Connector所屬的Engine的Logger。不需要特殊的配置來使能這個支持。

 

代理支持

在 Tomcat位於代理服務器后面時，可以使用proxyName和proxyPort屬性。這些屬性修改了調用 requset.getServerName()和request.getServerPort()的返回值，用來構造重定向的絕對URL。如果不設置這 些值，返回值反映了代理服務器收到的連接的服務器名稱和端口號，而不是客戶端發起的服務器名稱和端口號。

更多信息，參考代理支持HOW-TO

SSL支持

對Connector的特定實例，可以將secure屬性設為true，來使能SSL支持。另外，可以配置如下屬性：

 

屬性	描述
algorithm	使用的認證編碼算法。缺省值為SunX509。
clientAuth	如果在接受某個連接之前，需要客戶端發送有效證書鏈，將該值設為true。如果為false（缺省值），不需要使用證書鏈。除非客戶端請求被CLIENT-CERT認證保護的資源。
keystoreFile	存儲服務器證書的keystore文件路徑。缺省情況下，路徑指向運行Tomcat的用戶主目錄下的".keystore"。
keystorePass	用來訪問服務器證書的密碼，缺省值未"changeit"
keystoreType	用於存儲服務器證書的keystore文件的類型。缺省值未"JKS"
sslProtocol	SSL協議的版本號，缺省值是TLS
ciphers	可以使用的加密算法列表，用逗號分開。如果沒有指定，可以使用任何算法。

 

 

[Tomcat源碼系列] Tomcat Connector

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對象，一個請求處理完畢，功德圓滿。

來源：http://1632004.blog.163.com/blog/static/29991497201201912858468/