前言
最近笔者读了《深入剖析tomcat》这本书（原作：《how tomcat works》）,发现该书简单易读，每个
章节循序渐进的讲解了tomcat的原理，在接下来的章节中，tomcat都是基于上一章新增功能并完善，
到最后形成一个简易版tomcat的完成品。所以有兴趣的同学请按顺序阅读，本文为记录第三章的知识点
以及源码实现（造轮子）。
内容回顾
跟我一起动手实现Tomcat（二）:实现简单的Servlet容器
上一章我们实现了一个简单的Servlet容器，能够调用并执行用户自定义实现Servlet接口的类。
本章内容
- 模块模仿tomcat，实现Connector(连接器)、Bootstrap(启动器)和核心模块。
- 能够执行继承HttpServlet类的自定义Servlet(上一章是实现了Servlet接口)
- 能够解析用户请求参数(Parameters)/Cookie/请求头(Header)
开始之前
简单介绍Connector(连接器)
对Tomcat比较熟悉的朋友对这个词应该不陌生，后面的篇幅会继续比较详细介绍，在这里不熟悉的朋友可以理解为：连接器只是负责接收请求，然后将请求丢给Container(容器)去执行相应的请求。
javax.servlet.http.HttpServlet类
上一章我们自定义的Servlet是实现了Servlet接口，实例化Servlet的时候我们是将解析的Request/Response(分别实现了ServletRequest/ServletResponse接口)传入对应的service()方法中完成执行。
那我们来回顾一下刚学Servlet开发的时候，大部分教程都按顺序讲解实现Servlet接口、继承GenericServlet类、继承HttpServlet类这三种方式去写自己的Servlet，那么后面推荐的仍然是最后一种，重写其中的doGet()/doPost()方法即可，那么我们来看看上一章我们的tomcat能不能支持继承HttpServlet类的Servlet呢：
//HttpServlet源代码片段
public abstract class HttpServlet extends GenericServlet {
...
public void service(ServletRequest req, ServletResponse res)
throws ServletException, IOException{
HttpServletRequest request;
HttpServletResponse response;
//如果传进来的request/response对象不是Http类型的则抛异常
if (!(req instanceof HttpServletRequest &&
res instanceof HttpServletResponse)) {
throw new ServletException("non-HTTP request or response");
}
request = (HttpServletRequest) req;
response = (HttpServletResponse) res;
service(request, response);
}
...
}
如上所示源码，再来看看我们上一章的ServletProcess调用Servlet源码:
servlet.service(new RequestFacade(request), new ResponseFacade(response));
很明显上一章的request/response在HttpServlet时会抛出异常，所以本章我们会将Request/Response以及它们的外观类都实现HttpServletRequest/HttpServletResponse接口。
代码实现
在代码实现前我们看看整体模块以及流程执行图（看不清可以点击放大）：
1. Bootstrap模块
启动模块目前我们没有多大工作，只是启动HttpConnector：
public final class Bootstrap {
public static void main(String[] args){
new HttpConnector().start();
}
}
2. HttpConnector模块(连接器)
连接器模块和下面的核心模块的前身其实就是上一章的HttpServer类，我们把它按功能拆分成了
等待和建立连接(HttpConnector)/处理连接(HttpProcess)2个模块。
连接器功能是等待请求并将请求丢给相应执行器去执行：
public class HttpConnector implements Runnable {
public void start(){
new Thread(this).start();
}
@Override
public void run() {
ServerSocket serverSocket = new ServerSocket(8080, 1, InetAddress.getByName("127.0.0.1"));
while (true) {
Socket accept = serverSocket.accept();
HttpProcess process = new HttpProcess(this);
process.process(accept);
}
serverSocket.close();
}
}
3. 核心模块(执行器)
上面也有说到，执行器也是上一章HttpServer类的前身，只不过这章我们修改了解析请求信息的方式。
- 主要代码
public class HttpProcess {
private HttpRequest request;
private HttpResponse response;
public void process(Socket socket) {
InputStream input = socket.getInputStream();
OutputStream output = socket.getOutputStream();
//初始化request以及response
request = new HttpRequest(input);
response = new HttpResponse(output, request);
//解析request请求行和请求头
this.parseRequestLine(input);
this.parseHeaders(input);
//调用对应的处理器处理
if (request.getRequestURI().startsWith(SERVLET_URI_START_WITH)) {
new ServletProcess().process(request, response);
} else {
new StaticResourceProcess().process(request, response);
}
}
}
看了上面的实现可能很多人对有些对象有点陌生，下面一一介绍：
1. HttpRequest/HttpResponse变量就是上一章的Request/Response对象，因为实现了
HttpServletReuqest/HttpServletResponse也就顺便改了个名，将会在下面介绍；
2. 每一个请求都对应了一个HttpProcess对象，所以这里request/response是成员变量；
3. 解析请求行和解析请求头的方法也在下面介绍。
parseRequestLine、parseHeaders方法
让我们先看看一个原始的HTTP请求字符串，看看如何去解析请求行和请求头：
GET /index.html?utm_source=aaa HTTP/1.1\r\n
Host: www.baidu.com\r\n
Connection: keep-alive\r\n
Pragma: no-cache\r\n
Cache-Control: no-cache\r\n
Upgrade-Insecure-Requests: 1\r\n
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36\r\n
Accept: text/html\r\n
Accept-Encoding: gzip, deflate, sdch, br\r\n
Accept-Language: zh-CN,zh;q=0.8\r\n
Cookie: BAIDUID=462A9AC35EE6158AA7DFCD27AF:FG=1; BIDUPSID=462A9AC35EE6158AA7DF027AF; PSTM=1506310304; BD_CK_SAM=1; PSINO=7; BD_HOME=1; H_PS_PSSID=1459_24885_21115_25436; BD_UPN=12314353; sug=3; sugstore=0; ORIGIN=2; bdime=0\r\n大家可以发现，其实我们使用socket读取HTTP请求时候，发现每一行都会有'\r\n'这个回车换行符，只不过在我们浏览器按F12时被浏览器自动解析成了换行而已，我们分析上面的这个请求信息得出以下规律：
- 每一行结尾字符都是\r\n
- 请求行（第一行）的HTTP请求方法、URI、请求协议中间都有个空格
- 第二行开始（请求头）key和value的内容都是以':'和一个' '字符隔开
- Cookie的键值对是以'='分割，以';'和' '区分前后键值对接下来我们分别去解析以下ISO-8859-1编码情况下上面字符对应的值，并建立一个常量类：
public class HttpConstant {
/* 回车 \r */
public static final byte CARRIAGE_RETURN = 13;
/* 换行 \n */
public static final byte LINE_FEED = 10;
/* 空格 */
public static final byte SPACE = 32;
/* 冒号 : */
public static final byte COLON = 58;
}1.parseRequestLine方法
根据上面的思路，我们就可以轻松地解析请求行的数据：
StringBuilder temp = new StringBuilder();
int cache;
while ((cache = requestStream.read()) != -1) {
//读取到第一个\r\n时则说明读取请求行完毕
if (HttpConstant.CARRIAGE_RETURN == cache && HttpConstant.LINE_FEED == requestStream.read()) {
break;
}
temp.append((char)cache);
}
String[] requestLineArray = temp.toString().split(" ");最后分割空格使用数组装着请求行（如果你有更好的方案也可以在评论区说一说哈）
接下来判断URI有没有使用"?"传递参数，如果有就截取并丢到HttpRequest的QueryString变量中，
最后截取URI即可。
String uri = requestLineArray[1];
int question = uri.indexOf("?");
if (question >= 0) {
request.setQueryString(uri.substring(question+1,uri.length()));
uri = uri.substring(0,question);
}
判断是不是从?传递jsessionid过来，如果是就赋值到request对象中
String match = ";jsessionid=";
int semicolon = uri.indexOf(match);
if (semicolon >= 0) {
String rest = uri.substring(semicolon + match.length());
int semicolon2 = rest.indexOf(';');
if (semicolon2 >= 0) {
request.setRequestedSessionId(rest.substring(0, semicolon2));
rest = rest.substring(semicolon2);
} else {
request.setRequestedSessionId(rest);
rest = "";
}
request.setRequestedSessionURL(true);
uri = uri.substring(0, semicolon) + rest;
} else {
request.setRequestedSessionId(null);
request.setRequestedSessionURL(false);
}
这里调用了一个校验URI合法性的方法,如果URI不合法(例如包含'.//'之类跳转目录的危险字符)
则抛异常，否则就将上面解析到的内容丢到request中去。
String normalizedUri = this.normalize(uri);
if (normalizedUri == null) {
throw new ServletException("Invalid URI: " + uri + "'");
}
request.setRequestURI(normalizedUri);
request.setMethod(requestLineArray[0]);
request.setProtocol(requestLineArray[2]);
就这样，请求行的信息就被我们读取完毕，那我们再来看看读取请求头的代码：
parseHeaders方法
这里有个坑：Socket的read()方法读取完毕时最后一个字节不是-1，而是阻塞等待Socket客户端发送-1过来结束读取，但是我们的Socket客户端是浏览器，浏览器不会发送-1以表示结束发送，所以我们结合InputStream#available()方法(返回实际还可以读取的字节数)来判断是否读取完毕即可。
public void parseHeader() {
StringBuilder sb = new StringBuilder();
int cache;
while (input.available() > 0 && (cache = input.read()) > -1) {
sb.append((char)cache);
}
....看下文
}
读取完毕效果如图：
如果是POST请求，那么表单参数会在空行后面：
也很有规律，请求头都用\r\n隔开，并且如果是POST请求提交表单，那么表单参数会在一个空行后面(两个\r\n)
//使用\r\n分割请求头
Queue<String> headers = Stream.of(sb.toString().split("\r\n")).collect(toCollection(LinkedList::new));
while (!headers.isEmpty()) {
//获取一个请求头
String headerString = headers.poll();
//读取到空行则说明请求头已读取完毕
if (StringUtil.isBlank(headerString)) {
break;
}
//分割请求头的key和value
String[] headerKeyValue = headerString.split(": ");
request.addHeader(headerKeyValue[0], headerKeyValue[1]);
}
//如果在读取到空行后还有数据，说明是POST请求的表单参数
if(!headers.isEmpty()){
request.setPostParams(headers.poll());
}
大致流程：
最后我们对一些特殊的请求头信息设置到Request对象中(cookie、content-type、content-length);
String contentLength = request.getHeader("content-length");
if(contentLength!=null){
request.setContentLength(Integer.parseInt(contentLength));
}
request.setContentType(request.getHeader("content-type"));
Cookie[] cookies = parseCookieHeader( request.getHeader("cookie"));
Stream.of(cookies).forEach(cookie -> request.addCookie(cookie));
//如果sessionid不是从cookie中获取的，则优先使用cookie中的sessionid
if (!request.isRequestedSessionIdFromCookie()) {
Stream.of(cookies)
.filter(cookie -> "jsessionid".equals(cookie.getName()))
.findFirst().
ifPresent(cookie -> {
//设置cookie的值
request.setRequestedSessionId(cookie.getValue());
request.setRequestedSessionCookie(true);
request.setRequestedSessionURL(false);
});
}
读取cookie的方法也很简单：
private Cookie[] parseCookieHeader(String cookieListString) {
return Stream.of(cookieListString.split("; "))
.map(cookieStr -> {
String[] cookieArray = cookieStr.split("=");
return new Cookie(cookieArray[0], cookieArray[1]);
}).toArray(Cookie[]::new);
}
不熟悉JDK8语法的小伙伴们可能看不太懂干了什么，没关系来张图解释一下上面那段代码内容：
到这里，HttpProcess处理请求的逻辑就搞定啦，(是不是觉得代码有点多)，细心的客官们一定发现了，request怎么可以设置那么多属性呢？上一章的request好像没有那么多功能吧？是的，我们这一章也对request/response做了手脚，请看下文分析：
HttpRequest(上一章的Request对象)
没错，在文章的开头我们已经说了要把Request升级一下，那么怎么升级呢？也就是实现HttpServletRequest接口啦：
public class HttpRequest implements HttpServletRequest {
private String contentType;
private int contentLength;
private InputStream input;
private String method;
private String protocol;
private String queryString;
private String postParams;
private String requestURI;
private boolean requestedSessionCookie;
private String requestedSessionId;
private boolean requestedSessionURL;
protected ArrayList<Cookie> cookies = new ArrayList<>();
protected HashMap<String, ArrayList<String>> headers = new HashMap<>();
protected ParameterMap parameters;
...
}哈哈没有看错，多了一堆参数，但是细心的客官们应该可以看到，这些参数都是非常眼熟，而且上面已经对大部分参数设值过了，眼生的可能就是下面的那个ParameterMap，那么等下我们慢慢分析：(那些get、set方法就不分析了)
请求头(header)操作：
public void addHeader(String name, String value) {
name = name.toLowerCase();
//如果key对应的value不存在则new一个ArrayList
ArrayList<String> values = headers.computeIfAbsent(name, k -> new ArrayList<>());
values.add(value);
}
public ArrayList getHeaders(String name) {
name = name.toLowerCase();
return headers.get(name);
}
public String getHeader(String name) {
name = name.toLowerCase();
ArrayList<String> values = headers.get(name);
if (values != null) {
return values.get(0);
} else {
return null;
}
}
public ArrayList getHeaderNames() {
return new ArrayList(headers.keySet());
}大家可以看到请求头是是个Map，key是请求头的名字，value则是请求头的内容数组(一个请求头可以有多个内容)，所以也就是对这个Map做操作而已~
Cookie操作：
public Cookie[] getCookies() {
return cookies.toArray(new Cookie[cookies.size()]);
}
public void addCookie(Cookie cookie) {
cookies.add(cookie);
}好像也没什么好说的，对List\做常规操作。
Parameters操作：
这是我们最常用的一个操作啦，那么ParameterMap是个什么东西呢，我们先来看看：public final class ParameterMap extends HashMap<String,String[]> {
private boolean locked = false;
public boolean isLocked() {
return locked;
}
public void setLocked(boolean locked) {
this.locked = locked;
}
public String[] put(String key, String[] value) {
if (locked) {
throw new IllegalStateException("error");
}
return (super.put(key, value));
}
...
}好吧其实它就是在HashMap基础上加了一个locked对象(如果已经解析参数完毕了则将这个对象设置为true禁止更改),key是参数名，value是参数值数组(可有多个)
例如：127.0.0.1:8080/servlet/QueryServlet?name=geoffrey&name=yip那么我们来看看对parameter这个map的操作有：
public String getParameter(String name) {
parseParameters();
String[] values = parameters.get(name);
return Optional.ofNullable(values).map(arr -> arr[0]).orElse(null);
}
public Map getParameterMap() {
parseParameters();
return this.parameters;
}
public ArrayList<String> getParameterNames() {
parseParameters();
return new ArrayList<>(parameters.keySet());
}
public String[] getParameterValues(String name) {
parseParameters();
return parameters.get(name);
}代码都很简单，但是这个parseParameters()是什么呢，对，它是去解析请求的参数了(懒加载)，因为我们不知道用户使用Servlet会不会用到请求参数这个功能，而且解析它的开销比解析其他数据大，所以我们会在用户真正使用参数的时候才会去解析，提高整体的响应速度，大概的代码如下：
protected void parseParameters() {
if (parsed) {
//已经解析过则停止解析
return;
}
ParameterMap results = parameters;
if (results == null) {
results = new ParameterMap();
}
results.setLocked(false);
String encoding = getCharacterEncoding();
if (encoding == null) {
encoding = StringUtil.ISO_8859_1;
}
// 解析URI携带的请求参数
String queryString = getQueryString();
this.parseParameters(results, queryString, encoding);
// 初始化Content-Type的值
String contentType = getContentType();
if (contentType == null) {
contentType = "";
}
int semicolon = contentType.indexOf(';');
if (semicolon >= 0) {
contentType = contentType.substring(0, semicolon).trim();
} else {
contentType = contentType.trim();
}
//解析POST请求的表单参数
if (HTTPMethodEnum.POST.name().equals(getMethod()) && getContentLength() > 0
&& "application/x-www-form-urlencoded".equals(contentType)) {
this.parseParameters(results, getPostParams(), encoding);
}
//解析完毕就锁定
results.setLocked(true);
parsed = true;
parameters = results;
}
/**
* 解析请求参数
* @param map Request对象中的参数map
* @param params 解析前的参数
* @param encoding 编码
*/
public void parseParameters(ParameterMap map, String params, String encoding) {
String[] paramArray = params.split("&");
Stream.of(paramArray).forEach(param -> {
String[] splitParam = param.split("=");
String name = splitParam[0];
String value = splitParam[1];
//此处是将key和value使用URLDecode解码并添加进map中
putMapEntry(map, urlDecode(name, encoding), urlDecode(value, encoding));
});
}大概内容就是根据之前HttpProcess解析请求行的queryString参数以及如果是POST请求的表单数据放入ParameterMap中，并且锁定Map。
HttpResponse(上一章的Response对象)
HttpResponse对象也跟随者实现了HttpServletResponse接口，但是本章没有实现具体的内容，所以此处略过。
public class HttpResponse implements HttpServletResponse {
...
}ServletProcess
ServletProcess具体只需要将request和response的外观类跟着升级实现对应的接口即可：
public void process(HttpRequest request, HttpResponse response) throws IOException {
...
servlet.service(new HttpRequestFacade(request), new HttpResponseFacade(response));
...
}
public class HttpRequestFacade implements HttpServletRequest {
private HttpRequest request;
...
}
public class HttpResponseFacade implements HttpServletResponse {
private HttpResponse response;
...
}
实验
我们先编写一个Servlet：
/**
* 测试注册Servlet
*/
public class RegisterServlet extends HttpServlet {
@Override
public void doGet(HttpServletRequest req, HttpServletResponse resp) {
//打印表单参数
String name = req.getParameter("name");
String password = req.getParameter("password");
if (StringUtil.isBlank(name) || StringUtil.isBlank(password)) {
try {
resp.getWriter().println("账号/密码不能为空！");
} finally {
return;
}
}
//打印请求行
System.out.println("Parse user register method:" + req.getMethod());
//打印Cookie
System.out.println("Parse user register cookies:");
Optional.ofNullable(req.getCookies())
.ifPresent(cookies ->
Stream.of(cookies)
.forEach(cookie ->System.out.println(cookie.getName() + ":" + cookie.getValue()
)));
//打印请求头
System.out.println("Parse http headers:");
Enumeration<String> headerNames = req.getHeaderNames();
while (headerNames.hasMoreElements()) {
String headerName = headerNames.nextElement();
System.out.println(headerName + ":" + req.getHeader(headerName));
}
System.out.println("Parse User register name :" + name);
System.out.println("Parse User register password :" + password);
try {
resp.getWriter().println("注册成功！");
} finally {
return;
}
}
@Override
public void doPost(HttpServletRequest req, HttpServletResponse resp) {
this.doGet(req, resp);
}
}
编写一个HTML：
<html>
<head>
<title>注册</title>
</head>
<body>
<form method="post" action="/servlet/RegisterServlet">
账号：<input type="text" name="name"><br>
密码：<input type="password" name="password"><br>
<input type="submit" value="提交">
</form>
</body>
</html>
打开浏览器测试:
控制台输出：
到这里，咱们的Tomcat 3.0 web服务器就已经开发完成啦（滑稽脸），已经可以实现简单的自定义Servlet调用，以及请求行/请求头/请求参数/cookie等信息的解析，待完善的地方还有很多：
- HTTPProcess一次性只能处理一个请求，其他请求只能堵塞，不具备服务器使用性。
- 每一次请求就new一次Servlet，Servlet应该在初始化项目时就应该初始化，是单例的。
- 并未遵循Servlet规范实现相应的生命周期，例如init()/destory()方法我们均未调用。
- HttpServletRequest/HttpServletResponse接口的大部分方法我们仍未实现
- 架构/包结构和tomcat相差太多
- 其他未实现的功能
PS：本章源码已上传github： SimpleTomcat
