2. 首页 > 快讯

手写迷你 Tomcat 体验Java 核心

作者：无 • 更新时间：2024-11-16 02:45:00 •阅读

老铁们，大家好，相信还有很多朋友对于手写迷你 Tomcat 体验Java 核心和的相关问题不太懂，没关系，今天就由我来为大家分享分享手写迷你 Tomcat 体验Java 核心以及的问题，文章篇幅可能偏长，希望可以帮助到大家，下面一起来看看吧！

基本结构

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.     } 
  42. } 

客户端代码如下：

  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.     } 
  41. } 

过程如下：

第二版：我们直接请求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.     } 
  39. } 

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

  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.     } 
  26. } 

启动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.     } 
  46. } 

另外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.     } 
  78. } 

把第二版的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.     } 
  30. } 

然后再创建一个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; 
  5. } 

然后再写一个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; 
  26. } 

下面我们就来写一个自己的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.     } 
  24. } 

大家是否还记得，我们在学习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.     } 
  82. } 

启动，再次访问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解析了。

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

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

 

OK，关于手写迷你 Tomcat 体验Java 核心和的内容到此结束了，希望对大家有所帮助。

用户评论

命里缺他

这个想法太酷了！迷你版Tomcat，能试试看吗？

    有13位网友表示赞同！

灬一抹丶苍白

厉害了，手工打造Mini Tomcat！这可真考验编程能力和耐心。

    有13位网友表示赞同！

琴断朱弦

想了解一下手写的代码逻辑，在哪儿能看到呢？

    有10位网友表示赞同！

她的风骚姿势我学不来

太神奇了，小巧的应用功能强大吗？

    有20位网友表示赞同！

赋流云

会不会比原版Tomcat还稳定一点？好奇它运行的速度怎么样？

    有11位网友表示赞同！

雁過藍天

51CTO真是一个资源丰富的网站啊，总能看到新奇的内容。

    有19位网友表示赞同！

闷骚闷出味道了

手写代码这种事，不是太适合玩一玩吗？可以学习到很多东西哦！

    有17位网友表示赞同！

还未走i

Tomcat本身就是一个小巧的应用服务器，迷你版更加方便使用吧。

    有16位网友表示赞同！

人心叵测i

期待相关的教程或文档，这样我才能去尝试一下！

    有12位网友表示赞同！

站上冰箱当高冷

迷你版的Tomcat应用场景在哪里？能不能分享一些具体的例子？

    有19位网友表示赞同！

海盟山誓总是赊

这样的小型版本是否能够满足个人开发的需求呢？

    有19位网友表示赞同！

桃洛憬

手写代码的过程一定很不容易吧，佩服作者的技术水平。

    有20位网友表示赞同！

一笑傾城゛

Mini Tomcat 能用来开发哪些类型的项目？感兴趣啊。

    有16位网友表示赞同！

呆萌

有没有想过把它开源共享给开发者社区？

    有14位网友表示赞同！

﹎℡默默的爱

这真是一个很有创意的设计理念！

    有10位网友表示赞同！

权诈

这种迷你版应用，会不会成为未来软件发展趋势之一呢？

    有14位网友表示赞同！

该用户已上天

学习一下手写代码，也能增强我的逻辑思维能力吧。

    有12位网友表示赞同！

千城暮雪

看到这样的文章，真的会让我对编程充满兴趣！

    有7位网友表示赞同！

ヅ她的身影若隐若现

希望以后能看到更多关于Mini Tomcat的信息和教程！

    有18位网友表示赞同！

爱你心口难开

这个迷你版Tomcat可能非常适合初学者学习服务器的原理。

    有8位网友表示赞同！

〆mè村姑

期待更多开发者尝试这种手写的方式开发应用程序！

    有11位网友表示赞同！

本文采摘于网络，不代表本站立场，转载联系作者并注明出处：https://www.iotsj.com//kuaixun/7163.html

华为揭示全光自动驾驶网络，助力高效运维新时代
« 上一篇 2024-11-16
联想混合云Lenovo xCloud重塑SI市场格局
下一篇 » 2024-11-16

相关推荐

联系我们

在线咨询：点击这里给我发消息

微信号：666666