从零开始手写Tomcat的教程4节---Tomcat默认连接器

转x33g5p2x  于2022-03-13 转载在 其他  
字(10.3k)|赞(0)|评价(0)|浏览(577)

Tomcat默认连接器

本节我们来分析一下tomcat 4中默认连接器的源码

Tomcat 1-3节

注意: 本节所讲的连接器是指Tomcat 4中的默认连接器，虽然该连接器已经弃用，被另一个运行速度更快的连接器—Coyote—取代，但它仍然是一个不错的学习工具

一个 Tomcat 连接器必须符合以下条件：

  • 必须实现接口 org.apache.catalina.Connector。
  • 必须创建请求对象，该请求对象的类必须实现接口 org.apache.catalina.Request。
  • 必须创建响应对象，该响应对象的类必须实现接口 org.apache.catalina.Response。

Tomcat4 的默认连接器类似于上节的简单连接器。它等待前来的 HTTP 请求，创建 request和 response 对象，然后把 request 和 response 对象传递给容器(上节只是交给响应的处理器Processor处理)。

连接器是通过调用接口org.apache.catalina.Container 的 invoke 方法来传递 request 和 response 对象的。

Tomcat 4的默认连接器使用了很多技巧进行优化，例如: 使用了一个对象池来避免频繁创建对象带来的性能损耗，其次，在很多地方，Tomcat 4的默认连接器使用了字符数组来代替字符串。

Tomcat 4的默认连接器实现了HTPP 1.1 新特性，因此我们从Http 1.1新特性讲起，这是理解后文默认连接器为何要如此写的重点:

Http 1.1 新特性

持久连接

说白了就是复用连接，能少创建连接就少创建一点

块编码

Content-Length 字段

一个TCP连接现在可以传送多个回应，势必就要有一种机制，区分数据包是属于哪一个回应的。这就是Content-length字段的作用，声明本次回应的数据长度。

  1. Content-Length: 3495

上面代码告诉浏览器，本次回应的长度是3495个字节，后面的字节就属于下一个回应了。

在1.0版中，Content-Length字段不是必需的，因为浏览器发现服务器关闭了TCP连接，就表明收到的数据包已经全了。

使用Content-Length字段的前提条件是，服务器发送回应之前，必须知道回应的数据长度。

对于一些很耗时的动态操作来说，这意味着，服务器要等到所有操作完成，才能发送数据，显然这样的效率不高。更好的处理方法是，产生一块数据，就发送一块，采用"流模式"（stream）取代"缓存模式"（buffer）。

因此，1.1版规定可以不使用Content-Length字段，而使用"分块传输编码"（chunked transfer encoding）。只要请求或回应的头信息有Transfer-Encoding字段，就表明回应将由数量未定的数据块组成。

  1. Transfer-Encoding: chunked

每个非空的数据块之前，会有一个16进制的数值，表示这个块的长度。最后是一个大小为0的块，就表示本次回应的数据发送完了。下面是一个例子。

  1. HTTP/1.1 200 OK
  2. Content-Type: text/plain
  3. Transfer-Encoding: chunked
  5. 25
  6. This is the data in the first chunk
  8. 1C
  9. and this is the second one
  11. 3
  12. con
  14. 8
  15. sequence
  17. 0

状态码100的使用

Connector接口

功能组件大白话图解:

这张图现在可能看上去比较懵逼，后面等我讲完本节，大家再回头看一下，会发现豁然开朗

HttpConnector类

创建服务器套接字

其实就是绑定端口号，设置连接队列大小，然后创建ServerSocket对象

维护HttpProcessor实例

提供Http请求服务

HttpConnector拿到客户端连接后，会去栈里面看看还存不存在可用处理器

提前剧透:每一个HttpProcessor都在各自的线程中运行

  1. public void run() {
  2.         while (!stopped) {
  3.             Socket socket = null;
  4.             try {
  5.                 socket = serverSocket.accept();//等待用户请求，阻塞
  6.             } catch (AccessControlException ace) {
  7.                 continue;
  8.             } catch (IOException e) {
  9.                 //省略
  10.                 continue;
  11.             }
  12.             HttpProcessor processor = createProcessor(); //从池中获取处理器实例
  13.             if (processor == null) {
  14.                 try {
  15.                     socket.close();
  16.                 } catch (IOException e) {
  17.                     ;
  18.                 }
  19.                 continue;
  20.             }
  21.             processor.assign(socket); //将请求的socket交给得到的处理器实例中
  22.         }
  23.     }

HttpProcessor类

看一下recycle方法:

注意:连接器拥有处理器池的所有权，而不是处理器自己拥有，因此上面调用的是connector.recycle(this)

  1. public void run() {
  3.         while (!stopped) {
  5.             Socket socket = await(); //阻塞，直到用户请求到来获取到这个处理器才被唤醒
  6.             if (socket == null)
  7.                 continue;
  9.             try {
  10.                 process(socket); //处理用户请求
  11.             } catch (Throwable t) {
  12.                 log("process.invoke", t);
  13.             }
  15.             connector.recycle(this);  //连接器回收处理器
  16.         }
  17.     }

重点

这个实现有很意思，也非常值得我们学习，下面来看一下的源码:

  1. synchronized void assign(Socket socket) {
  3.     while (available) { //avaiable默认是false,，第一次执行时跳过while
  4.         try {
  5.             wait();
  6.         } catch (InterruptedException e) {
  7.         }
  8.     }
  10.     this.socket = socket; //将从池中获取到的HttpProcessor实例中的socket变量赋值
  11.     available = true;
  12.     notifyAll();//唤醒线程。
  13. }
  15. private synchronized Socket await() {
  17.     while (!available) {//默认是false，所以进入循环阻塞，因为处理器实例没有socket信息，
  18.         try {
  19.             wait();
  20.         } catch (InterruptedException e) {
  21.         }
  22.     }
  24.     Socket socket = this.socket;  //得到了socket
  25.     available = false;  //重新进入阻塞
  26.     notifyAll();
  28.     if ((debug >= 1) && (socket != null))
  29.         log("  The incoming request has been awaited");
  31.     return (socket);
  33. }

用户请求到来，得到了用户的 socket，调用 assign 方法，因为 avaiable 默认是 false,所以跳过 while 需要，将 socket 放入获取到的处理器实例中，同时将 avaiable 设为 true，唤醒线程，此时 await 方法中的 wait 方法被唤醒了，同时因为 avaliable 为 true，跳出循环，将 avaiable 设为 false 重新进入阻塞，得到用户的返回用户的 socket，最后就能够通过 process 处理请求了。

疑问：

为什么 await 需要使用一个本地变量(socket)而不是返回实例的 socket 变量呢？

  • 因为这样一来，在当前 socket 被完全处理之前，实例的 socket 变量可以赋给下一个前来的 socket。

为什么 await 方法需要调用 notifyAll 呢?

  • 这是为了防止在 available 为 true 的时候另一个 socket 到来。在这种情况下，连接器线程将会在 assign
    方法的 while 循环中停止，直到接收到处理器线程的 notifyAll 调用。

Request对象

默认连接器里 HTTP 请求对象实现org.apache.catalina.Request 接口。这个接口被类RequestBase 直接实现了，也是 HttpRequest 的父接口。最终的实现是继承于 HttpRequest 的HttpRequestImpl。像第 3 节的一样，有几个 facade 类：RequestFacade 和 HttpRequestFacade。需要注意的是，这里除了属于 javax.servlet和 javax.servlet.http 包的类，前缀 org.apache.catalina 已经被省略了。对HTTP响应对象也是类似的。

看了上面的类继承图，我们应该要学习一下Tocmat的继承体系的设计思想，例如：RequestBase类承担着两个接口公共属性的基础类， HttpRequestBase类也是，承担着RequestBase和HttpRequest类的公共属性

还有就是之前提过的外观对象的引入，对客户端隐藏了部分特殊方法,防止客户端强制转换进行调用

Response对象

处理请求

和第3节的一样，有一个 SocketInputStream 实例用来包装套接字的输入流。注意的是，SocketInputStream 的 构 造 方 法 同 样 传 递 了 从 连 接 器 获 得 的 缓 冲 区 大 小 ， 而 不 是 从HttpProcessor 的本地变量获得(第3节中是指定的2048)。这是因为对于默认连接器的用户而言，HttpProcessor 是不可访问的。通过传递 Connector 接口的缓冲区大小，这就使得使用连接器的任何人都可以设置缓冲大小。

  1. SocketInputStream input = null;
  2. OutputStream output = null;
  4. // Construct and initialize the objects we will need
  5. try {
  6.     input = new SocketInputStream(socket.getInputStream(),
  7.                                   connector.getBufferSize());
  8. } catch (Exception e) {
  9.     log("process.create", e);
  10.     ok = false;
  11. }

process 方法使用布尔变量 ok 来指代在处理过程中是否发现错误，从代码中可以看到一旦catch到错误，就会设为false 并使用布尔变量finishResponse 来指代 Response 接口中的 finishResponse 方法是否应该被调用。

  1. boolean ok = true;
  3.  boolean finishResponse = true;

另外， process 方法也使用了布尔变量 keepAlive,stopped 和 http11。 keepAlive 表示连接 是否是持久的， stopped 表示 HttpProcessor 实例是否已经被连接器终止来确认 process 是否也应该停止，http11 表示 从 web 客户端过来的 HTTP 请求是否支持 HTTP 1.1。

然后，有个 while 循环用来保持从输入流中读取，直到 HttpProcessor 被停止，一个异常被抛出或者连接给关闭为止。

  1. while (!stopped && ok && keepAlive) {
  3.     //....  
  4. }

在 while 循环的内部，process 方法首先把 finishResponse 设置为 true，并获得输出流，并对请求和响应对象做些初始化处理。

如果初始化过程都catch到错误，解析连接和头部就不用做了，所以抛错时ok会设为false

  1. //初始化请求和响应对象
  2. request.setStream(input);
  3. request.setResponse(response);
  4. output = socket.getOutputStream();
  5. response.setStream(output);
  6. response.setRequest(request);
  7. ((HttpServletResponse) response.getResponse()).setHeader
  8.                 ("Server", SERVER_INFO);

接着，process 方法通过调用 parseConnection，parseRequest 和 parseHeaders 方法开始解析前来的 HTTP 请求，这些方法将在这节的后面讨论。

  1. parseConnection(socket);
  2. parseRequest(input, output);
  3. if (!request.getRequest().getProtocol()   
  4.     .startsWith("HTTP/0"))
  5.    parseHeaders(input);

parseConnection 方法获得协议的值，像 HTTP0.9, HTTP1.0 或 HTTP1.1。

如果协议是 HTTP1.0，keepAlive 设置为 false，因为 HTTP1.0 不支持持久连接。

如果在 HTTP 请求里边找到 Expect: 100-continue 的头部信息，则 parseHeaders 方法将把 sendAck 设置为 true。

如果协议是 HTTP1.1，并且 web 客户端发送头部 Expect: 100-continue 的话，通过调用ackRequest 方法它将响应这个头部。它将会测试组块是否是允许的。

getProtocol()获取的协议值是在parseConnection时设置的

ackRequest 方法测试 sendAck 的值，并在 sendAck 为 true 的时候发送下面的字符串：HTTP/1.1 100 Continue\r\n\r\n

  1. if (http11) {
  2.     // Sending a request acknowledge back to the client if
  3.     // requested.
  4.     ackRequest(output);
  5.     // If the protocol is HTTP/1.1, chunking is allowed.
  6.     if (connector.isChunkingAllowed())
  7.         response.setAllowChunking(true);
  8. }

在解析 HTTP 请求的过程中，有可能会抛出异常。任何异常将会把 ok 或者 finishResponse设置为 false。

在解析过后，process 方法把请求和响应对象传递给容器的 invoke 方法：

  1. ((HttpServletResponse) response).setHeader
  2.    ("Date", FastHttpDateFormat.getCurrentDate());
  3. if (ok) {
  4.    connector.getContainer().invoke(request, response);
  5. }

BootStrap类

  1. public final class Bootstrap {
  3.     public static void main(String[] args) {
  5.         HttpConnector connector = new HttpConnector();
  6.         SimpleContainer container = new SimpleContainer();
  7.         connector.setContainer(container);
  8.         try {
  9.             connector.initialize();
  10.             connector.start();
  12.             System.in.read();
  13.         } catch (Exception e) {
  14.             e.printStackTrace();
  15.         }
  16.     }
  17. }

SimpleContainer是什么？ 它实现了Container接口，通过HttpConnector解析出请求和响应后传递给容器

容器通过请求和响应对象获得servletName，负责servlet的加载执行，第4节只是简单实现了invoke方法，其他方法未实现。

对应前面几节的ServletProcessor.java

所以为什么要有Container呢，就是将servlet加载执行过程分离出来，当然实际不止那么简单。

SimpleContainer类

  1. public class SimpleContainer implements Container{
  3. public void invoke(Request request, Response response) throws IOException,
  4.             ServletException {
  6.         String servletName = ((HttpServletRequest) request).getRequestURI();
  7.         servletName = servletName.substring(servletName.lastIndexOf("/") + 1);
  8.         URLClassLoader loader = null;
  9.         try {
  10.             URL[] urls = new URL[1];
  11.             URLStreamHandler streamHandler = null;
  12.             File classPath = new File(WEB_ROOT);
  13.             String repository = (new URL("file", null,
  14.                     classPath.getCanonicalPath() + File.separator)).toString();
  15.             urls[0] = new URL(null, repository, streamHandler);
  16.             loader = new URLClassLoader(urls);
  17.         } catch (IOException e) {
  18.             System.out.println(e.toString());
  19.         }
  20.         Class myClass = null;
  21.         try {
  22.             myClass = loader.loadClass(servletName);
  23.         } catch (ClassNotFoundException e) {
  24.             System.out.println(e.toString());
  25.         }
  27.         Servlet servlet = null;
  29.         try {
  30.             servlet = (Servlet) myClass.newInstance();
  31.             servlet.service((HttpServletRequest) request,
  32.                     (HttpServletResponse) response);
  33.         } catch (Exception e) {
  34.             System.out.println(e.toString());
  35.         } catch (Throwable e) {
  36.             System.out.println(e.toString());
  37.         }
  39.     }
  40. }

接着，如果 finishResponse 仍然是 true，则响应对象的 finishResponse 方法和请求对象的finishRequest 方法将被调用，并且结束输出。 (只要能够正常解析就是true,状态码是在执行servlet过程中修改的，默认是200)

finishResponse处理的是判断响应状态，如果是正常的，则setHeader(“Connection”, “close”); 否则会将错误写到到页面上，可以自己查看代码

finishRequest主要就是关闭HttRequest中的流

  1. if (finishResponse) {
  2.   //...
  3.   response.finishResponse();
  4.   //...
  5.   request.finishRequest();
  6. }

while 循环的最后一部分检查响应的 Connection 头部是否已经在 servlet 内部设为 close，或者协议是 HTTP1.0.如果是这种情况的话，keepAlive 设置为 false。同样，请求和响应对象接着会被回收利用。

进入这两个方法，可以看到其实就是将HttpRequestImpl.java和它的基类HttpRquestBase等类的实例变量还原到原来的值，这样在下次请求如果再从处理器池中拿到这个处理器时，保证里面的请求和响应对象是初始值。

  1. if ( "close".equals(response.getHeader("Connection")) ) {
  2.     keepAlive = false;
  3. }
  5. // End of request processing
  6. status = Constants.PROCESSOR_IDLE;
  8. // Recycling the request and the response objects
  9. request.recycle();
  10. response.recycle();

在这个场景中，如果 keepAlive 是 true 的话，while 循环将会在开头就启动。因为在前面的解析过程中和容器的 invoke 方法中没有出现错误，或者 HttpProcessor 实例没有被停止。否则，shutdownInput 方法将会调用，而套接字将被关闭.

  1. try {
  2.     shutdownInput(input);
  3.     socket.close();

shutdownInput 方法检查是否有未读取的字节。如果有的话，跳过那些字节。

解析连接

parseConnection 方法从套接字中获取到网络地址并把它赋予 HttpRequestImpl 对象。

它也检查是否使用代理并把套接字赋予请求对象。

  1. private void parseConnection(Socket socket)
  2.         throws IOException, ServletException {
  4.         ((HttpRequestImpl) request).setInet(socket.getInetAddress());
  5.         if (proxyPort != 0)
  6.             request.setServerPort(proxyPort);
  7.         else
  8.             request.setServerPort(serverPort);
  9.         request.setSocket(socket);
  11. }

解析请求

parseRequest 方法是第 3 节中类似方法的完整版本。如果你阅读过上一节，你通过阅读这个方法应该可以理解这个方法是怎么运行的。

解析头部

默认链接器的 parseHeaders 方法使用包 org.apache.catalina.connector.http 里边的HttpHeader 和 DefaultHeaders 类。类 HttpHeader 指代一个 HTTP 请求头部。类 HttpHeader 不是像第3节那样使用字符串，而是使用字符数据用来避免昂贵的字符串操作。类 DefaultHeaders是一个 final 类，在字符数组中包含了标准的 HTTP 请求头部

下面是DefaultHeaders.java部分代码

  1. static final char[] AUTHORIZATION_NAME = "authorization".toCharArray();
  2. static final char[] ACCEPT_LANGUAGE_NAME = "accept-language".toCharArray();
  3. static final char[] COOKIE_NAME = "cookie".toCharArray();
  4. static final char[] CONTENT_LENGTH_NAME = "content-length".toCharArray();

parseHeaders 方法包含一个 while 循环，可以持续读取 HTTP 请求直到再也没有更多的头部可以读取到。

while 循环首先调用请求对象的 allocateHeader 方法来获取一个空的 HttpHead 实例，如果看这个方法，发现HttpRequestImpl中以HttpHeader数组形式保存，如果，默认规定头部大小为10个，如果超过，则通过复制给新数组实现新Header对象的分配。

这个实例被传递给SocketInputStream 的 readHeader 方法。

  1. HttpHeader header = request.allocateHeader();
  3. // Read the next header
  4. input.readHeader(header);

假如所有的头部都被已经被读取的话， readHeader 方法将不会赋值给 HttpHeader 实例，这个时候 parseHeaders 方法将会返回。

  1. if (header.nameEnd == 0) {
  2.     if (header.valueEnd == 0) {
  3.         return;
  4.     } else {
  5.         throw new ServletException
  6.             (sm.getString("httpProcessor.parseHeaders.colon"));
  7.     }
  8. }

如果存在一个头部的名称的话，这里必须同样会有一个头部的值：String value = new String(header.value, 0, header.valueEnd); 接下去，像第 3 节那样， parseHeaders 方法将会把头部名称和 DefaultHeaders 里边的名称做对比。

注意的是，这样的对比是基于两个字符数组之间，而不是两个字符串之间的。

  1. if (header.equals(DefaultHeaders.AUTHORIZATION_NAME)) {
  2.        request.setAuthorization(value);
  3. } else if (header.equals(DefaultHeaders.ACCEPT_LANGUAGE_NAME)) {
  4.        parseAcceptLanguage(value);
  5. //...

总结

本节可学习技巧如下:

  • 对象池复用对象技术
  • 组件解耦合思想
  • 继承关系的设计
  • 多线程间的信息传输

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://cjdhy.blog.csdn.net/article/details/123434844

内容来源于网络，如有侵权，请联系作者删除！

Javatomcat服务器

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com