Tomcat原理之手写

作为一个Web应用资源容器（包括了静态Html或别的资源和servlet配置），它可以处理静态Html页面，同时也是servlet容器，用来处理动态Java服务请求；作为一款Java服务器，它的本质又可以理解为是一个ServerSocket，监听指定端口，接收浏览器发送过来的请求，本质也就是一个个socket，解析套接字输入流里的请求体内容，请求处理完毕后将响应信息，以标准的http协议规范的形式返回给浏览器（强调http协议规范，否则浏览器不认识）。

简单说，Tomcat可以被认为是Web资源容器+ServerSocket。

1.2 技术储备

socket套接字、IO、Http、servlet、xml。

二、实现步骤

根据使用Tomcat的经验，以及JavaWeb工程的配置方式等的分析，得出以下实现方案：

初始化servlet，即一般从web.xml中加载servlet配置，存至Map<url, servletClass>，该对象就是servlet容器
启动ServerSocket服务端，时刻准备接收浏览器请求
当请求来临，根据http协议规范解析请求头信息，获取到url，判断静态或动态资源，即是否存在于urlServletClassMap中
若存在于urlServletClassMap，则分发请求至对应的servlet，反射生成servlet实例，进入servlet的service生命周期阶段，调用doGet/doPost等，最后response.write输出内容（JSON、Xml或其他），service中途报错则response.write一个500页面
若不存在于urlServletClassMap，则尝试请求静态资源，可以找到资源则response.write资源内容，反之response.write一个404页面

三、相关类的实现和介绍

3.1 包结构

3.2 Servlet配置类

Tomcat作为servlet容器，在启动时会解析web.xml文件，并将servlet配置加载到服务器内存中。

3.2.1 servlet配置类ServletConfig

这些servlet在web.xml中的样式如下图。我们可以将一对servlet的配置抽象成配置类ServletConfig，它需要具有的属性也来自上图的<servlet-name>、<servlet-calss>和<url-pattern>三个节点。对应以下Java代码：

3.2.2 servlet配置加载类ServletConfigMapping

定义好Servlet配置类后，我们需要在Tomcat启动后自动加载所有配置的ServletConfig，存到一个集合中。ServletConfigMapping代码如下（这里我们只add一个servlet用来测试）：

package com.szh.tomcat.config;
import java.util.ArrayList;
import java.util.List;
/**
 * 解析并保存了web.xml里的很多对配置
 */
public class ServletConfigMapping {
	private static List<ServletConfig> configs = new ArrayList<>();
	static {
		configs.add(new ServletConfig("myServlet", "/testServlet", "com.szh.tomcat.servlet.MyServlet"));
	}
	public static List<ServletConfig> getConfigs() {
		return configs;
	}
}

3.3 Tomcat实现类

Tomcat作为一个socket服务端，需要占用一个网络端口，需要启动函数（启动脚本），需要servlet初始化方法，需要将请求分发至对应Servlet实现类，以下先贴出MyTomcat的代码：

package com.szh.tomcat;

import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.szh.tomcat.config.ServletConfig;
import com.szh.tomcat.config.ServletConfigMapping;
import com.szh.tomcat.servlet.Request;
import com.szh.tomcat.servlet.Response;
import com.szh.tomcat.servlet.Servlet;
import com.szh.tomcat.util.HttpUtil;

import lombok.Data;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Data
public class MyTomcat {
	private int port = 8080;

	/**
	 * servlet配置的url-clazz对
	 */
	private Map<String, Class<Servlet>> urlClassMap = new HashMap<>();

	public void start() throws Exception {
		initServlet();
		ServerSocket serverSocket = new ServerSocket(port);
		log.info("MyTomcat starting on {}..", port);
		while (true) {
			Socket socket = serverSocket.accept();
			Request request = new Request(socket.getInputStream());
			Response response = new Response(socket.getOutputStream());
			if (request.getUrl().equals("/")) {
				// 亦可为"/"配置一欢迎页，即web.xml中的<welcome-file>
				response.write(HttpUtil.getHttpResponseContext404());
			} else if (urlClassMap.get(request.getUrl()) == null) {
				response.writeHtml(request.getUrl());
			} else {
				dispatch(request, response);
			}
			socket.close();
		}
	}

	/**
	 * servlet容器初始化：将web.xml中的servlet放进Map&lt;url, servletClass&gt;中
	 */
	public void initServlet() throws ClassNotFoundException {
		List<ServletConfig> configs = ServletConfigMapping.getConfigs();
		log.info("初始化servlet：{}", configs);
		for (ServletConfig servletConfig : configs) {
			urlClassMap.put(servletConfig.getUrlMapping(), (Class<Servlet>) Class.forName(servletConfig.getClazz()));
		}
	}

	/**
	 * 分发各servlet：myServlet去找com.szh.tomcat.servlet.MyServlet，
	 * myServlet2去找com.szh.tomcat.servlet.MyServlet2
	 */
	public void dispatch(Request request, Response response) throws InstantiationException, IllegalAccessException {
		Class<Servlet> servletClass = urlClassMap.get(request.getUrl());
		if (servletClass != null) {
			Servlet servlet = servletClass.newInstance();
			try {
				servlet.service(request, response);
			} catch (Throwable cause) {
				response.write(HttpUtil.getHttpResponseContext500(cause));
			}
		} else {
			response.write(HttpUtil.getHttpResponseContext404());
		}
	}

	public static void main(String[] args) throws Exception {
		new MyTomcat().start();
	}
}

可以看出，MyTomcat主要有2个核心的函数，initServlet()和dispatch(req, resp)，分别用来初始化servlet容器和分发请求。另外，它还导入了工具类HttpUtil和自定义的请求Request、响应Response以及Servlet抽象类，当然你也可以尝试使用HttpRequest、HttpResponse、HttpServlet。接下来一个个介绍这几个类。

3.4 请求响应实现类Request/Response

3.4.1 请求实现类Request

客户端或浏览器发过来的请求，最原始就是一个从socket中获取到的InputStream，解析这个输入流中的内容后，即可获取到Request的属性：请求网址url和请求方法methodType。因此我们将Request抽象如下：

package com.szh.tomcat.servlet;

import java.io.IOException;
import java.io.InputStream;

import lombok.Data;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Data
public class Request {

	private String url;
	private String methodType;
	private InputStream inputStream;

	public Request(InputStream inputStream) throws IOException {
		this.inputStream = inputStream;
		int count = 0;
		while (count == 0) {
			// available预估网络包长度，可能为0
			count = inputStream.available();
		}
		byte[] bytes = new byte[count];
		inputStream.read(bytes);
		log.info(new String(bytes, "utf-8"));
		extractFields(new String(bytes, "utf-8"));
	}

	/**
	 * 根据Http协议标准解析请求头信息，提取并封装到Request中
	 */
	private void extractFields(String content) {
		if ("".equals(content)) {
			log.info("empty");
		} else {
			String firstLine = content.split("\n")[0];
			String[] segments = firstLine.split("\\s");
			setUrl(segments[1]);
			setMethodType(segments[0]);
		}
	}

}

3.4.2 响应实现类Response

对Response而言，它的任务就是通过socket获取到的输出流，将处理后的响应内容写回给客户端，所以我们将Response抽象如下：

package com.szh.tomcat.servlet;

import java.io.File;
import java.io.IOException;
import java.io.OutputStream;

import com.szh.tomcat.util.FileUtil;
import com.szh.tomcat.util.HttpUtil;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class Response {

	private OutputStream outputStream;

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

	public void write(String content) {
		try {
			outputStream.write(content.getBytes("utf-8"));
		} catch (IOException e) {
			log.error(e.getMessage());
		}
	}

	public void writeHtml(String path) throws IOException {
		String resourcePath = FileUtil.getResourcePath(path);
		File file = new File(resourcePath);
		if (file.exists()) {
			FileUtil.writeFile(file, outputStream);
		} else {
			write(HttpUtil.getHttpResponseContext404());
		}
	}
}

3.5 工具类HttpUtil/FileUtil

3.5.1 Http工具类HttpUtil

HttpUtil工具类以Http协议标准返回各种返回码对应的响应串，如下：

package com.szh.tomcat.util;

/**
 * 以Http协议标准规范，构造响应信息体，相当于response.setContentType("text/html")
 */
public class HttpUtil {

	public static String getHttpResponseContext(int code, String content, String errorMsg) {
		if (code == 200) {
			return "HTTP/1.1 200 OK \n" + 
					"Content-Type: text/html\n" + 
					"\r\n" + content;
		} else if (code == 500) {
			return "HTTP/1.1 500" + " \n" + 
					"Content-Type: text/html\n" + 
					"\r\n" + errorMsg;
		}
		return "HTTP/1.1 404 NOT Found \n" + 
				"Content-Type: text/html\n" + 
				"\r\n" + 
				"<h1>404 Not Found</h1>";
	}

	public static String getHttpResponseContext200(String content) {
		return getHttpResponseContext(200, content, "");
	}

	public static String getHttpResponseContext404() {
		return getHttpResponseContext(404, "", "");
	}

	public static String getHttpResponseContext500(Throwable cause) {
		StringBuffer sb = new StringBuffer(cause.toString());
		StackTraceElement[] stes = null;
		if ((stes = cause.getStackTrace()) != null) {
			for (StackTraceElement ste : stes) {
				// sb.append("<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;" + ste);
				sb.append("\n\t" + ste);
			}
		}
		return getHttpResponseContext(500, "", "<h1>Internal Server Error:</h1>".concat("<div style='white-space:pre-wrap;'>" + sb.toString() + "</div>"));
	}
}

3.5.2 静态资源处理工具类FileUtil

FileUtil工具类首先找到请求的静态资源，并将静态资源文件内容写入到输出流，如下：

package com.szh.tomcat.util;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import lombok.extern.slf4j.Slf4j;

/**
 * 将静态资源文件内容写入到输出流
 */
@Slf4j
public class FileUtil {

	public static boolean writeFile(InputStream inputStream, OutputStream outputStream) {
		boolean success = false;
		BufferedInputStream bufferedInputStream;
		BufferedOutputStream bufferedOutputStream;
		try {
			bufferedInputStream = new BufferedInputStream(inputStream);
			bufferedOutputStream = new BufferedOutputStream(outputStream);
			bufferedOutputStream.write(HttpUtil.getHttpResponseContext200("").getBytes("utf-8"));
			int count = 0;
			while (count == 0) {
				count = inputStream.available();
			}
			int fileSize = inputStream.available();
			long written = 0;
			int byteSize = 1024;
			byte[] bytes = new byte[byteSize];
			while (written < fileSize) {
				if (written + byteSize > fileSize) {
					byteSize = (int) (fileSize - written);
					bytes = new byte[byteSize];
				}
				bufferedInputStream.read(bytes);
				bufferedOutputStream.write(bytes);
				bufferedOutputStream.flush();
				written += byteSize;
			}
			success = true;
		} catch (IOException e) {
			log.error(e.getMessage());
		}
		return success;
	}

	public static boolean writeFile(File file, OutputStream outputStream) throws IOException {
		return writeFile(new FileInputStream(file), outputStream);
	}

	public static String getResourcePath(String path) {
		String resource = FileUtil.class.getResource("/").getPath();
		return resource + "\\" + path;
	}
}

3.6 Servlet抽象和测试实现类

3.6.1 Servlet抽象类

该抽象类同javax.servlet.http.HttpServlet，需要doGet/doPost/service方法，且必须强制抛出Web应用内部的异常或错误，以此来使Tomcat做出对应处理（即响应码=5xx），如下：

package com.szh.tomcat.servlet;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public abstract class Servlet {
	public abstract void doGet(Request request, Response response) throws Throwable;
	public abstract void doPost(Request request, Response response) throws Throwable;

	public void service(Request request, Response response) throws Throwable {
		if ("GET".equals(request.getMethodType())) {
			doGet(request, response);
		} else if ("POST".equals(request.getMethodType())) {
			doPost(request, response);
		} else {
			log.error("暂不支持的请求方式！");
		}
	}
}

3.6.2 Servlet测试实现类

最后的阶段，自然是实现一个com.szh.tomcat.servlet.Servlet，以此测试我们的Tomcat是否手写成功。这里我们实现ServletConfigMapping静态块中add的servlet实现类MyServlet，如下：

package com.szh.tomcat.servlet;

import com.szh.tomcat.util.HttpUtil;

public class MyServlet extends Servlet {

	@Override
	public void doGet(Request request, Response response) throws RuntimeException {
		// 测试服务器内部错误5xx
		// System.out.println(1/0);
		String content = "<h1>This is my GET request</h1>";
		response.write(HttpUtil.getHttpResponseContext200(content));
	}

	@Override
	public void doPost(Request request, Response response) throws RuntimeException {
		String content = "<h1>This is my POST request</h1>";
		response.write(HttpUtil.getHttpResponseContext200(content));
	}

}