[How Tomcat Works]第2章一个简单的Servlet容器-CSDN博客

译者 jarfield

博客 http://jarfield.iteye.com

概述

   本章通过两个应用程序，介绍了如何开发你自己的Servlet 容器。为了让你容易Servlet 容器的工作原理，第一个应用程序被设计地尽可能简单，然后演化为稍微复杂一些的第二个Servlet 容器。

    提示：每章的Servlet 容器都是在前一章的基础上逐步演化的，到第17 章就变成了一个羽翼丰满（full-functional ）的Tomcat Servlet 容器。

    本章的两个Servlet 容器，既能够运行简单的Servlet ，也能够处理静态资源。你可以使用 PrimitiveServlet 来测试本章的Servlet 容器。 PrimitiveServlet 类的代码在 Listing 2.1 中，源代码文件在webroot 目录下。本章的Servlet 容器还不能运行更加复杂的Servlet ，不过你在下一章就可以学到如何构建更加成熟的Servlet 容器。
Listing 2.1: PrimitiveServlet.java

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

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

本章两个应用（Servlet 容器）的类都在 ex02.pyrmont 包中。为了理解这两个应用是如何工作的，你需要熟悉 javax.servlet.Servlet 接口。因此，本章的第一节先讨论该接口。然后你将学习到，为了处理到Servlet 的HTTP 请求，Servlet 容器必须做哪些事情。

javax.servlet.Servlet 接口

Servlet 编程主要涉及到javax.servlet 和javax.servlet.http 这两个包中的类和接口。在这些类和接口中，javax.servlet.Servlet 接口是最重要的。所有的Servlet 都必须实现该接口，或继承该接口的实现类。

Servlet 接口有5 个方法，它们的原型如下所示。

public void init(ServletConfig config) throws ServletException
public void service(ServletRequest request, ServletResponse response)
   throws ServletException, java.io.IOException
public void destroy()
public ServletConfig getServletConfig()
public java.lang.String getServletInfo()

public void init(ServletConfig config) throws ServletException
public void service(ServletRequest request, ServletResponse response)
   throws ServletException, java.io.IOException
public void destroy()
public ServletConfig getServletConfig()
public java.lang.String getServletInfo()

    在上面5个方法中，init 、service 和destroy 是Serlvet 的生命周期方法。 Serlvet 容器初始化Servlet 之后会调用 init 方法。Servlet 容器只调用该方法一次，以表明Servlet 可以投入使用了。 init 方法执行成功前，Servlet 不可以接收任何请求。Servlet 程序员可以重写（override ）该方法，以添加仅需执行一次的代码，例如加载数据库驱动、初始化一些变量的值等等。其它情况下，该方法一般留空。

    接收到请求之后，Servlet 容器以一个 javax.servlet.ServletRequest 对象和一个 javax.servlet.ServletResponse 对象为参数，调用Servlet 的 service 方法。ServletRequest 对象包含了客户端的请求信息，而ServletResponse 对象封装了Servlet 的响应。service 方法在 Servlet的生命周期中可以被调用多次。

    在移除Servlet 实例之前，Servlet 容器会调用dest r oy 方法。这通常发生在Servlet 容器关闭或内存不够的时候。该方法只有在所有线程都退出 service 方法或超时之后，才能被调用。Serlvet 容器调用了一个Servlet 的 destroy 方法之后，就不会调用该Servlet 的 service 方法。 destroy 方法给了Servlet 一个机会，用来清理持有的资源，例如内存、文件句柄和线程，还可以用来持久化Servlet 的状态。

    Listing 2.1 是 PrimitiveServlet 类的代码, 该Serlvet 非常简单，我们用它来测试本章的Serlvet 容器。 PrimitiveServlet 实现了 javax.servlet.Servlet 接口（就像所有Servlet都必须做的那样），提供了所有Servlet 接口所有5 个方法的实现。每次调用 init 、 service 和 destroy 方法， PrimitiveServlet 都把方法名打印到标准控制台。另外， service 方法从 ServletResponse 对象中获取了 java.io.PrintWriter 对象，用来向浏览器发送字符串。

第一个应用

现在，让我们从Servlet 容器的视角来看看Servlet 编程。简而言之，一个功能完全的Serlvet 容器需要为每个HTTP 请求做以下的事情：

Servlet 第一次被调用时，加载Serlvet 类，并调用Serlvet 的init 方法（只调用一次）。
为每个请求，创建一个javax.servlet.ServletRequest 对象和一个javax.servlet.ServletResponse 对象。
以ServletRequest 对象和ServletResponse 为参数，调用Servlet 的service 方法。
当Servlet 被关闭时，调用Servlet 的destroy 方法，卸载（unload ）Servlet 类。

本章的第一个Servlet 容器不是功能完全。因此，它只能运行简单的Servlet ，没有调用 init 和 destroy 方法。相反，它做了以下事情：

等待HTTP 请求。
创建一个ServletRequest 对象和一个ServletResponse 对象。
如果请求的是静态资源，就以ServletRequest 对象和ServletResposne 对象为参数，调用StaticResourceProcessor 对象的process 方法。
如果请求的是Servlet ，就加载Servlet 类，并以ServletRequest 对象和ServletResposne 对象为参数，调用Servlet 的service 方法。

提示：在这个Servlet 容器中，每次请求Servlet ，Servlet 类都会被加载。

第一个Servlet 容器共包含6 个类：

HttpServer1
Request
Response
StaticResourceProcessor
ServletProcessor1
Constants

Figure 2.1 描绘了第一个 Servlet 容器的 UML 图。

该应用的入口（静态 main 方法）在 HttpServer1 类中。 main 方法创建了 HttpServer1 的一个实例，并且调用了它的 await 方法。 await 方法在等待HTTP 请求，并为每个请求创建一个 Request 对象和 Response 对象，然后将它们派发（dispatch ）到 StaticResourceProcessor 对象或 ServletProcessor 对象，派发的依据是：请求的内容是静态资源还是Servlet 。

Figure 2.1: The UML diagram of the first servlet container

    Constants 类包含了被其他类引用的静态常量 WEB_ROOT 。容器可以提供 PrimitiveServlet 和静态资源， WEB_ROOT 就指定了 PrimitiveServlet 和静态资源所在的目录。

   HttpServer1 对象一直等待HTTP 请求，直到接收到shutdown 命令位置。你可以用第1 章中的方法发送shutdowm 命令。

    本应用的每个类会在以下各小节中进行讨论。

HttpServer1类

本应用的 HttpServer1 类，和第1 章简单Web 服务器中的 HttpServer 类很类似。不过， HttpServer1 类既可以处理静态资源，又可以处理Servlet 。要请求一个静态资源，你可以在浏览器地址栏中敲入下面的URL：

http://machineName:port/staticResource

这就是你在第 1 章中请求静态资源的方法。

要请求 Servlet ，你可以使用下面的 URL ：

http://machineName:port/servlet/servletClass

因此，如果你使用本地浏览器请求名为 PrimitiveServlet 的Serlvet , 你可以在浏览器地址栏中敲入下面的URL ：

http://localhost:8080/servlet/PrimitiveServlet

Servlet 容器可以提供 PrimitiveServlet 。但是，如果你调用其他的Servlet ，比如 ModernServlet ，Servlet 容器就会抛出异常。下一章，你将会构建同时提供这两个Servlet 的应用。

HttpServer1 类的代码在 Listing 2.2 中。
Listing 2.2: The HttpServer1 Class's await method

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 {
 
   /** WEB_ROOT is the directory where our HTML and other files reside.
    *  For this package, WEB_ROOT is the "webroot" directory under the
    *  working directory.
    *  The working directory is the location in the file system
    *  from where the java command was invoked.
    */
   // shutdown command
   private static final String SHUTDOWN_COMMAND = "/SHUTDOWN";
 
   // the shutdown command received
   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 =  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/")) {
           ServletProcessor1 processor = new ServletProcessor1();
           processor.process(request, response);
         }
         else {
           StaticResoureProcessor 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);
       }
     }
   }
}

await 方法等待HTTP 请求，直到接收到shutdown 命令为止，这会让你想起第1 章的 await 方法。 Listing 2.2 中的 await 方法和第1 章的区别在于， Listing 2.2 的请求既可以派发到 StaticResourceProcessor 对象，又可以派发都 ServletProcessor 对象。如果请求的URI 以 /servlet/ 开头，那么就会被派发到 ServletProcessor 对象。否则，请求将被派发到 StaticResourceProcessor 对象。注意 Listing 2.2 中灰色的部分（59行~70行）。

Request 类

    Servlet 的 service 方法从容器接收一个 javax.servlet.ServletRequest 对象和一个 javax.servlet.ServletResponse 对象作为参数。这也就是说，对每个HTTP 请求，Servlet 容器都必须创建一个 ServletRequest 对象和 ServletResponse 对象，并将它们传递给处理该请求的Servlet 的 service 方法。

    ex02.pyrmont.Request 类代表了传递给Servlet 的 service 方法的请求对象。因此，它必须实现 javax.servlet.ServletRequest 接口。 Request 类必须提供 ServletRequest 接口所有方法的实现。不过，我们想让 Reuqest 类尽量简单，只实现其中一些方法，在后面章节再实现所有的方法。为了通过编译，你必须提供这些方法的“空”实现。从 Listing 2.3 可以看出，所有返回值类型为 Object 的方法都返回 null 。
Listing 2.3: The Request class

package ex02.pyrmont;
 
import java.io.InputStream;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.UnsupportedEncodingException;
import java.util.Enumeration;
import java.util.Locale;
import java.util.Map;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletRequest;
 
 
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 ServletRequest */
   public Object getAttribute(String attribute) {
     return null;
   }
   public Enumeration getAttributeNames() {
     return null;
   }
   public String getRealPath(String path) {      return null;
   }
   public RequestDispatcher getRequestDispatcher(String path) {
     return null;
   }
   public boolean isSecure() {
     return false;
   }
   public String getCharacterEncoding() {
     return null;
   }
   public int getContentLength() {
     return 0;
   }
 
   public String getContentType() {
     return null;
   }
   public ServletInputStream getInputStream() throws IOException {
     return null;
   }
   public Locale getLocale() {
     return null;
   }
   public Enumeration getLocales() {
     return null;
   }
   public String getParameter(String name) {
     return null;
   }
   public Map getParameterMap() {
     return null;
   }
   public Enumeration getParameterNames() {
     return null;
   }
   public String[] getParameterValues(String parameter) {
     return null;
   }
   public String getProtocol() {
     return null;
   }
   public BufferedReader getReader() throws IOException {
     return null;    }
   public String getRemoteAddr() {
     return null;
   }
   public String getRemoteHost() {
     return null;
   }
   public String getScheme() {
     return null;
   }
   public String getServerName() {
     return null;
   }
   public int getServerPort() {
     return 0;
   }
   public void removeAttribute(String attribute) {  }
   public void setAttribute(String key, Object value) {  }
   public void setCharacterEncoding(String encoding)
     throws UnsupportedEncodingException {  }
}

另外，Request 类仍包括第1 章讨论过的parse 方法和getUri 方法。

Response 类

Listing 2.4 中的 ex02.pyrmont.Response 类，实现了 javax.servlet.ServletResponse 接口。因此， Response 类必须提供 ServletResponse 接口所有方法的实现。和 Request 类一样，除了 getWriter ，我们将所有方法的实现“留空”。
Listing 2.4: The Response class

package ex02.pyrmont;
 
import java.io.OutputStream;
import java.io.IOException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.File;
import java.io.PrintWriter;
import java.util.Locale;
import javax.servlet.ServletResponse;
import javax.servlet.ServletOutputStream;
 
public class Response implements ServletResponse {
 
   private static final int BUFFER_SIZE = 1024;
   Request request;
   OutputStream output;
   PrintWriter writer;
 
   public Response(OutputStream output) {
     this.output = output;
   }
 
    public void setRequest(Request request) {
     this.request = request;
   }
 
   /* This method is used to serve static pages */
   public void sendStaticResource() throws IOException {
     byte[] bytes = new byte[BUFFER_SIZE];
     FileInputStream fis = null;
     try {
       /* request.getUri has been replaced by request.getRequestURI */
       File file = new File(Constants.WEB_ROOT, request.getUri());
       fis = new FileInputstream(file);
       /*
       HTTP Response = Status-Line
         *(( general-header | response-header | entity-header ) CRLF)
         CRLF
         [ message-body ]
         Status-Line = HTTP-Version SP Status-Code SP Reason-Phrase CRLF
       */
       int ch = fis.read(bytes, 0, BUFFER_SIZE);
       while (ch!=-1) {
 
         output.write(bytes, 0, ch);
         ch = fis.read(bytes, 0, BUFFER_SIZE);
       }
     }
     catch (FileNotFoundException e) {
       String errorMessage = "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>";
       output.write(errorMessage.getBytes());
     }
     finally {
       if (fis!=null)
         fis.close();
     }
   }
 
 
   /** implementation of ServletResponse  */
   public void flushBuffer() throws IOException (   }
   public int getBufferSize() {
     return 0;
   }
   public String getCharacterEncoding() {
     return null;
   }
   public Locale getLocale() {
     return null;
   }
   public ServletOutputStream getOutputStream() throws IOException {
     return null;
   }
   public PrintWriter getWriter() throws IOException {
     // autoflush is true, println() will flush,
     // but print() will not.
     writer = new PrintWriter(output, true);
     return writer;
   }
   public boolean isCommitted() {
     return false;
   }
   public void reset() {  }
   public void resetBuffer() {  }
   public void setBufferSize(int size) {  }
   public void setContentLength(int length) {  }
   public void setContentType(String type) {  }
   public void setLocale(Locale locale) {  }
}

package ex02.pyrmont;
 
import java.io.OutputStream;
import java.io.IOException;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.File;
import java.io.PrintWriter;
import java.util.Locale;
import javax.servlet.ServletResponse;
import javax.servlet.ServletOutputStream;
 
public class Response implements ServletResponse {
 
   private static final int BUFFER_SIZE = 1024;
   Request request;
   OutputStream output;
   PrintWriter writer;
 
   public Response(OutputStream output) {
     this.output = output;
   }
 
    public void setRequest(Request request) {
     this.request = request;
   }
 
   /* This method is used to serve static pages */
   public void sendStaticResource() throws IOException {
     byte[] bytes = new byte[BUFFER_SIZE];
     FileInputstream fis = null;
     try {
       /* request.getUri has been replaced by request.getRequestURI */
       File file = new File(Constants.WEB_ROOT, request.getUri());
       fis = new FileInputstream(file);
       /*
       HTTP Response = Status-Line
         *(( general-header | response-header | entity-header ) CRLF)
         CRLF
         [ message-body ]
         Status-Line = HTTP-Version SP Status-Code SP Reason-Phrase CRLF
       */
       int ch = fis.read(bytes, 0, BUFFER_SIZE);
       while (ch!=-1) {
 
         output.write(bytes, 0, ch);
         ch = fis.read(bytes, 0, BUFFER_SIZE);
       }
     }
     catch (FileNotFoundException e) {
       String errorMessage = "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>";
       output.write(errorMessage.getBytes());
     }
     finally {
       if (fis!=null)
         fis.close();
     }
   }
 
 
   /** implementation of ServletResponse  */
   public void flushBuffer() throws IOException (   }
   public int getBufferSize() {
     return 0;
   }
   public String getCharacterEncoding() {
     return null;
   }
   public Locale getLocale() {
     return null;
   }
   public ServletOutputStream getOutputStream() throws IOException {
     return null;
   }
   public PrintWriter getWriter() throws IOException {
     // autoflush is true, println() will flush,
     // but print() will not.
     writer = new PrintWriter(output, true);
     return writer;
   }
   public boolean isCommitted() {
     return false;
   }
   public void reset() {  }
   public void resetBuffer() {  }
   public void setBufferSize(int size) {  }
   public void setContentLength(int length) {  }
   public void setContentType(String type) {  }
   public void setLocale(Locale locale) {  }
}

    在 getWriter 方法中， PrintWriter 构造函数的第二个参数是布尔类型，表明是否启用自动刷新（ autoflush ）功能。第二个参数如果为 true ，所有的 println 调用均会刷新到输出流中。不过，调用 print 方法是不会刷新的。

    因此，如果Servlet 的 service 方法的最后一行恰好调用了 print 方法，那么 print 的输出是不会被发送到浏览器的。本节的应用就有这个问题，我们将在下一章修复。

    Response 类仍包括第1 章中讨论过的 sendStaticResource 方法。

StaticResourceProcessor 类

ex02.pyrmont.StaticResourceProcessor 类提供静态资源服务。该类只有一个 process 方法，代码见 Listing 2.5 。

Listing 2.5: The StaticResourceProcessor class

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

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

process 方法接收两个参数： ex02.pyrmont.Request 对象和 ex02.pyrmont.Response 对象。该方法只是简单地调用了Response 对象的 sendStaticResource 方法。

ServletProcessor1 类

Listing 2.6 中的ex02.pyrmont.ServletProcessor1类负责处理对Servlet的HTTP请求。
Listing 2.6: The ServletProcessor1 class

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();
     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.
       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());
     }
 
   }
}

ServletProcessor1 类出奇地简单，只包括一个方法：process 。该方法接收两个参数：一个javax.servlet.ServletRequest 对象和一个javax.servlet.ServletResponse 对象。从ServletRequest 对象中，该方法通过调用geUri 方法获得请求URI ：

String uri = request.getUri();

String uri = request.getUri();

记住，URI 的形式如下：

/servlet/servletName

其中servletName 是 Servlet 类的名称。要加载该 Serlvet 类，我们需要从 URI 中知道 Servlet 的名称。我们可以用 process 方法的下一行来获取 Servlet 的名称：

String servletName = uri.substring(uri.lastIndexOf("/") + 1);

String servletName = uri.substring(uri.lastIndexOf("/") + 1);

    接下来，process 方法开始加载servlet 。为此，你需要创建一个类加载器（class loader ），并且告诉它，要加载的类所在的位置。对于这个Servlet 容器，类加载器直接查找Constants.WEB_ROOT 指向的位置，也就是工作目录下的webroot 目录。

    提示：我们将在第8 章详细讨论类加载器。

    要加载servet ，你需要使用java.net.URLClassLoader 类，它是java.lang.ClassLoader 类的直接子类。一旦有了URLClassLoader 对象，你就可以调用它的loadClass 来加载servlet 类。实例化URLClassLoader 类是直观易懂的。该类有3 个构造函数，其中最简单的是：

public URLClassLoader(URL[] urls);

public URLClassLoader(URL[] urls);

其中urls 是java.net.URL 对象的数组，这些URL指向了类搜索路径。我们假设，任何以/ 结束的URL 都指向目录，其它URL 都指向，需要时可以下载和打开的JAR 文件。

提示：在 servlet 容器中，类加载器搜索 servlet 类文件的位置被称为仓库（ repository ）。

在我们的应用中，类加载器只需要查找一个路径，即工作目录下的webroot 目录。因此，我们先创建了一个长度仅为1 的URL 数组。URL 提供了很多构造函数，所以有多种方式创建URL 对象。对于本应用，我们和Tomcat 使用相同的构造函数。该构造函数的签名如下所示：

public URL(URL context, java.lang.String spec, URLStreamHandler hander) throws MalformedURLException

public URL(URL context, java.lang.String spec, URLStreamHandler hander) throws MalformedURLException

你可以这样使用上述构造函数，第一个参数传null ，第二个参数传一个有效的spec ，第三个值传null 。但是，这里还有另一个接收三个参数的构造函数：

public URL(java.lang.String protocol, java.lang.String host, java.lang.String file) throws MalformedURLException

public URL(java.lang.String protocol, java.lang.String host, java.lang.String file) throws MalformedURLException

因此，如果你以如下方式创建URL 对象，编译器将不知道调用哪个版本的构造函数。

new URL(null, aString, null);

new URL(null, aString, null);

要避免这个问题，你可以告诉编译器第三个参数的类型，就像这样：

URLStreamHandler streamHandler = null;
new URL(null, aString, streamHandler);

对于第二个参数，你传递了一个代表仓库（servlet 类文件所在的目录）的String 对象，代码如下：

String repository = (new URL("file", null, classPath.getCanonicalPath() + File.separator)).toString();

String repository = (new URL("file", null, classPath.getCanonicalPath() + File.separator)).toString();

把这些代码片段组合在一起，就是process 方法中创建URLClassLoader 对象的代码：

    // create a URLClassLoader
    URL[] urls = new URL[1];
    URLStreamHandler streamHandler = null;
    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);
    loader = new URLClassLoader(urls);

提示：组装仓库的代码来自org.apache.catalina.startup.ClassLoaderFactory 的createClassLoader 方法，组装URL 的代码来自org.apache.catalina.loader.StandardClassLoader 的addRepository 方法。不过，在本章你还不用关注这些类。

有了类加载器，你可以使用其loadClass 方法来加载servlet 类：

    Class myClass = null;
    try {
      myClass = loader.loadClass(servletName);
    }
    catch (ClassNotFoundException e) {
      System.out.println(e.toString());
    }

下一步， process 方法创建了 servlet 类的一个实例,并向下转型（ downcast ）到 javax.servlet.Servlet ，然后调用其 service 方法：

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

运行应用

要在Windows 运行该应用，在工作目录运行以下命令：

java -classpath ./lib/servlet.jar;./ ex02.pyrmont.HttpServer1

在Linux 上，你可以使用冒号分隔两个库：

java -classpath ./lib/servlet.jar:./ ex02.pyrmont.HttpServer1

要测试该应用，你可以在浏览器地址栏中敲入以下命令：

http://localhost:8080/index.html

或者

http://localhost:8080/servlet/PrimitiveServlet

如果请求的是PrimitiveServlet , 你会在浏览器中看到一些文本：

Hello. Roses are red.

提示：在浏览器中，你并不能看到第二个字符串“Violets are blue ”, 这是因为只有第一个字符串被flush 到浏览器。不过，我们将在第3章修复这个问题。

第二个应用

第一个应用有个严重的问题。在ServletProcessor1 类的process 方法中，你将ex02.pyrmont.Request 对象向上转型（upcast ）到javax.servlet.ServletRequest ，并将它作为servlet 的service 方法的第一个参数。同样，你也将ex02.pyrmont.Response 对象向上转型到javax.servlet.ServletResponse ，并将它作为servlet 的service 方法的第二个参数。

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

这是对安全性的一种妥协（compromise ）。了解Servlet 容器内部细节的Servlet 程序员，可以将ServletRequest 对象和ServletResponse 对象分别转回到ex02.pyrmont.Request 和ex02.pyrmont.Response ，并调用它们的public 方法。有了Request 对象，他们（指 Servlet程序员）就可以它的parse 方法。有了Resposne 对象，他们就可以调用它的sendStaticResource 方法。

你不能将parse 和sendStaticResource 方法设置成private ，否则它们就不能被其他类调用了。但是，这两个方法对servlet 应该是不可见的。我们的解决方案是让Request 和Response 类都具有默认访问修饰符，这样它们就不能在ex02.pyrmont 包外被使用。不过，这里有一个更优雅的方法：使用门面（facade ）类。请看Figure 2.2 中的UML图。

                          Figure 2.2: Façade classes

在第二个应用中，我们增加了两个facade 类：RequestFacade 和ResponseFacade 。RequestFacade 实现了ServletRequest 接口，并通过接受一个Request 对象的构造函数进行实例化，其中Request 对象将赋值给一个类型为ServletRequest 的成员变量。但是，该成员变量的访问类型是，因此不能在RequestFacade 类的外部被访问。我们构造了一个RequestFacade 对象传递给service 方法，而不是将Request 对象向上转型成ServletRequest 对象再传递给service 方法。Servlet 程序员仍可以将ServletRequest 对象向下转型回RequestFacade ，但是他们只能访问SerlvetRequest 接口中的方法。现在，parseUri 方法就安全了。

    Listing 2.7 展现了RequestFacade 类的部分代码。
Listing 2.7: The RequestFacade class

package ex02.pyrmont;

public class RequestFacade implements ServletRequest {
   private ServletRequest request = null;
 
   public RequestFacade(Request request) {
     this.request = request;
   }
 
   /* implementation of the ServletRequest*/
   public Object getAttribute(String attribute) {
     return request.getAttribute(attribute);
   }
 
   public Enumeration getAttributeNames() {
     return request.getAttributeNames();
   }
 
   ...
}

package ex02.pyrmont;
public class RequestFacade implements ServletRequest {
   private ServletRequest request = null;
 
   public RequestFacade(Request request) {
     this.request = request;
   }
 
   /* implementation of the ServletRequest*/
   public Object getAttribute(String attribute) {
     return request.getAttribute(attribute);
   }
 
   public Enumeration getAttributeNames() {
     return request.getAttributeNames();
   }
 
   ...
}

    请注意Request 的构造函数。它接受了一个Request 对象但是立即将其赋值给private 的ServletRequest 对象。同样也请注意RequestFacade 类的每个方法都调用了ServletRequest 对象的相应方法。

    ResponseFacade 也是这么做的。

    第二个应用使用了下面的类：

HttpServer2
Request
Response
StaticResourceProcessor
ServletProcessor2
Constants

HttpServer2 类和HttpServer1 基本相同，只是它的await 方法使用了ServletProcessor2 类，而不是ServletProcessor1 :

if (request.getUri().startWith("/servlet/")) {
      servletProcessor2 processor = new ServletProcessor2();
      processor.process(request, response);
    }
    else {
      ...
    }

if (request.getUri().startWith("/servlet/")) {
  servletProcessor2 processor = new ServletProcessor2();
  processor.process(request, response);
}
else {
  ...
}

ServletProcessor2 类和ServletProcessor1 基本相同，除了下面列出的process 方法的部分代码