<?xml version="1.0" encoding="UTF-8"?>
<Server>
    <Service name="Catalina">
        <Connector port="18080"/>
        <Connector port="18081"/>
        <Connector port="18082"/>
        <Engine defaultHost="localhost">
            <Host name = "localhost">
                <Context path="/b" docBase="d:/project/diytomcat/b" />
            </Host>
        </Engine>
    </Service>
</Server>

package cn.how2j.diytomcat.catalina;

import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

import cn.how2j.diytomcat.http.Request;
import cn.how2j.diytomcat.http.Response;
import cn.how2j.diytomcat.util.Constant;
import cn.how2j.diytomcat.util.ThreadPoolUtil;
import cn.how2j.diytomcat.util.WebXMLUtil;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.log.LogFactory;

public class Connector implements Runnable {
	int port;
	private Service service;
	public Connector(Service service) {
		this.service = service;
	}

	public Service getService() {
		return service;
	}

	public void setPort(int port) {
		this.port = port;
	}

	@Override
	public void run() {
		try {
			ServerSocket ss = new ServerSocket(port);

			while(true) {
				Socket s =  ss.accept();
				Runnable r = new Runnable(){
					@Override
					public void run() {
						try {
							Request request = new Request(s,service);
							Response response = new Response();
							String uri = request.getUri();
							if(null==uri)
								return;
							System.out.println("uri:"+uri);

							Context context = request.getContext();

							if("/500.html".equals(uri)){
								throw new Exception("this is a deliberately created exception");
							}

							if("/".equals(uri))
								uri = WebXMLUtil.getWelcomeFile(request.getContext());

							String fileName = StrUtil.removePrefix(uri, "/");
							File file = FileUtil.file(context.getDocBase(),fileName);

							if(file.exists()){
								String extName = FileUtil.extName(file);
								String mimeType = WebXMLUtil.getMimeType(extName);
								response.setContentType(mimeType);

//                                String fileContent = FileUtil.readUtf8String(file);
//                                response.getWriter().println(fileContent);

								byte body[] = FileUtil.readBytes(file);
								response.setBody(body);

								if(fileName.equals("timeConsume.html")){
									ThreadUtil.sleep(1000);
								}

							}
							else{
								handle404(s, uri);
								return;
							}
							handle200(s, response);
						} catch (Exception e) {
							LogFactory.get().error(e);
							handle500(s,e);
						}
						finally{
							try {
								if(!s.isClosed())
									s.close();
							} catch (IOException e) {
								e.printStackTrace();
							}
						}
					}
				};

				ThreadPoolUtil.run(r);
			}
		} catch (IOException e) {
			LogFactory.get().error(e);
			e.printStackTrace();
		}
	}

	public void init() {
		LogFactory.get().info("Initializing ProtocolHandler [http-bio-{}]",port);
	}

	public void start() {
		LogFactory.get().info("Starting ProtocolHandler [http-bio-{}]",port);
		new Thread(this).start();
	}

	private static void handle200(Socket s, Response response) throws IOException {
		String contentType = response.getContentType();
		String headText = Constant.response_head_202;
		headText = StrUtil.format(headText, contentType);
		byte[] head = headText.getBytes();

		byte[] body = response.getBody();

		byte[] responseBytes = new byte[head.length + body.length];
		ArrayUtil.copy(head, 0, responseBytes, 0, head.length);
		ArrayUtil.copy(body, 0, responseBytes, head.length, body.length);

		OutputStream os = s.getOutputStream();
		os.write(responseBytes);
	}

	protected void handle404(Socket s, String uri) throws IOException {
		OutputStream os = s.getOutputStream();
		String responseText = StrUtil.format(Constant.textFormat_404, uri, uri);
		responseText = Constant.response_head_404 + responseText;
		byte[] responseByte = responseText.getBytes("utf-8");
		os.write(responseByte);
	}

	protected void handle500(Socket s, Exception e) {
		try {
			OutputStream os = s.getOutputStream();
			StackTraceElement stes[] = e.getStackTrace();
			StringBuffer sb = new StringBuffer();
			sb.append(e.toString());
			sb.append("\r\n");
			for (StackTraceElement ste : stes) {
				sb.append("\t");
				sb.append(ste.toString());
				sb.append("\r\n");
			}

			String msg = e.getMessage();

			if (null != msg && msg.length() > 20)
				msg = msg.substring(0, 19);

			String text = StrUtil.format(Constant.textFormat_500, msg, e.toString(), sb.toString());
			text = Constant.response_head_500 + text;
			byte[] responseBytes = text.getBytes("utf-8");
			os.write(responseBytes);
		} catch (IOException e1) {
			e1.printStackTrace();
		}
	}
}

package cn.how2j.diytomcat.util;

import cn.how2j.diytomcat.catalina.*;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.io.FileUtil;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import java.util.ArrayList;
import java.util.List;

public class ServerXMLUtil {
    public static List<Connector> getConnectors(Service service) {
        List<Connector> result = new ArrayList<>();
        String xml = FileUtil.readUtf8String(Constant.serverXmlFile);
        Document d = Jsoup.parse(xml);

        Elements es = d.select("Connector");
        for (Element e : es) {
            int port = Convert.toInt(e.attr("port"));
            Connector c = new Connector(service);
            c.setPort(port);
            result.add(c);
        }
        return result;
    }

    public static List<Context> getContexts() {
        List<Context> result = new ArrayList<>();
        String xml = FileUtil.readUtf8String(Constant.serverXmlFile);
        Document d = Jsoup.parse(xml);

        Elements es = d.select("Context");
        for (Element e : es) {
            String path = e.attr("path");
            String docBase = e.attr("docBase");
            Context context = new Context(path, docBase);
            result.add(context);
        }
        return result;
    }

    public static String getEngineDefaultHost() {
        String xml = FileUtil.readUtf8String(Constant.serverXmlFile);
        Document d = Jsoup.parse(xml);

        Element host = d.select("Engine").first();
        return host.attr("defaultHost");
    }

    public static String getServiceName() {
        String xml = FileUtil.readUtf8String(Constant.serverXmlFile);
        Document d = Jsoup.parse(xml);

        Element host = d.select("Service").first();
        return host.attr("name");
    }

    public static List<Host> getHosts(Engine engine) {
        List<Host> result = new ArrayList<>();
        String xml = FileUtil.readUtf8String(Constant.serverXmlFile);
        Document d = Jsoup.parse(xml);

        Elements es = d.select("Host");
        for (Element e : es) {
            String name = e.attr("name");
            Host host = new Host(name,engine);
            result.add(host);
        }
        return result;
    }
}

package cn.how2j.diytomcat.catalina;

import cn.how2j.diytomcat.util.ServerXMLUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.date.TimeInterval;
import cn.hutool.log.LogFactory;

import java.util.List;

public class Service {
    private String name;
    private Engine engine;
    private Server server;

    private List<Connector> connectors;
    public Service(Server server){
        this.server = server;
        this.name = ServerXMLUtil.getServiceName();
        this.engine = new Engine(this);
        this.connectors = ServerXMLUtil.getConnectors(this);
    }

    public Engine getEngine() {
        return engine;
    }

    public Server getServer() {
        return server;
    }

    public void start() {
        init();
    }

    private void init() {
        TimeInterval timeInterval = DateUtil.timer();
        for (Connector c : connectors)
            c.init();
        LogFactory.get().info("Initialization processed in {} ms",timeInterval.intervalMs());
        for (Connector c : connectors)
            c.start();
    }
}

package cn.how2j.diytomcat.catalina;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.date.TimeInterval;
import cn.hutool.log.LogFactory;
import cn.hutool.system.SystemUtil;

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;

public class Server {
    private Service service;
    public Server(){
        this.service = new Service(this);
    }

    public void start(){
        TimeInterval timeInterval = DateUtil.timer();
        logJVM();
        init();
        LogFactory.get().info("Server startup in {} ms",timeInterval.intervalMs());
    }

    private void init() {
        service.start();
    }

    private static void logJVM() {
        Map<String,String> infos = new LinkedHashMap<>();
        infos.put("Server version", "How2J DiyTomcat/1.0.1");
        infos.put("Server built", "2020-04-08 10:20:22");
        infos.put("Server number", "1.0.1");
        infos.put("OS Name\t", SystemUtil.get("os.name"));
        infos.put("OS Version", SystemUtil.get("os.version"));
        infos.put("Architecture", SystemUtil.get("os.arch"));
        infos.put("Java Home", SystemUtil.get("java.home"));
        infos.put("JVM Version", SystemUtil.get("java.runtime.version"));
        infos.put("JVM Vendor", SystemUtil.get("java.vm.specification.vendor"));

        Set<String> keys = infos.keySet();
        for (String key : keys) {
            LogFactory.get().info(key+":\t\t" + infos.get(key));
        }
    }

}