这一章和第一章的区别就是对servlet的支持。我们看下是怎么做的。
1）首先Response和Request这两个类分别实现了ServletResponse和ServletRequest接口，这两个接口和后面用到的Servlet接口都在javax.servlet这个package下面，需要添加servlet-api这个第三方依赖到classpath才能访问，这里用的是servlet-api-2.5。所有新加的方法除了Response.getWriter() 都没有任何处理，因为暂时没有用到。
Response.getWriter():
@Override
public PrintWriter getWriter() throws IOException {
writer = new PrintWriter(output, true);
return writer;
}
实例化了一个PrintWriter对象，第一个参数就是request的OutputStream，第二个参数表示是否自动flush。
2）对于静态资源请求和servlet请求分别创建了StaticResourceProcessor和ServletProcessor1。
StaticResourceProcessor：
import java.io.IOException;
public class StaticResourceProcessor {
public void process(Request request, Response response) {
try {
response.sendStaticResource();
} catch (IOException e) {
e.printStackTrace();
}
}
}
这里比较简单，就是条用response的sendStaticResource这个方法。
ServletProcessor1：
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.net.URLClassLoader;
import java.net.URLStreamHandler;
import javax.servlet.Servlet;
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 {
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);
} 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(request, response);
} catch (Throwable e) {
System.out.println(e.toString());
}
}
}
这段代码的主要目的就是通过Request的uri找到对应的Servlet类，通过URLClassLoader从文件加载这个类并通过反射实例化一个Servlet对象，然后通过Servlet对象的service方法处理请求。servlet文件暂时都是放在webroot这个文件夹。所以很明显，目前只能根据uri是否是以/servlet/开头来判断一个请求是否是servlet请求。而且对于每个请求，都必须创建一个Servlet实例。
3）然后修改HttpServer这个类，对于Servlet和静态资源请求使用不同的processor：
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 chapter1.Request object and parse
Request request = new Request(input);
request.parse();
// create chapter1.Response object
Response response = new Response(output);
response.setRequest(request);
if (request.getUri().startsWith("/servlet/")) {
ServletProcessor1 processor = new ServletProcessor1();
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();
continue;
}
}
}
4）在webroot下创建测试用的PrimitiveServlet：
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.Servlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
public class PrimitiveServlet implements Servlet {
@Override
public void init(ServletConfig servletConfig) throws ServletException {
System.out.println("init");
}
@Override
public ServletConfig getServletConfig() {
return null;
}
@Override
public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
System.out.println("from service");
PrintWriter out = servletResponse.getWriter();
out.println("Hello, Roses are red");
out.print("Violets are blue");
}
@Override
public String getServletInfo() {
return null;
}
@Override
public void destroy() {
System.out.println("destroy");
}
}
启动HttpServelt访问http://localhost:8080/servlet/PrimitiveServlet 会发现（火狐）浏览器打印出了:
Hello, Roses are red
我们会发现下面这一行：
out.print("Violets are blue");
并没有打印出来，这个问题会在后面解决。
5）使用门面模式隐藏request和response的方法
这部分是讲，我们在调用servelt的时候：
Servlet servlet = null;
try {
servlet = (Servlet) myClass.newInstance();
servlet.service(request, response);
} catch (Throwable e) {
System.out.println(e.toString());
}
直接传入了request和response，那么request和response里面一些public但是又不应该被servlet访问的方法可以被访问到。虽然Servlet.service的签名是：
public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException;
但是在PrimitiveServlet里面还是可以通过向下转型得到一个Request类型的对象：
public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
System.out.println("from service");
PrintWriter out = servletResponse.getWriter();
out.println("Hello, Roses are red");
out.print("Violets are blue");
Request request = (Request) servletRequest;
request.xxx();
// others
}
这样Request内部不希望被Servlet访问但是又必须是public的方法就暴露了。所以作者在这里使用门面模式把request和response做了封装，以request为例，新增了RequestFacade：
public class RequestFacade implements ServletRequest {
private ServletRequest request;
public RequestFacade(ServletRequest request) {
this.request = request;
}
@Override
public Object getAttribute(String s) {
return request.getAttribute(s);
}
@Override
public Enumeration getAttributeNames() {
return request.getAttributeNames();
}
//.....
}
同样实现了ServletRequest接口，同时内部保留一个Request类型的引用，所有的方法都转发给真正的request。Response也是类似的处理。重构之后的ServletProcessor1:
Servlet servlet = null;
RequestFacade requestFacade = new RequestFacade(request);
ResponseFacade responseFacade = new ResponseFacade(response);
try {
servlet = (Servlet) myClass.newInstance();
servlet.service(requestFacade, responseFacade);
} catch (Throwable e) {
System.out.println(e.toString());
}
这里传给Servlet.service()的就是Facade了，不必再担心Servlet里面会对request和respone向下转型。