https://github.com/CoderXiaohui/mini-tomcat
作为一个服务器软件提供服务（通过浏览器客户端发送Http请求，它可以接收到请求进行处理，处理之后的结果返回浏览器客户端）。
*Tomcat的入口就是一个main函数
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.dxh</groupId>
<artifactId>MiniCat</artifactId>
<version>1.0-SNAPSHOT</version>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>11</source>
<target>11</target>
<encoding>utf-8</encoding>
</configuration>
</plugin>
</plugins>
</build>
</project>
这里我们把socket监听的端口号定义在主类中。
package server;
/**
* Minicat的主类
*/
public class Bootstrap {
/**
* 定义Socket监听的端口号
*/
private int port = 8080;
public int getPort() {
return port;
}
public void setPort(int port) {
this.port = port;
}
/**
* Minicat的启动入口
* @param args
*/
public static void main(String[] args) {
}
}
循序渐进，一点一点的完善，1.0版本我们需要的需求是：
start方法主要就是监听上面配置的端口，然后得到其输出流，最后写出。
/**
* MiniCat启动需要初始化展开的一些操作
*/
public void start() throws IOException {
/*
完成Minicat 1.0版本
需求：浏览器请求http://localhost:8080，返回一个固定的字符串到页面“Hello Minicat！”
*/
ServerSocket serverSocket = new ServerSocket(port);
System.out.println("========>>Minicat start on port："+port);
while(true){
Socket socket = serverSocket.accept();
//有了socket，接收到请求,获取输出流
OutputStream outputStream = socket.getOutputStream();
outputStream.write("Hello Minicat！".getBytes());
socket.close();
}
}
完整的代码：
/**
* Minicat的主类
*/
public class Bootstrap {
/**
* 定义Socket监听的端口号
*/
private int port = 8080;
public int getPort() {
return port;
}
public void setPort(int port) {
this.port = port;
}
/**
* Minicat的启动入口
* @param args
*/
public static void main(String[] args) {
Bootstrap bootstrap = new Bootstrap();
try {
//启动Minicat
bootstrap.start();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* MiniCat启动需要初始化展开的一些操作
*/
public void start() throws IOException {
ServerSocket serverSocket = new ServerSocket(port);
System.out.println("========>>Minicat start on port："+port);
while(true){
Socket socket = serverSocket.accept();
//有了socket，接收到请求,获取输出流
OutputStream outputStream = socket.getOutputStream();
outputStream.write("Hello Minicat！".getBytes());
socket.close();
}
}
}
此时，如果启动项目，从浏览器中输入http://localhost:8080/，能够正常接收到请求吗？
不能！
问题分析：
启动项目，从浏览器中输入http://localhost:8080/，可看到返回结果如下图：
因为Http协议是一个应用层协议，其规定了请求头、请求体、响应同样，如果没有这些东西的话浏览器无法正常显示。代码中直接把”Hello Minicat！“直接输出了，
新建一个工具类，主要提供响应头信息
package server;
/**
* http协议工具类，主要提供响应头信息，这里我们只提供200和404的情况
*/
public class HttpProtocolUtil {
/**
* 为响应码200提供请求头信息
*/
public static String getHttpHeader200(long contentLength){
return "HTTP/1.1 200 OK \n" +
"Content-Type: text/html \n" +
"Content-Length: "+contentLength +"\n"+
"\r\n";
}
/**
* 为响应码404提供请求头信息(也包含了数据内容)
*/
public static String getHttpHeader404(){
String str404="<h1>404 not found</h1>";
return "HTTP/1.1 404 NOT Found \n" +
"Content-Type: text/html \n" +
"Content-Length: "+str404.getBytes().length +"\n"+
"\r\n" + str404;
}
}
修改start方法
public void start() throws IOException {
ServerSocket serverSocket = new ServerSocket(port);
System.out.println("========>>Minicat start on port："+port);
while(true){
Socket socket = serverSocket.accept();
OutputStream outputStream = socket.getOutputStream();
String data = "Hello Minicat!";
String responseText = HttpProtocolUtil.getHttpHeader200(data.getBytes().length)+data;
outputStream.write(responseText.getBytes());
socket.close();
}
}
访问~
成功。
需求：
新建一个类，Bootstrap2 （为了方便与1.0版本做对比）。获得输入流，并打印出来看看。
package server;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
* Minicat的主类
*/
public class Bootstrap2 {
/**
* 定义Socket监听的端口号
*/
private int port = 8080;
public int getPort() {
return port;
}
public void setPort(int port) {
this.port = port;
}
/**
* Minicat的启动入口
* @param args
*/
public static void main(String[] args) {
Bootstrap2 bootstrap = new Bootstrap2();
try {
//启动Minicat
bootstrap.start();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* MiniCat启动需要初始化展开的一些操作
*/
public void start() throws IOException {
ServerSocket serverSocket = new ServerSocket(port);
System.out.println("========>>Minicat start on port："+port);
while (true){
Socket socket = serverSocket.accept();
InputStream inputStream = socket.getInputStream();
//从输入流中获取请求信息
int count = 0 ;
while (count==0){
count = inputStream.available();
}
byte[] bytes = new byte[count];
inputStream.read(bytes);
System.out.println("请求信息=====>>"+new String(bytes));
socket.close();
}
}
}
打印出来的信息：
这里我们需要得到的是 请求方式（GET） 和 url （/） ，接下来封装Request的时候也是只封装这两个属性
只封装两个参数——method和url
新建Request类
该类有三个属性（String method、String url、InputStream inputStream）
method和url都是从input流中解析出来的。
GET SET方法
编写有参构造
/**
* 构造器 输入流传入
*/
public Request(InputStream inputStream) throws IOException {
this.inputStream = inputStream;
//从输入流中获取请求信息
int count = 0 ;
while (count==0){
count = inputStream.available();
}
byte[] bytes = new byte[count];
inputStream.read(bytes);
String inputsStr = new String(bytes);
//获取第一行数据
String firstLineStr = inputsStr.split("\\n")[0]; //GET / HTTP/1.1
String[] strings = firstLineStr.split(" ");
//把解析出来的数据赋值
this.method=strings[0];
this.url= strings[1];
System.out.println("method=====>>"+method);
System.out.println("url=====>>"+url);
}
无参构造
完整的Request.java：
package server;
import java.io.IOException;
import java.io.InputStream;
/**
* 把我们用到的请求信息，封装成Response对象 （根据inputSteam输入流封装）
*/
public class Request {
/**
* 请求方式 例如：GET/POST
*/
private String method;
/**
* / ， /index.html
*/
private String url;
/**
* 其他的属性都是通过inputStream解析出来的。
*/
private InputStream inputStream;
/**
* 构造器 输入流传入
*/
public Request(InputStream inputStream) throws IOException {
this.inputStream = inputStream;
//从输入流中获取请求信息
int count = 0 ;
while (count==0){
count = inputStream.available();
}
byte[] bytes = new byte[count];
inputStream.read(bytes);
String inputsStr = new String(bytes);
//获取第一行数据
String firstLineStr = inputsStr.split("\\n")[0]; //GET / HTTP/1.1
String[] strings = firstLineStr.split(" ");
this.method=strings[0];
this.url= strings[1];
System.out.println("method=====>>"+method);
System.out.println("url=====>>"+url);
}
public Request() {
}
public String getMethod() {
return method;
}
public void setMethod(String method) {
this.method = method;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
a
public InputStream getInputStream() {
return inputStream;
}
public void setInputStream(InputStream inputStream) {
this.inputStream = inputStream;
}
}
package server;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
/**
* 封装Response对象，需要依赖于OutputStream
*
*/
public class Response{
private OutputStream outputStream;
public Response(OutputStream outputStream) {
this.outputStream = outputStream;
}
public Response() {
}
/**
* @param path 指的就是 Request中的url ，随后要根据url来获取到静态资源的绝对路径，进一步根据绝对路径读取该静态资源文件，最终通过输出流输出
*/
public void outputHtml(String path) throws IOException {
//获取静态资源的绝对路径
String absoluteResourcePath = StaticResourceUtil.getAbsolutePath(path);
//输出静态资源文件
File file = new File(absoluteResourcePath);
if (file.exists() && file.isFile()){
//读取静态资源文件，输出静态资源
StaticResourceUtil.outputStaticResource(new FileInputStream(file),outputStream);
}else{
//输出404
output(HttpProtocolUtil.getHttpHeader404());
}
}
//使用输出流输出指定字符串
public void output(String context) throws IOException {
outputStream.write(context.getBytes());
}
}
2.0版本只考虑输出静态资源文件
我们来分析一下outputHtml(String path)这个方法
首先，path就指 Request中的url，我们要用这个url找到该资源的绝对路径：
根据path，获取静态资源的绝对路径
public static String getAbsolutePath(String path){
String absolutePath = StaticResourceUtil.class.getResource("/").getPath();
return absolutePath.replaceAll("\\\\","/")+path;
}
判断静态资源是否存在
存在：读取静态资源文件，输出静态资源
public static void outputStaticResource(InputStream inputStream, OutputStream outputStream) throws IOException {
int count = 0 ;
while (count==0){
count=inputStream.available();
}
//静态资源长度
int resourceSize = count;
//输出Http请求头 , 然后再输出具体的内容
outputStream.write(HttpProtocolUtil.getHttpHeader200(resourceSize).getBytes());
//读取内容输出
long written = 0; //已经读取的内容长度
int byteSize = 1024; //计划每次缓冲的长度
byte[] bytes = new byte[byteSize];
while (written<resourceSize){
if (written+byteSize >resourceSize){ //剩余未读取大小不足一个1024长度，那就按照真实长度处理
byteSize= (int)(resourceSize-written); //剩余的文件内容长度
bytes=new byte[byteSize];
}
inputStream.read(bytes);
outputStream.write(bytes);
outputStream.flush();
written+=byteSize;
}
}
把上述的第一步和第三步的方法封装到一个类中：
package server;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class StaticResourceUtil {
/**
* 获取静态资源方法的绝对路径
*/
public static String getAbsolutePath(String path){
String absolutePath = StaticResourceUtil.class.getResource("/").getPath();
return absolutePath.replaceAll("\\\\","/")+path;
}
/**
* 读取静态资源文件输入流，通过输出流输出
*/
public static void outputStaticResource(InputStream inputStream, OutputStream outputStream) throws IOException {
int count = 0 ;
while (count==0){
count=inputStream.available();
}
//静态资源长度
int resourceSize = count;
//输出Http请求头 , 然后再输出具体的内容
outputStream.write(HttpProtocolUtil.getHttpHeader200(resourceSize).getBytes());
//读取内容输出
long written = 0; //已经读取的内容长度
int byteSize = 1024; //计划每次缓冲的长度
byte[] bytes = new byte[byteSize];
while (written<resourceSize){
if (written+byteSize >resourceSize){ //剩余未读取大小不足一个1024长度，那就按照真实长度处理
byteSize= (int)(resourceSize-written); //剩余的文件内容长度
bytes=new byte[byteSize];
}
inputStream.read(bytes);
outputStream.write(bytes);
outputStream.flush();
written+=byteSize;
}
}
}
修改Bootstrap2.java中的start()方法
public void start() throws IOException {
ServerSocket serverSocket = new ServerSocket(port);
System.out.println("========>>Minicat start on port："+port);
while (true){
Socket socket = serverSocket.accept();
InputStream inputStream = socket.getInputStream();
//封装Resuest对象和Response对象
Request request = new Request(inputStream);
Response response = new Response(socket.getOutputStream());
response.outputHtml(request.getUrl());
socket.close();
}
}
在项目的resources文件夹新建index.html文件
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Static resource </title>
</head>
<body>
Hello ~ Static resource
</body>
</html>
运行main方法
结果展现：
3.0版本就要定义Servlet了，大致分为以下几步：
public interface Servlet {
void init() throws Exception;
void destroy() throws Exception;
void service(Request request,Response response) throws Exception;
}
定义一个抽象类，实现Servlet，并且增加两个抽象方法doGet , doPost.
public abstract class HttpServlet implements Servlet{
public abstract void doGet(Request request,Response response);
public abstract void doPost(Request request,Response response);
@Override
public void init() throws Exception {
}
@Override
public void destroy() throws Exception {
}
@Override
public void service(Request request, Response response) throws Exception {
if ("GET".equals(request.getMethod())){
doGet(request, response);
}else{
doPost(request, response);
}
}
}
新建DxhServlet.java，并继承HttpServlet重写doGet和doPost方法
package server;
import java.io.IOException;
public class DxhServlet extends HttpServlet{
@Override
public void doGet(Request request, Response response) {
String content="<h1>DxhServlet get</h1>";
try {
response.output(HttpProtocolUtil.getHttpHeader200(content.getBytes().length)+content);
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void doPost(Request request, Response response) {
String content="<h1>DxhServlet post</h1>";
try {
response.output(HttpProtocolUtil.getHttpHeader200(content.getBytes().length)+content);
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void init() throws Exception {
super.init();
}
@Override
public void destroy() throws Exception {
super.destroy();
}
}
接下来要把DxhServlet配置到一个配置文件中，当MiniCat启动时，加载进去。
在resources目录下，新建web.xml
<?xml version="1.0" encoding="UTF-8" ?>
<web-app>
<servlet>
<servlet-name>dxh</servlet-name>
<servlet-class>server.DxhServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>dxh</servlet-name>
<url-pattern>/dxh</url-pattern>
</servlet-mapping>
</web-app>
标准的配置Servlet的标签。servlet-class改成自己写的Servlet全限定类名，url-pattern为/dxh，一会请求http://localhost:8080/dxh，来访问这个servlet
复制一份Bootstrap2.java，命名为Bootstrap3.java
加载解析相关的配置 ，web.xml
引入dom4j和jaxen的jar包
<dependency>
<groupId>dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>1.6.1</version>
</dependency>
<dependency>
<groupId>jaxen</groupId>
<artifactId>jaxen</artifactId>
<version>1.1.6</version>
</dependency>
在Bootstrap3.java中增加一个方法
//用于下面存储url-pattern以及其对应的servlet-class的实例化对象
private Map<String,HttpServlet> servletMap = new HashMap<>();
private void loadServlet(){
InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream("web.xml");
SAXReader saxReader = new SAXReader();
try {
Document document = saxReader.read(resourceAsStream);
//根元素
Element rootElement = document.getRootElement();
/**
* 1, 找到所有的servlet标签，找到servlet-name和servlet-class
* 2, 根据servlet-name找到<servlet-mapping>中与其匹配的<url-pattern>
*/
List<Element> selectNodes = rootElement.selectNodes("//servlet");
for (int i = 0; i < selectNodes.size(); i++) {
Element element = selectNodes.get(i);
/**
* 1, 找到所有的servlet标签，找到servlet-name和servlet-class
*/
//<servlet-name>dxh</servlet-name>
Element servletNameElement =(Element)element.selectSingleNode("servlet-name");
String servletName = servletNameElement.getStringValue();
//<servlet-class>server.DxhServlet</servlet-class>
Element servletClassElement =(Element)element.selectSingleNode("servlet-class");
String servletClass = servletClassElement.getStringValue();
/**
* 2, 根据servlet-name找到<servlet-mapping>中与其匹配的<url-pattern>
*/
//Xpath表达式：从/web-app/servlet-mapping下查询，查询出servlet-name=servletName的元素
Element servletMapping =(Element)rootElement.selectSingleNode("/web-app/servlet-mapping[servlet-name=‘" + servletName + "‘]‘");
// /dxh
String urlPattern = servletMapping.selectSingleNode("url-pattern").getStringValue();
servletMap.put(urlPattern,(HttpServlet) Class.forName(servletClass).newInstance());
}
} catch (DocumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
这段代码的意思就是读取web.xml转换成Document，然后遍历根元素内中的servlet标签（servlet是可以配置多个的），通过XPath表达式获得servlet-name、servlet-class，以及与其对应的<servlet-mapping>标签下的url-pattern，然后存在Map中。注意，这里Map的Key是url-pattern，Value是servlet-class的实例化对象。
这里进行了判断，判断servletMap中是否存在url所对应的value，如果没有，当作静态资源访问，如果有，取出并调用service方法，在HttpServlet的service方法中已经做了根据request判断具体调用的是doGet还是doPost方法。
在浏览器中输入：
http://localhost:8080/index.html，可以访问静态资源
可以访问【5.2中编写的Servlet】动态资源~
到此位置，一个简单的Tomcat Demo已经完成。
在现有的代码中，接收请求这部分它是一个IO模型——BIO，阻塞IO。
它存在一个问题，当一个请求还未处理完成时，再次访问，会出现阻塞的情况。
可以在DxhServlet的doGet方法中加入Thread.sleep(10000);然后访问http://localhost:8080/dxh和http://localhost:8080/index.html做个测试
那么我们可以使用多线程对其进行改造。
把上述代码放到一个新的线程中处理。
复制Bootstrap3，命名为Bootstrap4。把start()方法中上图的部分（包括socket.close()）剪切到下面的线程处理类的run方法中：
package server;
import java.io.InputStream;
import java.net.Socket;
import java.util.Map;
/**
* 线程处理类
*/
public class RequestProcessor extends Thread{
private Socket socket;
private Map<String,HttpServlet> servletMap;
public RequestProcessor(Socket socket, Map<String, HttpServlet> servletMap) {
this.socket = socket;
this.servletMap = servletMap;
}
@Override
public void run() {
try{
InputStream inputStream = socket.getInputStream();
//封装Resuest对象和Response对象
Request request = new Request(inputStream);
Response response = new Response(socket.getOutputStream());
String url = request.getUrl();
//静态资源处理
if (servletMap.get(url)==null){
response.outputHtml(request.getUrl());
}else{
//动态资源处理
HttpServlet httpServlet = servletMap.get(url);
httpServlet.service(request,response);
}
socket.close();
}catch (Exception e){
}
}
}
public void start() throws Exception {
//加载解析相关的配置 ，web.xml，把配置的servlet存入servletMap中
loadServlet();
ServerSocket serverSocket = new ServerSocket(port);
System.out.println("========>>Minicat start on port："+port);
/**
* 可以请求动态资源
*/
while (true){
Socket socket = serverSocket.accept();
//使用多线程处理
RequestProcessor requestProcessor = new RequestProcessor(socket,servletMap);
requestProcessor.start();
}
}
再次做6.1章节的测试， OK 没有问题了。
这一步，我们使用线程池进行改造。
复制Bootstrap4，命名为Bootstrap5。
修改start()方法。线程池的使用不再赘述。代码如下：
public void start() throws Exception {
//加载解析相关的配置 ，web.xml，把配置的servlet存入servletMap中
loadServlet();
/**
* 定义线程池
*/
//基本大小
int corePoolSize = 10;
//最大
int maxPoolSize = 50;
//如果线程空闲的话，超过多久进行销毁
long keepAliveTime = 100L;
//上面keepAliveTime的单位
TimeUnit unit = TimeUnit.SECONDS;
//请求队列
BlockingQueue<Runnable> workerQueue = new ArrayBlockingQueue<>(50);
//线程工厂，使用默认的即可
ThreadFactory threadFactory = Executors.defaultThreadFactory();
//拒绝策略，如果任务太多处理不过来了，如何拒绝
RejectedExecutionHandler handler = new ThreadPoolExecutor.AbortPolicy();
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(corePoolSize
,maxPoolSize
,keepAliveTime
,unit
,workerQueue
,threadFactory
,handler);
ServerSocket serverSocket = new ServerSocket(port);
System.out.println("========>>Minicat start on port(多线程)："+port);
/**
* 可以请求动态资源
*/
while (true){
Socket socket = serverSocket.accept();
RequestProcessor requestProcessor = new RequestProcessor(socket,servletMap);
threadPoolExecutor.execute(requestProcessor);
}
}
OK ，再次测试，成功~
MINI版Tomcat到此完成。
总结一下编写一个MINI版本的Tomcat都需要做些什么：
原文：https://www.cnblogs.com/isdxh/p/14199711.html