前几天有个做python的老哥问我啥是tomcat,我从python的flask说到springMVC,又从MVC说到Tomcat,但是感觉还是没解释清,今天突然想起来以前听过一节公开课,是手动实现一个自己的Tomcat(自己都能实现一个Tomcat了,原理自然就懂了),虽然找不到上课视频了,但是找了半天在我的老电脑里找到了以前写的源码,分享一下,希望能对大家有一点帮助。
首先我们新建一个Java工程MyTomcat,什么包都不用导入,只用原生的jdk1.8即可(其他版本也OK),目录结构如下:
第一步我们实现主启动类Server.java,在这个类里创建一个ServerSocket,不断循环等待连接他的Socket,也就是不断的等待客户端(浏览器)访问,内容如下:
package com.sunsy.tomcat;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Server {
private static ServerSocket serverSocket;
private static int port = 8080;
private final static int POOL_SIZE = 8;
private static ExecutorService executorService;
public static void start() {
try {
serverSocket = new ServerSocket(port);
Socket socket = null;
System.out.println("start server, port : " + port);
executorService = Executors.newFixedThreadPool(POOL_SIZE);
while (true) {
socket = serverSocket.accept();
executorService.execute(new Handler(socket));
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
start();
}
}
当有socket连接该ServerSocket时,会向线程池里放一个任务,也就是我们接下来要写的Handler.java类,这个类构建时需要把连接到ServerSocket的socket传入,从这个socket的输入流里我们能看到请求的信息(比如启动我们自己的Server后,用浏览器访问127.0.0.1:8080,然后在socket的输入流里我们能看到“GET / HTTP/1.1”这样的信息),通过这些信息我们就能构建我们自己的Request了,然后通过这个Request里的路径信息以及web.xml里的信息,我们可以利用反射得到我们自己写的HttpServlet类,这个HttpServlet会向socket的输出流里写数据(也就是写到我们自己的Response里,也就是dispatcher方法),这些数据就能被浏览器获取到,代码如下:
package com.sunsy.tomcat;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import com.sunsy.servlet.HttpServlet;
public class Handler implements Runnable {
private Socket socket;
private PrintWriter writer;
public Handler(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
try {
writer = new PrintWriter(new OutputStreamWriter(socket.getOutputStream(), "UTF-8"));
writer.println("HTTP/1.1 200 OK");
writer.println("Content-Type: text/html;charset=utf-8");
writer.println();
Request request = new Request();
Response response = new Response(writer);
InputStream inputStream = socket.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
while(true) {
String msg = reader.readLine();
if(msg==null || "".equals(msg.trim())) {
break;
}
String[] msgs = msg.split(" ");
if(msgs.length==3 && msgs[2].equalsIgnoreCase("HTTP/1.1")) {
request.setMethod(msgs[0]);
request.setPath(msgs[1]);
break;
}
}
if(request.getPath().endsWith("ico")) {
return;
}
HttpServlet httpServlet = request.initServlet();
dispatcher(httpServlet, request, response);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
writer.close();
socket.close();
} catch (IOException e2) {
e2.printStackTrace();
}
}
}
private void dispatcher(HttpServlet httpServlet, Request request, Response response) {
try {
if(httpServlet == null) {
response.write("<h1>404 not found</h1>");
return;
}
if("GET".equalsIgnoreCase(request.getMethod())) {
httpServlet.doGet(request, response);
}else if("POST".equalsIgnoreCase(request.getMethod())){
httpServlet.doPost(request, response);
}
} catch (Exception e) {
response.write("<h1>500 server error</h1>");
e.printStackTrace();
}
}
}
接下来是Request.java和Response.java,代码如下:
package com.sunsy.tomcat;
import java.util.Map;
import com.sunsy.servlet.HttpServlet;
public class Request {
private String path;
private String method;
private String parameter;
private Map<String, String> attribute;
public Request() {
super();
}
public HttpServlet initServlet() {
return ServletContainer.getHttpServlet(path);
}
public String getPath() {
return path;
}
public void setPath(String path) {
this.path = path;
}
public String getMethod() {
return method;
}
public void setMethod(String method) {
this.method = method;
}
public String getParameter() {
return parameter;
}
public void setParameter(String parameter) {
this.parameter = parameter;
}
public Map<String, String> getAttribute() {
return attribute;
}
public void setAttribute(Map<String, String> attribute) {
this.attribute = attribute;
}
}
package com.sunsy.tomcat;
import java.io.PrintWriter;
public class Response {
private PrintWriter writer;
public Response(PrintWriter writer) {
this.writer = writer;
}
public void write(String msg) {
writer.write(msg);
writer.flush();
}
}
那么接下来说一下我们自己定义的HttpServlet,以及怎么反射获取。
我们先按照Spring里的web.xml的样式写一个自己的web.xml,如下:
<?xml version="1.0" encoding="UTF-8"?>
<web-app>
<servlet>
<servlet-name>servlet</servlet-name>
<servlet-class>com.sunsy.servlet.impl.MyServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>servlet</servlet-name>
<url-pattern>/index</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>yourServlet</servlet-name>
<servlet-class>com.sunsy.servlet.impl.YourServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>yourServlet</servlet-name>
<url-pattern>/test</url-pattern>
</servlet-mapping>
</web-app>
只要做过web开发的应该对这个xml都不陌生,我们对其中的servlet子节点和servlet-mapping子节点生成对应的实体类,即Servlet.java和ServletMapping.java类:
package com.sunsy.model;
public class Servlet {
private String name;
private String clazz;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getClazz() {
return clazz;
}
public void setClazz(String clazz) {
this.clazz = clazz;
}
}
package com.sunsy.model;
public class ServletMapping {
private String name;
private String url;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
}
接下来我们要自己写几个HttpServlet(我们模仿servlet-api包里的HttpServlet类)首先是抽象父类HttpServlet.java,和servlet-api包里的HttpServlet一样,实现doPost、doGet、service方法,代码如下:
package com.sunsy.servlet;
import java.io.IOException;
import com.sunsy.tomcat.Response;
import com.sunsy.tomcat.Request;
public abstract class HttpServlet {
public void doGet(Request request, Response response) throws IOException {
this.service(request, response);
}
public void doPost(Request request, Response response) throws IOException {
this.service(request, response);
}
public void service(Request request, Response response) throws IOException {
if("GET".equalsIgnoreCase(request.getMethod())) {
doGet(request, response);
}else {
doPost(request, response);
}
}
}
接下来是web.xml里配置的两个具体servlet实现类,如下:
package com.sunsy.servlet.impl;
import java.io.IOException;
import com.sunsy.servlet.HttpServlet;
import com.sunsy.tomcat.Request;
import com.sunsy.tomcat.Response;
public class MyServlet extends HttpServlet {
@Override
public void doGet(Request request, Response response) throws IOException {
response.write("<h1>my servlet hello</h1>");
}
}
package com.sunsy.servlet.impl;
import com.sunsy.servlet.HttpServlet;
import com.sunsy.tomcat.Request;
import com.sunsy.tomcat.Response;
public class YourServlet extends HttpServlet {
@Override
public void doGet(Request request, Response response) {
response.write("<h1>your servlet hello</h1>");
}
}
接下来就是怎么读取web.xml里的信息,我们通过XMLUtil类读取web.xml,生成对应的Servlet实体类和ServletMapping实体类,代码如下(备注很细,应该很容易看懂):
package com.sunsy.util;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import com.sunsy.model.Servlet;
import com.sunsy.model.ServletMapping;
public class XMLUtil {
public static Map<Integer, Map<String, Object>> parseWebXML() throws Exception{
Map<Integer, Map<String, Object>> result = new HashMap<Integer, Map<String,Object>>();
//DOM解析器工厂实例
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
//获取DOM解析器
DocumentBuilder db = dbf.newDocumentBuilder();
//把要解析的XML文档转化为输入流,让DOM解析器解析,从src根目录开始读取
InputStream in = XMLUtil.class.getClassLoader().getResourceAsStream("web.xml");
//解析输入流,获得document对象
Document document = db.parse(in);
//得到xml的根节点
Element root = document.getDocumentElement();
// System.out.println("rootName:" + root.getTagName());
//得到根节点的子节点
NodeList xmlNodes = root.getChildNodes();
//循环读取
for(int i = 0; i < xmlNodes.getLength(); i++) {
Node config = xmlNodes.item(i);
//判断是否为元素节点
if(config != null && config.getNodeType()==Node.ELEMENT_NODE) {
String nodeName1 = config.getNodeName();
// System.out.println("nodeName1:" + nodeName1);
if("servlet".equals(nodeName1)) {
Map<String, Object> servletMaps = null;
if(result.containsKey(0)) {
servletMaps = result.get(0);
}else {
servletMaps = new HashMap<String, Object>();
}
//获取元素节点的所有子节点
NodeList childNodes = config.getChildNodes();
//创建servlet实体类准备接受数据
Servlet servlet = new Servlet();
for (int j = 0; j < childNodes.getLength(); j++) {
Node node = childNodes.item(j);
//判断是否为元素节点
if(node != null && node.getNodeType()==Node.ELEMENT_NODE) {
//读取servlet-name和servlet-class
String nodeName2 = node.getNodeName();
// System.out.println("nodeName2:" + nodeName2);
//读取文本内容
String textContent = node.getTextContent();
// System.out.println("textContent:" + textContent);
if(nodeName2.equals("servlet-name")) {
servlet.setName(textContent);
}else if(nodeName2.equals("servlet-class")) {
servlet.setClazz(textContent);
}
}
}
//结果放到Map中
servletMaps.put(servlet.getName(), servlet);
result.put(0, servletMaps);
}else if (nodeName1.equals("servlet-mapping")) {
Map<String, Object> servletMappingMaps = null;
if(result.containsKey(1)) {
servletMappingMaps = result.get(1);
}else {
servletMappingMaps = new HashMap<String, Object>();
}
//获取元素节点的所有子节点
NodeList childNodes = config.getChildNodes();
//创建实体类
ServletMapping servletMapping = new ServletMapping();
for(int j = 0; j < childNodes.getLength(); j++) {
Node node = childNodes.item(j);
if(node!=null && node.getNodeType()==Node.ELEMENT_NODE) {
String nodeName2 = node.getNodeName();
// System.out.println("nodeName2:" + nodeName2);
String textContent = node.getTextContent();
// System.out.println("textContent:" + textContent);
if(nodeName2.equals("servlet-name")) {
servletMapping.setName(textContent);
}else if (nodeName2.equals("url-pattern")) {
servletMapping.setUrl(textContent);
}
}
}
servletMappingMaps.put(servletMapping.getUrl(), servletMapping);
result.put(1, servletMappingMaps);
}
}
}
return result;
}
public static void main(String[] args) throws Exception {
System.out.println(parseWebXML());
}
}
最后我们在ServletContainer类中调用该Util类,获取Servlet、ServletMapping实体类,然后通过这两个实体类中的属性信息反射生成我们需要的HttpServlet对象,这个HttpServlet将由Handler中的dispatcher方法调用,ServletContainer.java如下:
package com.sunsy.tomcat;
import java.util.HashMap;
import java.util.Map;
import com.sunsy.model.Servlet;
import com.sunsy.model.ServletMapping;
import com.sunsy.servlet.HttpServlet;
import com.sunsy.util.XMLUtil;
public class ServletContainer {
private static Map<String, Object> servletMaps = new HashMap<>();
private static Map<String, Object> servletMappingMaps = new HashMap<>();
private static Map<String, HttpServlet> servletContainer = new HashMap<>();
//静态代码块加载model实体类
static {
try {
Map<Integer, Map<String, Object>> maps = XMLUtil.parseWebXML();
if(maps != null && 2==maps.size()) {
servletMaps = maps.get(0);
servletMappingMaps = maps.get(1);
}
}catch(Exception e){
e.printStackTrace();
}
}
//获取servlet容器中对应的HttpServlet
public static HttpServlet getHttpServlet(String path) {
if(path == null || "".equals(path.trim()) || "/".equals(path)) {
path = "/index";
}
if(servletContainer.containsKey(path)) {
return servletContainer.get(path);
}
if(!servletMappingMaps.containsKey(path)) {
return null;
}
ServletMapping servletMapping = (ServletMapping)servletMappingMaps.get(path);
String name = servletMapping.getName();
if(!servletMaps.containsKey(name)) {
return null;
}
Servlet servlet = (Servlet)servletMaps.get(name);
String clazz = servlet.getClazz();
if(clazz==null || clazz.trim().equals("")) {
return null;
}
HttpServlet httpServlet = null;
try {
httpServlet = (HttpServlet)Class.forName(clazz).newInstance();
servletContainer.put(path, httpServlet);
} catch (Exception e) {
e.printStackTrace();
}
return httpServlet;
}
}
至此我们就手动实现了一个我们自己的Tomcat服务器,启动Servlet.java类,然后浏览器访问127.0.0.1:8080,会显示my servlet hello字样,访问127.0.0.1:8080/test会显示your servlet hello字样,如图:
源码我放到github上了,地址是:https://github.com/ssystc/MyTomcat.git
希望这个简单的小工程能对大家理解tomcat有所帮助,最后请收藏硬币关注三连支持一下...额,请点赞支持一下,谢谢