Servlet容器有两个主要的模块，即连接器(connector)与容器(container)，本文接下来创建一个连接器来增强前面文章中的应用程序的功能，以一种更优雅的方式来创建request对象和response对象;为了兼容Servlet 2.3和2.4，连接器这里创建的是javax.servlet.http.HttpServletRequest对象和javax.servlet.http.HttpServletResponse对象（servlet对象类型可以是实现javax.servlet.Servlet接口或继承自javax.servlet.GenericServlet类或javax.servlet.http.HttpServlet类）。

在本文的应用程序中，连接器会解析http请求头、cookies和请求参数等；同时修改了Response类的getWriter()方法，使其工作得更好。

本文首先要介绍一下在servlet容器中是怎么实现错误消息国际化的，这里主要是StringManager类实现的功能

Tomcat是将错误消息存储在properties文件中，便于读取和编辑；可是由于 tomcat的类特别多，将所有类使用的错误消息都存储在同一个properties文件中将会造成维护的困难；所以tomcat的处理方式是将properties划分在不同的包中，每个properties文件都是用StringManager类的一个实例来处理，这样在tomcat运行时，会产生StringManager类的多个实例；同一个包里面的类共享一个StringManager类的实例（这里采用单例模式）；这些不同包用到的的StringManager类的实例存储在一个hashtable容器中，以包名作为key存储StringManager类的实例

public class StringManager {

/\*\*  
 \* The ResourceBundle for this StringManager.  
 \*/

private ResourceBundle bundle;

/\*\*  
 \* Creates a new StringManager for a given package. This is a  
 \* private method and all access to it is arbitrated by the  
 \* static getManager method call so that only one StringManager  
 \* per package will be created.  
 \*  
 \* @param packageName Name of package to create StringManager for.  
 \*/

private StringManager(String packageName) {  
String bundleName = packageName + ".LocalStrings";  
bundle = ResourceBundle.getBundle(bundleName);  
}

/\*\*  
 \* Get a string from the underlying resource bundle.  
 \*  
 \* @param key  
 \*/

public String getString(String key) {  
    if (key == null) {  
        String msg = "key is null";

        throw new NullPointerException(msg);  
    }

    String str = null;

    try {  
    str = bundle.getString(key);  
    } catch (MissingResourceException mre) {  
        str = "Cannot find message associated with key '" + key + "'";  
    }

    return str;  
}  

// --------------------------------------------------------------
// STATIC SUPPORT METHODS
// --------------------------------------------------------------

private static Hashtable managers = new Hashtable();

/\*\*  
 \* Get the StringManager for a particular package. If a manager for  
 \* a package already exists, it will be reused, else a new  
 \* StringManager will be created and returned.  
 \*  
 \* @param packageName  
 \*/

public synchronized static StringManager getManager(String packageName) {  
StringManager mgr = (StringManager)managers.get(packageName);  
if (mgr == null) {  
    mgr = new StringManager(packageName);  
    managers.put(packageName, mgr);  
}  
return mgr;  
}  

}

下面我们来分析连接器是怎样实现的：

public class HttpConnector implements Runnable {

boolean stopped;
private String scheme = "http";

public String getScheme() {
return scheme;
}

public void run() {
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 (!stopped) {
// Accept the next incoming connection from the server socket
Socket socket = null;
try {
socket = serverSocket.accept();
}
catch (Exception e) {
continue;
}
// Hand this socket off to an HttpProcessor
HttpProcessor processor = new HttpProcessor(this);
processor.process(socket);
}
}

public void start() {
Thread thread = new Thread(this);
thread.start();
}
}

我们从HttpConnector连接器的实现可以看到，该连接器负责监听客户端请求，当监听到客户端请求时，将获取的socket对象交给HttpProcessor对象的process()方法处理

我们接下来分析HttpProcessor类的实现：

/* this class used to be called HttpServer */
public class HttpProcessor {

public HttpProcessor(HttpConnector connector) {
this.connector = connector;
}
/**
* The HttpConnector with which this processor is associated.
*/
private HttpConnector connector = null;
private HttpRequest request;
private HttpResponse response;
public void process(Socket socket) {
SocketInputStream input = null;
OutputStream output = null;
try {
//包装为SocketInputStream对象
input = new SocketInputStream(socket.getInputStream(), 2048);
output = socket.getOutputStream();

  // create HttpRequest object and parse  
  request = new HttpRequest(input);

  // create HttpResponse object  
  response = new HttpResponse(output);  
  response.setRequest(request);

  response.setHeader("Server", "Pyrmont Servlet Container");  
  //解析请求行  
  parseRequest(input, output);  
  //解析请求头  
  parseHeaders(input);

  //check if this is a request for a servlet or a static resource  
  //a request for a servlet begins with "/servlet/"  
  if (request.getRequestURI().startsWith("/servlet/")) {  
    ServletProcessor processor = new ServletProcessor();  
    processor.process(request, response);  
  }  
  else {  
    StaticResourceProcessor processor = new StaticResourceProcessor();  
    processor.process(request, response);  
  }

  // Close the socket  
  socket.close();  
  // no shutdown for this application  
}  
catch (Exception e) {  
  e.printStackTrace();  
}  

}

上面的方法中获取socket对象的输入流与输出流分别创建Request对象与Response对象，然后解析http请求行与请求头（并填充到Request对象的相应属性），最后分发给处理器处理

接下来的Request对象实现了javax.servlet.http.HttpServletRequest接口，主要是提供一些设置相关请求参数的方法和获取相关请求参数的方法

http请求头、cookies和请求参数等信息分别存储在如下成员变量中

protected ArrayList cookies = new ArrayList();

protected HashMap headers = new HashMap();

protected ParameterMap parameters = null;

需要注意的是protected void parseParameters()方法只需执行一次，该方法是用来初始化ParameterMap parameters成员变量，方法如下

/**
* Parse the parameters of this request, if it has not already occurred.
* If parameters are present in both the query string and the request
* content, they are merged.
*/
protected void parseParameters() {
if (parsed)
return;
ParameterMap results = parameters;
if (results == null)
results = new ParameterMap();
results.setLocked(false);
String encoding = getCharacterEncoding();
if (encoding == null)
encoding = "ISO-8859-1";

// Parse any parameters specified in the query string  
String queryString = getQueryString();  
try {  
  RequestUtil.parseParameters(results, queryString, encoding);  
}  
catch (UnsupportedEncodingException e) {  
  ;  
}

// Parse any parameters specified in the input stream  
String contentType = getContentType();  
if (contentType == null)  
  contentType = "";  
int semicolon = contentType.indexOf(';');  
if (semicolon >= 0) {  
  contentType = contentType.substring(0, semicolon).trim();  
}  
else {  
  contentType = contentType.trim();  
}  
if ("POST".equals(getMethod()) && (getContentLength() > 0)  
  && "application/x-www-form-urlencoded".equals(contentType)) {  
  try {  
    int max = getContentLength();  
    int len = 0;  
    byte buf\[\] = new byte\[getContentLength()\];  
    ServletInputStream is = getInputStream();  
    while (len < max) {  
      int next = is.read(buf, len, max - len);  
      if (next < 0 ) {  
        break;  
      }  
      len += next;  
    }  
    is.close();  
    if (len < max) {  
      throw new RuntimeException("Content length mismatch");  
    }  
    RequestUtil.parseParameters(results, buf, encoding);  
  }  
  catch (UnsupportedEncodingException ue) {  
    ;  
  }  
  catch (IOException e) {  
    throw new RuntimeException("Content read fail");  
  }  
}

// Store the final results  
results.setLocked(true);  
parsed = true;  
parameters = results;  

}

我就不明白，该方法为什么不采取同步锁关键字？难道是对初始化ParameterMap parameters成员变量次数没有硬性要求？

上面方法中的ParameterMap对象，继承自HashMap，采用boolean locked = false成员变量设置写入的锁（这玩意也有问题）

public final class ParameterMap extends HashMap {

// ----------------------------------------------------------- Constructors

/\*\*  
 \* Construct a new, empty map with the default initial capacity and  
 \* load factor.  
 \*/  
public ParameterMap() {

    super();

}

/\*\*  
 \* Construct a new, empty map with the specified initial capacity and  
 \* default load factor.  
 \*  
 \* @param initialCapacity The initial capacity of this map  
 \*/  
public ParameterMap(int initialCapacity) {

    super(initialCapacity);

}

/\*\*  
 \* Construct a new, empty map with the specified initial capacity and  
 \* load factor.  
 \*  
 \* @param initialCapacity The initial capacity of this map  
 \* @param loadFactor The load factor of this map  
 \*/  
public ParameterMap(int initialCapacity, float loadFactor) {

    super(initialCapacity, loadFactor);

}

/\*\*  
 \* Construct a new map with the same mappings as the given map.  
 \*  
 \* @param map Map whose contents are dupliated in the new map  
 \*/  
public ParameterMap(Map map) {

    super(map);

}

// ------------------------------------------------------------- Properties

/\*\*  
 \* The current lock state of this parameter map.  
 \*/  
private boolean locked = false;

/\*\*  
 \* Return the locked state of this parameter map.  
 \*/  
public boolean isLocked() {

    return (this.locked);

}

/\*\*  
 \* Set the locked state of this parameter map.  
 \*  
 \* @param locked The new locked state  
 \*/  
public void setLocked(boolean locked) {

    this.locked = locked;

}

/\*\*  
 \* The string manager for this package.  
 \*/  
private static final StringManager sm =  
    StringManager.getManager("org.apache.catalina.util");

// --------------------------------------------------------- Public Methods

/\*\*  
 \* Remove all mappings from this map.  
 \*  
 \* @exception IllegalStateException if this map is currently locked  
 \*/  
public void clear() {

    if (locked)  
        throw new IllegalStateException  
            (sm.getString("parameterMap.locked"));  
    super.clear();

}

/\*\*  
 \* Associate the specified value with the specified key in this map.  If  
 \* the map previously contained a mapping for this key, the old value is  
 \* replaced.  
 \*  
 \* @param key Key with which the specified value is to be associated  
 \* @param value Value to be associated with the specified key  
 \*  
 \* @return The previous value associated with the specified key, or  
 \*  null if there was no mapping for key  
 \*  
 \* @exception IllegalStateException if this map is currently locked  
 \*/  
public Object put(Object key, Object value) {

    if (locked)  
        throw new IllegalStateException  
            (sm.getString("parameterMap.locked"));  
    return (super.put(key, value));

}

/\*\*  
 \* Copy all of the mappings from the specified map to this one.  These  
 \* mappings replace any mappings that this map had for any of the keys  
 \* currently in the specified Map.  
 \*  
 \* @param map Mappings to be stored into this map  
 \*  
 \* @exception IllegalStateException if this map is currently locked  
 \*/  
public void putAll(Map map) {

    if (locked)  
        throw new IllegalStateException  
            (sm.getString("parameterMap.locked"));  
    super.putAll(map);

}

/\*\*  
 \* Remove the mapping for this key from the map if present.  
 \*  
 \* @param key Key whose mapping is to be removed from the map  
 \*  
 \* @return The previous value associated with the specified key, or  
 \*  null if there was no mapping for that key  
 \*  
 \* @exception IllegalStateException if this map is currently locked  
 \*/  
public Object remove(Object key) {

    if (locked)  
        throw new IllegalStateException  
            (sm.getString("parameterMap.locked"));  
    return (super.remove(key));

}

}

同样Response对象实现了javax.servlet.http.HttpServletResponse接口

这里改写了前面文章中的getWriter()方法输出字符流到客户端

public PrintWriter getWriter() throws IOException {
ResponseStream newStream = new ResponseStream(this);
newStream.setCommit(false);
OutputStreamWriter osr =
new OutputStreamWriter(newStream, getCharacterEncoding());
writer = new ResponseWriter(osr);
return writer;
}

---------------------------------------------------------------------------

本系列How Tomcat Works系本人原创

转载请注明出处 博客园 刺猬的温驯

本人邮箱： chenying998179#163.com （#改为@）

本文链接 http://www.cnblogs.com/chenying99/p/3231639.html