深入剖析Tomcat 第二章一个简单的Servlet服务器

秒速五厘米 2022-10-01 00:59 84阅读 0赞

## 第一部分：概述 ##

这一篇基于《深度剖析Tomcat》第二章： 一个简单的Servlet服务器 总结而成。

上一篇，了解了一个简单的Web服务器的总体处理流程是怎样的；这一节，开始搭建一个简单的Servlet容器，也就是增加实现了servlet的简单加载执行，而不仅仅是将文件内容输出到浏览器上。当然，这一节的servlet的实现是最简单的，用来了解整个Servlet的大致工作流程。

说到servlet，首先得先了解 javax.servlet.Servlet 接口。Servlet接口中的方法描述了servlet的生命周期方法，即init()、service()和destroy()。我们自己实现的所有servlet必须实现这个接口或者继承实现了这个接口的类(最一般的情况就是继承HttpServlet)。对于servlet生命周期的方法就不在这里具体描述了，可以自行查询关于servlet生命周期的资料。在这里只要知道Servlet接口可以完成如下三个功能：

在请求第一次到来时初始化servlet；
    对每次请求调用service()方法执行请求；
    servlet关闭时调用destroy()方法销毁servlet；

一个Http请求过来时，Servlet服务器经历以下过程：

*  Server创建一个serverSocket对象，等待Client发送请求
 *  Client发送请求后，Server获取用户socket，从而得到请求的输入输出流
 *  从输入输出流中创建request和response对象
 *  解析request，如果是静态资源就创建StaticResourceProcessor实例，传递请求和响应给对应的方法，具体方法就是：从request中获取URI，判断文件是否存在，如果不存在就响应404，存在则将文件内容写到浏览器；如果是servlet请求就创建ServletProcessor1实例，同样传递请求和响应给对应的方法，完成加载servlet和调用Servlet的service方法执行。
 *  关闭用户socket
 *  判断URI是否为/SHUTDOWN，如果不是则重新进入等待请求状态，回到第2步，否则关闭服务器  
    整个流程主要包含5个类，HttpServer1、ServletProcessor1、StaticResourceProcessor、Request、Response。

HttpServer1.java：完成创建ServerSocket对象，获取Socket对象及其输入输出流，解析请求，创建Request对象和Response对象，并将不同类型的请求分派给不同的Processor处理

ServletProcessor1.java:当请求servlet时创建的对象，用于加载和执行servlet。

StaticResourceProcessor.java:当请求的资源是静态资源时创建的对象，调用Response对象的sendStaticResource()处理静态资源

Request.java：与上一节基本一样，是对输入流解析实现，获取URI。不同之处在于实现javax.servlet.ServletRequest 接口，这一节中除了解析请求的方法外，其它未实现的方法置为默认值。

Reponse.java：与上一节基本一样，完成对浏览器的响应，包含对请求文件存在与不存在的处理。不同之处在于实现 javax.servlet.ServletResponse接口，这一节中除了getWriter方法外，其它未实现的方法置为默认值。

注意：在这一节中有些东西看起来是不合理的，以后的章节中会改进：

Servlet接口仅仅是调用了service方法，没有调用init方法和destroy方法
    每一个servlet被请求时，servlet类就被加载一次

代码陈述更方便，下面开始将结合代码讲解。

## 第二部分：代码讲解 ##

HttpServer1.java 这个类和上一节HttpServer的非常相似。

不同之处只有在判断请求的类型时进行if-else处理，而不是直接用上一节的response.sendStaticResource()直接将文件内容写到浏览器

对应的，如果判断确实是请求静态资源（即URL不以/servlet/开头）就调用StaticResourceProcessor处理器的process方法，显示文件到浏览器中

反之，如果判断是servlet，调用ServletProcessor1的process方法加载和执行servlet。

package ex02.pyrmont;
    	
    	import java.net.Socket;
    	import java.net.ServerSocket;
    	import java.net.InetAddress;
    	import java.io.InputStream;
    	import java.io.OutputStream;
    	import java.io.IOException;
    	
    	public class HttpServer1 { 
    
        // 用于判断是否需要关闭服务器，默认是false
        private static final String SHUTDOWN_COMMAND = "/SHUTDOWN";
        private boolean shutdown = false;
    
        public static void main(String[] args) { 
            HttpServer1 server = new HttpServer1();
            server.await();
        }
    
        public void await() { 
    
            ServerSocket serverSocket = null;
            int port = 8080;
            try { 
                //创建服务器端的ServerSocket
                serverSocket = new ServerSocket(port, 1,
                        InetAddress.getByName("127.0.0.1"));
            } catch (IOException e) { 
                e.printStackTrace();
                System.exit(1);
            }
    
            while (!shutdown) { 
                Socket socket = null;
                InputStream input = null;
                OutputStream output = null;
                try { 
                    socket = serverSocket.accept();//Server一直等待直到Client发送请求
                    input = socket.getInputStream();//接收请求后获取输入输出流
                    output = socket.getOutputStream();
    
                    //创建request对象，传入input参数用于获取输入流的参数
                    Request request = new Request(input);
                    request.parse();//解析request对象，这一节同样也只是获取请求中请求行的URI
    
                    //创建response对象，传入output对象用于获取Writer对象
                    Response response = new Response(output);
                    response.setRequest(request);
    
                    //下面是这个类的关键所在
                    //当URL是以/servlet/开头时说明请求servlet，使用ServletProcessor1处理器处理
                    //否则说明是请求静态资源，由StaticResourceProcessor处理器处理
                    if (request.getUri().startsWith("/servlet/")) { 
                        ServletProcessor1 processor = new ServletProcessor1();
                        processor.process(request, response);
                    } else { 
                        StaticResourceProcessor processor = new StaticResourceProcessor();
                        processor.process(request, response);
                    }
    
                    //关闭用户socket
                    socket.close();
                    //如果URI是/SHUTDOWN说明需要关闭服务器
                    shutdown = request.getUri().equals(SHUTDOWN_COMMAND);
                } catch (Exception e) { 
                    e.printStackTrace();
                    System.exit(1);
                }
            }
        }
    }

HttpServer1.java的详细说明

可以参照第一节的HttpServer.java的详细说明

由此类可以看出：

要请求一个静态资源，你可以在你的浏览器地址栏或者网址框里边敲入一个URL：[http://machineName][http_machineName]:port/staticResource。  
要请求一个 servlet，你可以使用下面的URL：[http://machineName][http_machineName]:port/servlet/servletClass

ServletProcessor1.java这个类是这一节的关键类

仅仅只有一个process方法，但方法内部却没那么简单。先上代码

package ex02.pyrmont;
    	
    	import java.net.URL;
    	import java.net.URLClassLoader;
    	import java.net.URLStreamHandler;
    	import java.io.File;
    	import java.io.IOException;
    	
    	import javax.servlet.Servlet;
    	import javax.servlet.ServletRequest;
    	import javax.servlet.ServletResponse;
    	
    	public class ServletProcessor1 { 
    
        public void process(Request request, Response response) { 
    
            String uri = request.getUri();// 获取URI,如/servlet/className
            // 要知道servlet名，截取第二段，即可获得className
            String servletName = uri.substring(uri.lastIndexOf("/") + 1);
            URLClassLoader loader = null;
    
            try { 
                //try块中用于创建URLClassLoader对象
                URL[] urls = new URL[1];
                URLStreamHandler streamHandler = null;
                //Constants类存储静态常量，在本节最后贴上。
                //Constants.WEB_ROOT即System.getProperty("user.dir") + File.separator + "webroot";
                File classPath = new File(Constants.WEB_ROOT);
                String repository = (new URL("file", null,
                        classPath.getCanonicalPath() + File.separator)).toString();
                urls[0] = new URL(null, repository, streamHandler);
                //经过以上过程后可以得到类似“file:E:/java/tomcat/servletName/”的路径
                //最后URLClassLoader对象根据这个url获取到相应路径下serlvet的类加载器
                loader = new URLClassLoader(urls);
    
            } catch (IOException e) { 
                System.out.println(e.toString());
            }
            Class myClass = null;
            try { 
                myClass = loader.loadClass(servletName);  //根据反射获取Class对象
            } catch (ClassNotFoundException e) { 
                System.out.println(e.toString());
            }
    
            Servlet servlet = null;
            try { 
                servlet = (Servlet) myClass.newInstance();//创建Servlet实例
                servlet.service((ServletRequest) request,//执行servlet
                        (ServletResponse) response);
            } catch (Exception e) { 
                System.out.println(e.toString());
            } catch (Throwable e) { 
                System.out.println(e.toString());
            }
    
        }
    }

ServletProcess1.java详细说明：

要加载 servlet，你可以使用 java.net.URLClassLoader 类，它是 java.lang.ClassLoader类的一个直接子类。  
public URLClassLoader(URL\[\] urls); 这里 urls 是一个 java.net.URL 的对象数组，这些对象指向了加载类时候查找的位置。任何以/结尾的 URL 都假设是一个目录。  
类加载器必须查找的地方只有一个，如工作目录下面的 webroot目录。因此，我们首先创建一个单个 URL 组成的数组。URL 类提供了一系列的构造方法，所以有很多构造一个 URL 对象的方式。  
一旦你拥有一个 URLClassLoader 实例，你使用它的 loadClass 方法去加载一个 servlet 类。(实在不懂怎么用可以自己查看API或者百度谷歌一下)  
然后，process 方法创建一个 servlet 类加载器的实例, 把它向下转换(downcast) 为 javax.servlet.Servlet, 并调用 servlet 的 service 方法  
这里的servlet是自己定义的，如PrimitiveServlet.java，前面说了，我们自己所有的servlet必须实现这个接口或者继承实现了这个接口的类

访问时用http://machineName:port/servlet/PrimitiveServlet访问即可

package ex02.pyrmont;
    	
    	import javax.servlet.*;
    	import java.io.IOException;
    	import java.io.PrintWriter;
    	
    	public class PrimitiveServlet implements Servlet { 
    
        public void init(ServletConfig config) throws ServletException { 
            System.out.println("init");
        }
    
        public void service(ServletRequest request, ServletResponse response)
                throws ServletException, IOException { 
            System.out.println("from service");
    
            PrintWriter out = response.getWriter();
            out.println("Hello. Roses are red.");
            out.print("Violets are blue.");
        }
        public void destroy() { 
            System.out.println("destroy");
        }
        public String getServletInfo() { 
            return null;
        }
        public ServletConfig getServletConfig() { 
            return null;
        }
    }

Request.java、Response.java

这两个类内容很多而且不是本节关键代码，大家可以根据概述部分对这两个类的简单介绍，并结合我的github上的Tomcat4的代码找到ex02.pyrmont包下的这两个类，最后与上一节这两个类的代码(对应ex01.pyrmont包)对比以下。应该就没什么大问题，这里就不说了

下面的是Constants.java，打消大家的疑虑

package ex02.pyrmont;
    	
    	import java.io.File;
    	
    	public class Constants { 
    	  public static final String WEB_ROOT =
    	    System.getProperty("user.dir") + File.separator  + "webroot";
    	}

ServletProcessor2.java

ServletProcess1.java改成ServletProcess2.java，使用RequestFacade和ResponseFacade进行封装

改变的内容不多，如下

Servlet servlet = null;
    	RequestFacade requestFacade = new RequestFacade(request);
    	ResponseFacade responseFacade = new ResponseFacade(response);
    	try { 
    	  servlet = (Servlet) myClass.newInstance();
    	  servlet.service((ServletRequest) requestFacade, (ServletResponse) responseFacade);
    	}

当然，HttpServer1.java改为HttpServer2.java，改变之处只有一个地方，即创建ServletProcess1实例改成ServletProcess2实例

## 第三部分：代码安全性问题 ##

在 ServletProcessor1 类的 process 方法，你向上转换ex02.pyrmont.Request 实例为 javax.servlet.ServletRequest ，并作为第一个参数传递给servlet 的 service 方 法 。 你 也 向 下 转 换 ex02.pyrmont.Response 实 例 为javax.servlet.ServletResponse，并作为第二个参数传递给 servlet 的 service 方法。

try { 
    	    servlet = (Servlet) myClass.newInstance();
    	    servlet.service((ServletRequest) request,(ServletResponse) response);
    	}

这会危害安全性。知道这个 servlet 容器的内部运作的 Servlet 程序员可以分别把ServletRequest 和 ServletResponse 实例向下转换为 ex02.pyrmont.Request 和 ex02.pyrmont.Response，并调用他们的公共方法。拥有一个 Request 实例，它们就可以调用 parse方法。拥有一个 Response 实例，就可以调用 sendStaticResource 方法。

为了解决这个问题，我们增加了两个 façade 类: RequestFacade 和 ResponseFacade。RequestFacade 实现了 ServletRequest 接口并通过在构造方法中传递一个引用了 ServletRequest 对象的 Request 实例作为参数来实例化。ServletRequest 接口中每个方法的实现都调用了 Request 对象的相应方法。然而 ServletRequest 对象本身是私有的，并不能在类的外部访问。我们构造了一个 RequestFacade 对象并把它传递给 service 方法，而不是向下转换Request 对象为 ServletRequest 对象并传递给 service 方法。 Servlet 程序员仍然可以向下转换ServletRequest 实例为 RequestFacade，不过它们只可以访问 ServletRequest 接口里边的公共方法。现在 parseUri 方法就是安全的了。

上面这段话怎么理解呢？

其实就是门面模式（Facade Pattern）。门面模拟式简单来说就说屏蔽某些方法，让外部无法访问。字面上意思就是只看到门口的内容。

现在用上面的例子中的PrimitiveServlet.java，如果在service()添加如下注释掉的代码

前两行注释：结果是虽然可以强制转换为Request对象且可以调用parse()这个私有方法，但是是运行不了了，将会抛异常

后两行注释：结果是第一行可以正常的转换，但是第二行是没有这个方法的，调用不了

public void service(ServletRequest request, ServletResponse response)
    	            throws ServletException, IOException { 
    	        System.out.println("from service");
    	        //Request requestTest = (Request)request;
    	        //requestTest.parse(); //虽然可以调用，但是是报错的
    	        //RequestFacade requestFacadeTest = (RequestFacade)request;
    	        //requestFacadeTest.parse(); 发现没有这个方法 
    	        PrintWriter out = response.getWriter();
    	        out.println("Hello. Roses are red.");
    	        out.print("Violets are blue.");
    	}

如果还是不懂，下面有个我自己写来测试的代码。

ServletReq模拟javax.servlet.ServletRequest

Req模拟ex02.pyrmont.Request接口(所以这个类实现了模拟Tomcat的标准接口ServletRequest的ServletReq)

ReqFacade模拟ex02.pyrmont.RequestFacade(封装了Req)

setAttribute方法模拟了大家都通用的方法

main函数中，对应代码第8行中标准的ServletReq确实可以顺利转换为Req实体类

但是调用方法后，会报如下错误：

Exception in thread “main” java.lang.ClassCastException: ex02.pyrmont.ReqFacade cannot be cast to ex02.pyrmont.Req at ex02.pyrmont.MyTest.main(MyTest.java:10)

这就保证了安全性，明白了吗？

public class MyTest { 
    
    	    public static void main(String[] args){ 
    	
    	        Req request = new Req();
    	        ReqFacade requestFacade = new ReqFacade(request);
    	        ServletReq servletReq = (ServletReq)requestFacade;
    	        Req req = (Req)servletReq;
    	        req.parse();
    	    }
    	}
    
    	interface ServletReq{ 
    	    void setAttribute();
    	}
    
    	class Req implements ServletReq{ 
    
    	    @Override
    	    public void setAttribute() { 
    	        System.out.println("AAA");
    	    }
    	
    	    public void parse(){ 
    	
    	        System.out.println("AAA2");
    	    }
    
    	}
    	class ReqFacade implements ServletReq{ 
    
    	    private Req b;
    	    ReqFacade(Req b){ 
    	
    	        this.b = b;
    	    }
    	    @Override
    	    public void setAttribute() { 
    	
    	        b.setAttribute();
    	    }
    	}

## 第四部分：小结 ##

完成了根据判断不同的URI对servlet请求和静态资源请求分别处理的简单实现，相比上一节难度大了一些。

[http_machineName]: http://machineName