Tomcat超简洁版本

让我们来回顾一下基本的东西。

在servlet中有个对请求的封装HttpRequestServlet以及对响应的封装HttpResponseServlet，这个在servlet中是tomcat对其内的属性进行赋值，然后通过mapping也就是映射器查找对应的servlet，传给该servlet，然后执行serlvet的逻辑。

自定义request

接受前端传来的数据，进行解析，这里只解析了请求方式与请求url，然后进行封装成一个request对象，名字无所谓也可以叫a对象。只不过request好理解，见名知意。最终还是在server中进行操作赋值。

package com.cliong.tomcat;

import java.io.IOException;
import java.io.InputStream;

/**
 * 对请求的封装
 * 主要包括请求方式
 * 请求地址
 *
 * @author lc
 * @date 2020-12-08 20:48
 */
public class Request {
    private String method;
    private String url;

    public Request(InputStream inputStream) throws IOException {
        //建立缓存
        byte[] buffer = new byte[1024];
        int len = 0;
        String str = null;
        if ((len = inputStream.read(buffer)) > 0) {
            str = new String(buffer);
        }
        //处理传输过来的字符串
        assert str != null;
        String[] split = str.split("\n");
        String[] s = split[0].split(" ");
        method = s[0];
        url = s[1];
    }

    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;
    }
}

自定义response

封装的响应数据，这个也是在server的时候进行赋值，通过socket获取OutputStream对象，然后传递给response进行调用

package com.cliong.tomcat;

import java.io.IOException;
import java.io.OutputStream;

/**
 * @author lc
 * @date 2020-12-08 21:07
 */
public class Response {
    private final OutputStream outputStream;

    public Response(OutputStream outputStream) {
        this.outputStream = outputStream;
    }

    public void write(String str) throws IOException {
        //对响应字符的封装
        String s = "HTTP/1.1 200 OK\nContent-Type:text/html\n\r\n"+"<html>" +
                "<body>" + "<h1>" + str + "</h1></body></html>";
        outputStream.write(s.getBytes());
    }
}

自定义servlet

定义基本的处理方式，这里有个抽象类就是servlet的父类，里面定义了两个抽象的处理方式分别对应get与post请求。还有个service方法，根据不同的请求方式进入不同的处理方法

package com.cliong.tomcat;

/**
 * @author lc
 * @date 2020-12-08 21:17
 */
public abstract class Servlet {
    public static final String METHOD_GET = "GET";
    public static final String METHOD_POST = "POST";

    public abstract void doGet(Request request, Response response) throws Exception;

    public abstract void doPost(Request request, Response response) throws Exception;

    public void service(Request request, Response response) throws Exception {
        if (METHOD_GET.equals(request.getMethod())) {
            doGet(request, response);
        } else {
            doPost(request, response);

        }
    }

}

具体的实现类，在映射器mapping中请求路径对应的实际类

package com.cliong.tomcat;

/**
 * @author lc
 * @date 2020-12-08 21:19
 */
public class HttpServlet extends Servlet {

    @Override
    public void doGet(Request request, Response response) throws Exception {
        response.write("success");
    }

    @Override
    public void doPost(Request request, Response response) throws Exception {
        doGet(request, response);
    }
}

自定义mapping

获取请求对应的servlet

package com.cliong.tomcat;

import java.util.HashMap;

/**
 * @author lc
 * @date 2020-12-08 21:15
 */
public class HandlderMapping {
    final static HashMap<String, String> handlerMapping = new HashMap<>();

    static {
        handlerMapping.put("/test", HttpServlet.class.getName());
    }
    public HashMap<String, String> getHandlerMapping() {
        return handlerMapping;
    }
}

自定义server

启动ServerSocket监听来自客户端的请求

也就是tomcat的基本功能

package com.cliong.tomcat;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;

/**
 * 服务
 *
 * @author lc
 * @date 2020-12-08 21:30
 */
public class Server {
    public void startServer(int port) throws Exception {
        ServerSocket serverSocket = new ServerSocket(port);
        Socket socket = null;
        while (true) {
            socket = serverSocket.accept();
            //获取输入流
            InputStream inputStream = socket.getInputStream();
//            获取输出流
            OutputStream outputStream = socket.getOutputStream();
            //创建请求对象
            Request request = new Request(inputStream);
//            创建响应对象
            Response response = new Response(outputStream);
            //调用对应的servlet
            HashMap<String, String> handlerMapping = HandlderMapping.handlerMapping;
            String classpath = handlerMapping.get(request.getUrl());
            Class<HttpServlet> aClass = (Class<HttpServlet>) Class.forName(classpath);
            Constructor<HttpServlet> constructor = aClass.getConstructor();
            HttpServlet httpServlet = constructor.newInstance();
            httpServlet.service(request, response);
        }
    }
    public static void main(String[] args) throws Exception {
        new Server().startServer(8080);

    }
}

至此一个超级简易版的tomcat就完成了

posted @ 2020-12-09 11:13 小鸡小鸡快点跑阅读(140) 评论(0) 收藏举报

刷新页面返回顶部

小鸡小鸡快点跑

Tomcat超简洁版本

公告