Tomcat源码之旅--最简单的Servlet容器实现

最新推荐文章于 2021-10-14 14:41:36 发布

葵续浅笑

最新推荐文章于 2021-10-14 14:41:36 发布

阅读量971

点赞数

分类专栏： tomcat Tomcat源码之旅文章标签： tomcat java servlet

本文链接：https://blog.csdn.net/lovejj1994/article/details/79615159

版权

Tomcat源码之旅同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

tomcat

2 篇文章 0 订阅

订阅专栏

学习Tomcat源码是因为我之前写的《Spring之我见》系列文章，当学习到spring是如何启动的时候涉及到了tomcat从web.xml读取到ContextLoaderListener，从而初始化spring容器。换句话说，spring启动靠的是tomcat的帮助，这让我想先研究tomcat开始。

tomcat我参考的是《深入剖析Tomcat》，虽然介绍的tomcat比较老，还是tomcat4，但是学习思想是最重要的。而且这本书是教你怎么从零实现一个servlet容器，这种学习方法能够让我们知其然，并知其所以然。

最简单的servlet容器需要几个比较重要的组件

HttpServlet 等待并接受请求
Request 封装Request请求
Response 封装Response请求
ServletProcessor 具体处理Servlet请求
StaticResourceProcessor 具体处理静态页面

HttpServlet 容器的入口

我们先看 HttpServlet ，这段代码本质是ServerSocket 阻塞等待请求，如果拿到了就封装Request和Response,然后根据url分发给不同的处理器，处理完后继续轮询等待请求，直到遇到SHUTDOWN_COMMAND命令关闭程序。

import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.time.LocalDateTime;
import java.util.logging.Logger;

public class HttpServlet {

    private static final Logger log = Logger.getLogger(HttpServlet.class.getName());

//    请求接口
    private static final int port = 8088;
    private static final String SHUTDOWN_COMMAND = "/SHUTDOWN";
    private boolean shutdown = false;

    private void await() {
        ServerSocket serverSocket = null;

        try {
            serverSocket = new ServerSocket(HttpServlet.port, 1, InetAddress.getByName("127.0.0.1"));
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }

        while (true) {
            Socket socket;
            InputStream input;
            OutputStream output;

            try {
                System.out.println("等待指令。。。。" + LocalDateTime.now().toString());
//                从 socket拿到InputStream 和 OutputStream 并封装成 Request 和 Response
                socket = serverSocket.accept();
                input = socket.getInputStream();
                output = socket.getOutputStream();

                Request request = new Request(input);
                request.parse();
                Response response = new Response(output);

                if (SHUTDOWN_COMMAND.equals(request.getUri())) {
                    break;
                }

                response.setRequest(request);

//              根据url 分发任务给 servlet处理器（ServletProcessor） 或者 静态页面处理器 （StaticResourceProcessor）
                if (request.getUri().startsWith("/servlet/")) {
                    ServletProcessor servletProcessor = new ServletProcessor();
                    servletProcessor.process(request, response);
                } else {
                    StaticResourceProcessor staticResourceProcessor = new StaticResourceProcessor();
                    staticResourceProcessor.process(request, response);
                }
                socket.close();
            } catch (Exception e) {

            }
        }
    }

    public static void main(String[] args) {
        HttpServlet httpServlet = new HttpServlet();
        System.out.println("servlet容器启动成功");
        httpServlet.await();
    }
}

Socket的介绍我直接摘百度百科吧

网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket。
建立网络通信连接至少要一对端口号(socket)。socket本质是编程接口(API)，对TCP/IP的封装，TCP/IP也要提供可供程序员做网络开发所用的接口，这就是Socket编程接口；HTTP是轿车，提供了封装或者显示数据的具体形式；Socket是发动机，提供了网络通信的能力。

对于我肤浅的理解。socket就是操作TCP/IP请求的api，给编程人员带来便利，从这点我们也知道，Tomcat的基础是Socket。

Request 与 Response

HttpServlet代码首先提到了Request 和 Response，封装的理由是为了做一些额外的操作，我们看一下Request代码

import javax.servlet.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.util.Enumeration;
import java.util.Locale;
import java.util.Map;
import java.util.logging.Logger;

public class Request implements ServletRequest {

    private static final int BUFFER_SIZE = 2048;
    private InputStream inputStream;
    private String uri;

    private static final Logger log = Logger.getLogger(Request.class.getName());

    /**
     * 解析请求url
     */
    public String parseUri(String requestUri) {
        int index1, index2;

        index1 = requestUri.indexOf(" ");
        if (index1 != -1) {
            index2 = requestUri.indexOf(" ", index1 + 1);
            if (index2 > index1) {
                return requestUri.substring(index1 + 1, index2);
            }
        }
        return null;
    }

    /**
     * 读取inputStream
     */
    public void parse() {
        StringBuffer request = new StringBuffer(2048);
        int i;
        byte[] buffer = new byte[BUFFER_SIZE];
        try {
            i = inputStream.read(buffer);
        } catch (Exception e) {
            log.severe(e.toString());
            i = -1;
        }

        for (int j = 0; j < i; j++) {
            request.append((char) buffer[j]);
        }

        uri = parseUri(request.toString());
    }

    public Request(InputStream inputStream) {
        this.inputStream = inputStream;
    }

    public String getUri() {
        return uri;
    }

    public void setUri(String uri) {
        this.uri = uri;
    }

    public Object getAttribute(String s) {
        return null;
    }

    public Enumeration<String> getAttributeNames() {
        return null;
    }

    public String getCharacterEncoding() {
        return null;
    }

    public void setCharacterEncoding(String s) throws UnsupportedEncodingException {

    }

    public int getContentLength() {
        return 0;
    }

    public long getContentLengthLong() {
        return 0;
    }

    public String getContentType() {
        return null;
    }

    public ServletInputStream getInputStream() throws IOException {
        return null;
    }

    public String getParameter(String s) {
        return null;
    }

    public Enumeration<String> getParameterNames() {
        return null;
    }

    public String[] getParameterValues(String s) {
        return new String[0];
    }

    public Map<String, String[]> getParameterMap() {
        return null;
    }

    public String getProtocol() {
        return null;
    }

    public String getScheme() {
        return null;
    }

    public String getServerName() {
        return null;
    }

    public int getServerPort() {
        return 0;
    }

    public BufferedReader getReader() throws IOException {
        return null;
    }

    public String getRemoteAddr() {
        return null;
    }

    public String getRemoteHost() {
        return null;
    }

    public void setAttribute(String s, Object o) {

    }

    public void removeAttribute(String s) {

    }

    public Locale getLocale() {
        return null;
    }

    public Enumeration<Locale> getLocales() {
        return null;
    }

    public boolean isSecure() {
        return false;
    }

    public RequestDispatcher getRequestDispatcher(String s) {
        return null;
    }

    public String getRealPath(String s) {
        return null;
    }

    public int getRemotePort() {
        return 0;
    }

    public String getLocalName() {
        return null;
    }

    public String getLocalAddr() {
        return null;
    }

    public int getLocalPort() {
        return 0;
    }

    public ServletContext getServletContext() {
        return null;
    }

    public AsyncContext startAsync() throws IllegalStateException {
        return null;
    }

    public AsyncContext startAsync(ServletRequest servletRequest, ServletResponse servletResponse) throws IllegalStateException {
        return null;
    }

    public boolean isAsyncStarted() {
        return false;
    }

    public boolean isAsyncSupported() {
        return false;
    }

    public AsyncContext getAsyncContext() {
        return null;
    }

    public DispatcherType getDispatcherType() {
        return null;
    }
}

Request实现了ServletRequest，大部分方法因为现在用不上所以没有实现，其中parse()方法从inputStream读取请求信息，读取内容范例如下

GET /servlet/TestServlet HTTP/1.1
Host: localhost:8088
Connection: keep-alive
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.162 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9
Cookie: cookie_mobile=15921307683; cookie_user_info="{\"firstName\":\"%E8%B4%BE%E7%A7%8B%E7%94%9F\",\"mobile\":\"15921307683\",\"email\":\"\"}"; cookie_user_org="{\"orgName\":\"%E5%BC%80%E5%8F%91%E7%BB%84\",\"orgCode\":\"006\"}"; sessionid=cc8798be-08f6-4051-936f-988a5c846ad7

而作为最简单的servlet容器，我们先不管Cookie啥信息，只看第一行。嗯，我们读到了是一个GET请求，请求的url是 /servlet/TestServlet ，http协议版本是HTTP/1.1 ，前面说到我们要根据url要分发请求，这就用上了parseUri()方法，它通过字符串处理直接提取出了 “/servlet/TestServlet” 并保存到uri变量。

Response也是同理，多了一个sendStaticResource方法，这个方法是由静态页面处理器（StaticResourceProcessor）直接调用的，用来返回html页面。这个方法现在还没用上，后面会再提。

    public void sendStaticResource() throws IOException {
        byte[] bytes = new byte[BUFFER_SIZE];
        FileInputStream fis = null;

        try {
            File file = new File(WEB_ROOT + "webapp", request.getUri());
            fis = new FileInputStream(file);

            outputStream.write(("HTTP/1.1 200 \r\n"
                    + "Content-Type: text/html\r\n" + "\r\n"
            ).getBytes());

            int ch = fis.read(bytes, 0, BUFFER_SIZE);
            while (ch != -1) {
                outputStream.write(bytes, 0, ch);
                ch = fis.read(bytes, 0, BUFFER_SIZE);
            }


        } catch (Exception e) {
            String errorMsg = "HTTP/1.1 404 File Not Found\r\n"
                    + "Content-Type: text/html\r\n" + "Content-Length: 23\r\n"
                    + "\r\n" + "<h1>File Not Found</h1>";
            outputStream.write(errorMsg.getBytes());
        } finally {
            outputStream.flush();
            outputStream.close();
            if (fis != null) {
                fis.close();
            }
        }
    }

ServletProcessor StaticResourceProcessor 处理的大脑

介绍完了Request和Response，开始进入核心处理类ServletProcessor

ServletProcessor只有一个process方法，接受Request和Response参数，这里面涉及类加载器的，大概流程是通过类加载器加载url中同名的类，然后调用service方法，比如请求url是“/servlet/TestServlet”，“/servlet”说明需要调用servlet处理器（ServletProcessor），然后 “TestServlet”说明调用同名的TestServlet类。

ServletProcessor：


import javax.servlet.Servlet;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.io.File;
import java.net.URL;
import java.net.URLClassLoader;
import java.net.URLStreamHandler;
import java.util.logging.Logger;

public class ServletProcessor {

    private static final Logger log = Logger.getLogger(HttpServlet.class.getName());

    public void process(Request request, Response response) {
        String uri = request.getUri();
        String servletName = uri.substring(uri.lastIndexOf("/") + 1);

        URLClassLoader loader = null;

        try {
            URL[] urls = new URL[1];
            URLStreamHandler streamHandler = null;
            File classPath = new File(Response.WEB_ROOT + "servlet" + File.separator);
            String repository = (new URL("file", null, classPath.getCanonicalPath() + File.separator)).toString();

            urls[0] = classPath.toURI().toURL();

            loader = new URLClassLoader(urls);
        } catch (Exception e) {
            log.severe(e.toString());
        }

        Class myClass = null;

        try {
            myClass = loader.loadClass("servlet." + servletName);
        } catch (Exception e) {
            log.severe(e.toString());
        }

        Servlet servlet;

        try {
            servlet = (Servlet) myClass.newInstance();

//            使用包装类，可以让Servlet开发者接触不到parseUri等方法
            RequestWrapper requestWrapper = new RequestWrapper(request);
            ResponseWrapper responseWrapper = new ResponseWrapper(response);

            servlet.service(requestWrapper, responseWrapper);
        } catch (Exception e) {
            log.severe(e.toString());
        }
    }
}

TestServlet：继承标准的Servlet接口，复写service方法，service方法会由ServletProcessor调用，到这一块对于学习了Servlet的人就很熟悉了。

package servlet;

import javax.servlet.*;
import java.io.IOException;
import java.io.PrintWriter;

public class TestServlet implements Servlet {

    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
        System.out.println("TestServlet init");
    }

    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

    @Override
    public void service(ServletRequest req, ServletResponse res) throws IOException {
        System.out.println("TestServlet service ");
        PrintWriter writer = res.getWriter();
        writer.println("HTTP/1.1 200 \r\n"
                + "Content-Type: text/html\r\n" + "\r\n" + "hello , it is TestServlet");
    }

    @Override
    public String getServletInfo() {
        return null;
    }

    @Override
    public void destroy() {
        System.out.println("TestServlet destroy");
    }
}

这里面有一点改进的地方在于：对于TestServlet 来说，是客户端程序员会编写的类，而ServletProcessor做了什么是不需要关心的，但是service会拿到ServletProcessor给的ServletRequest 和ServletResponse 变量，也就是Request和Response对象，而我们知道Request和Response有一些拓展方法比如 parseUri，这些是不允许客户端程序员通过强转来调用的。那如何保证安全性呢？

我们可以通过外观类来实现，我们设计一个外观类RequestWrapper ，它拥有一个Request对象，一般方法都直接调用Request的方法，而对于私密的方法不暴露在RequestWrapper 类中，达到调用安全的目的。

ResponseWrapper一样，不再贴出代码


import javax.servlet.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Enumeration;
import java.util.Locale;
import java.util.Map;

public class RequestWrapper implements ServletRequest {

    private Request request;


    public RequestWrapper(Request request) {
        if (request == null) {
            throw new IllegalArgumentException("Request cannot be null");
        }
        this.request = request;
    }

    @Override
    public Object getAttribute(String name) {
        return request.getAttribute(name);
    }

    @Override
    public Enumeration<String> getAttributeNames() {
        return request.getAttributeNames();
    }

    @Override
    public String getCharacterEncoding() {
        return null;
    }

    @Override
    public void setCharacterEncoding(String env) throws UnsupportedEncodingException {

    }

    @Override
    public int getContentLength() {
        return 0;
    }

    @Override
    public long getContentLengthLong() {
        return 0;
    }

    @Override
    public String getContentType() {
        return null;
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        return null;
    }

    @Override
    public String getParameter(String name) {
        return null;
    }

    @Override
    public Enumeration<String> getParameterNames() {
        return null;
    }

    @Override
    public String[] getParameterValues(String name) {
        return new String[0];
    }

    @Override
    public Map<String, String[]> getParameterMap() {
        return null;
    }

    @Override
    public String getProtocol() {
        return null;
    }

    @Override
    public String getScheme() {
        return null;
    }

    @Override
    public String getServerName() {
        return null;
    }

    @Override
    public int getServerPort() {
        return 0;
    }

    @Override
    public BufferedReader getReader() throws IOException {
        return null;
    }

    @Override
    public String getRemoteAddr() {
        return null;
    }

    @Override
    public String getRemoteHost() {
        return null;
    }

    @Override
    public void setAttribute(String name, Object o) {

    }

    @Override
    public void removeAttribute(String name) {

    }

    @Override
    public Locale getLocale() {
        return null;
    }

    @Override
    public Enumeration<Locale> getLocales() {
        return null;
    }

    @Override
    public boolean isSecure() {
        return false;
    }

    @Override
    public RequestDispatcher getRequestDispatcher(String path) {
        return null;
    }

    @Override
    public String getRealPath(String path) {
        return null;
    }

    @Override
    public int getRemotePort() {
        return 0;
    }

    @Override
    public String getLocalName() {
        return null;
    }

    @Override
    public String getLocalAddr() {
        return null;
    }

    @Override
    public int getLocalPort() {
        return 0;
    }

    @Override
    public ServletContext getServletContext() {
        return null;
    }

    @Override
    public AsyncContext startAsync() throws IllegalStateException {
        return null;
    }

    @Override
    public AsyncContext startAsync(ServletRequest servletRequest, ServletResponse servletResponse) throws IllegalStateException {
        return null;
    }

    @Override
    public boolean isAsyncStarted() {
        return false;
    }

    @Override
    public boolean isAsyncSupported() {
        return false;
    }

    @Override
    public AsyncContext getAsyncContext() {
        return null;
    }

    @Override
    public DispatcherType getDispatcherType() {
        return null;
    }
}

而对于静态页面处理器就更简单了，只有一个方法，方法也只有一句话

sendStaticResource方法就是之前写在Response 的拓展方法。通过File读取servlet容器中预存的html页面，然后通过outputStream发出去。

/**
 * http://localhost:8080/index.html
 */
public class StaticResourceProcessor {

    public void process(Request request, Response response) {
        try {
            response.sendStaticResource();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

结语

大致的流程就是这些，这是最简单的servlet容器，本书会一层层深入，完整代码可以看我的项目SimpleServlet ，我会跟着看书的进度同时更新代码和文章

对应的分支是v1.1

https://github.com/lovejj1994/SimpleServlet

葵续浅笑

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
2
评论
Tomcat源码之旅--最简单的Servlet容器实现

学习Tomcat源码是因为我之前写的《Spring之我见》系列文章，当学习到spring是如何启动的时候涉及到了tomcat从web.xml读取到ContextLoaderListener，从而初始化spring容器。换句话说，spring启动靠的是tomcat的帮助，这让我想先研究tomcat开始。tomcat我参考的是《深入剖析Tomcat》，虽然介绍的tomcat比较老，还是tomcat...
复制链接

扫一扫

专栏目录