【吃透Java手写】4-Tomcat-简易版

【吃透Java手写】Tomcat-简易版-源码解析

1 准备工作
- 1.1 引入依赖
- 1.2 创建一个Tomcat的启动类
2 线程池技术回顾
- 2.1 线程池的使用流程
- 2.2 线程池的参数
- - 2.2.1 任务队列（workQueue）
  - 2.2.2 线程工厂（threadFactory）
  - 2.2.3 拒绝策略（handler）
- 2.3 功能线程池
- - 2.3.1 定长线程池（FixedThreadPool）
  - 2.3.2 定时线程池（ScheduledThreadPool ）
  - 2.3.3 可缓存线程池（CachedThreadPool）
  - 2.3.4 单线程化线程池（SingleThreadExecutor）
  - 2.3.5 对比
3 Tomcat逻辑
- 3.1 请求
- - 3.1.1 单次请求
  - 3.1.2 多次请求
  - 3.1.3 线程池处理请求
- 3.2 处理socket连接
- - 3.2.1 http协议格式
  - 3.2.2 具体解析
  - 3.2.3 Request
- 3.3 请求类Request
- 3.4 响应类Response
- - 3.4.1 请求体输出流ResponseOutputStream
- 3.5 servlet SJBServlet
- 3.6 测试
- 3.7 Tomcat的部署应用
- - 3.7.1 @WebServlet 注解和 web.xml 的区别
  - 3.7.2 目录存放
  - 3.7.3 部署
  - 3.7.4 部署测试

1 准备工作

1.1 引入依赖

<dependencies><dependency><groupId>javax.servlet</groupId><artifactId>javax.servlet-api</artifactId><version>3.0.1</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>3.8.1</version><scope>test</scope></dependency>
</dependencies>

1.2 创建一个Tomcat的启动类

创建com.sjb.Tomcat

public class Tomcat {public void start(){}public static void main(String[] args) {Tomcat tomcatApplication = new Tomcat();tomcatApplication.start();}
}

2 线程池技术回顾

线程池的真正实现类是 ThreadPoolExecutor

2.1 线程池的使用流程

// 创建线程池
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(CORE_POOL_SIZE,MAXIMUM_POOL_SIZE,KEEP_ALIVE,TimeUnit.SECONDS,sPoolWorkQueue,sThreadFactory);
// 向线程池提交任务
threadPool.execute(new Runnable() {@Overridepublic void run() {... // 线程执行的任务}
});
// 关闭线程池
threadPool.shutdown(); // 设置线程池的状态为SHUTDOWN，然后中断所有没有正在执行任务的线程
threadPool.shutdownNow(); // 设置线程池的状态为 STOP，然后尝试停止所有的正在执行或暂停任务的线程，并返回等待执行任务的列表

2.2 线程池的参数

主要参数：

corePoolSize（必需)

核心线程数。默认情况下，核心线程会一直存活，但是当将 allowCoreThreadTimeout 设置为 true 时，核心线程也会超时回收。
maximumPoolSize（必需）

线程池所能容纳的最大线程数。当活跃线程数达到该数值后，后续的新任务将会阻塞
keepAliveTime（必需）

线程闲置超时时长。如果超过该时长，非核心线程就会被回收。如果将 allowCoreThreadTimeout 设置为 true 时，核心线程也会超时回收。
unit（必需）

指定 keepAliveTime 参数的时间单位。常用的有：TimeUnit.MILLISECONDS（毫秒）、TimeUnit.SECONDS（秒）、TimeUnit.MINUTES（分）。
workQueue（必需）

任务队列。通过线程池的 execute() 方法提交的 Runnable 对象将存储在该参数中。其采用阻塞队列实现。
threadFactory（可选）

线程工厂。用于指定为线程池创建新线程的方式。
handler（可选）

拒绝策略。当达到最大线程数时需要执行的饱和策略。

2.2.1 任务队列（workQueue）

任务队列是基于阻塞队列实现的，即采用生产者消费者模式，在 Java 中需要实现 BlockingQueue 接口。但 Java 已经为我们提供了 7 种阻塞队列的实现：

ArrayBlockingQueue：一个由数组结构组成的有界阻塞队列（数组结构可配合指针实现一个环形队列）。
LinkedBlockingQueue： 一个由链表结构组成的有界阻塞队列，在未指明容量时，容量默认为 Integer.MAX_VALUE。
PriorityBlockingQueue： 一个支持优先级排序的无界阻塞队列，对元素没有要求，可以实现 Comparable 接口也可以提供 Comparator 来对队列中的元素进行比较。跟时间没有任何关系，仅仅是按照优先级取任务。
DelayQueue： 类似于PriorityBlockingQueue，是二叉堆实现的无界优先级阻塞队列。要求元素都实现 Delayed 接口，通过执行时延从队列中提取任务，时间没到任务取不出来。
SynchronousQueue： 一个不存储元素的阻塞队列，消费者线程调用 take() 方法的时候就会发生阻塞，直到有一个生产者线程生产了一个元素，消费者线程就可以拿到这个元素并返回；生产者线程调用 put() 方法的时候也会发生阻塞，直到有一个消费者线程消费了一个元素，生产者才会返回。
LinkedBlockingDeque： 使用双向队列实现的有界双端阻塞队列。双端意味着可以像普通队列一样 FIFO（先进先出），也可以像栈一样 FILO（先进后出）。
LinkedTransferQueue： 它是ConcurrentLinkedQueue、LinkedBlockingQueue 和 SynchronousQueue 的结合体，但是把它用在 ThreadPoolExecutor 中，和 LinkedBlockingQueue 行为一致，但是是无界的阻塞队列。

注意有界队列和无界队列的区别：如果使用有界队列，当队列饱和时并超过最大线程数时就会执行拒绝策略；而如果使用无界队列，因为任务队列永远都可以添加任务，所以设置 maximumPoolSize 没有任何意义。

2.2.2 线程工厂（threadFactory）

线程工厂指定创建线程的方式，需要实现 ThreadFactory 接口，并实现 newThread(Runnable r) 方法。该参数可以不用指定，Executors 框架已经为我们实现了一个默认的线程工厂

2.2.3 拒绝策略（handler）

当线程池的线程数达到最大线程数时，需要执行拒绝策略。拒绝策略需要实现 RejectedExecutionHandler 接口，并实现 rejectedExecution(Runnable r, ThreadPoolExecutor executor) 方法。不过 Executors 框架已经为我们实现了 4 种拒绝策略：

AbortPolicy（默认）：丢弃任务并抛出 RejectedExecutionException 异常。
CallerRunsPolicy：由调用线程处理该任务。
DiscardPolicy：丢弃任务，但是不抛出异常。可以配合这种模式进行自定义的处理方式。
DiscardOldestPolicy：丢弃队列最早的未处理任务，然后重新尝试执行任务。

2.3 功能线程池

Executors已经为我们封装好了 4 种常见的功能线程池，如下：

定长线程池（FixedThreadPool）
定时线程池（ScheduledThreadPool ）
可缓存线程池（CachedThreadPool）
单线程化线程池（SingleThreadExecutor）

2.3.1 定长线程池（FixedThreadPool）

源码：

public static ExecutorService newFixedThreadPool(int nThreads) {return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());
}
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {return new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>(),threadFactory);
}

特点：只有核心线程，线程数量固定，执行完立即回收，任务队列为链表结构的有界队列。
应用场景：控制线程最大并发数。

使用示例：

// 1. 创建定长线程池对象 & 设置线程池线程数量固定为3
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
// 2. 创建好Runnable类线程对象 & 需执行的任务
Runnable task =new Runnable(){public void run() {System.out.println("执行任务啦");}
};
// 3. 向线程池提交任务
fixedThreadPool.execute(task);

2.3.2 定时线程池（ScheduledThreadPool ）

源码：

private static final long DEFAULT_KEEPALIVE_MILLIS = 10L;public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {return new ScheduledThreadPoolExecutor(corePoolSize);
}
public ScheduledThreadPoolExecutor(int corePoolSize) {super(corePoolSize, Integer.MAX_VALUE,DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,new DelayedWorkQueue());
}public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize, ThreadFactory threadFactory) {return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
}
public ScheduledThreadPoolExecutor(int corePoolSize,ThreadFactory threadFactory) {super(corePoolSize, Integer.MAX_VALUE,DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,new DelayedWorkQueue(), threadFactory);
}

特点：核心线程数量固定，非核心线程数量无限，执行完闲置 10ms 后回收，任务队列为延时阻塞队列。
应用场景：执行定时或周期性的任务。

// 1. 创建 定时线程池对象 & 设置线程池线程数量固定为5
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
// 2. 创建好Runnable类线程对象 & 需执行的任务
Runnable task =new Runnable(){public void run() {System.out.println("执行任务啦");}
};
// 3. 向线程池提交任务
scheduledThreadPool.schedule(task, 1, TimeUnit.SECONDS); // 延迟1s后执行任务
scheduledThreadPool.scheduleAtFixedRate(task,10,1000,TimeUnit.MILLISECONDS);// 延迟10ms后、每隔1000ms执行任务

2.3.3 可缓存线程池（CachedThreadPool）

源码：

public static ExecutorService newCachedThreadPool() {return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>());
}
public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {return new ThreadPoolExecutor(0, Integer.MAX_VALUE,60L, TimeUnit.SECONDS,new SynchronousQueue<Runnable>(),threadFactory);
}

特点：无核心线程，非核心线程数量无限，执行完闲置 60s 后回收，任务队列为不存储元素的阻塞队列。
应用场景：执行大量、耗时少的任务。

// 1. 创建可缓存线程池对象
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
// 2. 创建好Runnable类线程对象 & 需执行的任务
Runnable task =new Runnable(){public void run() {System.out.println("执行任务啦");}
};
// 3. 向线程池提交任务
cachedThreadPool.execute(task);

2.3.4 单线程化线程池（SingleThreadExecutor）

源码：

public static ExecutorService newSingleThreadExecutor() {return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>()));
}
public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {return new FinalizableDelegatedExecutorService(new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>(),threadFactory));
}

特点：只有 1 个核心线程，无非核心线程，执行完立即回收，任务队列为链表结构的有界队列。
应用场景：不适合并发但可能引起 IO 阻塞性及影响 UI 线程响应的操作，如数据库操作、文件操作等。

// 1. 创建单线程化线程池
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
// 2. 创建好Runnable类线程对象 & 需执行的任务
Runnable task =new Runnable(){public void run() {System.out.println("执行任务啦");}
};
// 3. 向线程池提交任务
singleThreadExecutor.execute(task);

2.3.5 对比

在这里插入图片描述

3 Tomcat逻辑

3.1 请求

3.1.1 单次请求

在com.sjb.Tomcat#start

public class Tomcat {public void start(){//socket连接TCPtry {ServerSocket serverSocket = new ServerSocket(8080);Socket socket = serverSocket.accept();processSocket(socket);}} catch (IOException e) {throw new RuntimeException(e);}}private void processSocket(Socket socket) {//处理socket请求}public static void main(String[] args) {Tomcat tomcatApplication = new Tomcat();tomcatApplication.start();}
}

使用了 ServerSocket 类来监听8080端口上的连接。

通过serverSocket.accept()阻塞监听8080端口，一直等待直到有一个客户端连接请求到达。一旦有连接请求到达，accept() 方法会返回一个新的 Socket 对象，该对象表示服务器和客户端之间建立的连接。然后你就可以使用这个 Socket 对象来进行通信，发送和接收数据。

每当有一个连接到达，它会调用 processSocket() 方法来处理该连接。

3.1.2 多次请求

但是这个有个只处理单次请求，我们需要加上一个while来不断地进行阻塞监听

try {ServerSocket serverSocket = new ServerSocket(8080);while(true){Socket socket = serverSocket.accept();processSocket(socket);}
} catch (IOException e) {throw new RuntimeException(e);
}

但是这个是线性的，一次只能处理一个

3.1.3 线程池处理请求

引入线程池，提升并行处理能力

public class Tomcat {public void start(){//socket连接TCPtry {ExecutorService executorService = Executors.newFixedThreadPool(20);ServerSocket serverSocket = new ServerSocket(8080);while(true){Socket socket = serverSocket.accept();executorService.execute(new SocketProcessor(socket));}} catch (IOException e) {throw new RuntimeException(e);}}public static void main(String[] args) {Tomcat tomcatApplication = new Tomcat();tomcatApplication.start();}
}

创建com.sjb.SocketProcessor实现Runnable

public class SocketProcessor implements Runnable{private Socket socket;public SocketProcessor(Socket socket) {this.socket = socket;}@Overridepublic void run() {processSocket(socket);}private void processSocket(Socket socket) {//处理socket}
}

3.2 处理socket连接

3.2.1 http协议格式

在这里插入图片描述

tomcat需要按照这个格式进行解析，这里先把他全部输出就不解析了。

在com.sjb.SocketProcessor#processSocket中

private void processSocket(Socket socket) {//处理sockettry {InputStream inputStream = socket.getInputStream();byte[] bytes = new byte[1024];//循环读取数据while (true){int read = inputStream.read(bytes);if(read == -1){break;}System.out.println(new String(bytes,0,read));}} catch (IOException e) {throw new RuntimeException(e);}
}

访问http://localhost:8080/，输出

GET / HTTP/1.1
Host: localhost:8080
Connection: keep-alive
Cache-Control: max-age=0
sec-ch-ua: "Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"
sec-ch-ua-mobile: ?0
sec-ch-ua-platform: "Windows"
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Accept-Encoding: gzip, deflate, br, zstd
Accept-Language: zh-CN,zh;q=0.9
Cookie: Idea-7b055fc6=c09dc312-ccaa-43d4-bf1f-95a39406b2e6; username-localhost-60524="2|1:0|10:1713800933|24:username-localhost-60524|196:eyJ1c2VybmFtZSI6ICJjMTdjZmFhYjA0MGQ0Njg3YWFjNzZiYzc1MmQ3Zjc0ZCIsICJuYW1lIjogIkFub255bW91cyBUaHlvbmUiLCAiZGlzcGxheV9uYW1lIjogIkFub255bW91cyBUaHlvbmUiLCAiaW5pdGlhbHMiOiAiQVQiLCAiY29sb3IiOiBudWxsfQ==|d3
42be023b8e3ab274c8019dd4a41dc7f3102301b8faf7ea83435c06dd9b614b"; _xsrf=2|0e634e08|aaad0368070a9f2267481456f73e2dd6|1713800933; username-localhost-61085=2|1:0|10:1713801376|24:username-localhost-61085|204:eyJ1c2VybmFtZSI6ICJhM2IzOTQwNjhjYzM0OWM4OTYyYzUxODQ2Y2IwNzU1YiIsICJuYW1lIjogIkFub255bW91cyBDYWxsaXJyaG9lIiwgImRpc3BsYXlfbmFtZSI6ICJBbm9ueW1vdXMgQ2FsbGlycmhvZSIsICJpbml0aWFscyI6ICJBQyIsICJjb2xvciI6IG51bGx9|e49adff6d260df7ee49848807369b565e82e36906318b9546796c968f21a9361; username-localhost-61138="2|1:0|10:1713801443|24:username-localhost-61138|200:eyJ1c2VybmFtZSI6ICI4YzVkOWRkYTBmNGE0YTk1YjQ0MjFkMzYwZDRmNTFhMyIsICJuYW1lIjogIkFub255bW91cyBMeXNpdGhlYSIsICJkaXNwbGF5X25hbWUiOiAiQW5vbnltb3VzIEx5c2l0aGVhIiwgImluaXRpYWxzIjogIkFMIiwgImNvbG9yIjogbnVsbH0=|587e609fe7fc575e84763d39c6fd8b9feb8cdd0da05046d03dec57ba58307aef"

3.2.2 具体解析

我们需要获得method、url、protocl来创建Request对象

访问http://localhost:8080/abc

//处理socket
try {InputStream inputStream = socket.getInputStream();//解析请求头，获得method、url、protocolbyte[] bytes = new byte[1024];int read = inputStream.read(bytes);String request = new String(bytes, 0, read);String[] split = request.split("\r\n");String[] split1 = split[0].split(" ");String method = split1[0];String url = split1[1];String protocol = split1[2];System.out.println("method: " + method);System.out.println("url: " + url);System.out.println("protocol: " + protocol);
} catch (IOException e) {throw new RuntimeException(e);
}

输出

method: GET
url: /abc
protocol: HTTP/1.1

请求头和请求体同理

3.2.3 Request

创建com.sjb.Request

public class Request {private String method;private String url;private String protocol;public Request(String method, String url, String protocol) {this.method = method;this.url = url;this.protocol = protocol;}public String getMethod() {return method;}public String getUrl() {return url;}public String getProtocol() {return protocol;}
}

在com.sjb.SocketProcessor#processSocket中创建Request对象，再进行之后的匹配servlet之后执行对应的doGet方法、doPost方法等等

//处理socket
try {InputStream inputStream = socket.getInputStream();//解析请求头，获得method、url、protocolbyte[] bytes = new byte[1024];int read = inputStream.read(bytes);String request = new String(bytes, 0, read);String[] split = request.split("\r\n");String[] split1 = split[0].split(" ");String method = split1[0];String url = split1[1];String protocol = split1[2];Request tomcatrequest = new Request(method, url, protocol);//根据url找到对应的servlet} catch (IOException e) {throw new RuntimeException(e);
}

3.3 请求类Request

Request类需要实现接口HttpServletResponse，里面有很多方法，我们避免麻烦创建一个com.sjb.AbstractHttpServletResponse类实现接口，我们的Request类只需要继承AbstractHttpServletResponse即可

创建com.sjb.AbstractHttpServletResponse

public class AbstractHttpServletRequest implements HttpServletRequest {@Overridepublic String getAuthType() {return null;}@Overridepublic Cookie[] getCookies() {return new Cookie[0];}.................

创建com.sjb.Request

public class Request extends AbstractHttpServletRequest {private String method;private String url;private String protocol;private Socket socket;public Socket getSocket() {return socket;}public Request(String method, String url, String protocol, Socket socket) {this.method = method;this.url = url;this.protocol = protocol;this.socket = socket;}public String getMethod() {return method;}public StringBuffer getRequestURL() {return new StringBuffer(url);}public String getProtocol() {return protocol;}
}

public Request(String method, String url, String protocol, Socket socket)一个socket对应一个Request对应一个response

3.4 响应类Response

与3.3类似

创建com.sjb.AbstractHttpServletResponse

public class AbstractHttpServletResponse implements HttpServletResponse {@Overridepublic void addCookie(Cookie cookie) {}@Overridepublic boolean containsHeader(String s) {return false;}...................

创建com.sjb.Response

public class Response extends AbstractHttpServletResponse {private String message="OK";private int status=200;private Map<String,String> headers = new HashMap<>();private Request request;private OutputStream socketOutputStream;private ResponseOutputStream responseOutputStream=new ResponseOutputStream();public Response(Request request) {this.request = request;try {this.socketOutputStream = request.getSocket().getOutputStream();} catch (IOException e) {throw new RuntimeException(e);}}@Overridepublic void setStatus(int status, String message) {this.status = status;this.message = message;}@Overridepublic int getStatus() {return status;}@Overridepublic void addHeader(String s, String s1) {headers.put(s, s1);}@Overridepublic ResponseOutputStream getOutputStream() throws IOException {return responseOutputStream;}public void complete() {//发送响应sendResponseLine();sendResponseHeader();sendResponseBody();}private void sendResponseBody() {try {byte[] body = getOutputStream().getBody();int pos = getOutputStream().getPos();socketOutputStream.write(body, 0, pos);} catch (IOException e) {throw new RuntimeException(e);}}private void sendResponseHeader() {try {for (Map.Entry<String, String> entry : headers.entrySet()) {String key = entry.getKey();String value = entry.getValue();socketOutputStream.write(key.getBytes());socketOutputStream.write(": ".getBytes());socketOutputStream.write(value.getBytes());socketOutputStream.write("\r\n".getBytes());}socketOutputStream.write("\r\n".getBytes());} catch (IOException e) {throw new RuntimeException(e);}}private void sendResponseLine() {try {socketOutputStream.write(request.getProtocol().getBytes());socketOutputStream.write(" ".getBytes());socketOutputStream.write(String.valueOf(status).getBytes());socketOutputStream.write(" ".getBytes());socketOutputStream.write(message.getBytes());socketOutputStream.write("\r\n".getBytes());} catch (IOException e) {throw new RuntimeException(e);}    }
}

属性：

int status：状态码
String message：说明
Map<String,String> header：存储响应头，例如一些长度、编码信息等
Request request：一个response对应一个request
OutputStream socketOutputStream：socket的整个输出流
ResponseOutputStream responseOutputStream：响应体的输出流，因为响应体可能有很多，所以需要用一个输出流进行缓存，并且如果响应失败的话，也只有响应行和响应头返回，响应体不返回。

private ResponseOutputStream responseOutputStream=new ResponseOutputStream();一开始就创建好响应响应体的输出流，保证public ResponseOutputStream getOutputStream()拿到的都是同一个响应体的输出流

3.4.1 请求体输出流ResponseOutputStream

因为响应体可能有很多，所以需要用一个输出流进行缓存，并且如果响应失败的话，也只有响应行和响应头返回，响应体不返回。

创建com.sjb.ResponseOutputStream

public class ResponseOutputStream extends ServletOutputStream {public byte[] getBody() {return body;}public int getPos() {return pos;}private byte[] body=new byte[1024];private int pos=0;@Overridepublic void write(int b) throws IOException {//响应体body[pos++]=(byte)b;}
}

3.5 servlet SJBServlet

根据Request创建对应的Response并且创建servlet，调用servlet的service方法,匹配doGet或者doPost

在com.sjb.SocketProcessor#processSocket中

try {InputStream inputStream = socket.getInputStream();//解析请求头，获得method、url、protocolbyte[] bytes = new byte[1024];int read = inputStream.read(bytes);String request = new String(bytes, 0, read);String[] split = request.split("\r\n");String[] split1 = split[0].split(" ");String method = split1[0];String url = split1[1];String protocol = split1[2];Request tomcatrequest = new Request(method, url, protocol, socket);//根据url找到对应的servletResponse response = new Response(tomcatrequest);SJBServlet servlet = new SJBServlet();//调用servlet的service方法,匹配doGet或者doPostservlet.service(tomcatrequest, response);//输出响应response.complete();
}

创建com.sjb.SJBServlet，service方法自动给匹配请求方法，我们只需要重写对应的doGet、doPost方法即可

public class SJBServlet extends HttpServlet {@Overrideprotected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {System.out.println(req.getMethod());resp.addHeader("Content-Type", "text/html;charset=utf-8");resp.addHeader("Content-Length", "15");resp.getOutputStream().write("Hello World sjb".getBytes());}
}

在doGet方法调用response.addHeader()中设置请求头，编码方式、请求体长度等。

也不一定在doGet方法设置请求头，亦可以在com.sjb.Response#sendResponseHeader中设置请求头

private void sendResponseHeader() {try {if(!headers.containsKey("Content-Type")){headers.put("Content-Type", "text/html;charset=utf-8");}if(!headers.containsKey("Content-Length")){headers.put("Content-Length", String.valueOf(responseOutputStream.getPos()));}

resp.getOutputStream().write("Hello World sjb".getBytes());设置请求体。

最后调用response.complete();写请求行、请求头、请求体。完成输出流的输出。

3.6 测试

访问

在这里插入图片描述

3.7 Tomcat的部署应用

在tomcat中有一个专门的目录webapps用来存放tomcat的项目，一个tomcat项目中的classes中可以有多个servlet

如果要部署tomcat需要在对应的servlet上加上@WebServlet 注解

在SJBServlet上添加注解

@WebServlet(urlPatterns = {"/sjb"}
)
public class SJBServlet extends HttpServlet {public SJBServlet() {}

@WebServlet 属于类级别的注解，标注在继承了 HttpServlet 的类之上。常用的写法是将 Servlet 的相对请求路径（即 value）直接写在注解内，@WebServlet(urlPatterns = {“/sjb”})。@WebServlet(urlPatterns = {“/sjb”})省略了 urlPatterns 属性名
如果 @WebServlet 中需要设置多个属性，则属性之间必须使用逗号隔开。
通过实现 Serlvet 接口或继承 GenericServlet 创建的 Servlet 类无法使用 @WebServlet 注解。
使用 @WebServlet 注解配置的 Servlet 类，不要在 web.xml 文件中再次配置该 Servlet 相关属性。若同时使用 web.xml 与 @WebServlet 配置同一 Servlet 类，则 web.xml 中的值与注解中 name 取值不能相同，否则容器会忽略注解中的配置。

3.7.1 @WebServlet 注解和 web.xml 的区别

使用 web.xml 或 @WebServlet 注解都可以配置 Servlet

@WebServlet 注解配置 Servlet
- 优点：@WebServlet 直接在 Servlet 类中使用，代码量少，配置简单。每个类只关注自身业务逻辑，与其他 Servlet 类互不干扰，适合多人同时开发。
- 缺点：Servlet 较多时，每个 Servlet 的配置分布在各自的类中，不便于查找和修改。
web.xml 配置文件配置 Servlet
- 优点：集中管理 Servlet 的配置，便于查找和修改。
- 缺点：代码较繁琐，可读性不强，不易于理解。

3.7.2 目录存放

要将重新编译好的SJBServlet.class放入Tomcat/webapps/hello/classes/com/sjb目录下，并且删除之前的SJBServlet.class

在这里插入图片描述

所以在com.sjb.SocketProcessor#processSocket中就不能直接调用SJBServlet，需要对环境进行解析找到对应的Servlet

3.7.3 部署

在com.sjb.Tomcat#main中需要部署apps

public static void main(String[] args) {Tomcat tomcatApplication = new Tomcat();tomcatApplication.deployApps();tomcatApplication.start();
}

deployApps() ：获取当前父项目目录下所有的Tomcat/webapps下的所有目录

private void deployApps() {//拿到当前模块的目录的子目录//webapps = D:\Code\JavaCode\handwith-Spring\handwith-Spring\Tomcat\webappsFile webapps = new File(System.getProperty("user.dir"),"Tomcat/webapps");for(String app: webapps.list()){//app: hellodeployApp(webapps,app);}
}

针对app: hello进行部署，deployApp(webapps,app)：

webapps父目录，app子目录
context负责存放当前项目。一个context项目下可能有多个app（servlet）

private void deployApp(File webapps,String app) {Context context = new Context(app);//appDir = D:\Code\JavaCode\handwith-Spring\handwith-Spring\Tomcat\webapps\helloFile appDir = new File(webapps, app);//classesDir = D:\Code\JavaCode\handwith-Spring\handwith-Spring\Tomcat\webapps\hello\classesFile classesDir = new File(appDir, "classes");List<File> files = getAllFilePath(classesDir);for(File file:files){//name: D:\Code\JavaCode\handwith-Spring\handwith-Spring\Tomcat\webapps\hello\classes\com\sjb\SJBServlet.classString name=file.getPath();//name: com\sjb\SJBServlet.classname=name.replace(classesDir.getPath()+"\\","");//name: com\sjb\SJBServletname=name.replace(".class","");//name: com.sjb.SJBServletname=name.replace("\\",".");System.out.println(name);//加载类加载器try {WebappClassLoader webappClassLoader = new WebappClassLoader(new URL[]{classesDir.toURL()});Class<?> aClass = webappClassLoader.loadClass(name);if(HttpServlet.class.isAssignableFrom(aClass)){if(aClass.isAnnotationPresent(WebServlet.class)){WebServlet webServlet = aClass.getAnnotation(WebServlet.class);//urlPatterns：["/sjb"]String[] urlPatterns = webServlet.urlPatterns();for(String urlPattern:urlPatterns){context.addServlet(urlPattern, (Servlet) aClass.newInstance());        }}}} catch (ClassNotFoundException e) {throw new RuntimeException(e);} catch (MalformedURLException e) {throw new RuntimeException(e);} catch (InstantiationException e) {throw new RuntimeException(e);} catch (IllegalAccessException e) {throw new RuntimeException(e);}}contextMap.put(app,context);}

List<File> files = getAllFilePath(classesDir);获取hello\classes下所有的文件，递归搜索

private List<File> getAllFilePath(File classesDir) {List<File> result = new ArrayList<>();File[] files = classesDir.listFiles();if(files!=null){for(File file:files){if(file.isDirectory()){result.addAll(getAllFilePath(file));}else{result.add(file);}}}return result;}

获取到类名name：com.sjb.SJBServlet后，通过类加载器进行加载。

这里不能使用Class<?> aClass1 = Thread.currentThread().getContextClassLoader().loadClass(name);因为这里name是webapps目录下的com.sjb.SJBServlet，而用Thread.currentThread().getContextClassLoader().loadClass()只能加载当前项目下的target目录下的类。aClass.newInstance()通过类加载器new一个对象，和url一起组成Entry放入context下的map里，最后将context放入context的map里

因此需要创建一个新的类加载器com.sjb.WebappClassLoader，继承URLClassLoader，通过url来进行加载

public class WebappClassLoader extends URLClassLoader {public WebappClassLoader(URL[] urls) {super(urls);}
}

HttpServlet.class.isAssignableFrom(aClass)然后再判断这个类是不是HttpServlet，aClass.isAnnotationPresent(WebServlet.class)判断有没有@WebServlet，然后获取注解的内容，并且获取url,，然后把他存入<string,context>的map中，context用来存放每个项目/应用（hello），每个项目中可能有多个servlet

创建com.sjb.Context

public class Context {private String appName;private Map<String, Servlet> servletMap=new HashMap<>();public Context(String appName) {this.appName = appName;}public void addServlet(String url, Servlet servlet){servletMap.put(url,servlet);}public Servlet getServletByUrl(String url){return servletMap.get(url);}
}

在com.sjb.Tomcat中创建一个Map<String, Context>的map

public class Tomcat {public Map<String, Context> getContextMap() {return contextMap;}private Map<String,Context> contextMap=new HashMap<>();

这样就在解析阶段就已经找到了对应的servlet

在com.sjb.SocketProcessor#processSocket中

Request tomcatrequest = new Request(method, url, protocol, socket);
Response response = new Response(tomcatrequest);
//根据url找到对应的servlet
// url: "/hello/sjb"
url=url.substring(1);
// parts: ["abc"]
String[] parts= url.split("/");
String appName=parts[0];
Context context = tomcat.getContextMap().get(appName);
Servlet servlet = context.getServletByUrl("/"+parts[1]);
servlet.service(tomcatrequest, response);