tomcat学习笔记手写tomcat

Posted 2021-07-27 拐柒

tomcat学习笔记（二）手写tomcat

• 手写实现迷你版tomcat
• • Bootstrap
  • HttpProtocolUtil
  • Servlet
  • HttpServlet
  • LagouServlet
  • Request
  • RequestProcessor
  • Response
  • StaticResourceUtil

手写实现迷你版tomcat

名称：Minicat
Minicat：作为服务器软件提供服务，我们通过浏览器客户端发送HTTP请求，Minicat可以接受请求进行处理，处理之后的结果可以返回浏览器客户端。
1、提供服务，接受请求（socket通信）
2、请求信息封装成request/response对象
3、客户端请求资源，资源分为静态资源（html）和动态资源（servlet）
4、资源返回给客户端浏览器

Bootstrap

迷你tomcta启动类。

public class Bootstrap {
    /**
     * 定义socket监听端口号
     */
    private int port=8080;

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }
    /**
     *Minicat启动需要初始化展开的一些操作
     */
    public void start() throws Exception {
        //加载解析配置文件web.xml
        loadServlet();
        //定义线程池
        //初始大小
        int corePoolSize=10;
        //最大大小
        int maximumPoolSize=50;
        //存活时长
        long keepAliveTime=100L;
        //时长单位
        TimeUnit unit= TimeUnit.SECONDS;
        //请求队列
        BlockingQueue<Runnable> workQueue=new ArrayBlockingQueue<>(50);
        //线程工厂
        ThreadFactory threadFactory=Executors.defaultThreadFactory();
        //拒绝策略
        RejectedExecutionHandler handler=new ThreadPoolExecutor.AbortPolicy();
        ThreadPoolExecutor threadPoolExecutor=new ThreadPoolExecutor(corePoolSize,maximumPoolSize,keepAliveTime,unit,workQueue,threadFactory,handler);



        /**
         * 1.0
         * 完成minicat1.0版本（浏览器请求localhost:8080，返回固定的字符串到页面"hellow 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();
//            String data="Hello Minicat!";
//            String responseText=HttpProtocolUtil.getHttpHeader200(data.getBytes().length)+data;
//            outputStream.write(responseText.getBytes());
//            socket.close();
//        }
        /**
         * 2.0
         * 完成minicat2.0版本
         * 封装Request和Response对象，返回html静态资源文件
         */
//        while (true) {
//            Socket socket = serverSocket.accept();
//            InputStream inputStream = socket.getInputStream();
//            //封装request/response对象
//            Request request=new Request(inputStream);
//            Response response=new Response(socket.getOutputStream());
//            response.outPutHtml(request.getUrl());
//            socket.close();
//        }

        /**
         * 3.0
         * 请求动态资源servlet
         */
//        while (true) {
//            Socket socket = serverSocket.accept();
//            InputStream inputStream = socket.getInputStream();
//            //封装request/response对象
//            Request request=new Request(inputStream);
//            Response response=new Response(socket.getOutputStream());
//            if(servletMap.get(request.getUrl())==null){
//                response.outPutHtml(request.getUrl());
//            }else {
//                HttpServlet httpServlet = servletMap.get(request.getUrl());
//                httpServlet.service(request,response);
//            }
//            socket.close();
//        }


        /**
         * 不适用线程池
         * 多线程改造
         */
//        while (true) {
//            Socket socket = serverSocket.accept();
//            RequestProcessor requestProcessor=new RequestProcessor(socket,servletMap);
//            requestProcessor.start();
//        }

        System.out.println("使用线程池进行多线程改造");
        /**
         * 使用线程池
         * 多线程改造
         */
        while (true) {
            Socket socket = serverSocket.accept();
            RequestProcessor requestProcessor=new RequestProcessor(socket,servletMap);
            threadPoolExecutor.execute(requestProcessor);
        }
    }
    private Map<String,HttpServlet> servletMap=new HashMap<>();
    //加载解析web.xml初始化servlet
    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();
            List<Element> list = rootElement.selectNodes("//servlet");
            for (int i = 0; i < list.size(); i++) {
                Element element = list.get(i);
                Element servletNameElement = (Element) element.selectSingleNode("servlet-name");
                //servlet-name>lagouServlet</servlet-name>
                String servletName=servletNameElement.getStringValue();
                Element servletClassElement = (Element) element.selectSingleNode("servlet-class");
                //<servlet-class>server.LagouServlet</servlet-class>
                String servletClass=servletClassElement.getStringValue();


                //根据servletName的值找到url-pattern
                Element servletMapping = (Element) rootElement.selectSingleNode("/web-app/servlet-mapping[servlet-name='" + servletName + "']");
                //<url-pattern>/lagou</url-pattern>
                String urlPattern = servletMapping.selectSingleNode("url-pattern").getStringValue();
                try {
                    servletMap.put(urlPattern, (HttpServlet) Class.forName(servletClass).newInstance());
                } catch (InstantiationException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        }
    }

    /**
     * Minicat启动入口
     * @param args
     */
    public static void main(String[] args) {
        Bootstrap bootstrap=new Bootstrap();
        try {
            //启动Minicat
            bootstrap.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

HttpProtocolUtil

http协议工具类，

/**
 * http协议工具类，主要是提供响应头信息，这里我们提供200和404的情况
 */
public class HttpProtocolUtil {
    /**
     * 为响应码200提供请求头信息
     * @return
     */
    public static String getHttpHeader200(long contentLength){
        return "HTTP/1.1 200 OK \\n" +
                "Content-Type: text/html;charset=utf-8 \\n" +
                "Content-Length: " +contentLength+" \\n" +
                "\\r\\n";
    }

    /**
     * 为响应码404提供请求头信息(此处也包含了数据内容)
     * @return
     */
    public static String getHttpHeader404(){
        String str="<h1>404 not found</h1>";
        return "HTTP/1.1 404 NOT Found \\n" +
                "Content-Type: text/html;charset=utf-8 \\n" +
                "Content-Length: " +str.getBytes().length+" \\n" +
                "\\r\\n" + str;
    }

}

Servlet

servlet接口，定义servlet规范

public interface Servlet {
    void init() throws Exception;
    void destroy() throws Exception;
    void service(Request request,Response response) throws Exception;
}

HttpServlet

处理请求的httpservlet

public abstract class HttpServlet implements Servlet{
    public abstract void doGet(Response response,Request request);
    public abstract void doPost(Request request,Response response);
    @Override
    public void service(Request request, Response response) throws Exception {
        if("GET".equals(request.getMethod())){
            doGet(response,request);
        }else {
            doPost(request,response);
        }
    }
}

LagouServlet

自定义servlet

public class LagouServlet extends HttpServlet{
    @Override
    public void doGet(Response response, Request request) {
        try {
            Thread.sleep(200000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        String string="<h1>LagouServlet get</h1>";
        try {
            response.outPut(HttpProtocolUtil.getHttpHeader200(string.getBytes().length)+string);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void doPost(Request request, Response response) {
        String string="<h1>LagouServlet post</h1>";
        try {
            response.outPut(HttpProtocolUtil.getHttpHeader200(string.getBytes().length)+string);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void init() throws Exception {

    }

    @Override
    public void destroy() throws Exception {

    }
}

Request

请求信息封装类

/**
 * 把请求信息封装为Request对象（根据inputStream封装）
 */
public class Request {
    //请求方式get/post
    private String method;
    //url
    private String url;
    //输入流，其他属性从输入流解析出来
    private InputStream inputStream;

    public Request() {
    }
    //构造器，输入流传入，解析出url和method
    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);
        System.out.println("请求信息："+new String(bytes));
        String string=new String(bytes);
        //获取第一行请求头信息 GET / HTTP/1.1
        String firstLine=string.split("\\\\n")[0];
        String[] s = firstLine.split(" ");
        this.method=s[0];
        this.url=s[1];

        System.out.println("method:"+this.method);
        System.out.println("url:"+this.url);
    }

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

    public InputStream getInputStream() {
        return inputStream;
    }

    public void setInputStream(InputStream inputStream) {
        this.inputStream = inputStream;
    }
}

RequestProcessor

请求处理器

public class RequestProcessor extends Thread{
    private Socket socket;
    private Map<String,HttpServlet> servletMap;

    public RequestProcessor() {
    }

    public RequestProcessor(Socket socket, Map<String, HttpServlet> servletMap) {
        this.socket = socket;
        this.servletMap = servletMap;
    }

    @Override
    public void run() {
        try {
            InputStream inputStream = socket.getInputStream();
            //封装request/response对象
            Request request=new Request(inputStream);
            Response response=new Response(socket.getOutputStream());
            if(servletMap.get(request.getUrl())==null){
                response.outPutHtml(request.getUrl());
            }else {
                HttpServlet httpServlet = servletMap.get(request.getUrl());
                httpServlet.service(request,response);
            }
            socket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Response

返回信息封装类

/**
 * 把相应信息封装为Response对象（根据outputStream封装）
 * 该对象需要提供核心对象，输出静态资源（html）
 */
public class Response {
    private OutputStream outputStream;

    public Response() {
    }

    public Response(OutputStream outputStream) {

        this.outputStream = outputStream;
    }
    //使用输出流输出指定字符串
    public void outPut(String content) throws IOException {
        this.outputStream.write(content.getBytes());
    }
    /**
     *
     * @param path 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());
        }
    }
}

StaticResourceUtil

静态资源工具类

public class StaticResourceUtil {
    /**
     * 获取静态资源的绝对路径
     * @param path
     * @return
     */
    public static String getAbsolutePath(String path){
        String absolutePath=StaticResourceUtil.class.getResource("/").getPath();
        return absolutePath.replaceAll("\\\\\\\\","/")+path;
    }

    /**
     * 读取静态资源文件输入流，通过输出流输出
     * @param inputStream
     * @param outputStream
     */
    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;
        }
    }
}