20年伊始小愿望<手写一个简易http服务器>完成

2020-11-08

序

2020年伊始,有一个仿照tomcat手写一个简单的http服务器,如今11月份先完成了V1.0基本的乞丐版.

暂时先乞丐版本,后续随着tomcat源码的深入了解再迭代.

项目地址: https://github.com/Superinterface/JerryMouse

jdk: 1.8

项目描述: 基于java原生ServerSocket实现了http协议的服务器端,现可以处理静态资源的处理与动态请求的自定义与处理.

处理流程图

核心逻辑代码

// 启动入口
public class StartMain {
    public static void main(String[] args) {
        ServerEngine se = new ServerEngine();
        se.startServerEngine();
    }
}

// 初始化http协议的 ContentType的Map
/**
 * <mime-mapping>
        <extension>png</extension>
        <mime-type>image/png</mime-type>
    </mime-mapping>
    ...
 */
private static void readMimeMap() {
        // mime.type
        SAXReader saxreader = new SAXReader();
        InputStream is = ServerEngine.class.getClassLoader().getResourceAsStream("web.xml");
        try {
            // 解析配置文件
            Document doc = saxreader.read(is);
            // 根节点
            Element rootEle = doc.getRootElement();
            List<Element> elements = rootEle.elements("mime-mapping");
            for (Element e : elements) {
                MIME_MAP.put(e.element("extension").getText(), e.element("mime-type").getText());
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        } finally {
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

// 扫描指定目录下的业务Controller
/* controller.xml
 *<controllers>
    <controller class="www.superinterface.xyz.controller.helloController"></controller>
    ...
  </controllers>
 */
private static void loadRequestMapping() {
        SAXReader saxreader = new SAXReader();
        InputStream is = ServerEngine.class.getClassLoader().getResourceAsStream("controller.xml");
        List<Object> beans = new ArrayList<Object>();
        try {
            Document document = saxreader.read(is);
            Element root = document.getRootElement();
            List<Element> elements = root.elements("controller");
            for (Element e : elements) {
                String packagePath = e.attributeValue("class");
                Object bean = Class.forName(packagePath).newInstance();
                beans.add(bean);
            }
            HANDLER_MAPPING = new HandlerMapping();
            HANDLER_MAPPING.process(beans);
        } catch (DocumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally{
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

// 初始化服务引擎开始监听端口,并对发送过来的数据进行处理响应.
public void startServerEngine() {
    try {
        System.out.println("=====启动ServerEngine开始");
        ss = new ServerSocket(port);// 默认9090
        while (true) {
            System.out.println("=====等待一个客户端连接");
            new Thread(new Connector(ss.accept())).start(); 
// Connector实现了runnable接口run方法,所以当客户端请求的时候,就会自动创建一个Connector对象来处理本次的请求.
            System.out.println("=====处理客户端连接完毕");
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            ss.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// 连接器
public class Connector implements Runnable {

    private Socket sc = null;
    private HttpRequest request = null;
    private HttpResponse response = null;
    private HandlerMapping handlerMapping = ServerEngine.getHandlerMapping();
    private Map<String, Handler> mapping = handlerMapping.getReqeustMapping();

    private Connector() {

    }

    public Connector(Socket sc) {
        this.sc = sc;
    }

    /*
     * 读取请求数据,分析请求,处理请求,最终响应.
     */
    public void run() {
        try {
            this.request = new HttpRequest(this.sc.getInputStream());
            this.response = new HttpResponse(this.sc.getOutputStream());
            this.request.parseRequest();
            // 处理逻辑,判断是静态资源请求还是需要业务处理的动态请求
            handler();
            this.response.response();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void handler() throws UnsupportedEncodingException {
        // 判断请求类型(静态资源文件,动态业务请求)
        // 静态资源文件,加载文件流,根据文件后缀名设置对应的Content-Type进行响应.
        // 动态请求,则进入RequestMapping查找是否有对应的处理程序,有则进行调用处理,无则响应404.
        String url = this.request.getHttpUrl();
        String suffix = url.contains(".") ? url.substring(url.lastIndexOf("."), url.length()) : null;
        Map<String, String> mimeMapping = ServerEngine.getMimeMap();
        // 是否为静态资源文件
        if (suffix != null && mimeMapping.containsKey(suffix)) {
            // 读取文件流,填充到响应对象的输出流.
//            System.out.printf(url);
            this.response.setHttpResponseCode(200);
            this.response.setHttpResponseMessage("ok");
            Map<String, String> heads = this.response.getHttpResponseHeads();
            heads.put("Content-Type", "text/html;charset=utf8");
            this.response.setHttpResponseBody("<h1>静态资源文件获取</h1>".getBytes("utf-8"));
        } else if (mapping.containsKey(url)) { // 查找HandlerMapping是否可以处理请求
            Handler h = mapping.get(url);
            Method m = h.getM();
            Object o = h.getO();
            // v1.0版本将所有方法返回值为String
            Object returnStr = null;
            try {
                Class[] types = m.getParameterTypes();
                if (types.length > 0) { // 处理方法带参数,则先将参数赋值,再调用方法.// v1.0 暂时不处理赋值参数.
//                    Object[] params = new Object[types.length];
//                    for (Object param : params) {
//                    }
                    returnStr = m.invoke(o);
                } else { // 处理方法不带参数
                    returnStr = m.invoke(o);
                }
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
            this.response.setHttpResponseCode(200);
            this.response.setHttpResponseMessage("ok");
            Map<String, String> heads = this.response.getHttpResponseHeads();
            heads.put("Content-Type", "text/html;charset=utf8");
            this.response.setHttpResponseBody(new String(returnStr.toString()).getBytes("utf-8"));
        } else { // 不能处理当前的请求,响应404.
            this.response.setHttpResponseCode(404);
            this.response.setHttpResponseMessage("not found");
            Map<String, String> heads = this.response.getHttpResponseHeads();
            heads.put("Content-Type", "text/html;charset=utf8");
            this.response.setHttpResponseBody(new StringBuffer().append("<h1>404 not found</h1>").toString().getBytes("utf-8"));
            this.response.response();
        }
    }
}

统述：基于ServerSocket 从输入流读取http请求并分析，判断请求的类型,并进行响应。

最后，感谢阅读。

作者： k

公众号：知易行楠
博客：www.superinterface.xyz