【Tomcat】第八篇：150代码手写Tomcat（基于BIO，超详细注释）

r囧r小猫 2022-12-09 15:55 153阅读 0赞

既然要手写tomcat，那么从哪里入手呢？我们都知道tomcat是web容器，所以如果理解了tomcat的作用，我们应该就知道如何设计它了：

1.  tomcat要负责接受http请求，所以需要一个 **MYRequest**
2.  tomcat要负责返回响应，所以需要一个 **MYResponse**
3.  tomcat要负责实例化Servlet，所以需要一个 **MYServlet** 规范（以及一个配置了映射关系的**配置文件**）

那这三者如何统一起来呢，或者说谁来处理映射关系呢？**MYTomcat**。

## 1.MYRequest ##

Request 本质就是 InputStream，主要工作下：

1.  读取 InputStream 的内容，并保存
2.  对读取的结果进行解码，提取关键信息（URL，请求方式）

所以，它会对外提供 getUrl 方法与 getMethod 方法

public class MYRequest {
        
    
        private String method; // 请求方式（get、post、delete、put）
        private String url; 
    
        public MYRequest(InputStream in) {
        
            try {
        
                // 1.content用来保存InputStream中的http请求信息
                String content = "";
                byte[] buff = new byte[1024];
                int len = 0;
                if ((len = in.read(buff)) > 0) {
        
                    content = new String(buff, 0, len);
                }
    
                // 2.对http请求信息进行处理，得到Method与Url
                String line = content.split("\\n")[0];
                String[] arr = line.split("\\s");
                this.method = arr[0];
                this.url = arr[1].split("\\?")[0];
    
            } catch (IOException e) {
        
                e.printStackTrace();
            }
        }
    
        public String getUrl() {
        
            return this.url;
        }
    
        public String getMethod() {
        
            return this.method;
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center]

## 2.MYResponse ##

Response 本质就是 OutputStream，主要工作是：

1.  将 Servlet 处理结果编码成 http 协议格式
2.  通过 OutputStream 写出

所以，它只需要对外提供 write 方法即可。

public class MYResponse {
        
    
        private OutputStream out;
    
        public MYResponse(OutputStream out) {
        
            this.out = out;
        }
    
        /**
         * 向浏览器写出内容
         */
        public void write(String s) throws IOException {
        
            StringBuilder sb = new StringBuilder();
            // 因为写出的内容要被http协议解析，所以要符合http协议规范，有其要求的响应头（主要是状态码和响应格式）
            sb.append("HTTP/1.1 200 OK\n") // 状态码
                    .append("Content-Type: text/html;\n") // 响应格式
                    .append("\r\n")
                    .append(s);
            out.write(sb.toString().getBytes()); // 通过IO流写出
        }
    }

## 3.MYServlet ##

Servlet 就是一个应用于 web 的对象，具有规范作用。这里的 MYServlet 是一个抽象类，它的主要工作是：

1.  提供Servlet规范，即每个处理业务逻辑的Servlet都要继承它，重写doPost和doGet这俩模板方法
2.  完成请求方式与对应方法的映射，对外提供统一方法 service。这里其实采用了模板方法模式。

> PS：Servlet 对象一般是单例的，会在 Tomcat 初始化时创建

public abstract class MYServlet{
        
    
        // 注：这里的request与response都是Tomcat对象创建好然后传进来的
        public void service(MYRequest request, MYResponse response) throws IOException {
        
            if ("GET".equalsIgnoreCase(request.getMethod())) {
        
                doGet(request, response);
            } else{
        
                doPost(request, response);
            }
        }
    
        // 这里是模板方法模式，交给子类去具体实现
        protected abstract void doPost(MYRequest request, MYResponse response) throws IOException;
        protected abstract void doGet(MYRequest request, MYResponse response) throws IOException;
    }

## 4.MYTomcat（核心） ##

MYTomcat主要做了两件事：

1）初始化 tomcat：

1.  加载web.properties文件，在这里其实相当于Tocmat中的web.xml
2.  寻找url与servlet的映射关系，即对配置文件进行解析
3.  将url与Servlet实例保存在Map中，到时可直接根据url获取到处理业务的servlet（单例模式）

2）启动 tomcat：

1.  调用init，目的是得到servletMapping的映射关系
2.  通过BIO创建socket的服务端，在指定端口开始监听
3.  用一个死循环持续等待并处理用户请求，处理用户请求的具体逻辑是：
    
    1.  获取IO流，并包装成Request与Response
    2.  获取请求URL，寻找相应Servlet进行处理。如果能找到就调用 servlet 的 service 方法进行处理；找不到就写出404。
    3.  等处理完之后关闭本次连接的相关资源

public class MYTomcat {
        
    
        private int port = 8080;
        private ServerSocket server;
        // 用来保存路径与Servlet的映射关系（servlet单例模式）
        private Map<String, MYServlet> servletMapping = new HashMap<>();
        // web.properties，相当于tomcat的web.xml
        private Properties webxml = new Properties();
    	
    	/**
    	*初始化tocmat
    	*/
        private void init(){
        
    
            try{
        
            	// 1.加载web.properties文件
                String WEB_INF = this.getClass().getResource("/").getPath();
                FileInputStream fis = new FileInputStream(WEB_INF + "web.properties");
                webxml.load(fis);
    			
    			// 2.遍历配置文件，寻找url与servlet映射关系配置
                for (Object k : webxml.keySet()) {
        
    
                    String key = k.toString();
                    // 以url结尾的key就是要映射的路径，下面是两条配置示例：
        			// servlet.one.url=/firstServlet.do
    				// servlet.one.className=com.yzh.tomcat.servlet.FirstServlet
                    if(key.endsWith(".url")){
        
                    	// 去掉.url就是servlet的name（servlet.one）
                        String servletName = key.replaceAll("\\.url$", "");
                        
    					// 2.1 获取到url（/first.do）          
                        String url = webxml.getProperty(key);
    					
                        // 2.2 获取对应servlet全类名（com.yzh.tomcat...FirstServlet），并通过反进行实例化
                        String className = webxml.getProperty(servletName + ".className");
                        // 注：这里是将所有Servlet都强转为MyServlet，所以一定要继承MyServlet
                        MYServlet obj = (MYServlet)Class.forName(className).newInstance();
    					
    					// 3.将url与servlet实例保存到servletMapping中（单例模式）
                        servletMapping.put(url, obj);
                    }
                }
            }catch(Exception e){
        
                e.printStackTrace();
            }
        }
    
        /**
         * 启动tomcat
         */
        public void start() {
        
        	// 1.调用init，目的是得到servletMapping的映射关系
            init();
    
            try {
        
            	// 2.通过BIO创建socket的服务端，在指定端口开始监听
                server = new ServerSocket(this.port);
                System.out.println("MYTomcat已启动，监听的端口是" + this.port);
    
                // 3.用一个死循环持续等待并处理用户请求
                while (true) {
        
                    Socket client = server.accept();
                    // process是具体处理请求的逻辑，参数是当前连接的Socket
                    process(client);
                }
            } catch (IOException e) {
        
                e.printStackTrace();
            }
    
        }
    
        /**
         * 具体处理请求
         * 1.创建IO流，并包装成Request与Response
         * 2.获取请求Url，取出对应Servlet进行处理
         * 
         */
        private void process(Socket client) throws IOException {
        
            // 1.获取IO流，并封装成Request与Response
            InputStream is = client.getInputStream();
            OutputStream os = client.getOutputStream();
            // 注：这里要明白，每次请求的Request和Response都是不同的（因为连接时的socket不同），他俩的作用域仅为当前会话
            MYRequest request = new MYRequest(is);
            MYResponse response = new MYResponse(os);
    
            // 获取请求URL，寻找相应Servlet进行处理
            String url = request.getUrl();
    		// 2.判断改url是否有对应的Servlet实例
            if (servletMapping.containsKey(url)) {
        
                // 如果有，调用service方法进行处理
                servletMapping.get(url).service(request, response);
            } else {
        
            	// 如果没有，写出404
                response.write("404 - Not Found");
            }
    		
    		// 3.关闭本次连接相关资源
            os.flush();
            os.close();
            is.close();
            client.close();
        }
    	
    	/**
    	* 启动入口
    	*/
        public static void main(String[] args) {
        
            new MYTomcat().start();
        }
    }

好了，到这里手写的所有代码都结束了，下面就测试一下吧。

## 成果演示 ##

首先，我们写了一个FirstServlet，他继承了 MYServlet 并且重写了 doGet 与 doPost

public class FirstServlet extends MYServlet {
        
        @Override
        protected void doPost(MYRequest request, MYResponse response) throws IOException {
        
            response.write("this is FirstServlet!");
        }
    
        @Override
        protected void doGet(MYRequest request, MYResponse response) throws IOException {
        
            doPost(request, response);
        }
    }

然后就是配置文件 web.properties 了，配置的具体内容如下，其实就是配置url与全类名的映射关系

servlet.one.url=/firstServlet.do
    servlet.one.className=com.yzh.tomcat.servlet.FirstServlet
    
    servlet.two.url=/secondServlet.do
    servlet.two.className=com.yzh.tomcat.servlet.SecondServlet

项目的整体结构截图如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center 1]

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

好了，到了最激动人心的时刻了 --启动 Tomcat！  
![在这里插入图片描述][20201230002038659.png_pic_center]  
很好，没有报错，下面我们在浏览器上通过8080端口进行访问。

1.  情况一：访问一个没有相应servlet的url，返回404  
    ![在这里插入图片描述][20200922222014884.png_pic_center]
2.  情况二：访问FirstServlet的url，返回正确内容  
    ![在这里插入图片描述][20200922222143458.png_pic_center]

> BIO 是阻塞式IO，一次只能处理一个客户端的线程，无法支持并发，显然在实际生产中没有一个web项目敢这么搞。所以，在[下一篇][Link 1]我们就来看看如何使用 netty 重构现在的 tomcat。

到这里这篇文件就结束了，完整代码我放到GitHub上了，点[这里][Link 2]跳转…

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/b440084c2e824f53812cc7e3075d6779.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/3fdad936b8944452ba628eabdabc0ec8.png
[20201230002038659.png_pic_center]: /images/20221123/644bec856c3844e184437eccc9658deb.png
[20200922222014884.png_pic_center]: /images/20221123/2a220850659146b2b75cb527c6fb707a.png
[20200922222143458.png_pic_center]: /images/20221123/25fb038030724662a5b0949bfacba65c.png
[Link 1]: https://blog.csdn.net/weixin_43935927/article/details/111939530
[Link 2]: https://github.com/YZHyaa/framework/tree/main/myTomcat-bio