第三章：MiniTomcat-连接器（Connector）组件大揭秘：构建强大服务器的关键一步！

第三章：MiniTomcat 系列 —— 实现连接器（Connector）组件

上一章内容：第二章：解析 HTTP 请求，支持静态文件-MiniTomcat

各位技术大神和爱好者们，今天我们要深入探索 MiniTomcat 中一个超级重要的组件——连接器（Connector）。它就像一座桥梁，连接着客户端与服务器，让信息在两者之间顺畅流通。准备好跟我一起揭开它的神秘面纱，看看如何通过代码构建这个神奇的组件，让我们的服务器变得更加强大吧！💪

一、连接器（Connector）组件：MiniTomcat 的“通信枢纽”🧐

（一）连接器的使命

在 MiniTomcat 这个小而强大的世界里，连接器组件扮演着至关重要的角色。它就像是一个超级智能的“通信枢纽”，负责管理 HTTP 连接，与客户端建立紧密的联系，时刻监听并读取传入的数据包。同时，它还具备一项超厉害的技能——解耦网络传输和请求处理的逻辑。这意味着什么呢？简单来说，它让网络传输部分和处理请求的部分能够各自独立发展，互不干扰，就像两个并行的轨道，大大提升了代码的清晰度和容错性。这样一来，当我们需要对其中一部分进行修改或优化时，不会影响到另一部分，是不是很神奇呢？😎

（二）MiniTomcat 项目结构概览

为了实现这个强大的连接器组件，我们在 MiniTomcat 项目中构建了一系列相关的类。下面是项目的基本代码结构，就像一座大厦的蓝图，每个类都在自己的位置上发挥着重要作用。🧐

MiniTomcat
├─ src
│ ├─ main
│ │ ├─ java
│ │ │ ├─ com.daicy.minitomcat
│ │ │ │ ├─ HttpConnector.java // 连接器类，负责建立连接和监听
│ │ │ │ ├─ HttpProcessor.java // 请求处理器，解析请求并构建响应
│ │ │ │ ├─ HttpServer.java // 主服务器类，启动连接器并接受请求
│ │ │ │ ├─ Request.java // 请求封装类，承载客户端请求数据
│ │ │ │ ├─ Response.java // 响应封装类，用于生成和发送服务器响应
│ │ │ │ ├─ StaticResourceProcessor.java // 静态资源处理器，处理静态文件请求
│ │ ├─ resources
│ ├─ test
│ ├─ webroot
│ │ ├─ index.html
├─ pom.xml

（三）代码实现大揭秘

1. HttpConnector 类：连接的“守护者”👮‍♂️

HttpConnector 可是服务器的连接大门，它静静地监听在指定端口（这里是 8080 端口哦，就像一个忠诚的门卫在等待客人来访）。当客户端试图连接时，它就像热情的主人一样接受连接，并迅速将这个连接任务交给 HttpProcessor 去处理。下面是它的代码实现，让我们一起来看看它是如何工作的。💼

package com.daicy.minitomcat;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class HttpConnector implements Runnable {
// 定义服务器监听的端口号
private static final int PORT = 8080;

// 启动连接器，创建一个新线程来运行连接器
public void start() {
Thread thread = new Thread(this);
thread.start();
}

@Override
public void run() {
try (ServerSocket serverSocket = new ServerSocket(PORT)) {
System.out.println("HTTP Connector is running on port " + PORT);

// 进入一个无限循环，持续监听客户端连接
while (true) {
// 接受客户端连接，返回一个代表客户端连接的 Socket 对象
Socket clientSocket = serverSocket.accept();
System.out.println("Accepted connection from " + clientSocket.getInetAddress());

// 创建 HttpProcessor 实例来处理该连接
HttpProcessor processor = new HttpProcessor(clientSocket);
processor.process();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

[这里可以画一个简单的示意图，展示 HttpConnector 如何监听端口、接受连接并将任务交给 HttpProcessor，比如画一个带有端口号的服务器图标，连接着多个客户端图标，旁边有箭头指向 HttpProcessor]

2. HttpProcessor 类：请求的“解析大师”🧐

HttpProcessor 类就像是一个超级聪明的“解析大师”，它的任务是处理传入的 HTTP 请求。它会从客户端连接的输入流中读取请求数据，然后像一个细致的工匠一样，将这些数据精心解析为 Request 对象，这个对象就像是一个装满请求信息的盒子。之后，它会根据请求的内容构建相应的响应，准备好送给客户端的“礼物”。🎁

package com.daicy.minitomcat;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;

public class HttpProcessor {
private Socket socket;
// 创建静态资源处理器实例
private StaticResourceProcessor staticProcessor = new StaticResourceProcessor();

public HttpProcessor(Socket socket) {
this.socket = socket;
}

public void process() {
try (InputStream inputStream = socket.getInputStream();
OutputStream outputStream = socket.getOutputStream()) {
// 解析请求，将输入流转换为 Request 对象
Request request = parseRequest(inputStream);
// 创建响应对象，关联输出流
Response response = new Response(outputStream);
if (null == request) {
return;
}
String uri = request.getUri();
// 如果请求的 URI 是 HTML、CSS 或 JS 文件，使用静态资源处理器处理
if (uri.endsWith(".html") || uri.endsWith(".css") || uri.endsWith(".js")) {
staticProcessor.process(request, response);
} else {
staticProcessor.process(request, response);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
// 关闭客户端连接
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

// 从输入流中解析请求行，构建 Request 对象
private Request parseRequest(InputStream inputStream) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
String requestLine = reader.readLine();
if (requestLine == null || requestLine.isEmpty()) {
return null;
}
System.out.println("Request Line: " + requestLine);
String[] parts = requestLine.split(" ");
String method = parts[0];
String path = parts[1];
return new Request(method, path);
}
}

[可以画一个图，展示 HttpProcessor 如何从输入流读取数据、解析请求并构建响应，比如用箭头表示数据流向，从客户端连接到输入流，再到解析和构建响应，最后通过输出流返回给客户端]

3. StaticResourceProcessor 类：静态资源的“搬运工”🚚

StaticResourceProcessor 类就像是一个勤劳的“搬运工”，专门负责查找和读取服务器上的静态文件（比如 HTML、CSS、JS 文件等），并构建响应返回给客户端。它会根据请求的 URI 找到对应的文件，如果文件存在，就把文件内容打包成响应发送给客户端；如果文件不存在，就发送一个 404 错误响应，告诉客户端“对不起，你要的资源没找到”。😅

package com.daicy.minitomcat;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.URL;

import static com.daicy.minitomcat.HttpServer.WEB_ROOT;

public class StaticResourceProcessor {
public void process(Request request, Response response) {
try {
OutputStream outputStream = response.getOutputStream();
// 获取请求的静态文件路径
String path = request.getUri();
URL url = HttpServer.class.getClassLoader().getResource(WEB_ROOT + path);
if (null == url) {
sendResponse(outputStream, 404, "Not Found", "The requested resource was not found.");
return;
}
File file = new File(url.getPath());
if (file.exists() &&!file.isDirectory()) {
sendFileResponse(outputStream, file);
} else {
sendResponse(outputStream, 404, "Not Found", "The requested resource was not found.");
}
} catch (IOException e) {
e.printStackTrace();
}
}

// 发送普通文本响应，如错误信息等
private static void sendResponse(OutputStream outputStream, int statusCode, String statusText, String message) throws IOException {
PrintWriter writer = new PrintWriter(outputStream, true);
writer.println("HTTP/1.1 " + statusCode + " " + statusText);
writer.println("Content-Type: text/html; charset=UTF-8");
writer.println();
writer.println("<html><body><h1>" + statusCode + " " + statusText + "</h1><p>" + message + "</p></body></html>");
}

// 发送文件响应，将文件内容读取并发送给客户端
private static void sendFileResponse(OutputStream outputStream, File file) throws IOException {
PrintWriter writer = new PrintWriter(outputStream, true);
writer.println("HTTP/1.1 200 OK");
writer.println("Content-Type: " + getContentType(file));
writer.println("Content-Length: " + file.length());
writer.println();
try (FileInputStream fis = new FileInputStream(file)) {
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = fis.read(buffer))!= -1) {
outputStream.write(buffer, 0, bytesRead);
}
}
}

// 根据文件后缀名确定 Content-Type
private static String getContentType(File file) {
String name = file.getName().toLowerCase();
if (name.endsWith(".html") || name.endsWith(".htm")) {
return "text/html";
} else if (name.endsWith(".css")) {
return "text/css";
} else if (name.endsWith(".js")) {
return "application/javascript";
} else if (name.endsWith(".jpg") || name.endsWith(".jpeg")) {
return "image/jpeg";
} else if (name.endsWith(".png")) {
return "image/png";
} else {
return "application/octet-stream";
}
}
}

[可以画一个简单的图，展示 StaticResourceProcessor 如何查找文件、判断文件是否存在并发送相应的响应，比如用文件图标表示静态文件，箭头表示查找和读取过程]

4. Request 和 Response 类：请求与响应的“容器”📦

Request 类就像是一个小巧的“容器”，它的任务是封装客户端发送过来的请求数据，比如请求方法（GET、POST 等）和请求路径。而 Response 类则是服务器用来生成和发送响应的“得力助手”，它关联着输出流，通过这个输出流将服务器的响应数据发送回客户端。🎯

package com.daicy.minitomcat;

public class Request {
private String method;
private String path;

public Request(String method, String path) {
this.method = method;
this.path = path;
}

public String getMethod() {
return method;
}

public String getPath() {
return path;
}
}
package com.daicy.minitomcat;

import java.io.OutputStream;

public class Response {
private OutputStream outputStream;

public Response(OutputStream outputStream) {
this.outputStream = outputStream;
}

public OutputStream getOutputStream() {
return outputStream;
}
}

（四）代码解析与智慧结晶🧠

二、连接器组件的优势与应用场景💡

（一）优势尽显

（二）应用场景广泛

三、优化与展望🌈

总之，MiniTomcat 连接器组件以其精巧设计、实用功能在构建服务器路上踏出坚实一步，持续挖掘优化、拓展潜能，定能在更多复杂多变场景大放异彩，为网络交互世界筑牢根基、输送动力，各位技术达人不妨深挖细究、动手实践，解锁更多惊喜与可能！

专题链接：分类：MiniTomcat – 代老师的博客

项目源代码地址：

https://github.com/daichangya/MiniTomcat/tree/chapter3/mini-tomcat