【深入剖析Tomcat笔记】第三篇 基本容器模型

简述

简单回顾一下上文,上文中我们通过ServerSocket和Socket类实现基本的Socket连接。此篇我们将DemoServer进行重构。上篇最后,我们发现了一些问题,但这些问题无法进行整体性解决,因此我们将项目进行更为合理的拆分成独立的模块。
结构图
重构后结构图如上。重构之后,主要分为Connecor、Processor、Response、Request几个模块

测试源码方法请参考【深入剖析Tomcat笔记】第二篇 ServerSocket模型
此篇Demo中Servlet测试需要自己配置Servlet。

本期源代码:
practice-tomcat


Connector模块

相比起上一篇中的简单Socket连接,容器所遇到的启动场景会越来越复杂,针对于不同的使用场景,Socket在接入方案上就需要提供更多的选择。因此,有别于之前的简单创建,我们将ServerSocket实例化场景单独抽象为一个模块Connector。
对于ServerSocket初始化参数(*int port , int backlog , InetAddress bindAddr)
在实际使用中,我们通常会基于文件配置的形式提供状态无关的配置。Connector实例拆分,可以模块化提供基于文件的配置,如maxIdle,maxKeepAliveRequests等属性的配置,在实际Tomcat配置中< connector >标签中承担的是Connector的配置工作。
对于Connector模块进行梳理,在Connector所提供的的核心功能包括:
1. 创建ServerSocket
2. 请求接入
3. 请求处理

将请求接入和请求处理 模块分离,这样做的优势在于

1. 模块化,代码条理更清晰
2. 为多线程处理提供了条件
3. 扩展性增强

代码如下

    /**
     * 连接器连接操作
     * 创建ServerSocket
     * 接入请求
     * 调用Prossor进行处理
     */
    void connect() {
        ServerSocket serverSocket = null;
        int port = 8080;
        //1.创建ServerSocket
        try {
            serverSocket = new ServerSocket(port, 1, InetAddress.getByName("localhost"));
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(1);
        }

        //若非终止参数,则循环接入请求
        while (!stopped) {
            Socket socket = null;
            try {
                //2.socket请求接入
                socket = serverSocket.accept();

                //判断是否由于端口映射造成的二次访问
                if(socket.getLocalPort() != port)
                    continue;

            } catch (IOException e) {
                e.printStackTrace();
            }

            //3.Socket请求转交Processor处理
            HttpProcessor processor = new HttpProcessor ();
            processor.process(socket);
        }
    }

Processor模块

Processor承担了主要的解析逻辑,在实际使用场景中,解析的场景更加多样化,例如对HTTP的解析和对于SMTP的解析是不同的场景。实际上Processor是对于四层网络模型中应用层的解析场景,例如实际中Tomcat中对于Http的解析提供的Processor是HttpProcessor。
Processor模块的主要职责:
1. 请求头解析
2. Request构造
3. Response构造
4. 请求解析

代码如下

    /**
     * 解析器解析
     * @param socket Socket请求
     */
    public void process(Socket socket) {
        SocketInputStream input = null;
        OutputStream output = null;
        try {
               //Request构造
                input = socket.getInputStream();
                if(input == null)
                    continue;

                Request request = new Request(input);
                request.parse();

                if(request.getUri() == null)
                    continue;

                //Request构造
                output = socket.getOutputStream();
                Response response = new Response(output);
                response.setRequest(request);

                //请求解析
                if(request.getUri().startsWith("/servlet/")) {
                    ServletProcessor processor = new ServletProcessor();
                    processor.process(request, response);
                } else {
                    StaticResourceProcessor processor = new StaticResourceProcessor();
                    processor.process(request, response);
                }

                response.sendStaticResource();
                socket.close();

                shutdown = request.getUri().equals(SHUTDOWN_COMMEND);
            } catch (IOException e) {
                e.printStackTrace();
                System.exit(1);
            }
    }

对应Processor有两个实现ServletProcessor和StaticResourceProcessor,在解析请求行后,对于请求类型进行判断,决定调用哪种解析器。实例代码中,为了简化配置,使用了”/servlet/”进行判断,实际使用中,我们通过web.xml进行Servlet配置。这里不难将xml映射关系转化为ServletProcessor解析判断的请求行。

StaticResourceProcessor是对静态资源的解析,例如:index.html,icon.jpg等文件。
在此处实际代码为,具体实现见Response。

     public void process(Request request, Response response) {

        response.sendStaticResource();
    }

ServletProcessor是对Servlet的解析,由于Servlet解析是动态解析,所以此处需要加载运行在平台之上的Servlet服务。此处需要用到java.net.URLClassLoader对Servlet服务进行加载。

    /**
     * 动态Servlet处理
     * @param request 请求 处理
     * @param response 结果处理
     */
    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];
            File classPath = new File(Constants.WEB_ROOT);

            /**
             * 因为URL类还有一个构造方法URL(String protocol, String host, String file)
             * 编译器可能造成无法识别
             * 这里还可以写作
             * urls[0] = new URL(null, repository, (URLStreamHandler)null);
             */
            URLStreamHandler streamHandler = null;
            String repository = (new URL("file", null, classPath.getCanonicalPath() + File.separator)).toString();

            urls[0] = new URL(null, repository, streamHandler);
            loader = new URLClassLoader(urls);
        } catch (IOException e) {
            e.printStackTrace();
        }

        //ClassLoader加载Servlet服务
        Class myClass = null;
        try {
            myClass = loader.loadClass(servletName);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        //RequestFacade和ResponseFacade包装类
        //Servlet实例化,载入service()
        Servlet servlet = null;
        RequestFacade requestFacade = new RequestFacade(request);
        ResponseFacade responseFacade = new ResponseFacade(response);
        try {
            servlet = (Servlet) myClass.newInstance();
            servlet.service((ServletRequest) requestFacade, (ServletResponse) responseFacade);
        } catch (ServletException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

Request模块

Request是对外部请求的封装,在Processor中Request用到的主要包括对请求行解析和请求头解析,构造方法如下

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

在第一章中我们了解到,HTTP协议请求行格式为 “GET /index.html HTTP/1.1”,取第一个空格前字符串记录为Method = “GET”,取第二个空格前第一个空格后字符串记录为uri = “/index.html”,取第二个空格后字符串为Protocol = “HTTP/1.1”。

public void parse() {
        StringBuffer requset = new StringBuffer(BUFFER_SIZE);
        int i;
        byte[] buffer = new byte[BUFFER_SIZE];
        try {
            i = inputStream.read(buffer);
        } catch (IOException e) {
            e.printStackTrace();
            i = -1;
        }
        for (int j = 0; j < i; j++) {
            requset.append((char) buffer[j]);
        }
        System.out.println(requset.toString());
        uri = parseUri(requset.toString());
    }

    //解析请求行
    String parseUri(String requestString) {
        int index1, index2;
        index1 = requestString.indexOf(' ');
        if(index1 != -1) {
            index2 = requestString.indexOf(' ', index1 + 1);
            return index2 > index1 ? requestString.substring(index1 + 1, index2) : null;
        }
        return null;
    }

Response模块

Response在Processor中用到的方法主要是sendStaticResource(),将静态资源进行转发。

public void sendStaticResource() {
        byte[] bytes = new byte[BUFFER_SIZE];
        FileInputStream fis = null;
        if(request == null)
            return;
        File file = new File(Constants.WEB_ROOT, request.getUri());
        try {
            if(file.isFile()) {
                fis = new FileInputStream(file);
                int ch = fis.read(bytes, 0, BUFFER_SIZE);
                while (ch != -1) {
                    outputStream.write(bytes, 0, ch);
                    ch = fis.read(bytes, 0, BUFFER_SIZE);
                }
            } else {
                String errorMessage = "HTTP/1.1 404 File Not Found\r\n" +
                        "Content-Type: text/html\r\n" +
                        "Content-Length: 23\n\n" +
                        "\r\n" +
                        "<h1>File Not Found</h1>";
                outputStream.write(errorMessage.getBytes());
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if( fis != null)
                    fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return;
    }

Facade类

包装类主要用于解决访问性问题,一条很通用的设计原则是

第13条使类和成员的可访问性最小化
要区别设计良好的模块与设计不好的模块,最重要的因素在于,这个模块对于外部的其他模块而言,是否隐藏其内部数据和其他实现细节。设计良好的模块会隐藏所有的设计细节,把它的API与它的实现清晰地隔离开来。然后,模块之间只通过他们的API进行通信,一个模块不需要知道其他模块的内部工作情况。这个概念被称为信息隐藏或封装,是软件设计的基本原则之一。
–《Effective Java》

信息隐藏可以解除模块间的耦合关系,使这些模块可以独一的开发、测试和优化。并使模块更为清晰的结构,易于理解,易于性能评测,易于整体性优化,易于重构。
Java对于此方面的主要实现是通过多态实现 访问控制 ,访问控制最基本的使用是访问控制修饰符实现,但仅仅使用 访问权限修饰符 在面向接口设计方面,也会产生一些问题。

从源码来看

        ...
        //RequestFacade和ResponseFacade包装类
        //Servlet实例化,载入service()
        Servlet servlet = null;
        RequestFacade requestFacade = new RequestFacade(request);
        ResponseFacade responseFacade = new ResponseFacade(response);
        try {
            servlet = (Servlet) myClass.newInstance();
            servlet.service((ServletRequest) requestFacade, (ServletResponse) responseFacade);
       ...

因为使用面向接口编程,这里子类都被转化为ServletRequest,面向接口是一种普遍方案,但在这里会造成一个问题

    //Client代码
    protected void doPost(ServletRequest req, ServletResponse resp) throws ServletException, IOException {
        req = (Request)req;
        //回顾parse()方法,其访问性控制是public,这一点是无可厚非的
        //public的可访问性是针对Tomcat项目内部,并不针对项目外部
        //但Client端完全可以通过类型下转,转换为Request调用parse方法
        //这样的使用是危险的
        req = req.parse();
        ...

在这里Tomcat使用了Facade设计模式(外观设计模式)

Facade设计模式
为子系统中的一组接口提供一个一致的界面,Facade模式定义了一个高层接口,这个接口使得这一子系统更容易使用。
–《设计模式》

Facade优势有:

- Client屏蔽子系统组件,减少客户处理对象的数目并使得子系统使用起来更加方便
- 它实现了子系统与客户之间的松耦合关系,而子系统内部的功能组件往往是斤耦合的。减少这种耦合关系对于Client的影响
- 不限制子系统类,可以易用性和通用性之间选择

实际的UML关系如下
Response&Request Facade UML Structrue

public class RequestFacade implements ServletRequest {
    private ServletRequest request = null;

    //构造方法
    public RequestFacade(Request request) {
        this.request = request;
    }

    //实际使用调用Request对应方法实现,其他方法类似
    public Object getAttribute(String attribute) {
        return request.getAttribute(attribute);
    }
    ...

采用Facade模式后,Client端 再执行 req = (Request)req 由于Request类和RequestFacade没有继承关系,所以类型转换会失败,且对外提供的ServletRequest 接口实现不会受到影响。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值