Coder 爱通译 How Tomcat Works 第四章 第二部分

Coder 爱翻译 How Tomcat Works 第四章 第二部分
Request Objects

在默认的连接器中org.apache.catalina.Request接口代表了一个HTTP请求对象。HttpRequest的父类—RequestBase类直接实现了这个接口。最终的实现是HttpRequestImpl，它继承HttpRequest。在第三章中，有facade类：RequstFacade和HttpRequestFacade。



Response Objects



Processing Requests

现在，你已经了解了request、response对象和HttpConnector对象怎么创建它们。这部分我们关注HttpProcessor类的process方法，这个方法是HttpProcessor类的被指配了一个socket后的run方法里调用。这个process方法处理一下工作：

?解析连接
?解析请求
?解析头部信息

process方法使用boolean变量ok来表示在处理过程中是否出错和使用boolean变量finishResponse来表示Response接口的finishResponse方法应该被调用。

boolean ok = true; boolean finishResponse = true;

此外，http11.keepAlive表明了这个连接时持久的，stopped表明HttpProcessor实例连接器
process方法也应该停止，http11表明一个web客户端到来HTTP请求从支持HTTP1.1。

象第三章，一个SocketInputStream实例被用来包装socket的输入流。注意：SocketInputStream的构造函数也传递从连接器得到的buffer size，不是从HttpProcessor类的一个局部变量得到的。这是因为HttpProcessor不能被默认连接器的用户访问。通过把buffer size放进Connector接口，这就允许任何一个人使用连接器来设置buffer size。

OutputStream output = null; // Construct and initialize the objects we will need try {     input = new SocketInputStream(socket.getInputstream(),       connector.getBufferSize()); } catch (Exception e) { ok = false;}

然后，有一个while循环保持读取输入流，知道HttpProcessor停止、一个异常抛出或者是连接被关闭。

  keepAlive = true;    while (!stopped && ok && keepAlive) {      ...    }

在这个while循环里，process方法在finishResponse被设为true、获取输出流、处理一些request和resposne对象的初始化后开始执行。

finishResponse = true;      try {        request.setStream(input);        request.setResponse(response);        output = socket.getOutputStream();        response.setStream(output);        response.setRequest(request);        ((HttpServletResponse) response.getResponse()).setHeader          ("Server", SERVER_INFO);      }  catch (Exception e) {        log("process.create", e);  //logging is discussed in Chapter 7        ok = false;      }

后来，process方法通过调用parseConnection，parseRequest和parseHeader方法来解析到来的HTTP请求。

 try {        if (ok) {          parseConnection(socket);          parseRequest(input, output);          if (!request.getRequest().getProtocol()            .startsWith("HTTP/0"))            parseHeaders(input);

parseConnection方法获取协议的值。可以使：HTTP0.9，HTTP1.0或者是HTTP1.1。如果协议是HTTP1.0，keepAlive的boolean值设置成false，因为HTTP1.0不支持持久连接。parseHeader方法设置sendAck的boolean值为true(但在100-continue头信息被HTTP请求发现除外)

如果协议时HTTP1.1，如果web客户端发送了100—continue头部信息，它还要检查块编码是否允许。

if (http11) {        // Sending a request acknowledge back to the client if        // requested.        ackRequest(output);        // If the protocol is HTTP/1.1, chunking is allowed.        if (connector.isChunkingAllowed())          response.setAllowChunking(true);      }

AckRequest方法检查sendAck的值和在sendAckweitrue时发送下面的字符串：

HTTP/1.1 100 Continue\r\n\r\n

在解析HTTP请求期间，可能会抛出异常。任何异常将设置ok或finishResponse为false。在解析后，process方法把request和response对象传递给容器的invoke方法。

  try {        ((HttpServletResponse) response).setHeader          ("Date", FastHttpDateFormat.getCurrentDate());        if (ok) {          connector.getContainer().invoke(request, response);        }      }

最后，如果finishResponse任然为true，调用response对象的finishResponse方法和request对象的finishRequest方法，把输出flush。

 if (finishResponse) {        ...        response.finishResponse();        ...        request.finishRequest();        ...        output.flush();

while循环的最后一部分是检查response的Connection头部信息在servlet或HTTP1.0协议中是否被设置成colse。如果是这种情况，keepAlive被设置成false。同样的，request和response对象被回收。

  if ( "close".equals(response.getHeader("Connection")) ) {        keepAlive = false;      }      // End of request processing      status = Constants.PROCESSOR_IDLE;      // Recycling the request and the response objects      request.recycle();      response.recycle();}

While循环如果keepAlive是true，在之前的解析和容器的invoke方法没有错误，或者HttpProcessor实例没有停止。shutdownInput方法被调用，关闭socket。

try { shutdownInput(input); socket.close(); } ...

shutdownInput方法检查是否有没有读取的字节。如果有，跳过这些字节。

Parsing the Connection

parseConnection方法包含来自socket的Internet地址，并把它指配给HttpRequestImpl对象。它也检查代理是否被使用，并把它指配给request对象。

private void parseConnection(Socket socket)    throws IOException, ServletException {    if (debug >= 2)      log("  parseConnection: address=" + socket.getInetAddress() +        ", port=" + connector.getPort());    ((HttpRequestImpl) request).setInet(socket.getInetAddress());  if (proxyPort != 0)      request.setServerPort(proxyPort);    else      request.setServerPort(serverPort);    request.setSocket(socket); }

Parsing the Request

parseRequest方法跟第三章的方法相似。

Parsing Headers

在默认连接器的parseHeaders方法使用org.apache.catalina.connector.http包中的HttpHeader和DefaultHeaders类。HttpHeader类代表一个HTTP请求头部信息。第三章使用字符串。HttpHeader类使用字符数组来避免字符串操作的开销。DefaultHeaders类是一个final类，它在字符数组中包含标准的HTTP请求头部信息。

static final char[] AUTHORIZATION_NAME =     "authorization".toCharArray(); static final char[] ACCEPT_LANGUAGE_NAME =     "accept-language".toCharArray(); static final char[] COOKIE_NAME = "cookie".toCharArray(); ...

parseHeaders方法包含一个while循环，保持读取HTTP请求，直到没有更多的头部信息可读取。while循环调用request对象allocateHeader方法来获取一个空的HttpHeader实例后开始。这个实例被传递给SocketInputStream的readHeader方法。

  HttpHeader header = request.allocateHeader();       // Read the next header      input.readHeader(header);

如果所有头部信息被读取，readHeader方法

   if (header.nameEnd == 0) {      if (header.valueEnd == 0) {        return;      }      else {        throw new ServletException          (sm.getString("httpProcessor.parseHeaders.colon"));      }    }

如果有一个header name，这里就会有一个header value与之对应。

String value = new String(header.value, 0, header.valueEnd);

接下来，就象第三章，parseHeaders方法让header name和在DefaultHeaders的标准name相比较。
注意：是在两个字符数组比较，而不是字符串。

  if (header.equals(DefaultHeaders.AUTHORIZATION_NAME)) {        request.setAuthorization(value);      }      else if (header.equals(DefaultHeaders.ACCEPT_LANGUAGE_NAME)) {        parseAcceptLanguage(value);      }      else if (header.equals(DefaultHeaders.COOKIE_NAME)) {        // parse cookie      }      else if (header.equals(DefaultHeaders.CONTENT_LENGTH_NAME)) {        // get content length      }      else if (header.equals(DefaultHeaders.CONTENT_TYPE_NAME)) {          request.setContentType(value);      }      else if (header.equals(DefaultHeaders.HOST_NAME)) {        // get host name      }      else if (header.equals(DefaultHeaders.CONNECTION_NAME)) {  if (header.valueEquals(DefaultHeaders.CONNECTION_CLOSE_VALUE)) {          keepAlive = false;          response.setHeader("Connection", "close");        }  }      else if (header.equals(DefaultHeaders.EXPECT_NAME)) {        if (header.valueEquals(DefaultHeaders.EXPECT_100_VALUE))          sendAck = true;        else          throw new ServletException(sm.getstring            ("httpProcessor.parseHeaders.unknownExpectation"));      }       else if (header.equals(DefaultHeaders.TRANSFER_ENCODING_NAME)) {        //request.setTransferEncoding(header);      }       request.nextHeader();

The Simple Container Application

ex04.pyrmont.core.SimpleContainer和ex04 pyrmont.startup.Bootstrap。

Listing 4.3: The SimpleContainer class    package ex04.pyrmont.core; import java.beans.PropertyChangeListener; import java.net.URL; import java.net.URLClassLoader; import java.net.URLStreamHandler; import java.io.File; import java.io.IOException; import javax.naming.directory.DirContext; import javax.servlet.Servlet; import javax.servlet.ServletException; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.apache.catalina.Cluster;import org.apache.catalina.Container; import org.apache.catalina.ContainerListener; import org.apache.catalina.Loader; import org.apache.catalina.Logger; import org.apache.catalina.Manager; import org.apache.catalina.Mapper; import org.apache.catalina.Realm; import org.apache.catalina.Request; import org.apache.catalina.Response;  public class SimpleContainer implements Container {     public static final String WEB_ROOT =      System.getProperty("user.dir") + File.separator + "webroot";     public SimpleContainer() {  }    public String getInfo() {  return null;    }    public Loader getLoader() {      return null;    }    public void setLoader(Loader loader) {  }    public Logger getLogger() {      return null;    }    public void setLogger(Logger logger) {  }    public Manager getManager() {      return null;    }  public void setCluster(Cluster cluster) {  }     public String getName() {      return null;    }    public void setName(String name) {  }    public Container getParent() {      return null;    }    public void setParent(Container container) {  }  public ClassLoader getParentClassLoader() {      return null;    }    public void setParentClassLoader(ClassLoader parent) {  }    public Realm getRealm() {      return null;    }    public void setRealm(Realm realm) {  }    public DirContext getResources() {      return null;    }    public void setResources(DirContext resources) {  }    public void addChild(Container child) {  }    public void addContainerListener(ContainerListener listener) {  }    public void addMapper(Mapper mapper) {  }    public void addPropertyChangeListener(    PropertyChangeListener listener) {  }    public Container findchild(String name) {      return null;    }    public Container[] findChildren() {      return null;    }  public ContainerListener[] findContainerListeners() {      return null;    }    public Mapper findMapper(String protocol) {      return null;    }    public Mapper[] findMappers() {      return null;    }    public void invoke(Request request, Response response)      throws IoException, ServletException {       string servletName = ( (Httpservletrequest) request).getRequestURI();      servletName = servletName.substring(servletName.lastIndexof("/") + 1);      URLClassLoader loader = null;  try {        URL[] urls = new URL[1];        URLStreamHandler streamHandler = null;        File classpath = new File(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((HttpServletRequest) request,(HttpServletResponse) response);      }      catch (Exception e) {        System.out.println(e.toString());      }      catch (Throwable e) {        System.out.println(e.toString());      }    }     public Container map(Request request, boolean update) {      return null;    }    public void removeChild(Container child) {  }    public void removeContainerListener(ContainerListener listener) {  }    public void removeMapper(Mapper mapper) {  }   public void removeMapper(Mapper mapper) {  }    public void removoPropertyChangeListener(      PropertyChangeListener listener) {    } }

这里只提供了SimpleContainer类的invoke方法的实现。因为默认的连接器将调用这个方法。invoke方法创建一个类加载器，加载servlet类，调用它的servlet的service方法。

Listing 4.4: The ex04.pyrmont.startup.Bootstrap class    package ex04.pyrmont.startup; import ex04.pyrmont.core.simplecontainer; import org.apache.catalina.connector.http.HttpConnector;  public final class Bootstrap {    public static void main(string[] args) {   HttpConnector connector = new HttpConnector();      SimpleContainer container = new SimpleContainer();      connector.setContainer(container);      try {        connector.initialize();        connector.start();         // make the application wait until we press any key.        System in.read();      }      catch (Exception e) {        e.printStackTrace();      }    } }

Bootstrap类的main方法构建了一个org.apache.catalina.connector.http.HttpConnector的实例和一个SimpleContainer接口。然后调用连接器的setContainer方法把连接器和容器联系起来。接下来，它调用连接器的initialize和start方法。它将让连接器处理在8080端口上的任何HTTP请求。
                                                                第四章 完

查看更多 下一篇