针对上述的类继承层级图，我们做如下说明：

1. ajp和http11是两种不同的协议
2. nio、nio2和apr是不同的通信方式
3. 协议和通信方式可以相互组合。

ProtocolHandler包含三个部件：Endpoint、Processor、Adapter。

1. Endpoint用来处理底层Socket的网络连接，Processor用于将Endpoint接收到的Socket封装成Request，Adapter用于将Request交给Container进行具体的处理。
2. Endpoint由于是处理底层的Socket网络连接，因此Endpoint是用来实现TCP/IP协议的，而Processor用来实现HTTP协议的，Adapter将请求适配到Servlet容器进行具体的处理。
3. Endpoint的抽象实现类AbstractEndpoint里面定义了Acceptor和AsyncTimeout两个内部类和一个Handler接口。Acceptor用于监听请求，AsyncTimeout用于检查异步Request的超时，Handler用于处理接收到的Socket，在内部调用Processor进行处理。

至此，我们已经明白了问题（1）、（2）和（3）。至于（4），当我们了解了Container自然就明白了，前面章节内容已经详细分析过了。

Connector源码分析入口

在这个文件中，我们看到一个Connector有几个关键属性，port和protocol是其中的两个。server.xml默认支持两种协议：HTTP/1.1和AJP/1.3。其中HTTP/1.1用于支持http1.1协议，而AJP/1.3用于支持对apache服务器的通信。

接下来我们看看构造方法。

从上面的代码我们看到构造方法主要做了下面几件事情：

1. 无参构造方法，传入参数为空协议，会默认使用HTTP/1.1
2. HTTP/1.1或null，protocolHandler使用org.apache.coyote.http11.Http11NioProtocol，不考虑apr
3. AJP/1.3，protocolHandler使用org.apache.coyote.ajp.AjpNioProtocol，不考虑apr
4. 其他情况，使用传入的protocol作为protocolHandler的类名
5. 使用protocolHandler的类名构造ProtocolHandler的实例

init()方法做了3件事情

1. 初始化adapter
2. 设置接受body的method列表，默认为POST
3. 初始化protocolHandler

从ProtocolHandler类继承层级我们知道ProtocolHandler的子类都必须实现AbstractProtocol抽象类，而protocolHandler.init();的逻辑代码正是在这个抽象类里面。我们来分析一下。

@Override

public void init() throws Exception {

    if (getLog().isInfoEnabled()) {

        getLog().info(sm.getString("abstractProtocolHandler.init", getName()));

    }

    if (oname == null) {

        // Component not pre-registered so register it

        oname = createObjectName();

        if (oname != null) {

            Registry.getRegistry(null, null).registerComponent(this, oname, null);

        }

    }

    if (this.domain != null) {

        rgOname = new ObjectName(domain + ":type=GlobalRequestProcessor,name=" + getName());

        Registry.getRegistry(null, null).registerComponent(

                getHandler().getGlobal(), rgOname, null);

    }

    // 1. 设置endpoint的名字，默认为：http-nio-{port}

    String endpointName = getName();

    endpoint.setName(endpointName.substring(1, endpointName.length()-1));

    endpoint.setDomain(domain);

    // 2. 初始化endpoint

    endpoint.init();

}

public abstract void bind() throws Exception;

public abstract void unbind() throws Exception;

public abstract void startInternal() throws Exception;

public abstract void stopInternal() throws Exception;

public void init() throws Exception {

    // 执行bind()方法

    if (bindOnInit) {

        bind();

        bindState = BindState.BOUND_ON_INIT;

    }

    if (this.domain != null) {

        // Register endpoint (as ThreadPool - historical name)

        oname = new ObjectName(domain + ":type=ThreadPool,name=\"" + getName() + "\"");

        Registry.getRegistry(null, null).registerComponent(this, oname, null);

        ObjectName socketPropertiesOname = new ObjectName(domain +

                ":type=ThreadPool,name=\"" + getName() + "\",subType=SocketProperties");

        socketProperties.setObjectName(socketPropertiesOname);

        Registry.getRegistry(null, null).registerComponent(socketProperties, socketPropertiesOname, null);

        for (SSLHostConfig sslHostConfig : findSslHostConfigs()) {

            registerJmx(sslHostConfig);

        }

    }

}

@Override

public void bind() throws Exception {

    if (!getUseInheritedChannel()) {

        serverSock = ServerSocketChannel.open();

        socketProperties.setProperties(serverSock.socket());

        InetSocketAddress addr = (getAddress()!=null?new InetSocketAddress(getAddress(),getPort()):new InetSocketAddress(getPort()));

        //绑定ServerSocket到指定的IP和端口

        serverSock.socket().bind(addr,getAcceptCount());

    } else {

        // Retrieve the channel provided by the OS

        Channel ic = System.inheritedChannel();

        if (ic instanceof ServerSocketChannel) {

            serverSock = (ServerSocketChannel) ic;

        }

        if (serverSock == null) {

            throw new IllegalArgumentException(sm.getString("endpoint.init.bind.inherited"));

        }

    }

    serverSock.configureBlocking(true); //mimic APR behavior

    // Initialize thread count defaults for acceptor, poller

    if (acceptorThreadCount == 0) {

        // FIXME: Doesn't seem to work that well with multiple accept threads

        acceptorThreadCount = 1;

    }

    if (pollerThreadCount <= 0) {

        //minimum one poller thread

        pollerThreadCount = 1;

    }

    setStopLatch(new CountDownLatch(pollerThreadCount));

    // Initialize SSL if needed

    initialiseSsl();

    selectorPool.open();

}

@Override

protected void startInternal() throws LifecycleException {

    // Validate settings before starting

    if (getPort() < 0) {

        throw new LifecycleException(sm.getString(

                "coyoteConnector.invalidPort", Integer.valueOf(getPort())));

    }

    setState(LifecycleState.STARTING);

    try {

        protocolHandler.start();

    } catch (Exception e) {

        throw new LifecycleException(

                sm.getString("coyoteConnector.protocolHandlerStartFailed"), e);

    }

}

@Override

public void start() throws Exception {

    if (getLog().isInfoEnabled()) {

        getLog().info(sm.getString("abstractProtocolHandler.start", getName()));

    }

    // 1. 调用`Endpoint.start()`方法

    endpoint.start();

    // Start async timeout thread

    // 2. 开启异步超时线程，线程执行单元为`Asynctimeout`

    asyncTimeout = new AsyncTimeout();

    Thread timeoutThread = new Thread(asyncTimeout, getNameInternal() + "-AsyncTimeout");

    int priority = endpoint.getThreadPriority();

    if (priority < Thread.MIN_PRIORITY || priority > Thread.MAX_PRIORITY) {

        priority = Thread.NORM_PRIORITY;

    }

    timeoutThread.setPriority(priority);

    timeoutThread.setDaemon(true);

    timeoutThread.start();

}

public final void start() throws Exception {

    // 1. `bind()`已经在`init()`中分析过了

    if (bindState == BindState.UNBOUND) {

        bind();

        bindState = BindState.BOUND_ON_START;

    }

    startInternal();

}

@Override

public void startInternal() throws Exception {

    if (!running) {

        running = true;

        paused = false;

        processorCache = new SynchronizedStack<>(SynchronizedStack.DEFAULT_SIZE,

                socketProperties.getProcessorCache());

        eventCache = new SynchronizedStack<>(SynchronizedStack.DEFAULT_SIZE,

                        socketProperties.getEventCache());

        nioChannels = new SynchronizedStack<>(SynchronizedStack.DEFAULT_SIZE,

                socketProperties.getBufferPool());

        // Create worker collection

        // 2. 创建工作者线程池

        if ( getExecutor() == null ) {

            createExecutor();

        }

        // 3. 初始化连接latch，用于限制请求的并发量

        initializeConnectionLatch();

        // Start poller threads

        // 4. 开启poller线程。poller用于对接受者线程生产的消息（或事件）进行处理，poller最终调用的是Handler的代码

        pollers = new Poller[getPollerThreadCount()];

        for (int i=0; i<pollers.length; i++) {

            pollers[i] = new Poller();

            Thread pollerThread = new Thread(pollers[i], getName() + "-ClientPoller-"+i);

            pollerThread.setPriority(threadPriority);

            pollerThread.setDaemon(true);

            pollerThread.start();

        }

        // 5. 开启acceptor线程

        startAcceptorThreads();

    }

}

protected final void startAcceptorThreads() {

    int count = getAcceptorThreadCount();

    acceptors = new Acceptor[count];

    for (int i = 0; i < count; i++) {

        acceptors[i] = createAcceptor();

        String threadName = getName() + "-Acceptor-" + i;

        acceptors[i].setThreadName(threadName);

        Thread t = new Thread(acceptors[i], threadName);

        t.setPriority(getAcceptorThreadPriority());

        t.setDaemon(getDaemon());

        t.start();

    }

}

从以上代码可以看到：

• countUpOrAwaitConnection函数检查当前最大连接数，若未达到maxConnections则加一，否则等待；
• socket = serverSock.accept()这一行中的serverSock正是NioEndpoint的bind函数中打开的ServerSocketChannel。为了引用这个变量，NioEndpoint的Acceptor类是成员而不再是静态类；
• setSocketOptions函数调用上的注释表明该函数将已连接套接字交给Poller线程处理。

• 从NioChannel栈中出栈一个，若能重用（即不为null）则重用对象，否则新建一个NioChannel对象；
• getPoller0方法利用轮转法选择一个Poller线程，利用Poller类的register方法将上述NioChannel对象注册到该Poller线程上；
• 若成功转给Poller线程该函数返回true，否则返回false。返回false后，Acceptor类的closeSocket函数会关闭通道和底层Socket连接并将当前最大连接数减一。

在run函数中：

• 若感兴趣集是自定义的OP_REGISTER，则说明该事件表示的已连接套接字通道尚未被轮询线程处理过，那么将该通道注册到Poller线程的Selector上，感兴趣集是OP_READ，通道注册的附件是一个NioSocketWrapper对象。从Poller的register方法添加事件即是这样的过程；
• 否则获得已连接套接字通道注册到Poller线程的Selector上的SelectionKey，为key添加新的感兴趣集。

• 若队列里有元素则会先把队列里的事件均执行一遍，PollerEvent的run方法会将通道注册到Poller的Selector上；
• 对select返回的SelectionKey进行处理，由于在PollerEvent中注册通道时带上了NioSocketWrapper附件，因此这里可以用SelectionKey的attachment方法得到，接着调用processKey去处理已连接套接字通道。

protected void processKey(SelectionKey sk, NioSocketWrapper attachment) {

    try {

        if ( close ) {

            cancelledKey(sk);

        } else if ( sk.isValid() && attachment != null ) {

            if (sk.isReadable() || sk.isWritable() ) {

                if ( attachment.getSendfileData() != null ) {

                    processSendfile(sk,attachment, false);

                } else {

                    unreg(sk, attachment, sk.readyOps());

                    boolean closeSocket = false;

                    // 1. 处理读事件，比如生成Request对象

                    // Read goes before write

                    if (sk.isReadable()) {

                        if (!processSocket(attachment, SocketEvent.OPEN_READ, true)) {

                            closeSocket = true;

                        }

                    }

                    // 2. 处理写事件，比如将生成的Response对象通过socket写回客户端

                    if (!closeSocket && sk.isWritable()) {

                        if (!processSocket(attachment, SocketEvent.OPEN_WRITE, true)) {

                            closeSocket = true;

                        }

                    }

                    if (closeSocket) {

                        cancelledKey(sk);

                    }

                }

            }

        } else {

            //invalid key

            cancelledKey(sk);

        }

    } catch ( CancelledKeyException ckx ) {

        cancelledKey(sk);

    } catch (Throwable t) {

        ExceptionUtils.handleThrowable(t);

        log.error("",t);

    }

}

public boolean processSocket(SocketWrapperBase<S> socketWrapper,

        SocketEvent event, boolean dispatch) {

    try {

        if (socketWrapper == null) {

            return false;

        }

        // 1. 从`processorCache`里面拿一个`Processor`来处理socket，`Processor`的实现为`SocketProcessor`

        SocketProcessorBase<S> sc = processorCache.pop();

        if (sc == null) {

            sc = createSocketProcessor(socketWrapper, event);

        } else {

            sc.reset(socketWrapper, event);

        }

        // 2. 将`Processor`放到工作线程池中执行

        Executor executor = getExecutor();

        if (dispatch && executor != null) {

            executor.execute(sc);

        } else {

            sc.run();

        }

    } catch (RejectedExecutionException ree) {

        getLog().warn(sm.getString("endpoint.executor.fail", socketWrapper) , ree);

        return false;

    } catch (Throwable t) {

        ExceptionUtils.handleThrowable(t);

        // This means we got an OOM or similar creating a thread, or that

        // the pool and its queue are full

        getLog().error(sm.getString("endpoint.process.fail"), t);

        return false;

    }

    return true;

}

@Override

protected SocketProcessorBase<NioChannel> createSocketProcessor(

        SocketWrapperBase<NioChannel> socketWrapper, SocketEvent event) {

    return new SocketProcessor(socketWrapper, event);

}

/**

 * This class is the equivalent of the Worker, but will simply use in an

 * external Executor thread pool.

 */

protected class SocketProcessor extends SocketProcessorBase<NioChannel> {

    public SocketProcessor(SocketWrapperBase<NioChannel> socketWrapper, SocketEvent event) {

        super(socketWrapper, event);

    }

    @Override

    protected void doRun() {

        NioChannel socket = socketWrapper.getSocket();

        SelectionKey key = socket.getIOChannel().keyFor(socket.getPoller().getSelector());

        try {

            int handshake = -1;

            try {

                if (key != null) {

                    if (socket.isHandshakeComplete()) {

                        // No TLS handshaking required. Let the handler

                        // process this socket / event combination.

                        handshake = 0;

                    } else if (event == SocketEvent.STOP || event == SocketEvent.DISCONNECT ||

                            event == SocketEvent.ERROR) {

                        // Unable to complete the TLS handshake. Treat it as

                        // if the handshake failed.

                        handshake = -1;

                    } else {

                        handshake = socket.handshake(key.isReadable(), key.isWritable());

                        // The handshake process reads/writes from/to the

                        // socket. status may therefore be OPEN_WRITE once

                        // the handshake completes. However, the handshake

                        // happens when the socket is opened so the status

                        // must always be OPEN_READ after it completes. It

                        // is OK to always set this as it is only used if

                        // the handshake completes.

                        event = SocketEvent.OPEN_READ;

                    }

                }

            } catch (IOException x) {

                handshake = -1;

                if (log.isDebugEnabled()) log.debug("Error during SSL handshake",x);

            } catch (CancelledKeyException ckx) {

                handshake = -1;

            }

            if (handshake == 0) {

                SocketState state = SocketState.OPEN;

                // Process the request from this socket

                // 将处理逻辑交给`Handler`处理，当event为null时，则表明是一个`OPEN_READ`事件

                if (event == null) {

                    state = getHandler().process(socketWrapper, SocketEvent.OPEN_READ);

                } else {

                    state = getHandler().process(socketWrapper, event);

                }

                if (state == SocketState.CLOSED) {

                    close(socket, key);

                }

            } else if (handshake == -1 ) {

                close(socket, key);

            } else if (handshake == SelectionKey.OP_READ){

                socketWrapper.registerReadInterest();

            } else if (handshake == SelectionKey.OP_WRITE){

                socketWrapper.registerWriteInterest();

            }

        } catch (CancelledKeyException cx) {

            socket.getPoller().cancelledKey(key);

        } catch (VirtualMachineError vme) {

            ExceptionUtils.handleThrowable(vme);

        } catch (Throwable t) {

            log.error("", t);

            socket.getPoller().cancelledKey(key);

        } finally {

            socketWrapper = null;

            event = null;

            //return to cache

            if (running && !paused) {

                processorCache.push(this);

            }

        }

    }

}

@Override

public SocketState process(SocketWrapperBase<S> wrapper, SocketEvent status) {

    try {

        if (processor == null) {

            processor = getProtocol().createProcessor();

            register(processor);

        }

        processor.setSslSupport(

                wrapper.getSslSupport(getProtocol().getClientCertProvider()));

        // Associate the processor with the connection

        connections.put(socket, processor);

        SocketState state = SocketState.CLOSED;

        do {

            // 关键的代码，终于找到你了

            state = processor.process(wrapper, status);

        } while ( state == SocketState.UPGRADING);

        return state;

    }

    catch (Throwable e) {

        ExceptionUtils.handleThrowable(e);

        // any other exception or error is odd. Here we log it

        // with "ERROR" level, so it will show up even on

        // less-than-verbose logs.

        getLog().error(sm.getString("abstractConnectionHandler.error"), e);

    } finally {

        ContainerThreadMarker.clear();

    }

    // Make sure socket/processor is removed from the list of current

    // connections

    connections.remove(socket);

    release(processor);

    return SocketState.CLOSED;

}

protected Http11Processor createProcessor() {

    // 构建 Http11Processor

    Http11Processor processor = new Http11Processor(

            proto.getMaxHttpHeaderSize(), (JIoEndpoint)proto.endpoint, // 1. http header 的最大尺寸

            proto.getMaxTrailerSize(),proto.getMaxExtensionSize());

    processor.setAdapter(proto.getAdapter());

    // 2. 默认的 KeepAlive 情况下, 每个 Socket 处理的最多的 请求次数

    processor.setMaxKeepAliveRequests(proto.getMaxKeepAliveRequests());

    // 3. 开启 KeepAlive 的 Timeout

    processor.setKeepAliveTimeout(proto.getKeepAliveTimeout());

    // 4. http 当遇到文件上传时的 默认超时时间 (300 * 1000)

    processor.setConnectionUploadTimeout(

            proto.getConnectionUploadTimeout());

    processor.setDisableUploadTimeout(proto.getDisableUploadTimeout());

    // 5. 当 http 请求的 body size超过这个值时, 通过 gzip 进行压缩

    processor.setCompressionMinSize(proto.getCompressionMinSize());

    // 6. http 请求是否开启 compression 处理

    processor.setCompression(proto.getCompression());

    processor.setNoCompressionUserAgents(proto.getNoCompressionUserAgents());

    // 7. http body里面的内容是 "text/html,text/xml,text/plain" 才会进行 压缩处理

    processor.setCompressableMimeTypes(proto.getCompressableMimeTypes());

    processor.setRestrictedUserAgents(proto.getRestrictedUserAgents());

    // 8. socket 的 buffer, 默认 9000

    processor.setSocketBuffer(proto.getSocketBuffer());

    // 9. 最大的 Post 处理尺寸的大小 4 * 1000

    processor.setMaxSavePostSize(proto.getMaxSavePostSize());

    processor.setServer(proto.getServer());

    processor.setDisableKeepAlivePercentage(

            proto.getDisableKeepAlivePercentage());

    register(processor);

    return processor;

}

public abstract class AbstractProcessorLight implements Processor {

    @Override

    public SocketState process(SocketWrapperBase<?> socketWrapper, SocketEvent status)

            throws IOException {

        SocketState state = SocketState.CLOSED;

        Iterator<DispatchType> dispatches = null;

        do {

            if (dispatches != null) {

                DispatchType nextDispatch = dispatches.next();

                state = dispatch(nextDispatch.getSocketStatus());

            } else if (status == SocketEvent.DISCONNECT) {

                // Do nothing here, just wait for it to get recycled

            } else if (isAsync() || isUpgrade() || state == SocketState.ASYNC_END) {

                state = dispatch(status);

                if (state == SocketState.OPEN) {

                    // There may be pipe-lined data to read. If the data isn't

                    // processed now, execution will exit this loop and call

                    // release() which will recycle the processor (and input

                    // buffer) deleting any pipe-lined data. To avoid this,

                    // process it now.

                    state = service(socketWrapper);

                }

            } else if (status == SocketEvent.OPEN_WRITE) {

                // Extra write event likely after async, ignore

                state = SocketState.LONG;

            } else if (status == SocketEvent.OPEN_READ){

                // 调用`service()`方法

                state = service(socketWrapper);

            } else {

                // Default to closing the socket if the SocketEvent passed in

                // is not consistent with the current state of the Processor

                state = SocketState.CLOSED;

            }

            if (getLog().isDebugEnabled()) {

                getLog().debug("Socket: [" + socketWrapper +

                        "], Status in: [" + status +

                        "], State out: [" + state + "]");

            }

            if (state != SocketState.CLOSED && isAsync()) {

                state = asyncPostProcess();

                if (getLog().isDebugEnabled()) {

                    getLog().debug("Socket: [" + socketWrapper +

                            "], State after async post processing: [" + state + "]");

                }

            }

            if (dispatches == null || !dispatches.hasNext()) {

                // Only returns non-null iterator if there are

                // dispatches to process.

                dispatches = getIteratorAndClearDispatches();

            }

        } while (state == SocketState.ASYNC_END ||

                dispatches != null && state != SocketState.CLOSED);

        return state;

    }

}

@Override

public void service(org.apache.coyote.Request req, org.apache.coyote.Response res)

        throws Exception {

    // 1. 根据coyote框架的request和response对象，生成connector的request和response对象（是HttpServletRequest和HttpServletResponse的封装）

    Request request = (Request) req.getNote(ADAPTER_NOTES);

    Response response = (Response) res.getNote(ADAPTER_NOTES);

    if (request == null) {

        // Create objects

        request = connector.createRequest();

        request.setCoyoteRequest(req);

        response = connector.createResponse();

        response.setCoyoteResponse(res);

        // Link objects

        request.setResponse(response);

        response.setRequest(request);

        // Set as notes

        req.setNote(ADAPTER_NOTES, request);

        res.setNote(ADAPTER_NOTES, response);

        // Set query string encoding

        req.getParameters().setQueryStringCharset(connector.getURICharset());

    }

    // 2. 补充header

    if (connector.getXpoweredBy()) {

        response.addHeader("X-Powered-By", POWERED_BY);

    }

    boolean async = false;

    boolean postParseSuccess = false;

    req.getRequestProcessor().setWorkerThreadName(THREAD_NAME.get());

    try {

        // Parse and set Catalina and configuration specific

        // request parameters

        // 3. 解析请求，该方法会出现代理服务器、设置必要的header等操作

        // 用来处理请求映射 (获取 host, context, wrapper, URI 后面的参数的解析, sessionId )

        postParseSuccess = postParseRequest(req, request, res, response);

        if (postParseSuccess) {

            //check valves if we support async

            request.setAsyncSupported(

                    connector.getService().getContainer().getPipeline().isAsyncSupported());

            // Calling the container

            // 4. 真正进入容器的地方，调用Engine容器下pipeline的阀门

            connector.getService().getContainer().getPipeline().getFirst().invoke(

                    request, response);

        }

        if (request.isAsync()) {

            async = true;

            ReadListener readListener = req.getReadListener();

            if (readListener != null && request.isFinished()) {

                // Possible the all data may have been read during service()

                // method so this needs to be checked here

                ClassLoader oldCL = null;

                try {

                    oldCL = request.getContext().bind(false, null);

                    if (req.sendAllDataReadEvent()) {

                        req.getReadListener().onAllDataRead();

                    }

                } finally {

                    request.getContext().unbind(false, oldCL);

                }

            }

            Throwable throwable =

                    (Throwable) request.getAttribute(RequestDispatcher.ERROR_EXCEPTION);

            // If an async request was started, is not going to end once

            // this container thread finishes and an error occurred, trigger

            // the async error process

            if (!request.isAsyncCompleting() && throwable != null) {

                request.getAsyncContextInternal().setErrorState(throwable, true);

            }

        } else {

            //5. 通过request.finishRequest 与 response.finishResponse(刷OutputBuffer中的数据到浏览器) 来完成整个请求

            request.finishRequest();

            //将 org.apache.catalina.connector.Response对应的 OutputBuffer 中的数据 刷到 org.apache.coyote.Response 对应的 InternalOutputBuffer 中, 并且最终调用 socket对应的 outputStream 将数据刷出去( 这里会组装 Http Response 中的 header 与 body 里面的数据, 并且刷到远端 )

            response.finishResponse();

        }

    } catch (IOException e) {

        // Ignore

    } finally {

        AtomicBoolean error = new AtomicBoolean(false);

        res.action(ActionCode.IS_ERROR, error);

        if (request.isAsyncCompleting() && error.get()) {

            // Connection will be forcibly closed which will prevent

            // completion happening at the usual point. Need to trigger

            // call to onComplete() here.

            res.action(ActionCode.ASYNC_POST_PROCESS,  null);

            async = false;

        }

        // Access log

        if (!async && postParseSuccess) {

            // Log only if processing was invoked.

            // If postParseRequest() failed, it has already logged it.

            Context context = request.getContext();

            // If the context is null, it is likely that the endpoint was

            // shutdown, this connection closed and the request recycled in

            // a different thread. That thread will have updated the access

            // log so it is OK not to update the access log here in that

            // case.

            if (context != null) {

                context.logAccess(request, response,

                        System.currentTimeMillis() - req.getStartTime(), false);

            }

        }

        req.getRequestProcessor().setWorkerThreadName(null);

        // Recycle the wrapper request and response

        if (!async) {

            request.recycle();

            response.recycle();

        }

    }

}

protected boolean postParseRequest(org.apache.coyote.Request req, Request request,

        org.apache.coyote.Response res, Response response) throws IOException, ServletException {

    // 省略部分代码

    MessageBytes decodedURI = req.decodedURI();

    if (undecodedURI.getType() == MessageBytes.T_BYTES) {

        // Copy the raw URI to the decodedURI

        decodedURI.duplicate(undecodedURI);

        // Parse the path parameters. This will:

        //   - strip out the path parameters

        //   - convert the decodedURI to bytes

        parsePathParameters(req, request);

        // URI decoding

        // %xx decoding of the URL

        try {

            req.getURLDecoder().convert(decodedURI, false);

        } catch (IOException ioe) {

            res.setStatus(400);

            res.setMessage("Invalid URI: " + ioe.getMessage());

            connector.getService().getContainer().logAccess(

                    request, response, 0, true);

            return false;

        }

        // Normalization

        if (!normalize(req.decodedURI())) {

            res.setStatus(400);

            res.setMessage("Invalid URI");

            connector.getService().getContainer().logAccess(

                    request, response, 0, true);

            return false;

        }

        // Character decoding

        convertURI(decodedURI, request);

        // Check that the URI is still normalized

        if (!checkNormalize(req.decodedURI())) {

            res.setStatus(400);

            res.setMessage("Invalid URI character encoding");

            connector.getService().getContainer().logAccess(

                    request, response, 0, true);

            return false;

        }

    } else {

        /* The URI is chars or String, and has been sent using an in-memory

            * protocol handler. The following assumptions are made:

            * - req.requestURI() has been set to the 'original' non-decoded,

            *   non-normalized URI

            * - req.decodedURI() has been set to the decoded, normalized form

            *   of req.requestURI()

            */

        decodedURI.toChars();

        // Remove all path parameters; any needed path parameter should be set

        // using the request object rather than passing it in the URL

        CharChunk uriCC = decodedURI.getCharChunk();

        int semicolon = uriCC.indexOf(';');

        if (semicolon > 0) {

            decodedURI.setChars

                (uriCC.getBuffer(), uriCC.getStart(), semicolon);

        }

    }

    // Request mapping.

    MessageBytes serverName;

    if (connector.getUseIPVHosts()) {

        serverName = req.localName();

        if (serverName.isNull()) {

            // well, they did ask for it

            res.action(ActionCode.REQ_LOCAL_NAME_ATTRIBUTE, null);

        }

    } else {

        serverName = req.serverName();

    }

    // Version for the second mapping loop and

    // Context that we expect to get for that version

    String version = null;

    Context versionContext = null;

    boolean mapRequired = true;

    while (mapRequired) {

        // This will map the the latest version by default

        connector.getService().getMapper().map(serverName, decodedURI,

                version, request.getMappingData());

        // 省略部分代码

    }

    // 省略部分代码

}