Tomcat原理之手写

深藏阁楼爱情的钟 2024-04-17 23:30 59阅读 0赞

**目录**

一、准备工作

1.1 Tomcat概要

1.2 技术储备

二、实现步骤

三、相关类的实现和介绍

3.1 包结构

3.2 Servlet配置类

3.3 Tomcat实现类

3.4 请求响应实现类Request/Response

3.5 工具类HttpUtil/FileUtil

3.6 Servlet抽象和测试实现类

四、测试运行

4.1 成功请求servlet（200）

4.2 错误请求servlet（5xx）

4.3 找不到请求servlet（404）

4.4 成功请求静态资源（200）

4.5 找不到请求静态资源（404）

--------------------

## 一、准备工作 ##

在准备工作这一部分中，将预热一下Tomcat的基本知识，进而罗列所需的基本技术储备。

### 1.1 Tomcat概要 ###

Apache Tomcat作为目前广大Java技术爱好者使用最多、接触最早的轻量级**Web应用服务器**，至今流行依旧，也被SpringBoot内置其中。

作为一个Web应用资源容器（包括了静态Html或别的资源和servlet配置），它可以处理静态Html页面，同时也是servlet容器，用来处理动态Java服务请求；作为一款Java服务器，它的本质又可以理解为是一个**ServerSocket**，监听指定端口，接收浏览器发送过来的请求，本质也就是一个个**socket**，解析套接字输入流里的请求体内容，请求处理完毕后将响应信息，以标准的http协议规范的形式返回给浏览器（强调http协议规范，否则浏览器不认识）。

简单说，Tomcat可以被认为是Web资源容器+ServerSocket。

### 1.2 技术储备 ###

socket套接字、IO、Http、servlet、xml。

## 二、实现步骤 ##

根据使用Tomcat的经验，以及JavaWeb工程的配置方式等的分析，得出以下实现方案：

*  初始化servlet，即一般从web.xml中加载servlet配置，存至Map<url, servletClass>，该对象就是servlet容器
 *  启动ServerSocket服务端，时刻准备接收浏览器请求
 *  当请求来临，根据http协议规范解析请求头信息，获取到url，判断静态或动态资源，即是否存在于urlServletClassMap中
 *  若存在于urlServletClassMap，则分发请求至对应的servlet，反射生成servlet实例，进入servlet的service生命周期阶段，调用doGet/doPost等，最后response.write输出内容（JSON、Xml或其他），service中途报错则response.write一个500页面
 *  若不存在于urlServletClassMap，则尝试请求静态资源，可以找到资源则response.write资源内容，反之response.write一个404页面

## 三、相关类的实现和介绍 ##

### 3.1 包结构 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nvbmd6ZWhhbw_size_16_color_FFFFFF_t_70][]

### 3.2 Servlet配置类 ###

Tomcat作为servlet容器，在启动时会解析web.xml文件，并将servlet配置加载到服务器内存中。

**3.2.1 servlet配置类ServletConfig**

这些servlet在web.xml中的样式如下图。我们可以将一对servlet的配置抽象成配置类**ServletConfig**，它需要具有的属性也来自上图的<servlet-name>、<servlet-calss>和<url-pattern>三个节点。对应以下Java代码：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nvbmd6ZWhhbw_size_16_color_FFFFFF_t_70 1][]

**3.2.2 servlet配置加载类ServletConfigMapping**

定义好Servlet配置类后，我们需要在Tomcat启动后自动加载所有配置的ServletConfig，存到一个集合中。**ServletConfigMapping**代码如下（这里我们只add一个servlet用来测试）：

package com.szh.tomcat.config;
    import java.util.ArrayList;
    import java.util.List;
    /**
     * 解析并保存了web.xml里的很多对配置
     */
    public class ServletConfigMapping {
        private static List<ServletConfig> configs = new ArrayList<>();
        static {
            configs.add(new ServletConfig("myServlet", "/testServlet", "com.szh.tomcat.servlet.MyServlet"));
        }
        public static List<ServletConfig> getConfigs() {
            return configs;
        }
    }

### 3.3 Tomcat实现类 ###

Tomcat作为一个socket服务端，需要占用一个网络端口，需要启动函数（启动脚本），需要servlet初始化方法，需要将请求分发至对应Servlet实现类，以下先贴出**MyTomcat**的代码：

package com.szh.tomcat;
    
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    import com.szh.tomcat.config.ServletConfig;
    import com.szh.tomcat.config.ServletConfigMapping;
    import com.szh.tomcat.servlet.Request;
    import com.szh.tomcat.servlet.Response;
    import com.szh.tomcat.servlet.Servlet;
    import com.szh.tomcat.util.HttpUtil;
    
    import lombok.Data;
    import lombok.extern.slf4j.Slf4j;
    
    @Slf4j
    @Data
    public class MyTomcat {
        private int port = 8080;
    
        /**
         * servlet配置的url-clazz对
         */
        private Map<String, Class<Servlet>> urlClassMap = new HashMap<>();
    
        public void start() throws Exception {
            initServlet();
            ServerSocket serverSocket = new ServerSocket(port);
            log.info("MyTomcat starting on {}..", port);
            while (true) {
                Socket socket = serverSocket.accept();
                Request request = new Request(socket.getInputStream());
                Response response = new Response(socket.getOutputStream());
                if (request.getUrl().equals("/")) {
                    // 亦可为"/"配置一欢迎页，即web.xml中的<welcome-file>
                    response.write(HttpUtil.getHttpResponseContext404());
                } else if (urlClassMap.get(request.getUrl()) == null) {
                    response.writeHtml(request.getUrl());
                } else {
                    dispatch(request, response);
                }
                socket.close();
            }
        }
    
        /**
         * servlet容器初始化：将web.xml中的servlet放进Map<url, servletClass>中
         */
        public void initServlet() throws ClassNotFoundException {
            List<ServletConfig> configs = ServletConfigMapping.getConfigs();
            log.info("初始化servlet：{}", configs);
            for (ServletConfig servletConfig : configs) {
                urlClassMap.put(servletConfig.getUrlMapping(), (Class<Servlet>) Class.forName(servletConfig.getClazz()));
            }
        }
    
        /**
         * 分发各servlet：myServlet去找com.szh.tomcat.servlet.MyServlet，
         * myServlet2去找com.szh.tomcat.servlet.MyServlet2
         */
        public void dispatch(Request request, Response response) throws InstantiationException, IllegalAccessException {
            Class<Servlet> servletClass = urlClassMap.get(request.getUrl());
            if (servletClass != null) {
                Servlet servlet = servletClass.newInstance();
                try {
                    servlet.service(request, response);
                } catch (Throwable cause) {
                    response.write(HttpUtil.getHttpResponseContext500(cause));
                }
            } else {
                response.write(HttpUtil.getHttpResponseContext404());
            }
        }
    
        public static void main(String[] args) throws Exception {
            new MyTomcat().start();
        }
    }

可以看出，MyTomcat主要有2个核心的函数，**initServlet()**和**dispatch(req, resp)**，分别用来初始化servlet容器和分发请求。另外，它还导入了工具类**HttpUtil**和自定义的请求**Request**、响应**Response**以及**Servlet**抽象类，当然你也可以尝试使用HttpRequest、HttpResponse、HttpServlet。接下来一个个介绍这几个类。

### 3.4 请求响应实现类Request/Response ###

**3.4.1 请求实现类Request**

客户端或浏览器发过来的请求，最原始就是一个从socket中获取到的InputStream，解析这个输入流中的内容后，即可获取到Request的属性：请求网址url和请求方法methodType。因此我们将**Request**抽象如下：

package com.szh.tomcat.servlet;
    
    import java.io.IOException;
    import java.io.InputStream;
    
    import lombok.Data;
    import lombok.extern.slf4j.Slf4j;
    
    @Slf4j
    @Data
    public class Request {
    
        private String url;
        private String methodType;
        private InputStream inputStream;
    
        public Request(InputStream inputStream) throws IOException {
            this.inputStream = inputStream;
            int count = 0;
            while (count == 0) {
                // available预估网络包长度，可能为0
                count = inputStream.available();
            }
            byte[] bytes = new byte[count];
            inputStream.read(bytes);
            log.info(new String(bytes, "utf-8"));
            extractFields(new String(bytes, "utf-8"));
        }
    
        /**
         * 根据Http协议标准解析请求头信息，提取并封装到Request中
         */
        private void extractFields(String content) {
            if ("".equals(content)) {
                log.info("empty");
            } else {
                String firstLine = content.split("\n")[0];
                String[] segments = firstLine.split("\\s");
                setUrl(segments[1]);
                setMethodType(segments[0]);
            }
        }
    
    }

**3.4.2 响应实现类Response**

对Response而言，它的任务就是通过socket获取到的输出流，将处理后的响应内容写回给客户端，所以我们将**Response**抽象如下：

package com.szh.tomcat.servlet;
    
    import java.io.File;
    import java.io.IOException;
    import java.io.OutputStream;
    
    import com.szh.tomcat.util.FileUtil;
    import com.szh.tomcat.util.HttpUtil;
    
    import lombok.extern.slf4j.Slf4j;
    
    @Slf4j
    public class Response {
    
        private OutputStream outputStream;
    
        public Response(OutputStream outputStream) {
            super();
            this.outputStream = outputStream;
        }
    
        public void write(String content) {
            try {
                outputStream.write(content.getBytes("utf-8"));
            } catch (IOException e) {
                log.error(e.getMessage());
            }
        }
    
        public void writeHtml(String path) throws IOException {
            String resourcePath = FileUtil.getResourcePath(path);
            File file = new File(resourcePath);
            if (file.exists()) {
                FileUtil.writeFile(file, outputStream);
            } else {
                write(HttpUtil.getHttpResponseContext404());
            }
        }
    }

### 3.5 工具类HttpUtil/FileUtil ###

**3.5.1 Http工具类HttpUtil**

**HttpUtil**工具类以Http协议标准返回各种返回码对应的响应串，如下：

package com.szh.tomcat.util;
    
    /**
     * 以Http协议标准规范，构造响应信息体，相当于response.setContentType("text/html")
     */
    public class HttpUtil {
    
        public static String getHttpResponseContext(int code, String content, String errorMsg) {
            if (code == 200) {
                return "HTTP/1.1 200 OK \n" + 
                        "Content-Type: text/html\n" + 
                        "\r\n" + content;
            } else if (code == 500) {
                return "HTTP/1.1 500" + " \n" + 
                        "Content-Type: text/html\n" + 
                        "\r\n" + errorMsg;
            }
            return "HTTP/1.1 404 NOT Found \n" + 
                    "Content-Type: text/html\n" + 
                    "\r\n" + 
                    "<h1>404 Not Found</h1>";
        }
    
        public static String getHttpResponseContext200(String content) {
            return getHttpResponseContext(200, content, "");
        }
    
        public static String getHttpResponseContext404() {
            return getHttpResponseContext(404, "", "");
        }
    
        public static String getHttpResponseContext500(Throwable cause) {
            StringBuffer sb = new StringBuffer(cause.toString());
            StackTraceElement[] stes = null;
            if ((stes = cause.getStackTrace()) != null) {
                for (StackTraceElement ste : stes) {
                    // sb.append("<br>        " + ste);
                    sb.append("\n\t" + ste);
                }
            }
            return getHttpResponseContext(500, "", "<h1>Internal Server Error:</h1>".concat("<div style='white-space:pre-wrap;'>" + sb.toString() + "</div>"));
        }
    }

**3.5.2 静态资源处理工具类FileUtil**

**FileUtil**工具类首先找到请求的静态资源，并将静态资源文件内容写入到输出流，如下：

package com.szh.tomcat.util;
    
    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    
    import lombok.extern.slf4j.Slf4j;
    
    /**
     * 将静态资源文件内容写入到输出流
     */
    @Slf4j
    public class FileUtil {
    
        public static boolean writeFile(InputStream inputStream, OutputStream outputStream) {
            boolean success = false;
            BufferedInputStream bufferedInputStream;
            BufferedOutputStream bufferedOutputStream;
            try {
                bufferedInputStream = new BufferedInputStream(inputStream);
                bufferedOutputStream = new BufferedOutputStream(outputStream);
                bufferedOutputStream.write(HttpUtil.getHttpResponseContext200("").getBytes("utf-8"));
                int count = 0;
                while (count == 0) {
                    count = inputStream.available();
                }
                int fileSize = inputStream.available();
                long written = 0;
                int byteSize = 1024;
                byte[] bytes = new byte[byteSize];
                while (written < fileSize) {
                    if (written + byteSize > fileSize) {
                        byteSize = (int) (fileSize - written);
                        bytes = new byte[byteSize];
                    }
                    bufferedInputStream.read(bytes);
                    bufferedOutputStream.write(bytes);
                    bufferedOutputStream.flush();
                    written += byteSize;
                }
                success = true;
            } catch (IOException e) {
                log.error(e.getMessage());
            }
            return success;
        }
    
        public static boolean writeFile(File file, OutputStream outputStream) throws IOException {
            return writeFile(new FileInputStream(file), outputStream);
        }
    
        public static String getResourcePath(String path) {
            String resource = FileUtil.class.getResource("/").getPath();
            return resource + "\\" + path;
        }
    }

### 3.6 Servlet抽象和测试实现类 ###

**3.6.1 Servlet抽象类**

该抽象类同javax.servlet.http.HttpServlet，需要doGet/doPost/service方法，且必须强制抛出Web应用内部的异常或错误，以此来使Tomcat做出对应处理（即响应码=5xx），如下：

package com.szh.tomcat.servlet;
    
    import lombok.extern.slf4j.Slf4j;
    
    @Slf4j
    public abstract class Servlet {
        public abstract void doGet(Request request, Response response) throws Throwable;
        public abstract void doPost(Request request, Response response) throws Throwable;
    
        public void service(Request request, Response response) throws Throwable {
            if ("GET".equals(request.getMethodType())) {
                doGet(request, response);
            } else if ("POST".equals(request.getMethodType())) {
                doPost(request, response);
            } else {
                log.error("暂不支持的请求方式！");
            }
        }
    }

**3.6.2 Servlet测试实现类**

最后的阶段，自然是实现一个com.szh.tomcat.servlet.Servlet，以此测试我们的Tomcat是否手写成功。这里我们实现ServletConfigMapping静态块中add的servlet实现类**MyServlet**，如下：

package com.szh.tomcat.servlet;
    
    import com.szh.tomcat.util.HttpUtil;
    
    public class MyServlet extends Servlet {
    
        @Override
        public void doGet(Request request, Response response) throws RuntimeException {
            // 测试服务器内部错误5xx
            // System.out.println(1/0);
            String content = "<h1>This is my GET request</h1>";
            response.write(HttpUtil.getHttpResponseContext200(content));
        }
    
        @Override
        public void doPost(Request request, Response response) throws RuntimeException {
            String content = "<h1>This is my POST request</h1>";
            response.write(HttpUtil.getHttpResponseContext200(content));
        }
    
    }

## 四、测试运行 ##

至此，手写Tomcat的工作已完结，测试以下几种case：

### 4.1 成功请求servlet（200） ###

启动MyTomcat.main()，直接访问配置的/testServlet，结果如下：

![20190903231112163.png][]

### 4.2 错误请求servlet（5xx） ###

打开MyServlet.doGet方法中的注释，使之发生服务器内部错误，重启MyTomcat然后同样访问，结果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nvbmd6ZWhhbw_size_16_color_FFFFFF_t_70 2][]

### 4.3 找不到请求servlet（404） ###

浏览器访问一个未注册的servlet，结果如下：

![20190903231806184.png][]

### 4.4 成功请求静态资源（200） ###

因为我这里使用的是SpringBoot，所以添加静态资源index.html至src/main/resources，访问该资源，结果如下：

![20190903232222247.png][]

### 4.5 找不到请求静态资源（404） ###

浏览器访问一个不存在的静态资源，结果如下：

![20190903232405396.png][]

--------------------

以上。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nvbmd6ZWhhbw_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/47cce29adde24d8096cadfa39a338690.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nvbmd6ZWhhbw_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/358da5fabfa94a97b1d9de399fa980e8.png
[20190903231112163.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/caf99f2e8dee40568c8d80a3bf43a20a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nvbmd6ZWhhbw_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/5900fa52cc5f4573bc6d8c7bb0e3b436.png
[20190903231806184.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/106ee1baf89b47149819ab4a5a59c4d3.png
[20190903232222247.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/0c64a30852174f76a9ddb8c6754aad6b.png
[20190903232405396.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/a57424d861534ce083ee2fbee0ebb3a8.png