tomcat原理（手写一个自己的tomcat）

其他 2019-04-06 16:20:57 阅读次数: 0

        前几天有个做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有所帮助，最后请收藏硬币关注三连支持一下...额，请点赞支持一下，谢谢

猜你喜欢

转载自blog.csdn.net/u014627099/article/details/86551735
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
让自己的头脑极度开放
CentOS 6.5(x64) 和Redhat6.5操作系误删libc
高可用注册中心
【日记】12.28/【题解】AtCoder AGC041
XML（5）_XML 约束_DTD
Java集合Map（四）
树梅派安装桌面环境教程
pipenv 的 使用和安装
小程序白屏问题和内存研究
C语言简单选择排序
每日归档
更多
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022