InputStream的封装类

package ex03.pyrmont.connector.http;

import java.io.IOException;
import java.io.InputStream;
import java.io.EOFException;
import org.apache.catalina.util.StringManager;

/**
 * 继承于InputStream，可以在处理HTTP请求头的时候更有效率
 */
public class SocketInputStream extends InputStream {

    // ---------------------------------------------------------解析字符串时的常量

    /**
     * CR. 回车
     */
    private static final byte CR = (byte) '\r';

    /**
     * LF.换行
     */
    private static final byte LF = (byte) '\n';

    /**
     * SP.空格
     */
    private static final byte SP = (byte) ' ';

    /**
     * HT. Tab
     */
    private static final byte HT = (byte) '\t';

    /**
     * COLON. 冒号
     */
    private static final byte COLON = (byte) ':';

    /**
     * Lower case offset. 小写字符转大写的偏移量
     */
    private static final int LC_OFFSET = 'A' - 'a';

    /**
     * 内部缓存.
     */
    protected byte buf[];

    /**
     * 最大字节数.
     */
    protected int count;

    /**
     * Position in the buffer.
     */
    protected int pos;

    /**
     * Underlying input stream.里层的输入流
     */
    protected InputStream is;

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

    /**
     * Construct a servlet input stream associated with the specified socket
     * input.
     *
     * @param is socket input stream
     * @param bufferSize size of the internal buffer
     */
    public SocketInputStream(InputStream is, int bufferSize) {

        this.is = is;
        buf = new byte[bufferSize];

    }

    // -------------------------------------------------------------- Variables

    /**
     * The string manager for this package.
     */
    protected static StringManager sm =
        StringManager.getManager(Constants.Package);

    // ----------------------------------------------------- Instance Variables

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

    /**
     * Read the request line, and copies it to the given buffer. This
     * function is meant to be used during the HTTP request header parsing.
     * Do NOT attempt to read the request body using it.
     *
     * @param requestLine Request line object
     * @throws IOException If an exception occurs during the underlying socket
     * read operations, or if the given buffer is not big enough to accomodate
     * the whole line.
     */
    public void readRequestLine(HttpRequestLine requestLine)
        throws IOException {

        // Recycling check
        if (requestLine.methodEnd != 0)
            requestLine.recycle();

        // Checking for a blank line
        int chr = 0;
        do { // Skipping CR or LF
            try {
                chr = read();
            } catch (IOException e) {
                chr = -1;
            }
        } while ((chr == CR) || (chr == LF));
        if (chr == -1)
            throw new EOFException
                (sm.getString("requestStream.readline.error"));
        pos--;

        // Reading the method name

        int maxRead = requestLine.method.length;
        int readStart = pos;
        int readCount = 0;

        boolean space = false;

        while (!space) {
            // if the buffer is full, extend it
            if (readCount >= maxRead) {
                if ((2 * maxRead) <= HttpRequestLine.MAX_METHOD_SIZE) {
                    char[] newBuffer = new char[2 * maxRead];
                    System.arraycopy(requestLine.method, 0, newBuffer, 0,
                                     maxRead);
                    requestLine.method = newBuffer;
                    maxRead = requestLine.method.length;
                } else {
                    throw new IOException
                        (sm.getString("requestStream.readline.toolong"));
                }
            }
            // We're at the end of the internal buffer
            if (pos >= count) {
                int val = read();
                if (val == -1) {
                    throw new IOException
                        (sm.getString("requestStream.readline.error"));
                }
                pos = 0;
                readStart = 0;
            }
            if (buf[pos] == SP) {
                space = true;
            }
            requestLine.method[readCount] = (char) buf[pos];
            readCount++;
            pos++;
        }

        requestLine.methodEnd = readCount - 1;

        // Reading URI

        maxRead = requestLine.uri.length;
        readStart = pos;
        readCount = 0;

        space = false;

        boolean eol = false;

        while (!space) {
            // if the buffer is full, extend it
            if (readCount >= maxRead) {
                if ((2 * maxRead) <= HttpRequestLine.MAX_URI_SIZE) {
                    char[] newBuffer = new char[2 * maxRead];
                    System.arraycopy(requestLine.uri, 0, newBuffer, 0,
                                     maxRead);
                    requestLine.uri = newBuffer;
                    maxRead = requestLine.uri.length;
                } else {
                    throw new IOException
                        (sm.getString("requestStream.readline.toolong"));
                }
            }
            // We're at the end of the internal buffer
            if (pos >= count) {
                int val = read();
                if (val == -1)
                    throw new IOException
                        (sm.getString("requestStream.readline.error"));
                pos = 0;
                readStart = 0;
            }
            if (buf[pos] == SP) {
                space = true;
            } else if ((buf[pos] == CR) || (buf[pos] == LF)) {
                // HTTP/0.9 style request
                eol = true;
                space = true;
            }
            requestLine.uri[readCount] = (char) buf[pos];
            readCount++;
            pos++;
        }

        requestLine.uriEnd = readCount - 1;

        // Reading protocol

        maxRead = requestLine.protocol.length;
        readStart = pos;
        readCount = 0;

        while (!eol) {
            // if the buffer is full, extend it
            if (readCount >= maxRead) {
                if ((2 * maxRead) <= HttpRequestLine.MAX_PROTOCOL_SIZE) {
                    char[] newBuffer = new char[2 * maxRead];
                    System.arraycopy(requestLine.protocol, 0, newBuffer, 0,
                                     maxRead);
                    requestLine.protocol = newBuffer;
                    maxRead = requestLine.protocol.length;
                } else {
                    throw new IOException
                        (sm.getString("requestStream.readline.toolong"));
                }
            }
            // We're at the end of the internal buffer
            if (pos >= count) {
                // Copying part (or all) of the internal buffer to the line
                // buffer
                int val = read();
                if (val == -1)
                    throw new IOException
                        (sm.getString("requestStream.readline.error"));
                pos = 0;
                readStart = 0;
            }
            if (buf[pos] == CR) {
                // Skip CR.
            } else if (buf[pos] == LF) {
                eol = true;
            } else {
                requestLine.protocol[readCount] = (char) buf[pos];
                readCount++;
            }
            pos++;
        }

        requestLine.protocolEnd = readCount;

    }

    /**
     * Read a header, and copies it to the given buffer. This
     * function is meant to be used during the HTTP request header parsing.
     * Do NOT attempt to read the request body using it.
     *
     * @param requestLine Request line object
     * @throws IOException If an exception occurs during the underlying socket
     * read operations, or if the given buffer is not big enough to accomodate
     * the whole line.
     */
    public void readHeader(HttpHeader header)
        throws IOException {

        // Recycling check
        if (header.nameEnd != 0)
            header.recycle();

        // Checking for a blank line
        int chr = read();
        if ((chr == CR) || (chr == LF)) { // Skipping CR
            if (chr == CR)
                read(); // Skipping LF
            header.nameEnd = 0;
            header.valueEnd = 0;
            return;
        } else {
            pos--;
        }

        // Reading the header name

        int maxRead = header.name.length;
        int readStart = pos;
        int readCount = 0;

        boolean colon = false;

        while (!colon) {
            // if the buffer is full, extend it
            if (readCount >= maxRead) {
                if ((2 * maxRead) <= HttpHeader.MAX_NAME_SIZE) {
                    char[] newBuffer = new char[2 * maxRead];
                    System.arraycopy(header.name, 0, newBuffer, 0, maxRead);
                    header.name = newBuffer;
                    maxRead = header.name.length;
                } else {
                    throw new IOException
                        (sm.getString("requestStream.readline.toolong"));
                }
            }
            // We're at the end of the internal buffer
            if (pos >= count) {
                int val = read();
                if (val == -1) {
                    throw new IOException
                        (sm.getString("requestStream.readline.error"));
                }
                pos = 0;
                readStart = 0;
            }
            if (buf[pos] == COLON) {
                colon = true;
            }
            char val = (char) buf[pos];
            if ((val >= 'A') && (val <= 'Z')) {
                val = (char) (val - LC_OFFSET);
            }
            header.name[readCount] = val;
            readCount++;
            pos++;
        }

        header.nameEnd = readCount - 1;

        // Reading the header value (which can be spanned over multiple lines)

        maxRead = header.value.length;
        readStart = pos;
        readCount = 0;

        int crPos = -2;

        boolean eol = false;
        boolean validLine = true;

        while (validLine) {

            boolean space = true;

            // Skipping spaces
            // Note : Only leading white spaces are removed. Trailing white
            // spaces are not.
            while (space) {
                // We're at the end of the internal buffer
                if (pos >= count) {
                    // Copying part (or all) of the internal buffer to the line
                    // buffer
                    int val = read();
                    if (val == -1)
                        throw new IOException
                            (sm.getString("requestStream.readline.error"));
                    pos = 0;
                    readStart = 0;
                }
                if ((buf[pos] == SP) || (buf[pos] == HT)) {
                    pos++;
                } else {
                    space = false;
                }
            }

            while (!eol) {
                // if the buffer is full, extend it
                if (readCount >= maxRead) {
                    if ((2 * maxRead) <= HttpHeader.MAX_VALUE_SIZE) {
                        char[] newBuffer = new char[2 * maxRead];
                        System.arraycopy(header.value, 0, newBuffer, 0,
                                         maxRead);
                        header.value = newBuffer;
                        maxRead = header.value.length;
                    } else {
                        throw new IOException
                            (sm.getString("requestStream.readline.toolong"));
                    }
                }
                // We're at the end of the internal buffer
                if (pos >= count) {
                    // Copying part (or all) of the internal buffer to the line
                    // buffer
                    int val = read();
                    if (val == -1)
                        throw new IOException
                            (sm.getString("requestStream.readline.error"));
                    pos = 0;
                    readStart = 0;
                }
                if (buf[pos] == CR) {
                } else if (buf[pos] == LF) {
                    eol = true;
                } else {
                    // FIXME : Check if binary conversion is working fine
                    int ch = buf[pos] & 0xff;
                    header.value[readCount] = (char) ch;
                    readCount++;
                }
                pos++;
            }

            int nextChr = read();

            if ((nextChr != SP) && (nextChr != HT)) {
                pos--;
                validLine = false;
            } else {
                eol = false;
                // if the buffer is full, extend it
                if (readCount >= maxRead) {
                    if ((2 * maxRead) <= HttpHeader.MAX_VALUE_SIZE) {
                        char[] newBuffer = new char[2 * maxRead];
                        System.arraycopy(header.value, 0, newBuffer, 0,
                                         maxRead);
                        header.value = newBuffer;
                        maxRead = header.value.length;
                    } else {
                        throw new IOException
                            (sm.getString("requestStream.readline.toolong"));
                    }
                }
                header.value[readCount] = ' ';
                readCount++;
            }

        }

        header.valueEnd = readCount;

    }

    /**
     * Read byte.
     */
    public int read()
        throws IOException {
        if (pos >= count) {
            fill();
            if (pos >= count)
                return -1;
        }
        return buf[pos++] & 0xff;
    }

    /**
     *
     */
    /*
    public int read(byte b[], int off, int len)
        throws IOException {

    }
    */

    /**
     *
     */
    /*
    public long skip(long n)
        throws IOException {

    }
    */

    /**
     * Returns the number of bytes that can be read from this input
     * stream without blocking.
     */
    public int available()
        throws IOException {
        return (count - pos) + is.available();
    }

    /**
     * Close the input stream.
     */
    public void close()
        throws IOException {
        if (is == null)
            return;
        is.close();
        is = null;
        buf = null;
    }

    // ------------------------------------------------------ Protected Methods

    /**
     * Fill the internal buffer using data from the undelying input stream.
     */
    protected void fill()
        throws IOException {
        pos = 0;
        count = 0;
        int nRead = is.read(buf, 0, buf.length);
        if (nRead > 0) {
            count = nRead;
        }
    }

}

下面是连接器HttpConnector的run方法

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);
		}
	}

下面是HttpProcessor类的process方法    与第二章的架构不同的是，创建Request和Response以及解析工作都放到了HttpProcessor当中，而不是在HttpServer当中，在这个模式当中仅仅向HttpProcessor当中传入Socket对象，输入流的处理防盗了HttpProcessor当中

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();
		}
	}

　　

　

Constants.java

package ex03.pyrmont.connector.http;

import java.io.File;

public final class Constants
{
	public static final String WEB_ROOT = System.getProperty("user.dir") + File.separator + "webroot";
	public static final String Package = "ex03.pyrmont.connector.http";
	public static final int DEFAULT_CONNECTION_TIMEOUT = 60000;
	public static final int PROCESSOR_IDLE = 0;
	public static final int PROCESSOR_ACTIVE = 1;
}

　

package org.apache.catalina.util;

import java.net.URLClassLoader;
import java.text.MessageFormat;
import java.util.Hashtable;
import java.util.Locale;
import java.util.MissingResourceException;
import java.util.ResourceBundle;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class StringManager
{
  private ResourceBundle bundle;
  private static Log log = LogFactory.getLog(StringManager.class);

  private static Hashtable managers = new Hashtable();

  private StringManager(String packageName)
  {
    String bundleName = packageName + ".LocalStrings";
    try {
      this.bundle = ResourceBundle.getBundle(bundleName);
      return;
    }
    catch (MissingResourceException ex) {
      ClassLoader cl = Thread.currentThread().getContextClassLoader();
      if (cl != null)
        try {
          this.bundle = ResourceBundle.getBundle(bundleName, Locale.getDefault(), cl);
          return;
        }
        catch (MissingResourceException ex2) {
        }
      if (cl == null) {
        cl = getClass().getClassLoader();
      }
      if (log.isDebugEnabled()) {
        log.debug("Can't find resource " + bundleName + " " + cl);
      }
      if (((cl instanceof URLClassLoader)) &&
        (log.isDebugEnabled()))
        log.debug(((URLClassLoader)cl).getURLs());
    }
  }

  public String getString(String key)
  {
    return MessageFormat.format(getStringInternal(key), (Object[])null);
  }

  protected String getStringInternal(String key)
  {
    if (key == null) {
      String msg = "key is null";

      throw new NullPointerException(msg);
    }

    String str = null;

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

    return str;
  }

  public String getString(String key, Object[] args)
  {
    String iString = null;
    String value = getStringInternal(key);
    try
    {
      Object[] nonNullArgs = args;
      for (int i = 0; i < args.length; i++) {
        if (args[i] == null) {
          if (nonNullArgs == args) nonNullArgs = (Object[])args.clone();
          nonNullArgs[i] = "null";
        }
      }

      iString = MessageFormat.format(value, nonNullArgs);
    } catch (IllegalArgumentException iae) {
      StringBuffer buf = new StringBuffer();
      buf.append(value);
      for (int i = 0; i < args.length; i++) {
        buf.append(" arg[" + i + "]=" + args[i]);
      }
      iString = buf.toString();
    }
    return iString;
  }

  public String getString(String key, Object arg)
  {
    Object[] args = { arg };
    return getString(key, args);
  }

  public String getString(String key, Object arg1, Object arg2)
  {
    Object[] args = { arg1, arg2 };
    return getString(key, args);
  }

  public String getString(String key, Object arg1, Object arg2, Object arg3)
  {
    Object[] args = { arg1, arg2, arg3 };
    return getString(key, args);
  }

  public String getString(String key, Object arg1, Object arg2, Object arg3, Object arg4)
  {
    Object[] args = { arg1, arg2, arg3, arg4 };
    return getString(key, args);
  }

  public static synchronized StringManager getManager(String packageName)
  {
    StringManager mgr = (StringManager)managers.get(packageName);

    if (mgr == null) {
      mgr = new StringManager(packageName);
      managers.put(packageName, mgr);
    }
    return mgr;
  }
}

　　

里面用到了Tomcat5中提供的StringManager类

（貌似在Tomcat7当中没有这个类了，或者更改了包的位置，目前不得而知）

作用：像Tomcat这样的大型程序必须小心的仔细处理错误消息。在Tomcat当中，错误消息对于系统管理员和Servlet程序员来说都是非常有用的。

例如：系统管理员可以很容易的根据Tomcat的错误日志消息定位到异常发生的位置。而对于servlet程序员来说，在抛出的每个javax.servlet.ServletException异常中，Tomcat都会发送一条特姝的错误消息。

这样，程序员就可以知道servlet程序到底哪里出错了

Tomcat处理错误消息的方法是将错误消息存储在一个properties文件中，便于读取和编辑，但是Tomcat中有几百个类。

若是将所有类使用的错误消息都存储在一个大的properties属性文件当中，

使用到的工具类HttpRequestLine类

package ex03.pyrmont.connector.http;

/**
 * HTTP request line enum type.
 *
 * @author Remy Maucherat
 * @version $Revision: 1.6 $ $Date: 2002/03/18 07:15:40 $
 * @deprecated
 */

final class HttpRequestLine
{

	// -------------------------------------------------------------- Constants

	public static final int INITIAL_METHOD_SIZE = 8;
	public static final int INITIAL_URI_SIZE = 64;
	public static final int INITIAL_PROTOCOL_SIZE = 8;
	public static final int MAX_METHOD_SIZE = 1024;
	public static final int MAX_URI_SIZE = 32768;
	public static final int MAX_PROTOCOL_SIZE = 1024;

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

	public HttpRequestLine()
	{

		this(new char[INITIAL_METHOD_SIZE], 0, new char[INITIAL_URI_SIZE], 0, new char[INITIAL_PROTOCOL_SIZE], 0);

	}

	public HttpRequestLine(char[] method, int methodEnd, char[] uri, int uriEnd, char[] protocol, int protocolEnd)
	{

		this.method = method;
		this.methodEnd = methodEnd;
		this.uri = uri;
		this.uriEnd = uriEnd;
		this.protocol = protocol;
		this.protocolEnd = protocolEnd;

	}

	// ----------------------------------------------------- Instance Variables

	public char[] method;
	public int methodEnd;
	public char[] uri;
	public int uriEnd;
	public char[] protocol;
	public int protocolEnd;

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

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

	/**
	 * Release all object references, and initialize instance variables, in
	 * preparation for reuse of this object.
	 */
	public void recycle()
	{

		methodEnd = 0;
		uriEnd = 0;
		protocolEnd = 0;

	}

	/**
	 * Test if the uri includes the given char array.
	 */
	public int indexOf(char[] buf)
	{
		return indexOf(buf, buf.length);
	}

	/**
	 * Test if the value of the header includes the given char array.
	 */
	public int indexOf(char[] buf, int end)
	{
		char firstChar = buf[0];
		int pos = 0;
		while (pos < uriEnd)
		{
			pos = indexOf(firstChar, pos);
			if (pos == -1)
				return -1;
			if ((uriEnd - pos) < end)
				return -1;
			for (int i = 0; i < end; i++)
			{
				if (uri[i + pos] != buf[i])
					break;
				if (i == (end - 1))
					return pos;
			}
			pos++;
		}
		return -1;
	}

	/**
	 * Test if the value of the header includes the given string.
	 */
	public int indexOf(String str)
	{
		return indexOf(str.toCharArray(), str.length());
	}

	/**
	 * Returns the index of a character in the value.
	 */
	public int indexOf(char c, int start)
	{
		for (int i = start; i < uriEnd; i++)
		{
			if (uri[i] == c)
				return i;
		}
		return -1;
	}

	// --------------------------------------------------------- Object Methods

	public int hashCode()
	{
		// FIXME
		return 0;
	}

	public boolean equals(Object obj)
	{
		return false;
	}

}

　

//HttpProcessor.java  对SocketInputStream类的使用   这里还是没有使用多线程，估计要到第4章才会介绍使用多线程吧，此时每次只能处理一个请求，其余请求只能排队。

package ex03.pyrmont.connector.http;

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;

import javax.servlet.ServletException;
import javax.servlet.http.Cookie;

import org.apache.catalina.util.RequestUtil;
import org.apache.catalina.util.StringManager;

import ex03.pyrmont.ServletProcessor;
import ex03.pyrmont.StaticResourceProcessor;

/* this class used to be called HttpServer */
public class HttpProcessor
{
        //将HttpConnector传递进来进行回调或者说绑定
	public HttpProcessor(HttpConnector connector)
	{
		this.connector = connector;
	}

	/**
	 * The HttpConnector with which this processor is associated.
	 */
	private HttpConnector connector = null;
	private HttpRequest request;
	private HttpRequestLine requestLine = new HttpRequestLine();
	private HttpResponse response;

	protected String method = null;
	protected String queryString = null;

	/**
	 * The string manager for this package.
	 */
	protected StringManager sm = StringManager.getManager("ex03.pyrmont.connector.http");

	public void process(Socket socket)
	{
		SocketInputStream input = null;
		OutputStream output = null;
		try
		{
                        //获得输入流
			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);
                        //为响应报文设置响应头Server 表明Server的名字 比如百度的就是bws baidu web server
			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();
		}
	}

	/**
	 * This method is the simplified version of the similar method in
	 * org.apache.catalina.connector.http.HttpProcessor. However, this method
	 * only parses some "easy" headers, such as "cookie", "content-length", and
	 * "content-type", and ignore other headers.
	 *
	 * @param input
	 *            The input stream connected to our socket
	 *
	 * @exception IOException
	 *                if an input/output error occurs
	 * @exception ServletException
	 *                if a parsing error occurs
	 */
	private void parseHeaders(SocketInputStream input) throws IOException, ServletException
	{
		while (true)
		{
			HttpHeader header = new HttpHeader();
			;

			// Read the next header   调用SocketInputStream当中的方法初始化HttpHeader()
			input.readHeader(header);
			if (header.nameEnd == 0)
			{
				if (header.valueEnd == 0)
				{
					return;
				} else
				{
					throw new ServletException(sm.getString("httpProcessor.parseHeaders.colon"));
				}
			}

			String name = new String(header.name, 0, header.nameEnd);
			String value = new String(header.value, 0, header.valueEnd);
			request.addHeader(name, value);
			// do something for some headers, ignore others.
			if (name.equals("cookie"))
			{
				Cookie cookies[] = RequestUtil.parseCookieHeader(value);
				for (int i = 0; i < cookies.length; i++)
				{
					if (cookies[i].getName().equals("jsessionid"))
					{
						// Override anything requested in the URL
						if (!request.isRequestedSessionIdFromCookie())
						{
							// Accept only the first session id cookie
							request.setRequestedSessionId(cookies[i].getValue());
							request.setRequestedSessionCookie(true);
							request.setRequestedSessionURL(false);
						}
					}
					request.addCookie(cookies[i]);
				}
			} else if (name.equals("content-length"))
			{
				int n = -1;
				try
				{
					n = Integer.parseInt(value);
				} catch (Exception e)
				{
					throw new ServletException(sm.getString("httpProcessor.parseHeaders.contentLength"));
				}
				request.setContentLength(n);
			} else if (name.equals("content-type"))
			{
				request.setContentType(value);
			}
		} // end while
	}

	private void parseRequest(SocketInputStream input, OutputStream output) throws IOException, ServletException
	{

		// Parse the incoming request line
		input.readRequestLine(requestLine);
		String method = new String(requestLine.method, 0, requestLine.methodEnd);
		String uri = null;
		String protocol = new String(requestLine.protocol, 0, requestLine.protocolEnd);

		// Validate the incoming request line
		if (method.length() < 1)
		{
			throw new ServletException("Missing HTTP request method");
		} else if (requestLine.uriEnd < 1)
		{
			throw new ServletException("Missing HTTP request URI");
		}
		// Parse any query parameters out of the request URI
		int question = requestLine.indexOf("?");
		if (question >= 0)
		{
			request.setQueryString(new String(requestLine.uri, question + 1, requestLine.uriEnd - question - 1));
			uri = new String(requestLine.uri, 0, question);
		} else
		{
			request.setQueryString(null);
			uri = new String(requestLine.uri, 0, requestLine.uriEnd);
		}

		// Checking for an absolute URI (with the HTTP protocol)
		if (!uri.startsWith("/"))
		{
			int pos = uri.indexOf("://");
			// Parsing out protocol and host name
			if (pos != -1)
			{
				pos = uri.indexOf('/', pos + 3);
				if (pos == -1)
				{
					uri = "";
				} else
				{
					uri = uri.substring(pos);
				}
			}
		}

		// Parse any requested session ID out of the request URI
		String match = ";jsessionid=";
		int semicolon = uri.indexOf(match);
		if (semicolon >= 0)
		{
			String rest = uri.substring(semicolon + match.length());
			int semicolon2 = rest.indexOf(';');
			if (semicolon2 >= 0)
			{
				request.setRequestedSessionId(rest.substring(0, semicolon2));
				rest = rest.substring(semicolon2);
			} else
			{
				request.setRequestedSessionId(rest);
				rest = "";
			}
			request.setRequestedSessionURL(true);
			uri = uri.substring(0, semicolon) + rest;
		} else
		{
			request.setRequestedSessionId(null);
			request.setRequestedSessionURL(false);
		}

		// Normalize URI (using String operations at the moment)
		String normalizedUri = normalize(uri);

		// Set the corresponding request properties
		((HttpRequest) request).setMethod(method);
		request.setProtocol(protocol);
		if (normalizedUri != null)
		{
			((HttpRequest) request).setRequestURI(normalizedUri);
		} else
		{
			((HttpRequest) request).setRequestURI(uri);
		}

		if (normalizedUri == null)
		{
			throw new ServletException("Invalid URI: " + uri + "'");
		}
	}

	/**
	 * Return a context-relative path, beginning with a "/", that represents the
	 * canonical version of the specified path after ".." and "." elements are
	 * resolved out. If the specified path attempts to go outside the boundaries
	 * of the current context (i.e. too many ".." path elements are present),
	 * return <code>null</code> instead.
	 *
	 * @param path
	 *            Path to be normalized
	 */
	protected String normalize(String path)
	{
		if (path == null)
			return null;
		// Create a place for the normalized path
		String normalized = path;

		// Normalize "/%7E" and "/%7e" at the beginning to "/~"
		if (normalized.startsWith("/%7E") || normalized.startsWith("/%7e"))
			normalized = "/~" + normalized.substring(4);

		// Prevent encoding '%', '/', '.' and '\', which are special reserved
		// characters
		if ((normalized.indexOf("%25") >= 0) || (normalized.indexOf("%2F") >= 0) || (normalized.indexOf("%2E") >= 0) || (normalized.indexOf("%5C") >= 0) || (normalized.indexOf("%2f") >= 0)
				|| (normalized.indexOf("%2e") >= 0) || (normalized.indexOf("%5c") >= 0))
		{
			return null;
		}

		if (normalized.equals("/."))
			return "/";

		// Normalize the slashes and add leading slash if necessary
		if (normalized.indexOf('\\') >= 0)
			normalized = normalized.replace('\\', '/');
		if (!normalized.startsWith("/"))
			normalized = "/" + normalized;

		// Resolve occurrences of "//" in the normalized path
		while (true)
		{
			int index = normalized.indexOf("//");
			if (index < 0)
				break;
			normalized = normalized.substring(0, index) + normalized.substring(index + 1);
		}

		// Resolve occurrences of "/./" in the normalized path
		while (true)
		{
			int index = normalized.indexOf("/./");
			if (index < 0)
				break;
			normalized = normalized.substring(0, index) + normalized.substring(index + 2);
		}

		// Resolve occurrences of "/../" in the normalized path
		while (true)
		{
			int index = normalized.indexOf("/../");
			if (index < 0)
				break;
			if (index == 0)
				return (null); // Trying to go outside our context
			int index2 = normalized.lastIndexOf('/', index - 1);
			normalized = normalized.substring(0, index2) + normalized.substring(index + 3);
		}

		// Declare occurrences of "/..." (three or more dots) to be invalid
		// (on some Windows platforms this walks the directory tree!!!)
		if (normalized.indexOf("/...") >= 0)
			return (null);

		// Return the normalized path that we have completed
		return (normalized);

	}

}

　　

//在HttpProcessor当中parseRequest的时候初始化HttpHeader对象

package ex03.pyrmont.connector.http;

/**
 * HTTP header enum type.
 *
 * @author Remy Maucherat
 * @version $Revision: 1.4 $ $Date: 2002/03/18 07:15:40 $
 * @deprecated
 */

final class HttpHeader
{

	// -------------------------------------------------------------- Constants

	public static final int INITIAL_NAME_SIZE = 32;
	public static final int INITIAL_VALUE_SIZE = 64;
	public static final int MAX_NAME_SIZE = 128;
	public static final int MAX_VALUE_SIZE = 4096;

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

	public HttpHeader()
	{

		this(new char[INITIAL_NAME_SIZE], 0, new char[INITIAL_VALUE_SIZE], 0);

	}

	public HttpHeader(char[] name, int nameEnd, char[] value, int valueEnd)
	{

		this.name = name;
		this.nameEnd = nameEnd;
		this.value = value;
		this.valueEnd = valueEnd;

	}

	public HttpHeader(String name, String value)
	{

		this.name = name.toLowerCase().toCharArray();
		this.nameEnd = name.length();
		this.value = value.toCharArray();
		this.valueEnd = value.length();

	}

	// ----------------------------------------------------- Instance Variables

	public char[] name;
	public int nameEnd;
	public char[] value;
	public int valueEnd;
	protected int hashCode = 0;

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

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

	/**
	 * Release all object references, and initialize instance variables, in
	 * preparation for reuse of this object.
	 */
	public void recycle()
	{

		nameEnd = 0;
		valueEnd = 0;
		hashCode = 0;

	}

	/**
	 * Test if the name of the header is equal to the given char array. All the
	 * characters must already be lower case.
	 */
	public boolean equals(char[] buf)
	{
		return equals(buf, buf.length);
	}

	/**
	 * Test if the name of the header is equal to the given char array. All the
	 * characters must already be lower case.
	 */
	public boolean equals(char[] buf, int end)
	{
		if (end != nameEnd)
			return false;
		for (int i = 0; i < end; i++)
		{
			if (buf[i] != name[i])
				return false;
		}
		return true;
	}

	/**
	 * Test if the name of the header is equal to the given string. The String
	 * given must be made of lower case characters.
	 */
	public boolean equals(String str)
	{
		return equals(str.toCharArray(), str.length());
	}

	/**
	 * Test if the value of the header is equal to the given char array.
	 */
	public boolean valueEquals(char[] buf)
	{
		return valueEquals(buf, buf.length);
	}

	/**
	 * Test if the value of the header is equal to the given char array.
	 */
	public boolean valueEquals(char[] buf, int end)
	{
		if (end != valueEnd)
			return false;
		for (int i = 0; i < end; i++)
		{
			if (buf[i] != value[i])
				return false;
		}
		return true;
	}

	/**
	 * Test if the value of the header is equal to the given string.
	 */
	public boolean valueEquals(String str)
	{
		return valueEquals(str.toCharArray(), str.length());
	}

	/**
	 * Test if the value of the header includes the given char array.
	 */
	public boolean valueIncludes(char[] buf)
	{
		return valueIncludes(buf, buf.length);
	}

	/**
	 * Test if the value of the header includes the given char array.
	 */
	public boolean valueIncludes(char[] buf, int end)
	{
		char firstChar = buf[0];
		int pos = 0;
		while (pos < valueEnd)
		{
			pos = valueIndexOf(firstChar, pos);
			if (pos == -1)
				return false;
			if ((valueEnd - pos) < end)
				return false;
			for (int i = 0; i < end; i++)
			{
				if (value[i + pos] != buf[i])
					break;
				if (i == (end - 1))
					return true;
			}
			pos++;
		}
		return false;
	}

	/**
	 * Test if the value of the header includes the given string.
	 */
	public boolean valueIncludes(String str)
	{
		return valueIncludes(str.toCharArray(), str.length());
	}

	/**
	 * Returns the index of a character in the value.
	 */
	public int valueIndexOf(char c, int start)
	{
		for (int i = start; i < valueEnd; i++)
		{
			if (value[i] == c)
				return i;
		}
		return -1;
	}

	/**
	 * Test if the name of the header is equal to the given header. All the
	 * characters in the name must already be lower case.
	 */
	public boolean equals(HttpHeader header)
	{
		return (equals(header.name, header.nameEnd));
	}

	/**
	 * Test if the name and value of the header is equal to the given header.
	 * All the characters in the name must already be lower case.
	 */
	public boolean headerEquals(HttpHeader header)
	{
		return (equals(header.name, header.nameEnd)) && (valueEquals(header.value, header.valueEnd));
	}

	// --------------------------------------------------------- Object Methods

	/**
	 * Return hash code. The hash code of the HttpHeader object is the same as
	 * returned by new String(name, 0, nameEnd).hashCode().
	 */
	public int hashCode()
	{
		int h = hashCode;
		if (h == 0)
		{
			int off = 0;
			char val[] = name;
			int len = nameEnd;
			for (int i = 0; i < len; i++)
				h = 31 * h + val[off++];
			hashCode = h;
		}
		return h;
	}

	public boolean equals(Object obj)
	{
		if (obj instanceof String)
		{
			return equals(((String) obj).toLowerCase());
		} else if (obj instanceof HttpHeader)
		{
			return equals((HttpHeader) obj);
		}
		return false;
	}

}