一个简单servlet容器

一个简单servlet容器

2.1 javax.servlet.Servlet接口

• Servlet编程需要使用javax.servlet和javax.servlet.http两个包下的接口和类
• 在所有的类中javax.servlet.Servlet接口是最重要的。所有的servlet程序都必须实现该接口或继承实现了该接口的类
• tomcat8中该接口如下：

•   package javax.servlet;
    import java.io.IOException;
    public interface Servlet {
        public void init(ServletConfig config) throws ServletException;
        public ServletConfig getServletConfig();
        public void service(ServletRequest req, ServletResponse res)
                throws ServletException, IOException;
        public String getServletInfo();
        public void destroy();
    }
  

• 在Servlet接口中，init()、service()和destroy()方法是和servlet生命周期相关的方法。当实例化某个servlet类后，servlet容器就会调用其init()方法进行初始化。servlet容器只会调用该方法一次，调用后则可以执行service()方法了。
• 在servlet接收任何请求之前，必须是经过初始化的。该方法可以进行覆盖，自定义初始化。
• 当servlet的一个客户端请求到达后，servlet容器就调用相应的servlet的service方法，并将 javax.servlet.ServletRequest对象和javax.servlet.ServletResponse对象作为参数传入。
• ServletRequest对象包含客户端的HTTP请求信息，ServletResponse对象则封装servlet的响应信息。
• 在整个servlet周期内，service会被多次调用。
• 在将servlet容器从服务中移除之前，servlet容器会调用servlet实例的destory方法。
• 使用PrimitiveServlet来测试servlet容器应用程序

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

2.2应用程序1

• 对一个Servlet的每个HTTP请求，一个功能齐全的servlet容器需要做到以下几点：
  • 当第一次调用某个servlet时，要载入该servlet类，并调用其init方法
  • 针对每一个request请求，创建一个javax.servlet.ServletRequest实例和一个javax.servlet.ServletResponse实例
  • 调用该servlet的service方法，将ServletRequest对象和ServletResponse对象作为参数传入
  • 当关闭servlet类时，调用destory方法
• 接下来建立一个Servlet容器，功能如下：
  • 等待HTTP请求
  • 创建一个ServletRequest对象和一个ServletResponse对象
  • 若请求静态资源，则调用StaticResourceProcessor对象的process方法，传入上面的两个对象
  • 若请求servlet，则载入相应的servlet类，调用其service方法。
  • 类关系UML图如下：
  • 
  • 基于Java的Servlet容器实现，需要调用Java提供的有关接口，比如javax.servlet.ServletRequest和javax.servlet.ServletResponse。
  • 任何一个Servlet都需要实现Servlet接口或者继承实现该接口的类。
  • 具体的请求过程以及类型如图：
  • 
• 代码示例：

  •   if (request.getUri().startsWith("/servlet/")) {
        ServletProcessor1 processor = new ServletProcessor1();
        processor.process(request, response);
      }
      else {
        StaticResourceProcessor processor = new StaticResourceProcessor();
        processor.process(request, response);
      }
    

  • 在上面代码中可以看出对于静态资源使用StaticResourceProcessor容器，对于动态Servlet资源使用ServletProcessor1容器

  •   package ex02.pyrmont;
      public class ServletProcessor1 {
      public void process(Request request, Response response) {
              String uri = request.getUri();
              String servletName = uri.substring(uri.lastIndexOf("/") + 1);
              URLClassLoader loader = null;
    
              try {
                  // create a URLClassLoader
                  URL[] urls = new URL[1];
                  URLStreamHandler streamHandler = null;
                  File classPath = new File(Constants.WEB_ROOT);
                  // the forming of repository is taken from the createClassLoader method in
                  // org.apache.catalina.startup.ClassLoaderFactory
                  String repository = (new URL("file", null, classPath.getCanonicalPath() + File.separator)).toString() ;
                  // the code for forming the URL is taken from the addRepository method in
                  // org.apache.catalina.loader.StandardClassLoader class.
                  urls[0] = new URL(null, repository, streamHandler);
                  loader = new URLClassLoader(urls);
              }
              catch (IOException e) {
                  System.out.println(e.toString() );
              }
              Class myClass = null;
              try {
                  myClass = loader.loadClass(servletName);
              }
              catch (ClassNotFoundException e) {
                  System.out.println(e.toString());
              }
    
              Servlet servlet = null;
    
              try {
                  servlet = (Servlet) myClass.newInstance();
                  servlet.service((ServletRequest) request, (ServletResponse) response);
              }
              catch (Exception e) {
                  System.out.println(e.toString());
              }
              catch (Throwable e) {
                  System.out.println(e.toString());
              }
    
          }
      }
    

  • 上面代码通过newInstance创建了一个Servlet的实例，并调用了service方法，并传入参数request和response。但是该参数是向上转型的。

  • 这通常是不安全的，因为外部人员可以将其向下转型为Request的对象，就可以调用其方法.解决方法是创建Request和Response的外观类（外观类和原类实现同一个接口，在外观类中创建私有接口对象用原类进行赋值即可）。而在调用接口对象时使用外观类就不会导致原类的方法泄露

  • 示例如下：

  •   package ex02.pyrmont;
      public class RequestFacade implements ServletRequest {
    
          private ServletRequest request = null;
    
          public RequestFacade(Request request) {
              this.request = request;
          }
    
      /* implementation of the ServletRequest*/
      ...
      }
      package ex02.pyrmont;
    
      public class Request implements ServletRequest {
    
          private InputStream input;
          private String uri;
    
          public Request(InputStream input) {
              this.input = input;
          }
    
          public String getUri() {
              return uri;
          }
    
          private String parseUri(String requestString) {
              int index1, index2;
              index1 = requestString.indexOf(' ');
              if (index1 != -1) {
              index2 = requestString.indexOf(' ', index1 + 1);
              if (index2 > index1)
                  return requestString.substring(index1 + 1, index2);
              }
              return null;
          }
    
          public void parse() {
              // Read a set of characters from the socket
              StringBuffer request = new StringBuffer(2048);
              int i;
              byte[] buffer = new byte[2048];
              try {
              i = input.read(buffer);
              }
              catch (IOException e) {
              e.printStackTrace();
              i = -1;
              }
              for (int j=0; j<i; j++) {
              request.append((char) buffer[j]);
              }
              System.out.print(request.toString());
              uri = parseUri(request.toString());
          }
    
          /* implementation of the ServletRequest*/
      }
    

  • 这样在上面service方法中使用RequestFacade类的实例向上转型就不会出现问题了。

  • 运行结果如下：

  • 

  •