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

111

　　    在第二章中，作者给出了一个简单的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;
}
}