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. import java.util.concurrent.BlockingQueue;
  3. import java.util.concurrent.LinkedBlockingQueue;
  4. import java.util.concurrent.ThreadPoolExecutor;
  5. import java.util.concurrent.TimeUnit;
  6. import org.apache.coyote.http11.Http11Protocol;
  7. public class TomcatMainV2
  8. {
  9. public static void main(String[] args) throws Exception
  10. {
  11. Http11Protocol protocol = new Http11Protocol();
  12. protocol.setPort(8000);
  13. ThreadPoolExecutor threadPoolExecutor = createThreadPoolExecutor();
  14. threadPoolExecutor.prestartCoreThread();
  15. protocol.setExecutor(threadPoolExecutor);
  16. protocol.setAdapter(new MyHandler());
  17. protocol.init();
  18. protocol.start();
  19. }
  20. public static ThreadPoolExecutor createThreadPoolExecutor()
  21. {
  22. int corePoolSize = 2;
  23. int maximumPoolSize = 10;
  24. long keepAliveTime = 60;
  25. TimeUnit unit = TimeUnit.SECONDS;
  26. BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<Runnable>();
  27. ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
  28. corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
  29. return threadPoolExecutor;
  30. }
  31. }

请求处理器向客户端打引Hello World,代码如下

Java代码  

  1. package ray.tomcat.test;
  2. import java.io.ByteArrayOutputStream;
  3. import java.io.OutputStreamWriter;
  4. import java.io.PrintWriter;
  5. import org.apache.coyote.Adapter;
  6. import org.apache.coyote.Request;
  7. import org.apache.coyote.Response;
  8. import org.apache.tomcat.util.buf.ByteChunk;
  9. import org.apache.tomcat.util.net.SocketStatus;
  10. public class MyHandler implements Adapter
  11. {
  12. //支持Comet,Servlet3.0将对Comet提供支持,Tomcat6目前是非标准的实现
  13. public boolean event(Request req, Response res, SocketStatus status)
  14. throws Exception
  15. {
  16. System.out.println("event");
  17. return false;
  18. }
  19. //请求处理
  20. public void service(Request req, Response res) throws Exception
  21. {
  22. System.out.println("service");
  23. ByteArrayOutputStream baos = new ByteArrayOutputStream();
  24. PrintWriter writer = new PrintWriter(new OutputStreamWriter(baos));
  25. writer.println("Hello World");
  26. writer.flush();
  27. ByteChunk byteChunk = new ByteChunk();
  28. byteChunk.append(baos.toByteArray(), 0, baos.size());
  29. res.doWrite(byteChunk);
  30. }
  31. }

运行主程序,在浏览器中输入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. // 初始化ServerSocket工厂类,如果需SSL/TLS支持,使用JSSESocketFactory/PureTLSSocketFactory
  5. . . . (略)
  6. //主要的初始化过程实际是在endpoint(JIoEndpoint)
  7. endpoint.init();
  8. . . . (略)
  9. }

Http11Protocol的初始化非常简单,准备好ServerSocket工厂,调用JIoEndPoint的初始化。让我们接下来看看JIoEndPoint的初始化过程

Java代码  

  1. public void init()
  2. throws Exception {
  3. if (initialized)
  4. return;
  5. // Initialize thread count defaults for acceptor
  6. // 请求接收处理线程,这个值实际1已经足够
  7. if (acceptorThreadCount == 0) {
  8. acceptorThreadCount = 1;
  9. }
  10. if (serverSocketFactory == null) {
  11. serverSocketFactory = ServerSocketFactory.getDefault();
  12. }
  13. //创建监停ServerSocket,port为监听端口,address为监停地址
  14. // backlog为连接请求队列容量(@param backlog how many connections are queued)
  15. if (serverSocket == null) {
  16. try {
  17. if (address == null) {
  18. serverSocket = serverSocketFactory.createSocket(port, backlog);
  19. } else {
  20. serverSocket = serverSocketFactory.createSocket(port, backlog, address);
  21. }
  22. } catch (BindException be) {
  23. throw new BindException(be.getMessage() + ":" + port);
  24. }
  25. }
  26. //if( serverTimeout >= 0 )
  27. //    serverSocket.setSoTimeout( serverTimeout );
  28. initialized = true;
  29. }

可以看到,监停端口在此处准备就绪

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. // Create worker collection
  11. // 初始化工作线程池,有WorkerStack(Tomcat自实现)和Executor(JDK concurrent包)两种实现
  12. if (executor == null) {
  13. workers = new WorkerStack(maxThreads);
  14. }
  15. // Start acceptor threads
  16. // 启动请求连接接收处理线程
  17. for (int i = 0; i < acceptorThreadCount; i++) {
  18. Thread acceptorThread = new Thread(new Acceptor(), getName() + "-Acceptor-" + i);
  19. acceptorThread.setPriority(threadPriority);
  20. acceptorThread.setDaemon(daemon); //设置是否daemon参数,默认为true
  21. acceptorThread.start();
  22. }
  23. }
  24. }

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. // Create worker collection
  11. // 初始化工作线程池,有WorkerStack(Tomcat自实现)和Executor(JDK concurrent包)两种实现
  12. if (executor == null) {
  13. workers = new WorkerStack(maxThreads);
  14. }
  15. // Start acceptor threads
  16. // 启动请求连接接收处理线程
  17. for (int i = 0; i < acceptorThreadCount; i++) {
  18. Thread acceptorThread = new Thread(new Acceptor(), getName() + "-Acceptor-" + i);
  19. acceptorThread.setPriority(threadPriority);
  20. acceptorThread.setDaemon(daemon); //设置是否daemon参数,默认为true
  21. acceptorThread.start();
  22. }
  23. }
  24. }

主要处理的事情无非就是准备和工作线程(处理具体请求的线程度池,可选,也可以使用JDK5.0的线程池),连接请求接收处理线程(代码中,一般acceptorThreadCount=1)

3.连接请求接收处理:准备就绪,可以连接入请求了。现在工作已经转到了Acceptor(JIoEndPoint$Acceptor)这里,我们看看Acceptor到底做了些啥

Java代码  

  1. public void run() {
  2. // Loop until we receive a shutdown command
  3. while (running) {
  4. . . . (略)
  5. //阻塞等待客户端连接
  6. Socket socket = serverSocketFactory.acceptSocket(serverSocket);
  7. serverSocketFactory.initSocket(socket);
  8. // Hand this socket off to an appropriate processor
  9. if (!processSocket(socket)) {
  10. // Close socket right away
  11. try {
  12. socket.close();
  13. } catch (IOException e) {
  14. // Ignore
  15. }
  16. }
  17. . . . (略)
  18. }
  19. }
  20. . . . (略)
  21. protected boolean processSocket(Socket socket) {
  22. try {
  23. //由工作线程继续后续的处理
  24. if (executor == null) {
  25. getWorkerThread().assign(socket);
  26. } else {
  27. executor.execute(new SocketProcessor(socket));
  28. }
  29. } catch (Throwable t) {
  30. . . . (略)
  31. return false;
  32. }
  33. return true;
  34. }

实际上也没有什么复杂的工作,无非就是有连接上来之后,将连接转交给工作线程(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对象,一个请求处理完毕,功德圆满。

tomcat connector连接器

时间: 2024-10-10 00:24:43

tomcat connector连接器的相关文章

tomcat Connector 连接器

连接器的核心功能,本文去除非核心功能,留下整个程序的框架,便于理解. 1.接受连接请求 2.创建request,和response. 3.调用容器对应的Invoke方法, 首先看类的依赖结构. 1.Connetor 构造方法,根据具体的协议名字,创建协议处理器,主要有NIO,BIO,AJP,协议.如果要自定义协议处理剂最重要的协议处理器了.如图,协议处理需要实现ProtocoHandler接口, 构造函数 输入为协议名称 public Connector(String protocol) { s

Tomcat剖析(四):Tomcat默认连接器(2)

Tomcat剖析(四):Tomcat默认连接器(2) 目录: Tomcat剖析(一):一个简单的Web服务器 Tomcat剖析(二):一个简单的Servlet服务器 Tomcat剖析(三):连接器(1) Tomcat剖析(三):连接器(2) Tomcat剖析(四):Tomcat默认连接器(1) Tomcat剖析(四):Tomcat默认连接器(2) 同样的,你需要先下载代码. https://github.com/zebinlin/Tomcat4-src 经过上一节的讲解,你已经理解了请求和响应对

Tomcat Connector

转自: http://blog.csdn.net/aesop_wubo/article/details/7617416 如下图所示,Tomcat服务器主要有两大核心模块组成:连接器和容器,本节只分析连接器的实现. 连接器主要是接收用户的请求,然后封装请求传递给容器处理,tomcat中默认的连接器是Coyote.首先来看连接器的类图: protocol 我们发现这个类里面有很多与protocol有关的属性和方法,tomcat中支持两种协议的连接器:HTTP/1.1与AJP/1.3,查看tomcat

修改Tomcat Connector运行模式,优化Tomcat运行性能

Tomcat是一个小型的轻量级应用服务器,也是JavaEE开发人员最常用的服务器之一.不过,许多开发人员不知道的是,Tomcat Connector(Tomcat连接器)有bio.nio.apr三种运行模式,那么这三种运行模式有什么区别呢,我们又如何修改Tomcat Connector的运行模式来提高Tomcat的运行性能呢? 下面,我们先大致了解Tomcat Connector的三种运行模式. bio bio(blocking I/O),顾名思义,即阻塞式I/O操作,表示Tomcat使用的是传

JBossWeb/Tomcat 初始化连接器和处理 Http 请求过程

概述 JBossWeb 是JBoss 中的 Web 容器,他是对 Tomcat 的封装,本文以 Http 连接器为例,简单说明 JBossWeb/Tomcat 初始化连接器和处理 Http 请求过程 .本文内容提要: Connector 初始化开始过程 如何理解 max-connections JIoEndpoint 处理 Socket 请求 Connector 初始化开始过程 如下图所示: WebConnectorService 指的是 `org.jboss.as.web.WebConnect

Tomcat Connector三种运行模式(BIO, NIO, APR)的比较和优化

Tomcat Connector的三种不同的运行模式性能相差很大,有人测试过的结果如下: 这三种模式的不同之处如下: BIO: 一个线程处理一个请求.缺点:并发量高时,线程数较多,浪费资源. Tomcat7或以下,在Linux系统中默认使用这种方式. NIO: 利用Java的异步IO处理,可以通过少量的线程处理大量的请求. Tomcat8在Linux系统中默认使用这种方式. Tomcat7必须修改Connector配置来启动: <Connector port="8080" pro

Tomcat Connector的三种运行模式

详情参考: http://tomcat.apache.org/tomcat-7.0-doc/apr.html http://www.365mini.com/page/tomcat-connector-mode.htm 操作环境:rhel6.3 x86_x64. tomcat7.0.42 tomcat connector三种运行模式分别为:bio.nio和apr.你可以简单地理解成,性能上:bio<nio<=apr 其中bio为默认运行方式,即(server.xml): <Connecto

The Apache Tomcat Connector

http://tomcat.apache.org/connectors-doc/generic_howto/quick.html 搭建最简单的tomcat connector 用到了apapche 的mod_jk 模块 . 下载编译 tomcat connector wget http://mirrors.cnnic.cn/apache/tomcat/tomcat-connectors/jk/tomcat-connectors-1.2.40-src.tar.gz tar xzf tomcat-c

Tomcat Connector三种执行模式(BIO, NIO, APR)的比較和优化

Tomcat Connector的三种不同的执行模式性能相差非常大,有人測试过的结果例如以下: 这三种模式的不同之处例如以下: BIO: 一个线程处理一个请求.缺点:并发量高时,线程数较多,浪费资源. Tomcat7或下面,在Linux系统中默认使用这样的方式. NIO: 利用Java的异步IO处理.能够通过少量的线程处理大量的请求. Tomcat8在Linux系统中默认使用这样的方式. Tomcat7必须改动Connector配置来启动: <Connector port="8080&qu