HTTP Requests
上面提过，HTTP1.1协议是请求/应答模式的协议，那么HTTP协议分为两个部分，一是请求协议，一是应答协议。下面看一下请求协议。
HTTP请求的格式如下：
1、方法-统一资源标识符-协议/协议版本
2、请求头
3、请求实体
下面是一个HTTP请求实例
POST /servlet/testt.jsp HTTP/1.1
Accept: text/plain; text/html
Accept-Language: en-us
Connection: Keep-Alive
Host: localhost
Referer: http://localhost/begin.jsp
User-Agent: Mozilla/4.0 (compatible; MSIE 4.01; Windows 98)
Content-Length: 33
Content-Type: application/x-www-form-urlencoded
Accept-Encoding: gzip
name=lisi&age=40
为了使您对HTTP协议有个大概印象，下面将就上面涉及的HTTP请求的相关项做以下介绍：
POST /servlet/test.jsp HTTP/1.1
POST是请求的方式, HTTP 1.1 支持7种请求，分别是：:GET, POST, HEAD, OPTIONS, PUT, DELETE, 和 TRACE. GET 和 POST 。其中最常用的是GET和POST，他们区别如下：
1、Post传输数据时，不需要在URL中显示出来，而Get方法要在URL中显示。
2、Post传输的数据量大，可以达到2M，而GET方法只能传递大约1024字节。
3、Post目的是将数据传送到服务器段。而Get目的是给服务器消息，要从服务器下载数据。、所以我们可以轻而易举的明白：GET既然只是通知服务器需要什么数据，那么它需要传递的信息量就很少，用来传送数据到服务器，那么它需要的信息量就很大，比如传递文件。这也是上面第二条之所以那样规定的理由。
POST /servlet/testt.jsp HTTP/1.1
其中POST规定了传输数据使用的方法，/servlet/test.jsp则是请求要访问的统一资源标识符（URI），要访问根目录下servlet目录下的test.jsp页面。URI 通常以相对于服务器的根目录来进行解析.,因此，它总是以 / 开始，比如上面的/servlet/test.jsp。(URL 实际是 URI 的一种)。HTTP表明使用的是HTTP协议，1.1表示使用的版本是1.1。
Accept: text/plain; text/html
客户浏览器可以接受的内容类型，这里是简单文本和html文档。
Accept-Language: en-us
客户浏览器希望从服务器接收的内容使用的语言。当服务器提供多于一种语言的时，这个选项起作用。
Connection: Keep-Alive
Content-Length: 33
Keep-Alive表示需要持久连接。如果Servlet看到这里的值为“Keep-Alive”，或者看到请求使用的是HTTP 1.1（HTTP 1.1默认进行持久连接），他就建立持久连接，当页面包含多个元素时（例如Applet，图片）时，使用这个连接将全部资源发给客户端后，才关闭连接，这样可以大量节约宝贵的网络和服务器资源，减少页面下载时间。这个选项和Content-Length一起使用。 因为使用持久连接，服务器需要知道何时读完请求字符串。
Host: localhost
指定请求资源的Intenet主机
Referer: http://localhost/begin.jsp
表示访问网络资源的出发点
User-Agent: Mozilla/4.0 (compatible; MSIE 4.01; Windows 98)
浏览器类型，如果Servlet返回的内容与浏览器类型有关则该值非常有用
Content-Type: application/x-www-form-urlencoded
表示后面的文档属于什么类型。Servlet默认为text/plain，但通常需要显式地指定。这里是指定为表单。
Accept-Encoding: gzip
文档的编码方法。只有在解码之后才可以得到Content-Type头指定的内容类型。利用gzip压缩文档能够显著地减少HTML文档的下载时间。Java的GZIPOutputStream可以很方便地进行gzip压缩。
HTTP请求使用两个回车换行将请求头和请求体分开，也就是说在请求头和请求体之间有一个空白行。
请求主体很简单，内容如下
name=lisi&age=40
当然我们使用的是post方法，请求体可以有很长，最大是2M。
HTTP Responses
HTTP 响应也是由3部分组成:
1、协议-状态代码-描述
2、响应头
3、响应实体
下面是一个 HTTP 响应的例子:
HTTP/1.1 200 OK
Server: Microsoft-IIS/4.0
Date: Thu, 13 Jul 1998 13:13:33 GMT
Content-Type: text/html
Content-Length: 84
<html>
<head>
<title>HTTP Response</title></head><body>
Welcome to HTTP word！
</body>
</html>
HTTP/1.1 200 OK
标示使用的是HTTP协议，版本是1.1，状态200，标示成功，ok，标示一切正确。
Server: Microsoft-IIS/4.0
标示服务器类型
Content-Type: text/html
内容类型是HTML
Content-Length: 112
内容长度是112字符
下面是两个回车换行，也就是隔一行。后面是响应体。
1.1.1. Socket类
此类是程序进行网络数据交换使用的类，通常用来发送请求和读取响应。位于java.net包中。下面我们看一下Socket类的相关重要方法方法签名。
1、构造方法签名
public Socket(String host, int port)
host是远程服务器名称或者IP 地址，port 是服务器的端口号。例如
new Socket("127.0.0.1", 80)
2、 获得向发送数据的输出流
public OutputStream getOutputStream() throws IOException
当你创建了套接字实例后，你就可以使用它发送和接收消息。发送消息的时候, 使用Socket 类的 getOutputStream 方法获得 java.io.OutputStream 对象。为了方便，可以对OutputStream 进行包装，包装成一个 java.io.PrintWriter 对象，用来发送文本。
3、获得从服务器读取消息的输入流
public InputStream getInputStream()throws IOException
输入流用来从目标机器读取消息。
--------------------------------------------------
[b]ServerSocket类
[/b]
此类通常服务器端，通常使用它来接收和响应客户请求。在互联网中，客户端可能有好多，每个客户随时可能向服务器发送请求，服务器根本不知道谁什么时间要和自己通信。所以，服务器端必须一直处于运行状态，等待客户连接请求。ServerSocket正是为此设计。
此类位于java.net包中，下面看一下它的其中几个重要方法签名。
1、其中的一个构造方法
public ServerSocket(int port, int backLog, InetAddress bindingAddress)
此类的构造器共有四个，我们来看一下其中的一个，也就是我们的简单服务器将要用到的构造器。其余三个可以参看JDK文档。
在此构造器中，port是服务器监听的端口，所有来自port端口指定的请求都会被监听到，也就是说，每个从port端口传来的数据都会由套接字来处理。backLog是服务器所能容忍的最大请求队列长度，当请求数量大约此数值时，服务器将拒绝响应新的请求。bindingAddress是服务器绑定的地址，它必须是java.net.InetAddress 的一个实例，构造此实例的方法之一是调用方法InetAddress.getByName("127.0.0.1")。
2、accept 方法
public Socket accept() throws IOException
创建了ServerSocket 实例,后，你就可以调用它的 accept 方法使服务器进入监听状态。它只有在有连接请求的时候才会有返回。它返回一个 Socket 类的实例，用于和客户端通信。
1.1.2. Servlet接口
J2EE作为一个标准，它规定了J2EE编程需要遵循的规范。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()
其中，init, service, 和 destroy 方法是 servlet 的生命周期方法。init 方法是初始化方法，只在Servlet初始化时调用一次。初始化成功后，servlet调用service 方法.，对客户端进行服务。它接受 服务器传递的一个 javax.servlet.ServletRequest 对象和一个 javax.servlet.ServletResponse 对象。ServletRequest 对象包含客户端 HTTP 请求信息，ServletResponse 封装了servlet 的响应。当服务器需要关闭或者需要释放内存时，服务器删会除一个servlet实例，在删除之前会执行destroy方法，允许servlet程序员做一些清理工作。getServletConfig()方法用来获得servlet配置对象，getServletInfo()用来获得servlet的信息。
1.1. 一个简单服务器
通过上面的准备，我们已经有了编写简单服务器的知识准备。现在，我们开始我们简单服务器。此简单服务器实现对客户端请求的静态资源和动态servlet的处理和响应。
1.1.1. HttpWebServer类
此类是我们简单服务器的核心类，在随书光盘中的chapter/execixe1/src/server/core目录下可以看到此类的源码。下面是此类的关键代码：
public class HttpWebServer {
private boolean shut = false;
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);
}
while (!shut) {
Socket socket = null;
InputStream is = null;
OutputStream os = null;
try {
socket = serverSocket.accept();
is = socket.getInputStream();
os = socket.getOutputStream();
HttpRequest request = new HttpRequest();
request.setIs(is);
request.parseRequest();
HttpResponse response = new HttpResponse();
response.setRequest(request);
response.setOs(os);
RequestFacade requestFacade = new RequestFacade(request);
ResponseFacade responseFacade = new ResponseFacade(response);
//响应动态servlet
if (request.getUri().startsWith("/servlet/")) {
ServletProcessor processor = new ServletProcessor();
processor.process(requestFacade, responseFacade);
}else{
StaticResourceProcessor processor = new StaticResourceProcessor();
processor.process(requestFacade, responseFacade);
}
socket.close();
shut = request.getUri().equals(GlobalConstants.SHUTDOWN_COMMAND);
}
catch (Exception e) {
e.printStackTrace();
continue;
}
}
}
}
2011-03-28 14:12
我们看到，此类中只有一个方法await，此方法首先创建一个ServerSocket 对象分配给变量serverSocket ：
serverSocket = new ServerSocket(port, 1,InetAddress.getByName("127.0.0.1"));
此ServerSocket 类的构造方法表明，我们服务器绑定的是本机的IP地址（127.0.0.1表示本机地址），端口是8080，最大处理的并发请求是1个，如果多于一个请求并发，那么将拒绝服务。此语句使用try...catch语句包围，如果创建服务器套接字失败，那么进入异常处理，打印堆栈后，退出系统。
接下来是一个while循环，循环的条件是shut为true（关于此变量稍后讨论）。在循环中，首先调用上面构建的ServerSocket 对象的accept方法：
socket = serverSocket.accept();
此方法只有有客户端的http请求到来时才返回，返回套接字对象。有了套接字对象，我们就可以通过套接字对象获得输入流和输出流来接收和发送信息。
is = socket.getInputStream();
os = socket.getOutputStream();
获得输入流对象后，我们就可以通过输入流来读取客户端的请求，并且解析它，这个是由HttpRequest 对象来完成的。所以程序构造了HttpRequest 对象，并在将输入流对象传递给它后，调用HttpRequest 对象的parse方法来解析http请求：
HttpRequest request = new HttpRequest();
request.setIs(is);
request.parseRequest();
构造并且解析请求对象后，紧接着构造了响应对象（HttpResponse ），并且将构造好的请求对象和输入流传递给HttpResponse 响应对象。在这里之所以将请求对象传递给响应对象，是因为我们在响应对象中做了响应客户端静态资源处理，在处理中需要用到我们构造的请求对象中的变量和方法。
当现在为止，我们分别构造好了请求对象和响应对象。那么我们就可以根据用户的请求类型构造不同的处理对象并调用相应的处理方法（process），从上面的代码列表1.1我们可以看到，process方法需要传递请求和响应对象。但是在这里我们并没有直接将我们构造好的对象传递给process方法，相反，我们对我们构造的请求对象（HttpRequest ）和响应对象（HttpResponse ）进行了包装，然后将我们的包装对象（门面）传递给process方法(具体原因在讨论RequestFacade 和ResponseFacade 时可以详细解释):：
RequestFacade requestFacade = new RequestFacade(request);
ResponseFacade responseFacade = new ResponseFacade(response);
if (request.getUri().startsWith("/servlet/")) {
ServletProcessor processor = new ServletProcessor();
processor.process(requestFacade, responseFacade);
}else{
StaticResourceProcessor processor = new StaticResourceProcessor();
processor.process(requestFacade, responseFacade);
}
区分不同用户的请求是根据请求对象解析的用户请求的uri来判定，如果请求的是以/servlet/开始的，那么响应servlet，否则响应静态资源。
处理完请求后我们关闭套接字，收回资源。
socket.close();
最后，判断服务器是否应该关闭：在此类中，我们定义一个布尔变量shut，用来标示当前服务器是否应该关闭，默认值是false，表明服务器处于运行状态。
shut = request.getUri().equals(GlobalConstants.SHUTDOWN_COMMAND);
此方法判断客户的请求是否是关闭服务器命令，也就是看请求对象中的uri是否是常量SHUTDOWN_COMMAND定义的字符串。
1.1.1. HttpRequest类
此类负责解析客户的http请求，并且获得客户请求的uri。此类在随书光盘中的chapter/execixe1/src/server/request目录下。此类实现了HttpServletRequest接口，主要目的是使服务器支持符合javaee标准的servlet。因为servlet程序员编写servlet是符合javaee标准的，在程序中他们会调用符合javaee标准的HttpServletRequest对象。下面是此类相关的重要代码：
public class HttpRequest implements HttpServletRequest{
private InputStream is = null;
private String uri = null;
public InputStream getIs() {
return is;
}
public void setIs(InputStream is) {
this.is = is;
}
public String getUri() {
return uri;
}
public void setUri(String uri) {
this.uri = uri;
}
public void parseRequest() {
byte[] content = new byte[0];
try{
int len;
byte[] buffer = new byte[1024];
len = is.read(buffer);
if(len>0){
byte[] tmp = new byte[content.length + len];
System.arraycopy(content, 0, tmp, 0, content.length);
System.arraycopy(buffer, 0, tmp, content.length, len);
content = tmp;
}
}catch (IOException e) {
e.printStackTrace();
}
uri = getRequestUri(new String(content));
}
private String getRequestUri(String content) {
int uirStartIndex = -1;
int uriEndIndex = -1;
uirStartIndex = content.indexOf(' ');
if (uirStartIndex >-1) {
uriEndIndex = content.indexOf(' ', uirStartIndex + 1);
if (uriEndIndex > uirStartIndex)
return content.substring(uirStartIndex + 1, uriEndIndex);
}
return null;
}
//以下省略一些没有用到的方法
．．．．．．
}
此类关键方法有两个：parseRequest和getRequestUri。首先看一下getRequestUri，在这个方法中，我们读入1024个字节，因为我们的简单服务器使用GET方式提交请求，那么我们可以肯定，请求不会大于1024字节。所以我们只读取一次。当然实际的服务器要支持POST提交方式，在这里我们主要说明web服务器的工作原理，所以没有讨论POST提交方式。
byte[] buffer = new byte[1024];
len = is.read(buffer);
if(len>0){
byte[] tmp = new byte[content.length + len];
System.arraycopy(content, 0, tmp, 0, content.length);
System.arraycopy(buffer, 0, tmp, content.length, len);
content = tmp;
}
获得请求后，我们开始解析请求，调用获得uri的方法：
uri = getRequestUri(new String(content));
在getRequestUri方法中。根据http协议的特性获得uri，回忆上面我们介绍的http协议的格式，我们会发现，在形如POST /servlet/testt.jsp HTTP/1.1 的格式总，uri正位于请求的第一个空格和第二个空格之间。那么我们根据此特性获得uri。
int uirStartIndex = -1;
int uriEndIndex = -1;
uirStartIndex = content.indexOf(' ');
if (uirStartIndex >-1) {
uriEndIndex = content.indexOf(' ', uirStartIndex + 1);
if (uriEndIndex > uirStartIndex)
return content.substring(uirStartIndex + 1, uriEndIndex);
}
当然，真正的服务器的请求对象并不是这么简单，方法也要多的多。
|
2011-03-28 14:13
1.1.1. HttpResponse类
此类负责响应客户的请求，但是这里仅限于响应静态请求和错误页面。此类也实现javaee的标准接口HttpServletResponse。
public class HttpResponse implements HttpServletResponse{
private HttpRequest request = null;
private OutputStream os = null;
public void setRequest(HttpRequest request) {
this.request = request;
}
public OutputStream getOs() {
return os;
}
public void setOs(OutputStream os) {
this.os = os;
}
public void responsStaticResource() {
byte[] buffer = new byte[1024];
FileInputStream fis = null;
try {
File file = new File(GlobalConstants.ROOT, request.getUri());
if (file.exists()) {
long length = file.length();
fis = new FileInputStream(file);
int len = fis.read(buffer);
long count = len;
while (true) {
os.write(buffer, 0, len);
len = fis.read(buffer);
if(count+len>=length){
break;
}
count = count+len;
}
}
else {
String error = "<h1>resourse Not Found</h1>";
String msg = "HTTP/1.1 404 resourse Not Found\r\n" +
"Content-Type: text/html\r\n" +
"Content-Length: "+error.length()+"\r\n" +
"\r\n" +error;
os.write(msg.getBytes());
}
}
catch (Exception e) {
e.printStackTrace();
}
finally {
if (fis != null)
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public PrintWriter getWriter() throws IOException {
PrintWriter printWrite = new PrintWriter(os, true);
return printWrite;
}
//以下省略一些没有用到的方法
．．．．．．
}
在这个类中中有一个主要方法responsStaticResource，在这个方法中，响应了客户的静态资源的请求。首先，建立一个ROOT常量（ROOT常量是规定服务器静态资源存在的根根目录）规定的目录下的uri文件对象，如果文件是存在的那么响应此文件，将它发送给客户端：如果文件不存在，发送给客户端错误页面。在这里，文件的发送使用了一个while循环，每次读取文件的数据发送给客户端，同时记录已经发送的数据的大小总数，如果字数大于等于文件的大小则跳出循环。
if (file.exists()) {
long length = file.length();
fis = new FileInputStream(file);
int len = fis.read(buffer);
long count = len;
while (true) {
os.write(buffer, 0, len);
len = fis.read(buffer);
if(count+len>=length){
break;
}
count = count+len;
}
}
else {
String error = "<h1>resourse Not Found</h1>";
String msg = "HTTP/1.1 404 resourse Not Found\r\n" +
"Content-Type: text/html\r\n" +
"Content-Length: "+error.length()+"\r\n" +
"\r\n" +error;
os.write(msg.getBytes());
}
}
在发送错误信息时，使用了对象PrintWriter 。getWriter() 负责构造此对象，它的构造参数是输出流和一个布尔变量，当为true表示缓冲将自动冲刷（flush），为false表示不会自动冲刷，要程序员手工冲刷：
PrintWriter printWrite = new PrintWriter(os, true);
1.1.2. ServletProcessor类
此类用来响应客户的servlet请求。
public class ServletProcessor {
public void process(RequestFacade request, ResponseFacade response) {
String uri = request.getUri();
String servletName = uri.substring(uri.lastIndexOf("/") + 1);
Loader loader = new Loader();
ClassLoader classLoader = loader.getClassLoader();
Class servletClass = null;
try {
servletClass = classLoader.loadClass("client.webapp."+servletName);
TestServlet servlet = (TestServlet) servletClass.newInstance();
servlet.init(null);
servlet.service((ServletRequest) request, (ServletResponse) response);
}
catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ServletException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
2011-03-28 14:14
此类只有一个方法，process，它接受两个参数：request和response。此方法完成客户请求的servlet名称的获得，servlet类的加载，实例化调用servlet的初始化init和服务service方法。首先获得servlet名称，servlet名称的获取是通过分析请求的uri获得的，依据是通过获得最后一个路径分割符位置，然后截取后面的字符串得到的：
String uri = request.getUri();
String servletName = uri.substring(uri.lastIndexOf("/") + 1);
比如uri为 /servet/TestServlet，那么获得servlet名称就是TestServlet。然后构造我们自己的类加载器：
Loader loader = new Loader();
ClassLoader classLoader = loader.getClassLoader();
有了类加载器，我们可以根据servlet名称加载我们的servlet类：实例化，调用servlet的初始化方法init和服务方法service。
servletClass = classLoader.loadClass("client.webapp."+servletName);
TestServlet servlet = (TestServlet) servletClass.newInstance();
servlet.init(null);
servlet.service((ServletRequest) request, (ServletResponse) response);
1.1.1. Loader类
此类是我们自定义的类加载器，它扩展类java.net.ClassLoader类，如果您对此类不了解，请参数JDK文档。
public class Loader extends ClassLoader{
public ClassLoader getClassLoader(){
ClassLoader loader = null;
try {
URLStreamHandler streamHandler = null;
URL[] urls = new URL[1];
File classPath = new File(GlobalConstants.ROOT);
String repository = (new URL("file", null,
classPath.getCanonicalPath() + File.separator)).toString() ;
urls[0] = new URL(null, repository, streamHandler);
loader = new URLClassLoader(urls);
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return loader;
}
}
此类的超类是java.lang.ClassLoader的间接子类. 如果构造 URLClassLoader 类的实例, 就可以使用它的 loadClass 方法加载一个 servlet 类。这个类有3种构造器, 最简单的如下:
public URLClassLoader(URL[] urls);
urls 是 java.net.URL 对象的数组， java.net.URL 对象指向当加载一个类时所要搜寻的位置。任何以 / 结尾的 URL 都假定是一个目录；否则, URL 假定应用的是一个 .jar 文件, 必要的时候， 会下载并打开这个 .jar 文件.
在服务器中, 一个 class loader 能够查找到 servlet 类的地方叫做 repository.。
在我们的程序里, 只有一处需要class loader搜索，那就是我们servlet存放的地方。 因此，我们先创建了一个包含单个 URL 的数组. URL 类提供了好几种构造器, 所以有很多方式去构造一个 URL，对象.本类中，我们使用如下构造器。
public URL(URL context, String spec, URLStreamHandler hander)
throws MalformedURLException
你可以这样使用这个构造器： 传递一个 specification 作为第二个参数， null 作为它的第一个和第三个参数. 但是, 还有另一种构造器，它也接收3个参数:
public URL(String protocol, String host, String file)
throws MalformedURLException
因此, 如果你像下面这样写，编译器将不知道你要用的是哪个构造器:
new URL(null, aString, null);
你可以这样解决： 告诉编译器第三个参数的类型:
URLStreamHandler streamHandler = null;
new URL(null, aString, streamHandler);
对于第二个参数, 传递一个包含 repository 的 String (the directory where servlet classes can be found). 使用下面的代码创建:
String repository = (new URL("file", null,
classPath.getCanonicalPath() + File.separator)).toString();
所以此类的创建方法如下：
URL[] urls = new URL[1];
File classPath = new File(GlobalConstants.ROOT);
String repository = (new URL("file", null,
classPath.getCanonicalPath() + File.separator)).toString() ;
urls[0] = new URL(null, repository, streamHandler);
loader = new URLClassLoader(urls);
1.1.2. RequestFacade类和ResponseFacade类
这两个类分别位于在随书光盘中的chapter/execixe1/src/server/request和chapter/execixe1/src/server/response目录下。
在HttpWebServer类中，我们记得，我们并没有直接将HttpRequest和HttpResponse传递给ServletProcessor对象的process方法，而是将它们做了包装，将它们包装成RequestFacade和ResponseFacade对象。之所以这么麻烦的做这个包装，主要是处于安全考虑。如果我们将HttpRequest和HttpResponse直接传递给ServletProcessor对象的process方法，尽管我们传递给servlet的是标准的Javaee标准的请求和响应对象，但是servlet程序员可以通过类型上溯获得HttpRequest和HttpResponse对象的直接引用，从而修改服务器的HttpRequest和HttpResponse的内部实现，如果那样，不是很危险吗？所以我们使用了包装类，这样我们传递给ServletProcessor对象的process方法是我们的包装类，即使servlet程序要类型上溯，那么也只能上溯到我们的包装类。这样对HttpRequest和HttpResponse就起到了保护作用。下面是这两个类的实现：
public class RequestFacade implements ServletRequest{
private HttpRequest request = null;
public RequestFacade(HttpRequest request){
this.request = request;
}
public String getAuthType() {
return request.getAuthType();
}
public String getContextPath() {
return request.getContextPath();
}
//以下省略了其他方法，因为其他方法的实现和这个实现类似，只是简单调用了request的相//应方法
．．．．．．
}
public class ResponseFacade implements ServletResponse{
private HttpResponse response = null;
public ResponseFacade(HttpResponse response){
this.response = response;
}
public void addCookie(Cookie arg0) {
response.addCookie(arg0);
}
//以下省略了其他方法，因为其他方法的实现和这个实现类似，只是简单调用了request的相//应方法
．．．．．．
}
1.1.2.1. 运行简单服务器
双击随书光盘中的chapter/execixe1/classes/client目录下的startup.bat文件，然后启动浏览器输入http://localhost:8080/servlet/TestServlet。就会出现如下效果：
1.1.3. 小结
2011-03-30 15:20
概览
容器是一个组件，这个组件为Servlet处理请求并为客户端呈现响应，容器接口位于org.apache.catalina.Container。一个有四种类型的容器：（引擎）Engine、（主机）Host、（上下文）Context、（包装器）Wrapper，这章将讲述上下文（Context）、包装器（Wrapper），而将引擎和主机留在第十三章讲述。这章开始讨论容器接口（Container），接着讲述容器饿pipeline机制。然后看看上下文（Context）、包装器（Wrapper）接口，这章包括两个应用：简单包装器（Wrapper）和简单上下文（Context）。
Container接口
容器必须实现org.apache.catalina.Container接口。正想你在第四章看到的，为了在连接器（Connector）中调用容器（Container）的invoke方法，必须传递一个Container实例到连接器（Connector）的setContainer方法来设置连接器对容器的引用。回忆第四章的bootStrap类的如下代码：
HttpConnector connector = new HttpConnector();
SimpleContainer container = new SimpleContainer();
connector.setContainer(container);
第一要注意的就是在Catalina中，有四种不同概念层次的容器：
● 引擎（Engine），是整个Catalina Servlet引擎。
● 主机（Host），包含一定数量上下文（Context）的虚拟主机
● 上下文（Context），代表一个web应用。上下文包含一个或多个包装器（Wrapper）。
、 ● 包装器（Wrapper），代表一个单独的Servlet。
上面的每种不同概念层次的容器在org.apache.catalina包中有相应的接口，他们分别是：Engine、Host、Context和Wrapper，四种接口都扩展了Container接口。四种容器的标准实现是StandardEngine、StandardHost、StandardContext和StandardWrapper，他们都位于org.apahce.catalina.core包内。
下面图表展示了Container接口和它的子接口及实现的关系。
一个基础的Catalina部署并不总是一直需要四种类型的容器。例如，这章的第一个应用的容器模块只有一个包装器（Wrapper）；第二个应用的容器模块包含一个上下文（Context）和一个包装器（Wrapper）；两个应用都没有用到虚拟主机（Host）和引擎（Engine）。
一个容器有零个或多个低层次的子容器。例如，一个上下文（Context）通常有一个或者多个包装器，一个主机可以有零个或者多个上下文。然而，一个包装器是最低层次的容器，它不能包含子容器。将一个子容器增加到父容器中，可以使用Container接口的addChild方法，其签名如下：
public void addChild(Container child);
从一个容器产出子容器，使用removeContainer方法，这个方法签名如下。
public void removeChild(Container child);
另外，容器接口支持通过findChild和findChilren对一个子容器或者多个子容器的查询。它们的方法签名如下：
public Container findChild(String name);
public Container[] findChildren();
一个容器可以包含一些支持的组件，比如，加载器（Loader），日志记录器（Logger），管理器（Manager）、安全域（Realm）和资源（Resources）。我们将在后面的章节中讨论这些组件。重要的是，容器提供set和get方法来将这些组件和容器关联起来。这些方法包括：setLoader和getLoader，setLogger和getLogger，setManager和getManager，setRealm和getRealm， getResources和setResources。
更有意思的是，容器接口被设计成在tocmat部署的时候，一个tocmat管理员可以通过编辑配置文件（server.xml）决定执行那个容器。这是通过pipeline任务和一系列阀来达到的。下面我们将讨论pipeline任务。
注释：在tomcat4中的容器和tomcat5的容器稍有不同，例如tomcat4中有map方法，但是tomcat5中取消了此方法
2011-03-30 15:21
Pipeline任务
这节阐述当连接器调用容器的invoke方法时，invoke方法做了什么工作。然后这节，讨论四个相关接口：Pipeline，Valve，ValveContext和Contained。他们位于org.apache.catalina包中。
一个pipeline包含容器将要执行的任务，一个阀（Valve）代表一个特定任务。在pipeline中只有一个基础阀（basic Valve），但是你可以增加任意多的其他阀，有意思的是阀可以通过编辑tomcat的配置文件（server.xml）来动态增加阀。
如果你理解了Servlet过滤器（filter），那么你不难理解pipeline和阀是如何工作的。一个pipeline象一个过滤器链，而阀则象过滤器。一个阀可以维护传递给它的请求（request）和响应（response）对象。当一个阀完成处理，它调用pipeline的下一个阀，而基础阀（basic valve）总是在最后调用。
一个容器可以有一个pipeline。当一个容器的invoke方法被调用时，容器将处理传递给pipeline，pipeline执行它的第一个阀，然后将继续执行下面的阀，直到pipeline的最后一个阀执行完毕。你可能想，你可以想pipeline的invoke方法代码如下：
// invoke each valve added to the pipeline
for (int n=0; n<valves.length; n++) {
valve
.invoke( ... );
}
// then, invoke the basic valve
basicValve.invoke( ... );
然而，tomcat设计者采用不同的方法。下面通过介绍ValveContext，你将了解它如何工作。
当连接器调用容器的invoke方法时，容器没有使用硬编码要执行的任务，而是容器调用了pipeline的invoke方法。Pipeline接口的invoke方法有如下签名，和容器的invoke方法的签名完全一样。
public void invoke(Request request, Response response)
throws IOException, ServletException;
下面是Container接口的invoke方法的实现，它位于org.apache.catalina.core.ContainerBasel类中。
public void invoke(Request request, Response response)
throws IOException, ServletException {
pipeline.invoke(request, response);
}
其中pipeline是容器内Pipeline接口的一个实例。
现在，pipeline必须确定它里面的所有的阀和基础阀都必须被执行一次。这是通过创建ValveContext接口实现的。为了ValveContext可以访问所有pipeline的成员，ValveContext作为Pipeline的内部类实现的。ValveContext中最重要的方法是invokeNext：
public void invokeNext(Request request, Response response)
throws IOException, ServletException
当ValveContext创建后，pipeline调用ValveContext的invoke方法。ValveContext首先执pipeline的第一个阀。并且在第一个阀做工作前，它执行下一个阀。为了阀可以执行 invokeNext方法，ValveContext要传递自己到每个阀中。下面是阀（Valve）接口的invoke方法的签名：
public void invoke(Request request, Response response,
ValveContext ValveContext) throws IOException, ServletException
阀的实现有点类似下面的代码：
public void invoke(Request request, Response response,
ValveContext valveContext) throws IOException, ServletException {
// Pass the request and response on to the next valve in our pipeline
valveContext.invokeNext(request, response);
// now perform what this valve is supposed to do
...
}
Org.apache.catalina.core.StandardPipeline类是所有容器的pipeline的实现。在tomcat4中，这个类有个内部类叫做StandardPipelineValveContext，它是ValveContext的实现类。下面是StandardPipelineValueContext类。
protected class StandardPipelineValveContext implements ValveContext {
protected int stage = 0;
public String getInfo() {
return info;
}
public void invokeNext(Request request, Response response)
throws IOException, ServletException {
int subscript = stage;
stage = stage + 1;
// Invoke the requested Valve for the current request thread
if (subscript < valves.length) {
valves[subscript].invoke(request, response, this);
}
else if ((subscript == valves.length) && (basic != null)) {
basic.invoke(request, response, this);
}
else {
throw new ServletException
(sm.getString("standardPipeline.noValve"));
}
}
}
tomcat容器（三）
2011-03-30 15:22
InvokeNext方法使用subscript和stage来记录将要执行哪个阀。当pipeline的invoke方法执行第一个invoke时，subscript值是0，stage值是1。因此，第一个阀被执行（索引subscript是0），pipeline的第一个阀接受一个ValveContext实例并且执行它的invokeNext方法。这时，subscript值是1，所以第二个阀被执行等等。
当最后的阀的invokeNexte被调用时，subscript的值等于阀的数量，结果基础阀（basic value）被执行。
在tomcat5中，删除了StandardPipeline的StandardPipelineValveContext类，取代的是org.apache.catalina.core.StandardValveContext类，下面是代码：
package org.apache.catalina.core;
import java.io.IOException;
import javax.servlet.ServletException;
import org.apache.catalina.Request;
import org.apache.catalina.Response;
import org.apache.catalina.Valve;
import org.apache.catalina.ValveContext;
import org.apache.catalina.util.StringManager;
public final class StandardValveContext implements ValveContext {
protected static StringManager sm =
StringManager.getManager(Constants.Package);
protected String info =
"org.apache.catalina.core.StandardValveContext/1.0";
protected int stage = 0;
protected Valve basic = null;
protected Valve valves[] = null;
public String getInfo() {
return info;
}
public final void invokeNext(Request request, Response response)
throws IOException, ServletException {
int subscript = stage;
stage = stage + 1;
// Invoke the requested Valve for the current request thread
if (subscript < valves.length) {
valves[subscript].invoke(request, response, this);
}
else if ((subscript == valves.length) && (basic != null)) {
basic.invoke(request, response, this);
}
else {
throw new ServletException
(sm.getString("standardPipeline.noValve"));
}
}
void set(Valve basic, Valve valves[]) {
stage = 0;
this.basic = basic;
this.valves = valves;
}
}
你可以看到tomcat4和tomcat5的上述类的相似之处吗？
我们将更详细阐述Pipeline、Valve、ValveContext接口，也将讨论阀通常实现的接口org.apache.catalina.Contained。
Pipeline接口
我们提过，Pipeline的第一个方法是invoke方法，这个方法将调用启动pipeline的阀和基础阀。Pipeline接口允许你通过addValve方法来增加一个新的阀，也可以通过removeValve方法删除一个阀。你可以使用setBasic方法来给pipeline分配一个基础阀。基础阀最后执行，负责处理请求和相应的响应。Pipeline接口如下：
package org.apache.catalina;
import java.io.IOException;
import javax.servlet.ServletException;
public interface Pipeline {
public Valve getBasic();
public void setBasic(Valve valve);
public void addValve(Valve valve);
public Valve[] getValves();
public void invoke(Request request, Response response)
throws IOException, ServletException;
public void removeValve(Valve valve);
}
|
|
|
|
|
|
