Tomcat4 源代码分析 （1, 2） How Tomcat Works 笔记

    在第二章中，作者给出了一个简单的web server的实现。麻雀虽小，五脏俱全。

    从中我们可以学习到 server 处理客户端请求的一个主体思路。

 

    项目由下面的类组成：

    |-- Constants.java // 里面仅仅定义了web root的路径

    |-- HttpServer2.java // 核心。处理socket连接，分析http请求，调用servlet容器

    |-- Request.java//实现ServletRequest接口，解析socket.inputStream（http请求）

    |-- RequestFacade.java // 实现ServletRequest接口，是Request的门面

    |-- Response.java//实现ServletResponse接口，关联到socket.outputStream

    |-- ResponseFacade.java //Response的门面

    |-- ServletProcessor2.java //Servlet 容器

    |-- StaticResourceProcessor.java //静态资源容器

 

    下面列出了HttpServer2.java的代码：

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 HttpServer2 {

  // shutdown command
  private static final String SHUTDOWN_COMMAND = "/SHUTDOWN";

  // the shutdown command received
  private boolean shutdown = false;

  public static void main(String[] args) {
    HttpServer2 server = new HttpServer2();
    server.await();
  }

  public void await() {
    ServerSocket serverSocket = null;
    int port = 8080;
    try {
      serverSocket =  new ServerSocket(port, 1, InetAddress.getByName("127.0.0.1"));
    }
    catch (IOException e) {
      e.printStackTrace();
      System.exit(1);
    }

    // Loop waiting for a request
    while (!shutdown) {
      Socket socket = null;
      InputStream input = null;
      OutputStream output = null;
      try {
        socket = serverSocket.accept();
        input = socket.getInputStream();
        output = socket.getOutputStream();

        // create Request object and parse
        Request request = new Request(input);
        request.parse();

        // create Response object
        Response response = new Response(output);
        response.setRequest(request);

        //check if this is a request for a servlet or a static resource
        //a request for a servlet begins with "/servlet/"
        if (request.getUri().startsWith("/servlet/")) {
          ServletProcessor2 processor = new ServletProcessor2();
          processor.process(request, response);
        }
        else {
          StaticResourceProcessor processor = new StaticResourceProcessor();
          processor.process(request, response);
        }

        // Close the socket
        socket.close();
        //check if the previous URI is a shutdown command
        shutdown = request.getUri().equals(SHUTDOWN_COMMAND);
      }
      catch (Exception e) {
        e.printStackTrace();
        System.exit(1);
      }
    }
  }
}

    处理过程很清晰：

    1、创建一个ServerSocket, 等待客户端的连接。

    2、客户端连接后，把底层的socket输入流解析、封装成Request对象。同时把socket的输出流关联给Response对象。

    3、根据Request对象中url的属性，相应的调用servlet容器，或者是静态资源的容器。

   

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 ServletProcessor2 {

  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;
    RequestFacade requestFacade = new RequestFacade(request);
    ResponseFacade responseFacade = new ResponseFacade(response);
    try {
      servlet = (Servlet) myClass.newInstance();
      servlet.service((ServletRequest) requestFacade, (ServletResponse) responseFacade);
    }
    catch (Exception e) {
      System.out.println(e.toString());
    }
    catch (Throwable e) {
      System.out.println(e.toString());
    }

  }
}

 

package ex02.pyrmont;

import java.io.IOException;

public class StaticResourceProcessor {

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

 

    上面两段代码分别为 servlet容器 和 静态资源的容器。容器和servlet的关系就像柜子和衣服的关系。容器做了什么很显然，但是容器具体是怎么做的通过上面的代码就能了解到。

 

    值得一提的是，本章中引入了一种设计模式,facade模式。这种模式使用的目的有若干个，但是在这里是为了实现安全性而引入。servlet容器调用具体的servlet的service方法时，如果直接把request对象转型成ServletRequest接口类型，潜在的问题是这个request对象可以被转型回Request类型，进而可以使用ServletRequest接口之外的Request对象的方法。

    facade类型关联到Request类型的对象，同时仅仅实现ServletRequest接口。这样facade对象传递给service方法后，就不会有上述的安全问题。

 

    下面给出具体servlet的实现，里面的service方法，将会被容器调用：

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