【学习笔记】手写 Tomcat 六
目录
一、线程池
昨天使用了数据库连接池，我们了解了连接池的优点，那么也可以使用线程池来管理线程，
java自带的线程池的参数有 核心线程数，最大线程数，线程活跃时间，时间单位，任务队列，线程工厂，拒绝策略
为了学习了解线程池，我们先手写一个简单的线程池，只需要做到核心线程可重复利用就行
1. 构建线程池的类
属性：核心线程数，任务队列
方法：获取线程（静态代码块），执行任务（需要的参数：线程任务 Runnable）
为了避免创建多个对象，还需要设置单例模式
package com.shao.net;
import java.util.concurrent.LinkedBlockingQueue;
public class ThreadPool {
// 定义一个成员静态变量，存储单例对象
private static ThreadPool instance;
// 线程池核心线程数
private final static int MAX_THREAD_NUM = 10;
// 存放任务的队列
private static final LinkedBlockingQueue<Runnable> taskQueue = new LinkedBlockingQueue<>();
static {
for (int i = 0; i < MAX_THREAD_NUM; i++) {
final int finalI = i;
new Thread(new Runnable() {
@Override
public void run() {
/**
* 线程池的线程，从队列中取出任务，这时线程不在临界区了，自动释放锁，然后执行任务，当执行完任务后，
* 因为是while循环，所以会在 synchronized (taskQueue) 等待，
* 当锁释放后，并且当前线程被唤醒时，会尝试获取锁，
* 如果获取到锁，会进入临界区，如果队列中有任务，则取出，然后执行任务，如果没有，则等待
* 等待下次获取到锁，会继续从上次进入等待态的位置继续往下执行，也就是 taskQueue.wait() 开始往下执行
* */
while (true) {
Runnable task = null;
synchronized (taskQueue) {
System.out.println("线程" + finalI + "准备完成");
// 队列为空，等待
while (taskQueue.isEmpty()) {
try {
taskQueue.wait(); // 使当前线程等待，释放锁
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("线程" + finalI + "开始执行");
// 从队列中取出任务
task = taskQueue.poll();
}
if (task != null) {
// 执行任务
task.run();
}
}
}
}).start();
}
}
// 私有化构造函数
private ThreadPool() {
}
// 获取对象
public static ThreadPool getInstance() {
synchronized (ThreadPool.class) {
if (instance == null) {
instance = new ThreadPool();
}
return instance;
}
}
public void execute(Runnable task) {
// 当方法被调用时，会尝试获取锁，如果获取到锁，则将任务加入队列，并唤醒等待的线程
synchronized (taskQueue) {
taskQueue.add(task);
taskQueue.notify();
}
}
}
2. 创建任务
这里的任务是之前线程执行的代码，我们把需要线程执行的任务放到一个类里，然后实现Runnable
package com.shao.net;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class MyTask implements Runnable {
private InputStream is;
private OutputStream os;
public MyTask(InputStream is, OutputStream os) {
this.is = is;
this.os = os;
}
@Override
public void run() {
// 定义一个字节数组，存放客户端发送的请求信息
byte[] bytes = new byte[1024];
// 读取客户端发送的数据，返回读取的字节数
int len = 0;
try {
len = is.read(bytes);
if (len == -1) {
return;
}
// 将读取的字节数组转换为字符串
String msg = new String(bytes, 0, len);
// 调用HttpRequest类解析请求信息
HttpRequest httpRequest = new HttpRequest(msg);
// 拼接请求的静态资源的路径
// 路径是相对路径，从模块的根路径开始
String filePath = "webs/" + httpRequest.getRequestModule();
HttpResponse httpResponse = new HttpResponse(os, httpRequest);
// 响应数据
httpResponse.response(filePath);
} catch (IOException e) {
e.printStackTrace();
}
}
}
3. 执行任务
初始化线程池，来一个用户连接时，就创建一个任务，然后交给线程池，线程池取出一条线程执行任务的 run 方法
package com.shao.net;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class Tomcat {
// 初始化线程池
ThreadPool threadPool = ThreadPool.getInstance();
public Tomcat() {
ServerSocket ss = null;
try {
ss = new ServerSocket(8080);
while (true) {
// 调用accept()方法阻塞等待，直到有客户端连接到服务器，返回一个Socket对象用于与该客户端通信
Socket socket = ss.accept();
System.out.println("客户端连接成功");
// 获取Socket对象的输入流，用于读取客户端发送的数据
InputStream is = socket.getInputStream();
// 获取Socket对象的输出流，用于向客户端发送数据
OutputStream os = socket.getOutputStream();
// 创建一个任务对象，将输入输出流作为参数传过去
MyTask myTask = new MyTask(is, os);
// 把任务作为参数传递给ThreadPool的execute()方法，启动一个线程执行MyTask对象中的run()方法
threadPool.execute(myTask);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//关闭连接通道
try {
ss.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
测试
二、URL编码
在HTTP请求中，如果参数包含中文字符，会进行URL编码，以避免乱码或传输错误。URL编码是一种将URL中的非ASCII字符（如中文字符）转换为可以在Web浏览器和服务器之间传输的格式的过程。
URL编码会将非ASCII字符转换为十六进制编码，以便于在HTTP请求中安全传输。
URL编码的基本原理： URL编码将非ASCII字符（如中文字符）转换为"%"后跟两位十六进制数字的形式。例如，空格在URL编码中通常被转换为"%20"。对于中文字符，它们会被转码为以"%E"开头，后面跟着若干位十六进制数字的字符串。
解决方案
在接收到请求信息后，先进行解码，然后再解析信息
URLDecoder.decode(需要解码的字符串, 字符集或编码方式)在 MyTask 类中添加
测试
三、如何接收客户端发送的全部信息
目前，我们的 Tomcat 最多只能一次接收 1KB，因为定义的字节数组只有1024个字节
但是，如果客户端发送的请求参数非常非常多呢？超过了 1024 个字节了怎么办？
把字节数组定义的大一点？不行的，因为网络传输一次最多传输 8KB，超过 8KB 就会分批传输，接收参数时也需要分批接收
那怎么判断参数已经接收完？
参数有很多一般是使用POST方法，而POST方法的请求头有 Content-Length 的字段，表示请求体的总长度
我们来试一下，打印一下请求的参数信息
这里可以看到 Content-Length 的值是 26，表示请求体的参数长度为26字节，图中显示参数的长度为 25，因为解析后没有显示参数连接符 &
我们来使用 Apipost 来压力测试一下，参数很多是什么样子
可以看到，只读取到了一部分 出师表 的内容，而且还有乱码，这是因为没有完整读取一个 汉字的字节，UTF-8 编码中一个汉字需要 3 个字节
解决方案
package com.shao.net;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URLDecoder;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MyTask implements Runnable {
private InputStream is;
private OutputStream os;
private int totalLength;
private StringBuilder sb;
public MyTask(InputStream is, OutputStream os) {
this.is = is;
this.os = os;
}
@Override
public void run() {
// 定义一个字节数组，存放客户端发送的请求信息
byte[] bytes = new byte[1024];
// 读取客户端发送的数据，返回读取的字节数
int len = 0;
try {
// 第一次读取请求信息
len = is.read(bytes);
if (len == -1) {
return;
}
// 将读取的字节数组转换为字符串
String msg = new String(bytes, 0, len);
// 调用HttpRequest类解析请求信息
HttpRequest httpRequest = new HttpRequest(msg);
/*
* 如果已读取的数据长度等于请求体的总长度，并且请求方法是 POST，说明请求体可能还没有读取完，需要读取剩余的数据
* */
if (bytes.length == len && "POST".equals(httpRequest.getRequestMethod())) {
// 创建一个StringBuilder对象，用于拼接请求信息
sb = new StringBuilder();
sb.append(msg);
// 获取 POST 请求方法中的请求体的总长度
String length = httpRequest.getRequestHeaderParams().get("Content-Length");
if (length != null) {
totalLength = Integer.parseInt(length);
}
// 调用方法，读取剩余的请求体数据
msg = getNotReadMsg(httpRequest, bytes, msg);
}
// 把请求信息进行URL解码，然后根据 UTF-8 进行编码
String decodedMsg = URLDecoder.decode(msg, "utf-8");
// 调用HttpRequest类解析请求信息
httpRequest = new HttpRequest(decodedMsg);
// 拼接请求的静态资源的路径
// 路径是相对路径，从模块的根路径开始
String filePath = "webs/" + httpRequest.getRequestModule();
HttpResponse httpResponse = new HttpResponse(os, httpRequest);
// 响应数据
httpResponse.response(filePath);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 读取剩余的请求体数据
*/
private String getNotReadMsg(HttpRequest httpRequest, byte[] bytes, String msg) throws IOException {
int len;
// 获取请求的参数
HashMap<String, String> requestBodyParams = httpRequest.getRequestBodyParams();
// 请求参数的数量
int size = requestBodyParams.size();
// 计算第一次读取到的请求体中参数的长度
Set<Map.Entry<String, String>> entries = requestBodyParams.entrySet();
int partLength = 0;
for (Map.Entry<String, String> entry : entries) {
partLength += (entry.getKey() + "=" + entry.getValue()).length();
}
// 减去第一次读取到的请求体中参数的长度，如果存在多个参数，需要考虑到 '&' 的个数
if (size > 1) {
totalLength -= (partLength + (size - 1));
} else {
totalLength -= partLength;
}
// 判断是否还有数据没有读完
while (totalLength > 0) {
// 第二次读取请求信息
len = is.read(bytes);
// 如果读取的字节数大于0，表示读取到数据了
if (len > 0) {
// 将读取的字节数组转换为字符串
msg = new String(bytes, 0, len);
// 拼接字符串
sb.append(msg);
// 减去读取的字节数
totalLength -= len;
} else {
break;
}
}
// 转成字符串格式返回
return sb.toString();
}
}
测试
可以看出已经全部读取到了，第二个参数也读取到了
四、作业
1. 了解工厂模式
优化 Dao，现在在 Service 层，调用Dao层都要 new 一下，这样就比较占内存，比如调用的都是 UserDao，那么只需要创建一次 UserDao 的对象就行了
2. 了解反射技术
优化 Servlet ，通过配置文件可以动态的创建 Servlet 对象
原文地址：https://blog.csdn.net/LearnTech_123/article/details/142470183
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！