《How Tomcat Works》读书笔记(三)--Connector(连接器)

《How Tomcat Works》读书笔记(三)--Connector(连接器)

这是《How Tomcat Works》第三四章的读书笔记。主要写了Tomcat4.0默认的连接器(Connector)的处理流程，后面Tomcat的连接器改为Coyote。

1. 概述

---

1.1 架构

• HttpConector：监听Http请求、维护HttpProcessor对象池、处理Http请求(调用HttpProcessor对象进行处理)
• HttpProcessor：解析请求(解析连接、解析请求行、解析请求头等等)、调用容器进行处理
• Request：表示Http请求，实现了org.apache.catalina.Request接口。
• Response：表示Http响应，实现了org.apache.catalina.Response接口。

其中Request、Response就是代表Http请求、Http响应，实现了Servlet编程中HttpServletRequest、HttpServletResponse接口，这样符合Java EE编程标准。只是Tomcat在这里使用了许多的类、接口等等(如：RequestBase、HttpRequestImpl、RequestFacade)，这样做就像Java Util包中哪些类库一样，反正看起来好复杂。

1.2 HttpProcessor处理逻辑
只是展示逻辑，省略一些具体的处理方式，省略了try-catch等等。

/**
 * Process an incoming HTTP request on the Socket that has been assigned
 * to this Processor.  Any exceptions that occur during processing must be
 * swallowed and dealt with.
 *
 * @param socket The socket on which we are connected to the client
 */
private void process(Socket socket) {
    boolean ok = true;
    boolean finishResponse = true;
    SocketInputStream input = null;

    // Construct and initialize the objects we will need
    // 构造对象，这里省略的许多的try-catch
    input = new SocketInputStream(socket.getInputStream(), connector.getBufferSize());
    // Http/1.1中新特性：长连接
    keepAlive = true;
    while (!stopped && ok && keepAlive) {
        finishResponse = true;
        request.setStream(input);
        request.setResponse(response);
        output = socket.getOutputStream();
        response.setStream(output);
        response.setRequest(request);
        ((HttpServletResponse) response.getResponse()).setHeader("Server", Constants.ServerInfo);
        
        // Parse the incoming request
        // 解析请求数据
        // 解析连接 
        parseConnection(socket);
        // 解析请求行
        parseRequest(input, output);
        if (!request.getRequest().getProtocol().startsWith("HTTP/0"))
            //解析请求头
            parseHeaders(input);
        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);
        }
        
        // Ask our Container to process this request
        // 调用Servlet容器处理请求
        ((HttpServletResponse) response).addDateHeader("Date", System.currentTimeMillis());
        connector.getContainer().invoke(request, response);
        
        // Finish up the handling of the request
        response.finishResponse();
        request.finishRequest();
        
        // Recycling the request and the response objects
        // 回收Request、Response对象：把该对象的状态复原使得下一次请求有自己独有的状态
        request.recycle();
        response.recycle();
    }       
}

2. 一些解释

2.1 有状态的对象线程池
有状态的对象线程池：池中每个对象有一个自己的线程，每个对象有自己的状态(域)。

Connector(连接器)中HttpConnector接受请求，调用HttpProcessor对象处理请求。HttpConnector管理一系列的HttpProcessor对象，每个HttpProcessor对象有自己单独的后台线程，这样每次都使用一个线程处理请求。

HttpConnector在最开始就启动池中所有的HttpProcessor对象，然后有请求来时从池中拿一个HttpProcessor对象进行处理。

public void run() {
    // Loop until we receive a shutdown command
    while (!stopped) {
        // Accept the next incoming connection from the server socket
        Socket socket = null;
        // Hand this socket off to an appropriate processor
        // 从池中拿一个HttpProcessor
        HttpProcessor processor = createProcessor();
        // 调用HttpProcessor进行处理
        processor.assign(socket);
    }
}

HttpProcessor对象一开始就全部启动，等待HttpConnector分配socket进行处理。

public void run() {
    // Process requests until we receive a shutdown signal
    while (!stopped) {
        // Wait for the next socket to be assigned
        // 在这里HttpProcessor对象会阻塞直到HttpConnector分配一个socket
        Socket socket = await();
        if (socket == null)
            continue;
        // Process the request from this socket
        // 进行处理
        process(socket);
        // Finish up this request
        // 处理完成，把该HttpProcessor放回HttpProcessor对象池中
        connector.recycle(this);
    }
}

HttpProcessor对象一开始就全部启动，然后会被阻塞(如上所示)直到HttpConnector分配socket。await()与assign(Socket socket)方法如下：

/**
 * The socket we are currently processing a request for.  This object
 * is used for inter-thread communication only.
 */
private Socket socket = null;
    
/**
 * Is there a new socket available?
 */
private boolean available = false;

/**
 * Process an incoming TCP/IP connection on the specified socket.  Any
 * exception that occurs during processing must be logged and swallowed.
 * NOTE:  This method is called from our Connector's thread.  We
 * must assign it to our own thread so that multiple simultaneous
 * requests can be handled.
 *
 * @param socket TCP socket to process
 */
synchronized void assign(Socket socket) {
    // Wait for the Processor to get the previous Socket
    // 如果已经分配，则等待
    while (available) {
        try {
            wait();
        } catch (InterruptedException e) {
        }
    }
    // Store the newly available Socket and notify our thread、
    // 分配socket
    this.socket = socket;
    available = true;
    notifyAll();
}

/**
 * Await a newly assigned Socket from our Connector, or null
 * if we are supposed to shut down.
 */
private synchronized Socket await() {
    // Wait for the Connector to provide a new Socket
    // 如果没有分配，则等待
    while (!available) {
        try {
            wait();
        } catch (InterruptedException e) {
        }
    }
    // Notify the Connector that we have received this Socket
    // 把分配的socket返回
    Socket socket = this.socket;
    available = false;
    notifyAll();
    return socket;
}

最后每一次的Request、Response对象状态是不一样的，所以在处理完完成后，需要把Request、Response对象状态还原。

// Recycling the request and the response objects
request.recycle();
response.recycle();

2.2 解析处理
HttpProcessor解析过程是一个耗时的过程，尤其是解析请求参数、Cookies时，所有Tomcat中设计为仅仅我们需要使用Parameter、Cookies时才解析。我们以Parameter为例：

在需要使用Parameter方法时(如：getParameter()方法)时，就验证是否需要解析，如果没有解析就解析，否则直接使用。

/**
 * The parsed parameters for this request.  This is populated only if
 * parameter information is requested via one of the
 * getParameter() family of method calls.  The key is the
 * parameter name, while the value is a String array of values for this
 * parameter.
 * 
 * IMPLEMENTATION NOTE - Once the parameters for a
 * particular request are parsed and stored here, they are not modified.
 * Therefore, application level access to the parameters need not be
 * synchronized.
 * 存放Parameter，继承HashMap，与HashMap基本无异
 */
protected ParameterMap parameters = null;

/**
 * Have the parameters for this request been parsed yet?
 * 是否已经解析
 */
protected boolean parsed = false;

/**
 * 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;
    // 具体解析逻辑就不给出来了
    
    // Store the final results
    parsed = true;
    parameters = results;
}

public String getParameter(String name) {
    parseParameters();
    String values[] = (String[]) parameters.get(name);
    if (values != null)
        return (values[0]);
    else
        return (null);
}

3. 代码

逻辑基本一致，但是自己省略了需要的具体逻辑，如仅仅解析了RequestURL等等。然后许多与Request的有关的类，我仅仅使用了HttpRequest全部代替了。

Container、Connector接口：

package note2;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Created by kanyuxia on 2017/4/27.
 * 模拟org.apache.catalina.Connector接口
 */
public interface Connector {
    /**
     * Return the Container used for processing requests received by this
     * Connector.
     */
    Container getContainer();

    /**
     * Set the Container used for processing requests received by this
     * Connector.
     *
     * @param container The new Container to use
     */
    void setContainer(Container container);

    /**
     * Return the scheme that will be assigned to requests received
     * through this connector.  Default value is "http".
     */
    String getScheme();

    /**
     * Set the scheme that will be assigned to requests received through
     * this connector.
     *
     * @param scheme The new scheme
     */
    void setScheme(String scheme);

    /**
     * Create (or allocate) and return a Request object suitable for
     * specifying the contents of a Request to the responsible Container.
     */
    HttpServletRequest createRequest();

    /**
     * Create (or allocate) and return a Response object suitable for
     * receiving the contents of a Response from the responsible Container.
     */
    HttpServletResponse createResponse();

    /**
     * Invoke a pre-startup initialization. This is used to allow connectors
     * to bind to restricted ports under Unix operating environments.
     */
    void initialize();

}

package note2;

import javax.servlet.ServletException;
import java.io.IOException;

/**
 * Created by kanyuxia on 2017/4/27.
 * 模拟org.apache.catalina.Container接口
 */
public interface Container {
    /**
     * Process the specified Request, and generate the corresponding Response,
     * according to the design of this particular Container.
     *
     * @param request Request to be processed
     * @param response Response to be produced
     *
     * @exception IOException if an input/output error occurred while
     *  processing
     * @exception ServletException if a ServletException was thrown
     *  while processing this request
     */
    void invoke(HttpRequest request, HttpResponse response) throws IOException, ServletException;
}

Request、Response相关类：

package note2;

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.security.Principal;
import java.util.*;

/**
 * Created by kanyuxia on 2017/4/26.
 * Http请求对象
 */
public class HttpRequest implements HttpServletRequest {

    // ---------------------------------Http Request Infomations
    /**
     * 存放Http request headers
     */
    private HashMap<String, ArrayList<String>> headers = new HashMap<>();

    /**
     * 存放Http request cookies
     */
    private ArrayList<Cookie> cookies = new ArrayList<>();

    /**
     * 存放Http请求参数：Query String or Form datas.
     * 只有当Servlet取参数时，才解析
     */
    private ParameterMap<String, String[]> parameterMap = null;

    /**
     * Have the parameters for this request been parsed yet?
     * 是否解析了Http Parameters
     */
    private boolean parameterPared = false;

    /**
     * The request URI associated with this request.
     * 请求URL地址
     */
    private String requestURI = null;


    /**
     * The input stream associated with this Request.
     */
    private InputStream input = null;


    // ---------------------------------------Servlet some infomations

    /**
     * The request attributes for this request.
     */
    private final HashMap<String, Object> attributes = new HashMap<>();

    /**
     * The Connector through which this Request was received.
     */
    private Connector connector = null;


    // --------------------------------------Some methods
    /**
     * 添加HTTP header
     * @param name header name
     * @param value header value
     */
    public void addHeader(String name, String value) {
        name = name.toLowerCase();
        ArrayList<String> values = headers.get(name);
        if (values != null) {
            values.add(value);
        }
        values = new ArrayList<>();
        headers.put(name, values);
    }

    /**
     * 返回门面类
     * @return RequestFacade
     */
    public HttpServletRequest getRequest() {
        return new HttpRequestFacade(this);
    }

    /**
     * 添加HTTP cookie
     * @param cookie http cookie
     */
    public void addCookie(Cookie cookie) {
        cookies.add(cookie);
    }

    /**
     * 解析HTTP Parameters，如果已经解析则返回。
     */
    public void parseParameters() {
        if (parameterPared) {
            return;
        }
        parameterMap = new ParameterMap<>();
        parameterMap.setLocked(false);

        // 解析Query String or Form data

        parameterMap.setLocked(true);
    }

    /**
     * 添加HTTP Parameter
     * @param name Http Parameter name
     * @param values Http Parameter values
     */
    public void addParameter(String name, String values[]) {
        parameterMap.put(name, values);
    }


    /**
     * Release all object references, and initialize instance variables, in
     * preparation for reuse of this object.
     * 清空所有数据
     */
    public void recycle() {
        headers.clear();
        cookies.clear();
        if (parameterMap != null) {
            parameterMap.setLocked(false);
            parameterMap.clear();
        }
        parameterPared = false;
        requestURI = null;
        input = null;
        attributes.clear();
    }

    //---------------------------some setter、getter methods

    public Connector getConnector() {
        return connector;
    }

    public void setConnector(Connector connector) {
        this.connector = connector;
    }

    public void setInput(InputStream input) {
        this.input = input;
    }

    public InputStream getInput() {
        return input;
    }

    public void setRequestURI(String requestURI) {
        this.requestURI = requestURI;
    }

    @Override
    public String getAuthType() {
        return null;
    }

    @Override
    public Cookie[] getCookies() {
        return new Cookie[0];
    }

    @Override
    public long getDateHeader(String name) {
        return 0;
    }

    @Override
    public String getHeader(String name) {
        return null;
    }

    @Override
    public Enumeration<String> getHeaders(String name) {
        return null;
    }

    @Override
    public Enumeration<String> getHeaderNames() {
        return null;
    }

    @Override
    public int getIntHeader(String name) {
        return 0;
    }

    @Override
    public String getMethod() {
        return null;
    }

    @Override
    public String getPathInfo() {
        return null;
    }

    @Override
    public String getPathTranslated() {
        return null;
    }

    @Override
    public String getContextPath() {
        return null;
    }

    @Override
    public String getQueryString() {
        return null;
    }

    @Override
    public String getRemoteUser() {
        return null;
    }

    @Override
    public boolean isUserInRole(String role) {
        return false;
    }

    @Override
    public Principal getUserPrincipal() {
        return null;
    }

    @Override
    public String getRequestedSessionId() {
        return null;
    }

    @Override
    public String getRequestURI() {
        return requestURI;
    }

    @Override
    public StringBuffer getRequestURL() {
        return null;
    }

    @Override
    public String getServletPath() {
        return null;
    }

    @Override
    public HttpSession getSession(boolean create) {
        return null;
    }

    @Override
    public HttpSession getSession() {
        return null;
    }

    @Override
    public String changeSessionId() {
        return null;
    }

    @Override
    public boolean isRequestedSessionIdValid() {
        return false;
    }

    @Override
    public boolean isRequestedSessionIdFromCookie() {
        return false;
    }

    @Override
    public boolean isRequestedSessionIdFromURL() {
        return false;
    }

    @Override
    public boolean isRequestedSessionIdFromUrl() {
        return false;
    }

    @Override
    public boolean authenticate(HttpServletResponse response) throws IOException, ServletException {
        return false;
    }

    @Override
    public void login(String username, String password) throws ServletException {

    }

    @Override
    public void logout() throws ServletException {

    }

    @Override
    public Collection<Part> getParts() throws IOException, ServletException {
        return null;
    }

    @Override
    public Part getPart(String name) throws IOException, ServletException {
        return null;
    }

    @Override
    public <T extends HttpUpgradeHandler> T upgrade(Class<T> handlerClass) throws IOException, ServletException {
        return null;
    }

    @Override
    public Object getAttribute(String name) {
        return null;
    }

    @Override
    public Enumeration<String> getAttributeNames() {
        return null;
    }

    @Override
    public String getCharacterEncoding() {
        return null;
    }

    @Override
    public void setCharacterEncoding(String env) throws UnsupportedEncodingException {

    }

    @Override
    public int getContentLength() {
        return 0;
    }

    @Override
    public long getContentLengthLong() {
        return 0;
    }

    @Override
    public String getContentType() {
        return null;
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        return null;
    }

    @Override
    public String getParameter(String name) {
        parseParameters();
        return parameterMap.get(name)[0];
    }

    @Override
    public Enumeration<String> getParameterNames() {
        parseParameters();
        return new Enumerator<>(parameterMap.keySet());
    }

    @Override
    public String[] getParameterValues(String name) {
        parseParameters();
        return parameterMap.get(name);
    }

    @Override
    public Map<String, String[]> getParameterMap() {
        parseParameters();
        return parameterMap;
    }

    @Override
    public String getProtocol() {
        return null;
    }

    @Override
    public String getScheme() {
        return null;
    }

    @Override
    public String getServerName() {
        return null;
    }

    @Override
    public int getServerPort() {
        return 0;
    }

    @Override
    public BufferedReader getReader() throws IOException {
        return null;
    }

    @Override
    public String getRemoteAddr() {
        return null;
    }

    @Override
    public String getRemoteHost() {
        return null;
    }

    @Override
    public void setAttribute(String name, Object o) {

    }

    @Override
    public void removeAttribute(String name) {

    }

    @Override
    public Locale getLocale() {
        return null;
    }

    @Override
    public Enumeration<Locale> getLocales() {
        return null;
    }

    @Override
    public boolean isSecure() {
        return false;
    }

    @Override
    public RequestDispatcher getRequestDispatcher(String path) {
        return null;
    }

    @Override
    public String getRealPath(String path) {
        return null;
    }

    @Override
    public int getRemotePort() {
        return 0;
    }

    @Override
    public String getLocalName() {
        return null;
    }

    @Override
    public String getLocalAddr() {
        return null;
    }

    @Override
    public int getLocalPort() {
        return 0;
    }

    @Override
    public ServletContext getServletContext() {
        return null;
    }

    @Override
    public AsyncContext startAsync() throws IllegalStateException {
        return null;
    }

    @Override
    public AsyncContext startAsync(ServletRequest servletRequest, ServletResponse servletResponse) throws IllegalStateException {
        return null;
    }

    @Override
    public boolean isAsyncStarted() {
        return false;
    }

    @Override
    public boolean isAsyncSupported() {
        return false;
    }

    @Override
    public AsyncContext getAsyncContext() {
        return null;
    }

    @Override
    public DispatcherType getDispatcherType() {
        return null;
    }
}

package note2;

import javax.servlet.ServletOutputStream;
import javax.servlet.ServletResponse;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Locale;

/**
 * Created by kanyuxia on 2017/4/26.
 * Http响应对象
 */
public class HttpResponse implements HttpServletResponse {
    // ----------------------Some Response Information
    /**
     * 存放Http response headers
     */
    private HashMap<String, ArrayList<String>> headers = new HashMap<>();

    /**
     * 存放Http response cookies
     */
    private ArrayList<Cookie> cookies = new ArrayList<>();
    /**
     * The Connector through which this Response was received.
     */
    private Connector connector = null;

    private OutputStream output = null;

    private HttpRequest httpRequest = null;

    // ------------------some methods

    public void recycle() {
        headers.clear();
        cookies.clear();
        output = null;
        httpRequest = null;
    }

    public HttpServletResponse getResponse() {
        return new HttpResponseFacade(this);
    }

    // ------------------some setter、getter methods
    public Connector getConnector() {
        return connector;
    }

    public void setConnector(Connector connector) {
        this.connector = connector;
    }

    public void setOutput(OutputStream output) {
        this.output = output;
    }

    public HttpRequest getHttpRequest() {
        return httpRequest;
    }

    public void setHttpRequest(HttpRequest httpRequest) {
        this.httpRequest = httpRequest;
    }

    @Override
    public void addCookie(Cookie cookie) {

    }

    @Override
    public boolean containsHeader(String name) {
        return false;
    }

    @Override
    public String encodeURL(String url) {
        return null;
    }

    @Override
    public String encodeRedirectURL(String url) {
        return null;
    }

    @Override
    public String encodeUrl(String url) {
        return null;
    }

    @Override
    public String encodeRedirectUrl(String url) {
        return null;
    }

    @Override
    public void sendError(int sc, String msg) throws IOException {

    }

    @Override
    public void sendError(int sc) throws IOException {

    }

    @Override
    public void sendRedirect(String location) throws IOException {

    }

    @Override
    public void setDateHeader(String name, long date) {

    }

    @Override
    public void addDateHeader(String name, long date) {

    }

    @Override
    public void setHeader(String name, String value) {

    }

    @Override
    public void addHeader(String name, String value) {

    }

    @Override
    public void setIntHeader(String name, int value) {

    }

    @Override
    public void addIntHeader(String name, int value) {

    }

    @Override
    public void setStatus(int sc) {

    }

    @Override
    public void setStatus(int sc, String sm) {

    }

    @Override
    public int getStatus() {
        return 0;
    }

    @Override
    public String getHeader(String name) {
        return null;
    }

    @Override
    public Collection<String> getHeaders(String name) {
        return null;
    }

    @Override
    public Collection<String> getHeaderNames() {
        return null;
    }

    @Override
    public String getCharacterEncoding() {
        return null;
    }

    @Override
    public String getContentType() {
        return null;
    }

    @Override
    public ServletOutputStream getOutputStream() throws IOException {
        return null;
    }

    @Override
    public PrintWriter getWriter() throws IOException {
        return new PrintWriter(output);
    }

    @Override
    public void setCharacterEncoding(String charset) {

    }

    @Override
    public void setContentLength(int len) {

    }

    @Override
    public void setContentLengthLong(long len) {

    }

    @Override
    public void setContentType(String type) {

    }

    @Override
    public void setBufferSize(int size) {

    }

    @Override
    public int getBufferSize() {
        return 0;
    }

    @Override
    public void flushBuffer() throws IOException {

    }

    @Override
    public void resetBuffer() {

    }

    @Override
    public boolean isCommitted() {
        return false;
    }

    @Override
    public void reset() {

    }

    @Override
    public void setLocale(Locale loc) {

    }

    @Override
    public Locale getLocale() {
        return null;
    }
}

package note2;

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.Principal;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Locale;
import java.util.Map;

/**
 * Created by kanyuxia on 2017/5/3.
 */
public class HttpRequestFacade implements HttpServletRequest {

    private HttpServletRequest httpServletRequest;

    HttpRequestFacade(HttpServletRequest httpServletRequest) {
        this.httpServletRequest = httpServletRequest;
    }

    @Override
    public Object getAttribute(String name) {
        return httpServletRequest.getAttribute(name);
    }

    @Override
    public Enumeration<String> getAttributeNames() {
        return httpServletRequest.getAttributeNames();
    }

    @Override
    public String getCharacterEncoding() {
        return httpServletRequest.getCharacterEncoding();
    }

    @Override
    public void setCharacterEncoding(String env) throws UnsupportedEncodingException {
        httpServletRequest.setCharacterEncoding(env);
    }

    @Override
    public int getContentLength() {
        return httpServletRequest.getContentLength();
    }

    @Override
    public long getContentLengthLong() {
        return httpServletRequest.getContentLengthLong();
    }

    @Override
    public String getContentType() {
        return httpServletRequest.getContentType();
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        return httpServletRequest.getInputStream();
    }

    @Override
    public String getParameter(String name) {
        return httpServletRequest.getParameter(name);
    }

    @Override
    public Enumeration<String> getParameterNames() {
        return httpServletRequest.getParameterNames();
    }

    @Override
    public String[] getParameterValues(String name) {
        return httpServletRequest.getParameterValues(name);
    }

    @Override
    public Map<String, String[]> getParameterMap() {
        return httpServletRequest.getParameterMap();
    }

    @Override
    public String getProtocol() {
        return httpServletRequest.getProtocol();
    }

    @Override
    public String getScheme() {
        return httpServletRequest.getScheme();
    }

    @Override
    public String getServerName() {
        return httpServletRequest.getServerName();
    }

    @Override
    public int getServerPort() {
        return httpServletRequest.getServerPort();
    }

    @Override
    public BufferedReader getReader() throws IOException {
        return httpServletRequest.getReader();
    }

    @Override
    public String getRemoteAddr() {
        return httpServletRequest.getRemoteAddr();
    }

    @Override
    public String getRemoteHost() {
        return httpServletRequest.getRemoteHost();
    }

    @Override
    public void setAttribute(String name, Object o) {
        httpServletRequest.setAttribute(name, o);
    }

    @Override
    public void removeAttribute(String name) {
        httpServletRequest.removeAttribute(name);
    }

    @Override
    public Locale getLocale() {
        return httpServletRequest.getLocale();
    }

    @Override
    public Enumeration<Locale> getLocales() {
        return httpServletRequest.getLocales();
    }

    @Override
    public boolean isSecure() {
        return httpServletRequest.isSecure();
    }

    @Override
    public RequestDispatcher getRequestDispatcher(String path) {
        return httpServletRequest.getRequestDispatcher(path);
    }

    @Override
    public String getRealPath(String path) {
        return httpServletRequest.getRealPath(path);
    }

    @Override
    public int getRemotePort() {
        return httpServletRequest.getRemotePort();
    }

    @Override
    public String getLocalName() {
        return httpServletRequest.getLocalName();
    }

    @Override
    public String getLocalAddr() {
        return httpServletRequest.getLocalAddr();
    }

    @Override
    public int getLocalPort() {
        return httpServletRequest.getLocalPort();
    }

    @Override
    public ServletContext getServletContext() {
        return httpServletRequest.getServletContext();
    }

    @Override
    public AsyncContext startAsync() throws IllegalStateException {
        return httpServletRequest.startAsync();
    }

    @Override
    public AsyncContext startAsync(ServletRequest servletRequest, ServletResponse servletResponse) throws IllegalStateException {
        return servletRequest.startAsync();
    }

    @Override
    public boolean isAsyncStarted() {
        return httpServletRequest.isAsyncStarted();
    }

    @Override
    public boolean isAsyncSupported() {
        return httpServletRequest.isAsyncSupported();
    }

    @Override
    public AsyncContext getAsyncContext() {
        return httpServletRequest.getAsyncContext();
    }

    @Override
    public DispatcherType getDispatcherType() {
        return httpServletRequest.getDispatcherType();
    }

    @Override
    public String getAuthType() {
        return httpServletRequest.getAuthType();
    }

    @Override
    public Cookie[] getCookies() {
        return httpServletRequest.getCookies();
    }

    @Override
    public long getDateHeader(String name) {
        return httpServletRequest.getDateHeader(name);
    }

    @Override
    public String getHeader(String name) {
        return httpServletRequest.getHeader(name);
    }

    @Override
    public Enumeration<String> getHeaders(String name) {
        return httpServletRequest.getHeaders(name);
    }

    @Override
    public Enumeration<String> getHeaderNames() {
        return httpServletRequest.getHeaderNames();
    }

    @Override
    public int getIntHeader(String name) {
        return httpServletRequest.getIntHeader(name);
    }

    @Override
    public String getMethod() {
        return httpServletRequest.getMethod();
    }

    @Override
    public String getPathInfo() {
        return httpServletRequest.getPathInfo();
    }

    @Override
    public String getPathTranslated() {
        return httpServletRequest.getPathTranslated();
    }

    @Override
    public String getContextPath() {
        return httpServletRequest.getContextPath();
    }

    @Override
    public String getQueryString() {
        return httpServletRequest.getQueryString();
    }

    @Override
    public String getRemoteUser() {
        return httpServletRequest.getRemoteUser();
    }

    @Override
    public boolean isUserInRole(String role) {
        return httpServletRequest.isUserInRole(role);
    }

    @Override
    public Principal getUserPrincipal() {
        return httpServletRequest.getUserPrincipal();
    }

    @Override
    public String getRequestedSessionId() {
        return httpServletRequest.getRequestedSessionId();
    }

    @Override
    public String getRequestURI() {
        return httpServletRequest.getRequestURI();
    }

    @Override
    public StringBuffer getRequestURL() {
        return httpServletRequest.getRequestURL();
    }

    @Override
    public String getServletPath() {
        return httpServletRequest.getServletPath();
    }

    @Override
    public HttpSession getSession(boolean create) {
        return httpServletRequest.getSession();
    }

    @Override
    public HttpSession getSession() {
        return httpServletRequest.getSession();
    }

    @Override
    public String changeSessionId() {
        return httpServletRequest.changeSessionId();
    }

    @Override
    public boolean isRequestedSessionIdValid() {
        return httpServletRequest.isRequestedSessionIdValid();
    }

    @Override
    public boolean isRequestedSessionIdFromCookie() {
        return httpServletRequest.isRequestedSessionIdFromCookie();
    }

    @Override
    public boolean isRequestedSessionIdFromURL() {
        return httpServletRequest.isRequestedSessionIdFromURL();
    }

    @Override
    public boolean isRequestedSessionIdFromUrl() {
        return httpServletRequest.isRequestedSessionIdFromUrl();
    }

    @Override
    public boolean authenticate(HttpServletResponse response) throws IOException, ServletException {
        return httpServletRequest.authenticate(response);
    }

    @Override
    public void login(String username, String password) throws ServletException {
        httpServletRequest.login(username, password);
    }

    @Override
    public void logout() throws ServletException {
        httpServletRequest.logout();
    }

    @Override
    public Collection<Part> getParts() throws IOException, ServletException {
        return httpServletRequest.getParts();
    }

    @Override
    public Part getPart(String name) throws IOException, ServletException {
        return httpServletRequest.getPart(name);
    }

    @Override
    public <T extends HttpUpgradeHandler> T upgrade(Class<T> handlerClass) throws IOException, ServletException {
        return httpServletRequest.upgrade(handlerClass);
    }
}

package note2;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Collection;
import java.util.Locale;

/**
 * Created by kanyuxia on 2017/5/3.
 */
public class HttpResponseFacade implements HttpServletResponse {
    private HttpServletResponse httpServletResponse;

    HttpResponseFacade(HttpServletResponse httpServletResponse) {
        this.httpServletResponse = httpServletResponse;
    }
    @Override
    public String getCharacterEncoding() {
        return httpServletResponse.getCharacterEncoding();
    }

    @Override
    public String getContentType() {
        return httpServletResponse.getContentType();
    }

    @Override
    public ServletOutputStream getOutputStream() throws IOException {
        return httpServletResponse.getOutputStream();
    }

    @Override
    public PrintWriter getWriter() throws IOException {
        return httpServletResponse.getWriter();
    }

    @Override
    public void setCharacterEncoding(String charset) {
        httpServletResponse.setCharacterEncoding(charset);
    }

    @Override
    public void setContentLength(int len) {
        httpServletResponse.setContentLength(len);
    }

    @Override
    public void setContentLengthLong(long len) {
        httpServletResponse.setContentLengthLong(len);
    }

    @Override
    public void setContentType(String type) {
        httpServletResponse.setContentType(type);
    }

    @Override
    public void setBufferSize(int size) {
        httpServletResponse.setBufferSize(size);
    }

    @Override
    public int getBufferSize() {
        return httpServletResponse.getBufferSize();
    }

    @Override
    public void flushBuffer() throws IOException {
        httpServletResponse.flushBuffer();
    }

    @Override
    public void resetBuffer() {
        httpServletResponse.resetBuffer();
    }

    @Override
    public boolean isCommitted() {
        return httpServletResponse.isCommitted();
    }

    @Override
    public void reset() {
        httpServletResponse.reset();
    }

    @Override
    public void setLocale(Locale loc) {
        httpServletResponse.setLocale(loc);
    }

    @Override
    public Locale getLocale() {
        return httpServletResponse.getLocale();
    }

    @Override
    public void addCookie(Cookie cookie) {
        httpServletResponse.addCookie(cookie);
    }

    @Override
    public boolean containsHeader(String name) {
        return httpServletResponse.containsHeader(name);
    }

    @Override
    public String encodeURL(String url) {
        return httpServletResponse.encodeURL(url);
    }

    @Override
    public String encodeRedirectURL(String url) {
        return httpServletResponse.encodeRedirectURL(url);
    }

    @Override
    public String encodeUrl(String url) {
        return httpServletResponse.encodeUrl(url);
    }

    @Override
    public String encodeRedirectUrl(String url) {
        return httpServletResponse.encodeRedirectURL(url);
    }

    @Override
    public void sendError(int sc, String msg) throws IOException {
        httpServletResponse.sendError(sc, msg);
    }

    @Override
    public void sendError(int sc) throws IOException {
        httpServletResponse.sendError(sc);
    }

    @Override
    public void sendRedirect(String location) throws IOException {
        httpServletResponse.sendRedirect(location);
    }

    @Override
    public void setDateHeader(String name, long date) {
        httpServletResponse.setDateHeader(name, date);
    }

    @Override
    public void addDateHeader(String name, long date) {
        httpServletResponse.addDateHeader(name, date);
    }

    @Override
    public void setHeader(String name, String value) {
        httpServletResponse.setHeader(name, value);
    }

    @Override
    public void addHeader(String name, String value) {
        httpServletResponse.addHeader(name, value);
    }

    @Override
    public void setIntHeader(String name, int value) {
        httpServletResponse.setIntHeader(name, value);
    }

    @Override
    public void addIntHeader(String name, int value) {
        httpServletResponse.addIntHeader(name, value);
    }

    @Override
    public void setStatus(int sc) {
        httpServletResponse.setStatus(sc);
    }

    @Override
    public void setStatus(int sc, String sm) {
        httpServletResponse.setStatus(sc, sm);
    }

    @Override
    public int getStatus() {
        return httpServletResponse.getStatus();
    }

    @Override
    public String getHeader(String name) {
        return httpServletResponse.getHeader(name);
    }

    @Override
    public Collection<String> getHeaders(String name) {
        return httpServletResponse.getHeaders(name);
    }

    @Override
    public Collection<String> getHeaderNames() {
        return httpServletResponse.getHeaderNames();
    }
}

工具类：

package note2;

import java.util.Collection;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Map;

/**
 * Created by kanyuxia on 2017/4/27.
 */
public class Enumerator<E> implements Enumeration<E> {
    private Iterator<E> iterator = null;

    public Enumerator(Collection<E> collection) {
        this(collection.iterator());
    }

    public Enumerator(Iterator<E> iterator) {
        super();
        this.iterator = iterator;
    }

    public Enumerator(Map<?, E> map) {
        this(map.values().iterator());
    }

    @Override
    public boolean hasMoreElements() {
        return iterator.hasNext();
    }

    @Override
    public E nextElement() {
        return (E) iterator.next();
    }
}


package note2;

import java.util.HashMap;
import java.util.Map;

/**
 * Extended implementation of <strong>HashMap</strong> that includes a
 * <code>locked</code> property.  This class can be used to safely expose
 * Catalina internal parameter map objects to user classes without having
 * to clone them in order to avoid modifications.  When first created, a
 * <code>ParmaeterMap</code> instance is not locked.
 *
 * 存放Http参数：Query String or Form Data
 * Created by kanyuxia on 2017/4/27.
 */
public class ParameterMap<K, V> extends HashMap<K, V> {
    private static final long serialVersionUID = -7752723814131658494L;

    /**
     * 一些构造函数
     */
    public ParameterMap() {
        super();
    }

    public ParameterMap(int initialCapacity) {
        super(initialCapacity);
    }

    public ParameterMap(int initialCapaticity, float loadFactory) {
        super(initialCapaticity, loadFactory);
    }

    public ParameterMap(Map<K, V> map) {
        super(map);
    }

    /**
     * The current lock state of this parameter map.
     * ParameterMap是否锁住。
     */
    private boolean locked = false;

    public boolean isLocked() {
        return locked;
    }

    public void setLocked(boolean locked) {
        this.locked = locked;
    }

    @Override
    public void clear() {
        if (locked) {
            throw new IllegalStateException("parameterMap.locked");
        }
        super.clear();
    }

    @Override
    public V put(K key, V value) {
        if (locked) {
            throw new IllegalStateException("parameterMap.locked");
        }
        return super.put(key, value);
    }

    @Override
    public void putAll(Map<? extends K, ? extends V> m) {
        if (locked) {
            throw new IllegalStateException("parameterMap.locked");
        }
        super.putAll(m);
    }

    @Override
    public boolean remove(Object key, Object value) {
        if (locked) {
            throw new IllegalStateException("parameterMap.locked");
        }
        return super.remove(key, value);
    }
}

HttpConnector类：

package note2;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Stack;
import java.util.Vector;

/**
 * Created by kanyuxia on 2017/4/26.
 * Http连接器。
 */
public class HttpConnector implements Runnable,Connector {
    /**
     * The Container used for processing requests received by this Connector.
     * Servlet容器
     */
    private Container container = null;

    /**
     * The current number of processors that have been created.
     * 当前已经创建的HttpProcessor
     */
    private int curProcessors = 0;

    /**
     * The minimum number of processors to start at initialization time.
     * HttpProcessor对象池最小对象数
     */
    private int minProcessors = 5;

    /**
     * The maximum number of processors allowed, or <0 for unlimited.
     * HttpProcessor对象池最大对象数
     */
    private int maxProcessors = 20;

    /**
     * The port number on which we listen for HTTP requests.
     * 服务器端口号
     */
    private int port = 10086;

    /**
     * The set of processors that have been created but are not currently
     * being used to process a request.
     * 存放已经创建但未被使用的Http处理器对象
     */
    private final Stack<HttpProcessor> processors = new Stack<>();

    /**
     * The set of processors that have ever been created.
     * 存放已经创建的Http处理器
     */
    private Vector<HttpProcessor> created = new Vector<>();

    /**
     * The request scheme that will be set on all requests received
     * through this connector.
     * 服务器处理请求模式(协议)
     */
    private String scheme = "http";

    /**
     * The server socket through which we listen for incoming TCP connections.
     * 服务器ServerSocket
     */
    private ServerSocket serverSocket = null;

    /**
     * The background thread that listens for incoming TCP/IP connections and
     * hands them off to an appropriate processor.
     * 启动Http连接器，监听Http请求，把socket分发给HttpProcessor进行处理。
     */
    public void run() {
        while (true) {
            Socket socket = null;
            try {
                socket = serverSocket.accept();
            } catch (IOException e) {
                e.printStackTrace();
            }
            HttpProcessor processor = createProcessor();
            if (processor != null) {
                processor.assign(socket);
            }
        }
    }

    /**
     * Create (or allocate) and return an available processor for use in
     * processing a specific HTTP request, if possible.  If the maximum
     * allowed processors have already been created and are in use, return
     * <code>null</code> instead.
     * 创建HttpProcessor：1. 从栈中拿 2. new一个 3. 返回null
     */
    public HttpProcessor createProcessor() {
        synchronized (processors) {
            if (processors.size() > 0) {
                return processors.pop();
            }
            if (maxProcessors > 0 && curProcessors < maxProcessors) {
                return newProcessor();
            } else {
                if (maxProcessors < 0) {
                    return newProcessor();
                }
                return null;
            }
        }
    }

    /**
     * Initialize this connector (create ServerSocket here!)
     * 创建ServerSocket，在原HttpConnector中使用ServerSocketFactory创建，这里就直接创建
     */
    public void initialize() {
        try {
            serverSocket = new ServerSocket(port);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * Begin processing requests via this Connector.
     * 启动Http连接器，并创建HttpProcessor线程对象池
     */
    public void start() {
        // 启动Http连接器
        Thread thread = new Thread(this);
        thread.setDaemon(true);
        thread.start();
        // 创建最小HttpProcessor线程对象池
        while (curProcessors < minProcessors) {
            if (maxProcessors > 0 && curProcessors >= maxProcessors) {
                break;
            }
            HttpProcessor processor = newProcessor();
            recycle(processor);
        }
    }

    /**
     * Create and return a new processor suitable for processing HTTP
     * requests and returning the corresponding responses.
     * 创建HttpProcessor对象，并使用运行它(它运行在一个单独的后台线程中)
     */
    private HttpProcessor newProcessor() {
        HttpProcessor processor = new HttpProcessor(this, curProcessors++);
        created.addElement(processor);
        processor.start();
        return processor;
    }

    /**
     * Recycle the specified Processor so that it can be used again.
     * 回收已经没有使用的HttpProcessor
     * @param processor The processor to be recycled
     */
    void recycle(HttpProcessor processor) {
        processors.push(processor);
    }

    @Override
    public HttpServletRequest createRequest() {
        HttpRequest httpRequest = new HttpRequest();
        httpRequest.setConnector(this);
        return httpRequest;
    }

    @Override
    public HttpServletResponse createResponse() {
        HttpResponse httpResponse = new HttpResponse();
        httpResponse.setConnector(this);
        return httpResponse;
    }

    @Override
    public Container getContainer() {
        return container;
    }

    @Override
    public void setContainer(Container container) {
        this.container = container;
    }

    @Override
    public String getScheme() {
        return scheme;
    }

    @Override
    public void setScheme(String scheme) {
        this.scheme = scheme;
    }

    public void setMaxProcessors(int maxProcessors) {
        this.maxProcessors = maxProcessors;
    }

    public int getMaxProcessors() {
        return maxProcessors;
    }

    public void setMinProcessors(int minProcessors) {
        this.minProcessors = minProcessors;
    }

    public int getMinProcessors() {
        return minProcessors;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }
}

HttpProcessor类：

package note2;

import javax.servlet.ServletException;
import java.io.*;
import java.net.Socket;

/**
 * Created by kanyuxia on 2017/4/26.
 * Http处理器
 */
public class HttpProcessor implements Runnable {

    /**
     * The HttpConnector with which this processor is associated.
     */
    private HttpConnector connector = null;

    /**
     * Is there a new socket available?
     * 是否有新的socket可用
     */
    private boolean available = false;

    /**
     * The socket we are currently processing a request for.  This object
     * is used for inter-thread communication only.
     */
    private Socket socket = null;

    /**
     * The identifier of this processor, unique per connector.
     */
    private int id = 0;

    /**
     * The HTTP request object we will pass to our associated container.
     */
    private HttpRequest httpRequest = null;

    /**
     * The HTTP response object we will pass to our associated container.
     */
    private HttpResponse httpResponse = null;


    /**
     * Construct a new HttpProcessor associated with the specified connector.
     *
     * @param connector HttpConnector that owns this processor
     * @param id Identifier of this HttpProcessor (unique per connector)
     */
    public HttpProcessor(HttpConnector connector, int id) {
        this.connector = connector;
        this.id = id;
        this.httpRequest = (HttpRequest) connector.createRequest();
        this.httpResponse = (HttpResponse) connector.createResponse();
    }


    /**
     * Start the background thread we will use for request processing.
     * 启动一个后台线程运行HttpProcessor
     */
    public void start() {
        Thread thread = new Thread(this);
        thread.setDaemon(true);
        thread.start();
    }


    /**
     * The background thread that listens for incoming TCP/IP connections and
     * hands them off to an appropriate processor.
     * 等待HttpConnector分配socket，然后处理该scoket，最后通知HttpConnector回收该HttpProcessor
     */
    public void run() {
        while (true) {
            // Wait for the next socket to be assigned
            Socket socket = await();
            if (socket == null) {
                continue;
            }
            System.out.println(Thread.currentThread().getName());
            // Process the request from this socket
            process(socket);

            // Finish up this request
            connector.recycle(this);
        }
    }

    /**
     * Process an incoming HTTP request on the Socket that has been assigned
     * to this Processor.  Any exceptions that occur during processing must be
     * swallowed and dealt with.
     * 处理HttpConector分配的socket：1. 解析请求  2. 处理请求(调用容器处理)
     * @param socket The socket on which we are connected to the client
     */
    private void process(Socket socket) {
        InputStream input = null;
        OutputStream output = null;
        try {
            input = socket.getInputStream();
            output = socket.getOutputStream();
        } catch (IOException e) {
            e.printStackTrace();
        }
        httpRequest.setInput(input);
        httpResponse.setOutput(output);
        httpResponse.setHttpRequest(httpRequest);
        // Parse the incoming request
        parseConnection(socket);
        parseRequest(input, output);
        parseHeader(input, output);

        // Ask our Container to process this request
        try {
            connector.getContainer().invoke(httpRequest, httpResponse);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ServletException e) {
            e.printStackTrace();
        }

        //
        httpRequest.recycle();
        httpResponse.recycle();
    }

    /**
     * Parse and record the connection parameters related to this request.
     * 解析连接
     * @param socket The socket on which we are connected
     */
    private void parseConnection(Socket socket) {
    }

    /**
     * Parse the incoming HTTP request and set the corresponding HTTP request
     * properties.
     * 解析请求行
     * @param input The input stream attached to our socket
     * @param output The output stream of the socket
     */
    private void parseRequest(InputStream input, OutputStream output) {
        // 在这里仅仅解析了requestURI
        BufferedInputStream inputStream = new BufferedInputStream(input);
        StringBuilder stringBuilder = new StringBuilder(1024);
        byte[] buffer = new byte[1024];
        int b = 0;
        try {
            b = inputStream.read(buffer);
        } catch (IOException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < b; i++) {
            stringBuilder.append((char) buffer[i]);
        }
        int begin = stringBuilder.indexOf(" ") + 1;
        int end = stringBuilder.indexOf(" ", begin);
        String requestURI = stringBuilder.substring(begin, end);
        httpRequest.setRequestURI(requestURI);
    }

    /**
     * Parse the incoming HTTP request headers, and set the appropriate
     * request headers.
     * 解析请求头
     * @param input The input stream connected to our socket
     */
    private void parseHeader(InputStream input, OutputStream output) {

    }

    /**
     * Process an incoming TCP/IP connection on the specified socket.  Any
     * exception that occurs during processing must be logged and swallowed.
     * <b>NOTE</b>:  This method is called from our Connector's thread.  We
     * must assign it to our own thread so that multiple simultaneous
     * requests can be handled.
     * HttpConnector分配一个新的socket
     * @param socket TCP socket to process
     */
    public void assign(Socket socket) {
        synchronized (this) {
            // Wait for the Processor to get the previous Socket
            while (available) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            // Store the newly available Socket and notify our thread
            this.socket = socket;
            available = true;
            notifyAll();
        }
    }

    /**
     * Await a newly assigned Socket from our Connector, or <code>null</code>
     * if we are supposed to shut down.
     * 等待HttpConenctor分配一个新的socket
     */
    private Socket await() {
        synchronized (this) {
            // Wait for the Connector to provide a new Socket
            while (!available) {
                try {
                    wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            // Notify the Connector that we have received this Socket
            available = false;
            notifyAll();
            return socket;
        }
    }
}

SimpleContainer类：

package note2;

import note1.HttpServer;

import javax.servlet.Servlet;
import javax.servlet.ServletException;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.net.URLClassLoader;
import java.net.URLStreamHandler;

/**
 * Created by kanyuxia on 2017/5/3.
 */
public class SimpleContainer implements Container {

    @SuppressWarnings("unchecked")
    public void invoke(HttpRequest request, HttpResponse response) throws IOException, ServletException {
        String servletName = request.getRequestURI().substring(request.getRequestURI().lastIndexOf("/") + 1);
        // 创建URLClassLoader
        URLClassLoader classLoader = null;
        try {
            // 创建URL
            URL[] urls = new URL[1];
            File classPath = new File(HttpServer.SERVLET_ROOT);
            String repository = (new URL("file", null, classPath.getCanonicalPath() + File.separator)).toString();
            URLStreamHandler streamHandler = null;
            urls[0] = new URL(null, repository, streamHandler);
            classLoader = new URLClassLoader(urls);
        } catch (IOException e) {
            System.out.println();
        }
        Class<Servlet> servletClass = null;
        try {
            servletClass = (Class<Servlet>) classLoader.loadClass(servletName);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        Servlet servlet = null;
        try {
            servlet = servletClass.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        servlet.service(request.getRequest(), response.getResponse());
    }
}

BootStrap启动类：

package note2;

/**
 * Created by kanyuxia on 2017/5/3.
 */
public class BootStrap {
    public static void main(String[] args) {
        HttpConnector httpConnector = new HttpConnector();
        httpConnector.setContainer(new SimpleContainer());
        httpConnector.initialize();
        httpConnector.start();
    }
}