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

huazhi · 发表于 2017-2-10 09:06:29

译者 jarfield

博客 http://jarfield.iteye.com

概述
javax.servlet.Servlet 接口
第一个应用
- HttpServer1 类
- Request 类
- Response 类
- StaticResourceProcessor 类
- ServletProcessor1 类
- 运行应用
第二个应用
- 运行应用
总结

概述
　　   本章通过两个应用程序，介绍了如何开发你自己的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

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

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 个方法，它们的原型如下所示。

Java代码

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()
Java代码

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：

Html代码

http://machineName:port/staticResource

http://machineName:port/staticResource
　　这就是你在第 1 章中请求静态资源的方法。

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

Html代码

http://machineName:port/servlet/servletClass

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

Html代码

http://localhost:8080/servlet/PrimitiveServlet

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

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

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

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

Java代码

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 k

账号		自动登录	找回密码
密码			立即注册

wirelessnetview好用的无线分析工具

Red Hat RHCE 8 (EX294) Cert Guide

Shell从入门到精通（阿良）

亿图图示专家(EDraw Max) V7.9 中文破解版

zabbix3.4.1安装部署+微信推送信息+大屏显

Red Hat OpenShift I: Containers & Kubern

2025 年，C++ 还能“硬核”多久？

[经验分享] [How Tomcat Works]第2章一个简单的Servlet容器

扫码加入运维网微信交流群

[经验分享] [How Tomcat Works]第2章 一个简单的Servlet容器

[经验分享] [How Tomcat Works]第2章一个简单的Servlet容器