源码放在了文章末尾

理论知识

何为Tomcat

Tomcat是一个开源的Servlet容器，它实现了Java Servlet、JavaServer Pages (JSP)、WebSocket等Java EE规范，用于在Web服务器上运行Java Web应用程序。

说的简单点，Tomcat能处理网络传输来的请求。

输入输出流

也就是说，Tomcat要帮我们完成客户端和服务器之间的连接、传输。传输的时候是用输入输出流来传输的。

客户端和服务器的通信，说到底就是两个数据的传输，客户端发送inputStream给服务器，服务器回复outputStream给客户端。

HTTP请求

http请求也就是 web浏览器发送给web服务器（Tomcat）之间的传输数据协议。也就是商量好一个格式去传输，这样服务器收到了之后，就能对其进行解析了，就知道了浏览器想表达的意思，再对其进行反馈。

http请求协议部分数据

GET /user HTTP/1.1
Host: localhost:8080
Connection: keep-alive
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.169 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9

第一部分：请求行：请求类型，资源路径以及http版本（上述第一行）

第二部分：请求头：紧接在请求行之后，用于说明服务器需要使用的附加信息（第二到第八行）

第三部分：空行（请求头和主体之间必须有换行）

第四部分：主体数据，可以添加任意数据

HTTP响应

HTTP响应是Web服务器向客户端（通常是浏览器）返回的数据。当客户端发送HTTP请求后，服务器会根据请求的内容和要求生成一个HTTP响应，将其发送回客户端。在仿写Tomcat时，了解HTTP响应的结构和内容是很重要的。

HTTP 响应是服务器向客户端发送的数据，用于回应客户端的请求。HTTP 响应需要满足一定的格式和要求，以下是一个标准的 HTTP 响应的格式

HTTP/1.1 200 OK
Content-Type: text/html
Content-Length: 37

<html>
<head>
    <title>简单的HTTP响应示例</title>
</head>
<body>
    <h1>Hello, World!</h1>
</body>
</html>

HTTP/1.1 200 OK：状态行，表示HTTP协议版本为1.1，状态码为200，状态短语为OK。这表示请求成功。
Content-Type: text/html：响应头部，指定响应内容的类型为HTML。
Content-Length: 37：响应头部，指定响应内容的长度，以字节为单位。
空行：用于分隔响应头部和响应体。
响应体：实际的响应内容。在本例中，它是一个简单的HTML页面，显示了"Hello, World!"。

静态请求和动态请求

在Web服务中，静态请求和动态请求是两种不同类型的HTTP请求，用于获取和呈现网页内容。它们有不同的特点和用途：

静态请求：静态请求是指浏览器请求服务器上的静态资源，如HTML、CSS、JavaScript、图像文件等，这些资源在服务器上存储为不可更改的文件。
动态请求：动态请求是指浏览器请求服务器上的动态生成内容，通常是通过服务器端的程序逻辑来生成的，如PHP、Python、Ruby等脚本语言。服务器会根据请求的参数和逻辑生成内容，然后将内容返回给浏览器。

总之，静态请求和动态请求在Web服务中都起着重要作用，静态请求用于提供固定不变的资源，而动态请求用于生成个性化、实时更新的内容。

项目演示

启动Tomcat

访问首页

url输入错误，404页面测试

静态请求测试：访问html页面

静态请求测试：css

动态请求测试：登录

项目流程

项目目录

简单流程图

客户端（浏览器）发送一个请求，Tomcat一直在监听，当受到请求后，开始解析这个请求信息，解析完毕开始处理请求，处理完毕就封装响应信息，再返回给前端。

详细流程图

详细的流程请看下面讲解

1启动类：MyTomcat

serverSocket：是一个 ServerSocket 对象，它通过 ServerSocket 类创建，并在特定端口上监听连接请求。
accept()方法是 ServerSocket 类的一个方法，它会阻塞程序执行，等待客户端连接。当有客户端连接到服务器时，accept() 方法将返回一个新的 Socket 对象，表示与客户端之间的连接。

2.线程任务处理类：ThreadTask

具体就是做下面四个步骤

对客户端收到的流数据进行解析与封装，得到request对象
根据流数据与request对象得到response对象
对静态请求与动态请求分开处理，完善响应对象
关闭连接

这四步骤也就是tomcat的全部了，但是具体的每个步骤的细分还有很多

3.请求类：HttpServletRequest

请求信息类，对客户端收到的输入流数据进行解析与封装，得到request对象

将输入流转换成String，开始解析

/**
 * 将输入流转换成String，开始解析
 */
public HttpServletRequest(InputStream iis) {
       //一次性读完所有请求信息
   StringBuilder sb = new StringBuilder();
   int length = -1;
   byte[] bs = new byte[100*1024];
   try {
      length = iis.read(bs);//读取socket输入流数据，将其放到byte数组里面
   } catch (IOException e) {
      e.printStackTrace();
      System.out.println("读取客户请求异常");
       }
   //将bs中的字节数据转为char
   for(int i = 0;i<length;i++){
      sb.append((char)bs[i]);
   }
   content = sb.toString();//将sb转换成String，存到content里面
   parseProtocol();      //开始解析
}

具体解析操作

解析协议

/**
 * 解析协议
 */
private void parseProtocol() {
   String[] ss = content.split(" ");
   //解析 请求方法类型，存到method
   this.method = ss[0];

   //解析 请求地址，存到requestURI
   this.requestURI = ss[1];

   //解析 请求参数，存到parameter的map中
   parseParameter();

   //解析 请求头，存到headers中
   parseHeader();

   //解析 请求cookie：从headers中取cookie
   parseCookie();

   //解析 sessionId：从cookie中取出jsessionid
   jsessionid = parseJSessionId();
}

各种解析方法

private String parseJSessionId() {
   if(cookies!=null&&cookies.size()>0) {
      for(Cookie c:cookies) {
         if("JSESSIONID".equals(c.getName())) {
            return c.getValue();
         }
      }
   } 
   return null;
}

   /**
    * headers中取出cookie，然后在解析出cookie对象存在cookies中
 * 取出协议中的 Cookie：xxxx  ,如果有则说明已经生成过Cookie  没有则表明是第一次请求，要生成Cookie编号
    */
private void parseCookie() {
   if(headers==null&&headers.size()<=0){
      return;
   }
   //从headers中取出键为cookie的 
   String cookieValue = headers.get("Cookie");
   if(cookieValue == null || cookieValue.length()<=0) {
      return;
   }
   String[] cvs = cookieValue.split(": ");
   if(cvs.length > 0) {
      for(String cv:cvs) {
         String[] str = cv.split("=");
         if(str.length > 0) {
            String key = str[0];
            String value = str[1];
            Cookie c = new Cookie(key,value);
            cookies.add(c);
         }
      }
   }
}
private void parseHeader() {
       //请求头
   String[] parts = this.content.split("\r\n\r\n");
       //GET /请求地址 HTTP/1.1
   String[] headerss = parts[0].split("\r\n");
      for(int i = 1;i<headerss.length;i++){
         String[] headPair = headerss[i].split(": ");
               //Host: localhost:8888     Connection: keep-alive ...
         headers.put(headPair[0], headPair[1]);
      }
}

   /**
    * 取参数
    */
private void parseParameter() {
   //requestURI: user.action?name=z&password=a
   int index = this.requestURI.indexOf("?");
   //有?的话
   if(index>=1){
      String[] pairs = this.requestURI.substring(index+1).split("&");
      for(String p:pairs){
         String[] po = p.split("=");
         parameter.put(po[0], po[1]);
      }
   }
   if(this.method.equals("POST")){
      String[] parts = this.content.split("\r\n\r\n");
      String entity = parts[1];
      String[] pairs = entity.split("&");
      for(String p:pairs){
         String[] po = p.split("=");
         parameter.put(po[0], po[1]);
      }
   }
}

4.响应类：HttpServletResponse

响应类：根据传过来的请求对象拿到 URL，找到请求的资源文件，设置对应的响应类型，将文件写入到响应流中返回

如果是静态请求，就会调用到相应类，因为静态请求就是要获取某个HTML、CSS、JavaScript、图像等文件，所以我们只需要从请求url中解析出文件的名称，再找到这个文件，再按照http响应的格式的写入到输出流中，返回给前端就行了。

按照不同类型调用send方法

//3、发送文件响应，不同的文件返回不同类型
      if(file.getName().endsWith(".jpg")){
          send(file,"application/x-jpg",code);
      }else if(file.getName().endsWith(".jpe")||file.getName().endsWith(".jpeg")){
          send(file,"image/jpeg",code);
      }else if(file.getName().endsWith(".gif")){
          send(file,"image/gif",code);
      }else if(file.getName().endsWith(".css")){
          send(file,"text/css",code);
      }else if(file.getName().endsWith(".js")){
          send(file,"application/x-javascript",code);
      }else if(file.getName().endsWith(".swf")){
          send(file,"application/x-shockwave-flash",code);
      }else{
          send(file,"text/html",code);
      }

send方法先调用genProtocol方法，先拼接好响应格式

   /**
    * 拼接响应协议
    */
private String genProtocol(long length, String contentType, int code) {
   String result = "HTTP/1.1 "+code+" OK\r\n";
   result+="Server: myTomcat\r\n";
   result+="Content-Type: "+contentType+";charset=utf-8\r\n"; 
   result+="Content-Length: "+length+"\r\n";
   result+="Date: "+new Date()+"\r\n"; 
   result+="\r\n";
   return result;
}

send方法再调用readFile方法把文件读出来，返回字节数组

   /**
    * 读取文件
    */
private byte[] readFile(File file) {
   ByteArrayOutputStream baos = new ByteArrayOutputStream();
   FileInputStream fis = null;
   
   try {
      fis = new FileInputStream(file);
      byte[] bs = new byte[1024];
      int length;
      while((length = fis.read(bs,0,bs.length))!=-1){
         baos.write(bs, 0, length);
         baos.flush();
      }
   } catch (Exception e) {
      e.printStackTrace();
   }finally{
      try {
               fis.close();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
   return baos.toByteArray();
}

最后send方法就返回给前端流数据了

   /**
    * 返回给前端响应流
    */
private void send(File file, String contentType, int code) {
   try {
      String responseHeader = genProtocol(file.length(),contentType,code);
      byte[] bs = readFile(file);
      
      this.oos.write(responseHeader.getBytes());
      this.oos.flush();//往前端传过去
      this.oos.write(bs);
      this.oos.flush();
   } catch (IOException e) {
      e.printStackTrace();
   }finally{
      try {
         this.oos.close();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

5.处理接口、动态处理类、静态处理类

静态处理就是前端需要一些静态的资源，例如HTML、CSS、图片等，后端直接找到文件，按照格式返回给前端就行了

动态处理就有对应得到业务了，要调用对应的servlet

区分动态还是静态，我这里是这样区分的：URL中有.action的就是动态，其他就是静态，下面代码就是在线程任务处理类里面的代码。

处理接口主要就是一个处理类的接口，动态处理类和静态处理类实现了它

/**
 * 处理器
 * 处理请求的接口
 *
 * @author 康有为
 * @date 2023/08/17
 */
public interface Processor {
    /** 处理请求，给出响应
     * @param request 请求
     * @param response 响应
     */
   void process(HttpServletRequest request, HttpServletResponse response);
}

静态处理类就很简单，直接调用相应类的sendRedirect方法，返回给前端就行了。

/**
 * 静态处理器
 *     实现处理接口
 *
 * @author 康有为
 * @date 2023/08/17
 */
public class StaticProcessor implements Processor {

   @Override
   public void process(HttpServletRequest request, HttpServletResponse response) {
      //调用响应类的 sendRedirect方法
      response.sendRedirect();
   }

}

动态处理类

因为动态处理的URL中肯定是有“.action”结尾的（我们自定义的），所以我们要解析URL，拿到.action 前面的那些东西。

例如：localhost:8888/User.action 这个请求，我们拿到User之后，再后面拼接一个“Servlet”，再利用反射，在对应的存放servlet实例文件目录中找到UserServlet，再调用其对应的servlet的方法就行了。