网钛远程桌面管理助手
当前位置:首页 > 服务器资讯

服务器资讯

惊呆了!手写4个mini版的Tomcat!

时间:2021-04-04 19:41:21   作者:   来源:   阅读:100   评论:0
内容摘要: 即将开播:4月29日,民生银行郭庆谈商业银行金融科技赋能的探索与实践--> 写在前面Apache Tomcat 是Java Servlet, JavaServer Pages (JSP),Java表达式语言和Java的WebSocket技术的一个开源实现 ,通常我们将To......

即将开播:4月29日,民生银行郭庆谈商业银行金融科技赋能的探索与实践

-->

 

写在前面

Apache Tomcat 是Java Servlet, JavaServer Pages (JSP),Java表达式语言和Java的WebSocket技术的一个开源实现 ,通常我们将Tomcat称为Web容器或者Servlet容器 。

今天,我们就来手写tomcat,但是说明一下:咱们不是为了装逼才来写tomcat,而是希望大家能更多的理解和掌握tomcat。

废话不多说了,直接开干。

基本结构

tomcat架构图

我们可以把上面这张架构图做简化,简化后为:

什么是http协议

Http是一种网络应用层协议,规定了浏览器与web服务器之间如何通信以及数据包的结构。

通信大致可以分为四步:

  1. 先建立连接。
  2. 发送请求数据包。
  3. 发送响应数据包。
  4. 关闭连接。

优点

web服务器可以利用有限的连接为尽可能多的客户请求服务。

tomcat中Servlet的运作方式

  1. 在浏览器地址栏输入http://ip:port/servlet-day01/hello
  2. 浏览器依据IP、port建立连接(即与web服务器之间建立网络连接)。
  3. 浏览器需要将相关数据打包(即按照http协议要求,制作一个 请求数据包,包含了一些数据,比如请求资源路径),并且将请求 数据包发送出去。
  4. web服务器会将请求数据包中数据解析出来,并且将这些数据添加 到request对象,同时,还会创建一个response对象。
  5. web服务器创建Servlet对象,然后调用该对象的service方法(会将request和response作为参数)。注:在service方法里面,通过使用request获得请求相关的数据, 比如请求参数值,然后将处理结果写到response。
  6. web服务器将response中的数据取出来,制作响应数据包,然后发送给浏览器。
  7. 浏览器解析响应数据包,然后展现。

可以总结唯一张图:

什么是Servlet呢?

Servlet是JavaEE规范的一种,主要是为了扩展Java作为Web服务的功能,统一接口。由其他内部厂商如tomcat,jetty内部实现web的功能。如一个http请求到来:容器将请求封装为servlet中的HttpServletRequest对象,调用init(),service()等方法输出response,由容器包装为httpresponse返回给客户端的过程。

什么是Servlet规范?

  1. 从 Jar 包上来说,Servlet 规范就是两个 Jar 文件。servlet-api.jar 和 jsp-api.jar,Jsp 也是一种 Servlet。
  2. 从package上来说,就是 javax.servlet 和 javax.servlet.http 两个包。
  3. 从接口来说,就是规范了 Servlet 接口、Filter 接口、Listener 接口、ServletRequest 接口、ServletResponse 接口等。类图如下:

第一版:Socket版

使用Socket编程,实现简单的客户端和服务端的聊天。

服务端代码如下:

  1. package com.tian.v1; 
  2.  
  3. import java.io.*; 
  4. import java.net.*; 
  5.  
  6.  
  7. public class Server { 
  8.  
  9.     public static String readline = null
  10.     public static String inTemp = null
  11.     public static String turnLine = "\n"
  12.     public static final String client = "客户端:"
  13.     public static final String server = "服务端:"
  14.     public static final int PORT = 8090; 
  15.  
  16.     public static void main(String[] args) throws Exception { 
  17.         ServerSocket serverSocket = new ServerSocket(PORT); 
  18.         System.out.println("服务端已经准备好了"); 
  19.         Socket socket = serverSocket.accept(); 
  20.  
  21.         BufferedReader systemIn = new BufferedReader(new InputStreamReader(System.in)); 
  22.         BufferedReader socketIn = new BufferedReader(new InputStreamReader(socket.getInputStream())); 
  23.         PrintWriter socketOut = new PrintWriter(socket.getOutputStream()); 
  24.         while (true) { 
  25.             inTemp = socketIn.readLine(); 
  26.             if (inTemp != null &&inTemp.contains("over")) { 
  27.                 systemIn.close(); 
  28.                 socketIn.close(); 
  29.                 socketOut.close(); 
  30.                 socket.close(); 
  31.                 serverSocket.close(); 
  32.             } 
  33.             System.out.println(client + inTemp); 
  34.             System.out.print(server); 
  35.  
  36.             readline = systemIn.readLine(); 
  37.  
  38.             socketOut.println(readline); 
  39.             socketOut.flush(); 
  40.         } 
  41.     } 

客户端代码如下:

  1. package com.tian.v1; 
  2.  
  3. import java.io.*; 
  4. import java.net.*; 
  5.  
  6. public class Client { 
  7.  
  8.     public static void main(String[] args) throws Exception { 
  9.         String readline; 
  10.         String inTemp; 
  11.         final String client = "客户端说:"
  12.         final String server = "服务端回复:"
  13.  
  14.         int port = 8090; 
  15.         byte[] ipAddressTemp = {127, 0, 0, 1}; 
  16.         InetAddress ipAddress = InetAddress.getByAddress(ipAddressTemp); 
  17.  
  18.         //首先直接创建socket,端口号1~1023为系统保存,一般设在1023之外 
  19.         Socket socket = new Socket(ipAddress, port); 
  20.  
  21.         BufferedReader systemIn = new BufferedReader(new InputStreamReader(System.in)); 
  22.         BufferedReader socketIn = new BufferedReader(new InputStreamReader(socket.getInputStream())); 
  23.         PrintWriter socketOut = new PrintWriter(socket.getOutputStream()); 
  24.         while (true) { 
  25.             System.out.print(client); 
  26.             readline = systemIn.readLine(); 
  27.  
  28.             socketOut.println(readline); 
  29.             socketOut.flush(); 
  30.             //处理 
  31.             inTemp = socketIn.readLine(); 
  32.             if (inTemp != null && inTemp.contains("over")) { 
  33.                 systemIn.close(); 
  34.                 socketIn.close(); 
  35.                 socketOut.close(); 
  36.                 socket.close(); 
  37.             } 
  38.             System.out.println(server + inTemp); 
  39.         } 
  40.     } 

过程如下:

第二版:我们直接请求http://localhost:8090

实现代码如下:

  1. package com.tian.v2; 
  2.  
  3. import java.io.IOException; 
  4. import java.io.OutputStream; 
  5. import java.net.ServerSocket; 
  6. import java.net.Socket; 
  7.  
  8. public class MyTomcat { 
  9.     /** 
  10.      * 设定启动和监听端口 
  11.      */ 
  12.     private int port = 8090; 
  13.  
  14.     /** 
  15.      * 启动函数 
  16.      * 
  17.      * @throws IOException 
  18.      */ 
  19.     public void start() throws IOException { 
  20.         System.out.println("my tomcat starting..."); 
  21.         String responseData = "6666666"
  22.         ServerSocket socket = new ServerSocket(port); 
  23.         while (true) { 
  24.             Socket accept = socket.accept(); 
  25.             OutputStream outputStream = accept.getOutputStream(); 
  26.             String responseText = HttpProtocolUtil.getHttpHeader200(responseData.length()) + responseData; 
  27.             outputStream.write(responseText.getBytes()); 
  28.             accept.close(); 
  29.         } 
  30.     } 
  31.  
  32.     /** 
  33.      * 启动入口 
  34.      */ 
  35.     public static void main(String[] args) throws IOException { 
  36.         MyTomcat tomcat = new MyTomcat(); 
  37.         tomcat.start(); 
  38.     } 

再写一个工具类,内容如下;

  1. ackage com.tian.v2; 
  2.  
  3. public class HttpProtocolUtil { 
  4.  
  5.     /** 
  6.      * 200 状态码,头信息 
  7.      * 
  8.      * @param contentLength 响应信息长度 
  9.      * @return 200 header info 
  10.      */ 
  11.     public static String getHttpHeader200(long contentLength) { 
  12.         return "HTTP/1.1 200 OK \n" + "Content-Type: text/html \n" 
  13.                 + "Content-Length: " + contentLength + " \n" + "\r\n"
  14.     } 
  15.  
  16.     /** 
  17.      * 为响应码 404 提供请求头信息(此处也包含了数据内容) 
  18.      * 
  19.      * @return 404 header info 
  20.      */ 
  21.     public static String getHttpHeader404() { 
  22.         String str404 = "<h1>404 not found</h1>"
  23.         return "HTTP/1.1 404 NOT Found \n" + "Content-Type: text/html \n" 
  24.                 + "Content-Length: " + str404.getBytes().length + " \n" + "\r\n" + str404; 
  25.     } 

启动main方法:

使用IDEA访问:

在浏览器访问:

自此,我们的第二版本搞定。下面继续第三个版本;

第三版:封装请求信息和响应信息

一个http协议的请求包含三部分:

  • 方法 URI 协议/版本
  • 请求的头部
  • 主体内容

比如

  1. POST /index.html HTTP/1.1 
  2. Accept: text/plain; text/html 
  3. Accept-Language: en-gb 
  4. Connection: Keep-Alive 
  5. Host: localhost 
  6. User-Agent: Mozilla/4.0 (compatible; MSIE 4.01; Windows 98) 
  7. Content-Length: 33 
  8. Content-Type: application/x-www-form-urlencoded 
  9. Accept-Encoding: gzip, deflate 
  10.  
  11. lastName=tian&firstName=JohnTian 

简单的解释

  • 数据的第一行包括:方法、URI、协议和版本。在这个例子里,方法为POST,URI为/index.html,协议为HTTP/1.1,协议版本号为1.1。他们之间通过空格来分离。
  • 请求头部从第二行开始,使用英文冒号(:)来分离键和值。
  • 请求头部和主体内容之间通过空行来分离,例子中的请求体为表单数据。

类似于http协议的请求,响应也包含三个部分。

  • 协议 状态 状态描述
  • 响应的头部
  • 主体内容

比如:

  1. HTTP/1.1 200 OK 
  2. Server: Microsoft-IIS/4.0 
  3. Date: Mon, 5 Jan 2004 13:13:33 GMT 
  4. Content-Type: text/html 
  5. Last-Modified: Mon, 5 Jan 2004 13:13:12 GMT 
  6. Content-Length: 112 
  7.  
  8. <html> 
  9. <head> 
  10. <title>HTTP Response Example</title> </head> 
  11. <body> 
  12. Welcome to Brainy Software 
  13. </body> 
  14. </html> 

简单解释

  • 第一行,HTTP/1.1 200 OK表示协议、状态和状态描述。
  • 之后表示响应头部。
  • 响应头部和主体内容之间使用空行来分离。

代码实现

创建一个工具类,用来获取静态资源信息。

  1. package com.tian.v3; 
  2.  
  3. import com.tian.v2.HttpProtocolUtil; 
  4.  
  5. import java.io.IOException; 
  6. import java.io.InputStream; 
  7. import java.io.OutputStream; 
  8.  
  9. /** 
  10.  * 提取了一些共用类和函数 
  11.  */ 
  12. public class ResourceUtil { 
  13.  
  14.     /** 
  15.      * 根据请求 url 获取完整绝对路径 
  16.      */ 
  17.     public static String getPath(String url) { 
  18.         String path = ResourceUtil.class.getResource("/").getPath(); 
  19.         return path.replaceAll("\\\\", "/") + url; 
  20.     } 
  21.  
  22.     /** 
  23.      * 输出静态资源信息 
  24.      */ 
  25.     public static void outputResource(InputStream input, OutputStream output) throws IOException { 
  26.         int count = 0; 
  27.         while (count == 0) { 
  28.             count = input.available(); 
  29.         } 
  30.         int resourceSize = count
  31.         output.write(HttpProtocolUtil.getHttpHeader200(resourceSize).getBytes()); 
  32.         long written = 0; 
  33.         int byteSize = 1024; 
  34.         byte[] bytes = new byte[byteSize]; 
  35.         while (written < resourceSize) { 
  36.             if (written + byteSize > resourceSize) { 
  37.                 byteSize = (int) (resourceSize - written); 
  38.                 bytes = new byte[byteSize]; 
  39.             } 
  40.             input.read(bytes); 
  41.             output.write(bytes); 
  42.             output.flush(); 
  43.             written += byteSize; 
  44.         } 
  45.     } 

另外HttpProtocolUtil照样用第二版本中。

再创建Request类,用来解析并存放请求相关参数。

  1. package com.tian.v3; 
  2.  
  3. import java.io.IOException; 
  4. import java.io.InputStream; 
  5.  
  6. public class Request { 
  7.     /** 
  8.      * 请求方式, eg: GET、POST 
  9.      */ 
  10.     private String method; 
  11.  
  12.     /** 
  13.      * 请求路径,eg: /index.html 
  14.      */ 
  15.     private String url; 
  16.  
  17.     /** 
  18.      * 请求信息输入流 <br> 
  19.      * 示例 
  20.      * <pre> 
  21.      *  GET / HTTP/1.1 
  22.      *  Host: localhost 
  23.      *  Connection: keep-alive 
  24.      *  Pragma: no-cache 
  25.      *  Cache-Control: no-cache 
  26.      *  Upgrade-Insecure-Requests: 1 
  27.      *  User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.83 Safari/537.36 
  28.      * </pre> 
  29.      */ 
  30.     private InputStream inputStream; 
  31.  
  32.     public Request() { 
  33.     } 
  34.  
  35.     public Request(InputStream inputStream) throws IOException { 
  36.         this.inputStream = inputStream; 
  37.         int count = 0; 
  38.         while (count == 0) { 
  39.             count = inputStream.available(); 
  40.         } 
  41.         byte[] bytes = new byte[count]; 
  42.         inputStream.read(bytes); 
  43.         // requestString 参考:this.inputStream 示例 
  44.         String requestString = new String(bytes); 
  45.         // 按换行分隔 
  46.         String[] requestStringArray = requestString.split("\\n"); 
  47.         // 读取第一行数据,即:GET / HTTP/1.1 
  48.         String firstLine = requestStringArray[0]; 
  49.         // 遍历第一行数据按空格分隔 
  50.         String[] firstLineArray = firstLine.split(" "); 
  51.         this.method = firstLineArray[0]; 
  52.         this.url = firstLineArray[1]; 
  53.     } 
  54.  
  55.     public String getMethod() { 
  56.         return method; 
  57.     } 
  58.  
  59.     public void setMethod(String method) { 
  60.         this.method = method; 
  61.     } 
  62.  
  63.     public String getUrl() { 
  64.         return url; 
  65.     } 
  66.  
  67.     public void setUrl(String url) { 
  68.         this.url = url; 
  69.     } 
  70.  
  71.     public InputStream getInputStream() { 
  72.         return inputStream; 
  73.     } 
  74.  
  75.     public void setInputStream(InputStream inputStream) { 
  76.         this.inputStream = inputStream; 
  77.     } 

把第二版的MyTomcat进行小小调整:

  1. package com.tian.v3; 
  2.  
  3. import java.io.IOException; 
  4. import java.io.OutputStream; 
  5. import java.net.ServerSocket; 
  6. import java.net.Socket; 
  7.  
  8. public class MyTomcat { 
  9.  
  10.     private static final int PORT = 8090; 
  11.     public void start() throws IOException { 
  12.         System.out.println("my tomcat starting..."); 
  13.         ServerSocket socket = new ServerSocket(PORT); 
  14.         while (true) { 
  15.             Socket accept = socket.accept(); 
  16.             OutputStream outputStream = accept.getOutputStream(); 
  17.             // 分别封装 Request 和 Response 
  18.             Request request = new Request(accept.getInputStream()); 
  19.             Response response = new Response(outputStream); 
  20.             // 根据 request 中的 url,输出 
  21.             response.outputHtml(request.getUrl()); 
  22.             accept.close(); 
  23.         } 
  24.     } 
  25.     
  26.     public static void main(String[] args) throws IOException { 
  27.         MyTomcat tomcat = new MyTomcat(); 
  28.         tomcat.start(); 
  29.     } 

然后再创建一个index.html,内容很简单:

  1. <!DOCTYPE html> 
  2. <html lang="en"
  3. <head> 
  4.     <meta charset="UTF-8"
  5.     <title>hello world</title> 
  6. </head> 
  7. <body> 
  8. <h2> you already succeed!</h2> 
  9. </body> 
  10. </html> 

这一需要注意,index.html文件的存放路径不放错了,视本地路径来定哈,放在classes文件夹下的。你可以debug试试,看看你应该放在那个目录下。

启动MyTomcat。

访问http://localhost:8090/index.html

自此,我们针对于Http请求参数和相应参数做了一个简单的解析以及封装。

尽管其中还有很多问题,但是字少看起来有那点像样了。我们继续第四版,

第四版:实现动态请求资源

用过servlet的同学都知道,Servlet中有三个很重要的方法init、destroy 、service 。其中还记得我们自己写LoginServlet的时候,还会重写HttpServlet中的doGet()和doPost()方法。下面们就自己来搞一个:

Servlet类代码如下:

  1. public interface Servlet { 
  2.     void init() throws Exception; 
  3.     void destroy() throws Exception; 
  4.     void service(Request request, Response response) throws Exception; 

然后再写一个HttpServlet来实现Servlet。

代码实现如下:

  1. package com.tian.v4; 
  2.  
  3. public abstract class HttpServlet implements Servlet { 
  4.     @Override 
  5.     public void init() throws Exception { 
  6.  
  7.     } 
  8.  
  9.     @Override 
  10.     public void destroy() throws Exception { 
  11.  
  12.     } 
  13.  
  14.     @Override 
  15.     public void service(Request request, Response response) throws Exception { 
  16.         String method = request.getMethod(); 
  17.         if ("GET".equalsIgnoreCase(method)) { 
  18.             doGet(request, response); 
  19.         } else { 
  20.             doPost(request, response); 
  21.         } 
  22.     } 
  23.     public abstract void doGet(Request request, Response response) throws Exception; 
  24.  
  25.     public abstract void doPost(Request request, Response response) throws Exception; 

下面我们就来写一个自己的Servlet,比如LoginServlet。

  1. package com.tian.v4; 
  2.  
  3. public class LoginServlet  extends HttpServlet { 
  4.  
  5.     @Override 
  6.     public void doGet(Request request, Response response) throws Exception { 
  7.         String repText = "<h1> LoginServlet by GET method</h1>"
  8.         response.output(HttpProtocolUtil.getHttpHeader200(repText.length()) + repText); 
  9.     } 
  10.  
  11.     @Override 
  12.     public void doPost(Request request, Response response) throws Exception { 
  13.         String repText = "<h1>LoginServlet by POST method</h1>"
  14.         response.output(HttpProtocolUtil.getHttpHeader200(repText.length()) + repText); 
  15.     } 
  16.  
  17.     @Override 
  18.     public void init() throws Exception { 
  19.     } 
  20.  
  21.     @Override 
  22.     public void destroy() throws Exception { 
  23.     } 

大家是否还记得,我们在学习Servlet的时候,在resources目录下面有个web.xml。我们这个版本也把这个xml文件给引入。

  1. <?xml version="1.0" encoding="utf-8"?> 
  2. <web-app> 
  3.     <servlet> 
  4.         <servlet-name>login</servlet-name
  5.         <servlet-class>com.tian.v4.LoginServlet</servlet-class> 
  6.     </servlet> 
  7.  
  8.     <servlet-mapping> 
  9.         <servlet-name>login</servlet-name
  10.         <url-pattern>/login</url-pattern> 
  11.     </servlet-mapping> 
  12. </web-app> 

既然引入了xml文件,那我们就需要去读取这个xml文件,并解析器内容。所以这里我们需要引入两个jar包。

  1. <dependencies> 
  2.     <dependency> 
  3.         <groupId>dom4j</groupId> 
  4.         <artifactId>dom4j</artifactId> 
  5.         <version>1.6.1</version> 
  6.     </dependency> 
  7.     <dependency> 
  8.         <groupId>jaxen</groupId> 
  9.         <artifactId>jaxen</artifactId> 
  10.         <version>1.1.6</version> 
  11.     </dependency> 
  12. </dependencies> 

万事俱备,只欠东风了。这时候我们来吧MyTomcat这个类做一些调整即可。

下面有个很重要的initServlet()方法,刚刚是对应下面这张图中的List servlets,但是我们代码里使用的是Map来存储Servlet的,意思就那么个意思,把Servlet放在集合里。

这也就是为什么大家都把Tomcat叫做Servlet容器的原因,其实真正的容器还是java集合。

  1. package com.tian.v4; 
  2.  
  3. import com.tian.v3.RequestV3; 
  4. import com.tian.v3.ResponseV3; 
  5. import org.dom4j.Document; 
  6. import org.dom4j.Element; 
  7. import org.dom4j.io.SAXReader; 
  8.  
  9. import java.io.IOException; 
  10. import java.io.InputStream; 
  11. import java.io.OutputStream; 
  12. import java.net.ServerSocket; 
  13. import java.net.Socket; 
  14. import java.util.HashMap; 
  15. import java.util.List; 
  16. import java.util.Map; 
  17.  
  18. public class MyTomcat { 
  19.     /** 
  20.      * 设定启动和监听端口 
  21.      */ 
  22.     private static final int PORT = 8090; 
  23.     /** 
  24.      * 存放 Servlet信息,url: Servlet 实例 
  25.      */ 
  26.     private Map<String, HttpServlet> servletMap = new HashMap<>(); 
  27.   
  28.     public void start() throws Exception { 
  29.  
  30.         System.out.println("my tomcat starting..."); 
  31.         initServlet(); 
  32.         ServerSocket socket = new ServerSocket(PORT); 
  33.         while (true) { 
  34.             Socket accept = socket.accept(); 
  35.             OutputStream outputStream = accept.getOutputStream(); 
  36.             // 分别封装 RequestV3 和 ResponseV3 
  37.             RequestV4 requestV3 = new RequestV4(accept.getInputStream()); 
  38.             ResponseV4 responseV3 = new ResponseV4(outputStream); 
  39.             // 根据 url 来获取 Servlet 
  40.             HttpServlet httpServlet = servletMap.get(requestV3.getUrl()); 
  41.             // 如果 Servlet 为空,说明是静态资源,不为空即为动态资源,需要执行 Servlet 里的方法 
  42.             if (httpServlet == null) { 
  43.                 responseV3.outputHtml(requestV3.getUrl()); 
  44.             } else { 
  45.                 httpServlet.service(requestV3, responseV3); 
  46.             } 
  47.             accept.close(); 
  48.         } 
  49.     }  
  50.      
  51.     public static void main(String[] args) throws Exception { 
  52.         MyTomcat tomcat = new MyTomcat(); 
  53.         tomcat.start(); 
  54.     } 
  55.  
  56.  
  57.     /** 
  58.      * 解析web.xml文件,把url和servlet解析出来, 
  59.      * 并保存到一个java集合里(Map) 
  60.      */ 
  61.     public void initServlet() throws Exception { 
  62.         InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream("web.xml"); 
  63.         SAXReader saxReader = new SAXReader(); 
  64.         Document document = saxReader.read(resourceAsStream); 
  65.         Element rootElement = document.getRootElement(); 
  66.         List<Element> list = rootElement.selectNodes("//servlet"); 
  67.         for (Element element : list) { 
  68.             // <servlet-name>show</servlet-name
  69.             Element servletnameElement = (Element) element.selectSingleNode("servlet-name"); 
  70.             String servletName = servletnameElement.getStringValue(); 
  71.             // <servlet-class>server.ShowServlet</servlet-class> 
  72.             Element servletclassElement = (Element) element.selectSingleNode("servlet-class"); 
  73.             String servletClass = servletclassElement.getStringValue(); 
  74.  
  75.             // 根据 servlet-name 的值找到 url-pattern 
  76.             Element servletMapping = (Element) rootElement.selectSingleNode("/web-app/servlet-mapping[servlet-name='" + servletName + "']"); 
  77.             // /show 
  78.             String urlPattern = servletMapping.selectSingleNode("url-pattern").getStringValue(); 
  79.             servletMap.put(urlPattern, (HttpServlet) Class.forName(servletClass).getDeclaredConstructor().newInstance()); 
  80.         } 
  81.     } 

启动,再次访问http://localhost:8090/index.html

同时,我们可以访问http://localhost:8090/login图片

到此,第四个版本也搞定了。

但是前面四个版本都有一个共同的问题,全部使用的是BIO。

BIO:同步并阻塞,服务器实现模式为一个连接一个线程,即客户端有连接请求时服务器端就需要启动一个线程进行处理,如果这个连接不做任何事情会造成不必要的线程开销,当然可以通过线程池机制改善。

所以,大家在网上看到的手写tomcat的,也有使用线程池来做的,这里希望大家能get到为什么使用线程池来实现。另外,其实在tomcat高版本中已经没有使用BIO了。

而 HTTP/1.1默认使用的就是NIO了。

但这个只是通信方式,重点是我们要理解和掌握tomcat的整体实现。

总结

另外,发现上面都是讲配置文件解析,并将对应数据保存起来。熟悉这个套路后,大家是不是想到,我们很多配置项都是在server.xml中,还记得否?也是可以通过解析某个目录下的server.xml文件,并把内容赋给java中相应的变量罢了。

比如:

1.server.xml中的端口配置,我们是在代码里写死的而已,改成MyTomcat启动的时候去解析并获取不久得了吗?

2.我们通常是将我们项目的打成war,然后解压到某个目录下,最后还不是可以通过读取这个解压后的某个目录中找到web.xml,然后用回到上面的web.xml解析了。

本文主要是分享如何从一个塑料版到黄金版、然后铂金版,最后到砖石版。可以把加入线程池的版本称之为星耀版,最后把相关server.xml解析,以及读取我们放入到tomcat中项目解析可以称之为王者版。

技术点:Socket编程、InputStream、OutputStream、线程池、xml文件解析、反射。更高级版本中NIO,AIO等。

不是为了装逼而来搞这个tomcat,而是为了我们更深刻的理解tomcat的原理。

本文转载自微信公众号「Java后端技术全栈」,可以通过以下二维码关注。转载本文请联系Java后端技术全栈公众号。


标签:quot  Servlet  importjava  请求  gt  

相关文章

相关评论