10、http的解析

分析tomcat对http的解析，我们还是要从tomcat接收到请求开始，我们可以通过浏览器直接请求一下，然后打断点，调试一下。

首先说明，一下分析的是NIO类型的socket处理，大致类图如下：

org.apache.tomcat.util.net.NioEndpoint.Acceptor

其run方法

public void org.apache.tomcat.util.net.NioEndpoint.Acceptor.run() {

    int errorDelay = 0;

    // Loop until we receive a shutdown command
    while (running) {

       。。。。。。
        try {
            //if we have reached max connections, wait
            countUpOrAwaitConnection();

            SocketChannel socket = null;
            try {
                // Accept the next incoming connection from the server
                // socket
                //阻塞，等待请求
                socket = serverSock.accept();
            } catch (IOException ioe) {
               。。。。。。
            }
            // Successful accept, reset the error delay
            errorDelay = 0;

            // Configure the socket
            if (running && !paused) {
                // setSocketOptions() will hand the socket off to
                // an appropriate processor if successful
                //（*1*）
                if (!setSocketOptions(socket)) {
                    closeSocket(socket);
                }
            } else {
                closeSocket(socket);
            }
        } catch (Throwable t) {
            ExceptionUtils.handleThrowable(t);
            log.error(sm.getString("endpoint.accept.fail"), t);
        }
    }
    state = AcceptorState.ENDED;
}

 //（*1*）
 protected boolean org.apache.tomcat.util.net.NioEndpoint.setSocketOptions(SocketChannel socket) {
        // Process the connection
        try {
            //disable blocking, APR style, we are gonna be polling it
            //设置为非阻塞
            socket.configureBlocking(false);
            //获取请求的socket
            Socket sock = socket.socket();
            //设置socket参数
            socketProperties.setProperties(sock);
            //从共享对象池中获取一个NioChannel
            NioChannel channel = nioChannels.pop();
            if (channel == null) {
                //创建SocketBufferHandler，用于获取缓冲区，设置可接受的buffer大小，可写的buffer大小
                SocketBufferHandler bufhandler = new SocketBufferHandler(
                        socketProperties.getAppReadBufSize(),
                        socketProperties.getAppWriteBufSize(),
                        socketProperties.getDirectBuffer());
                if (isSSLEnabled()) {
                    channel = new SecureNioChannel(socket, bufhandler, selectorPool, this);
                } else {
                    channel = new NioChannel(socket, bufhandler);
                }
            } else {
                channel.setIOChannel(socket);
                channel.reset();
            }
            //将通道包装成事件注册到poller的事件队列中
            //如果有必要的话会立即唤醒selector，然后注册通道到对应的selector中
            getPoller0().register(channel);
        } catch (Throwable t) {
            ExceptionUtils.handleThrowable(t);
            try {
                log.error("",t);
            } catch (Throwable tt) {
                ExceptionUtils.handleThrowable(tt);
            }
            // Tell to close the socket
            return false;
        }
        return true;
    }

新的请求被注册到了poller中，我们来看看poller的run方法

public void org.apache.tomcat.util.net.NioEndpoint.Pollerrun() {
    // Loop until destroy() is called
    while (true) {

        boolean hasEvents = false;

        try {
            if (!close) {
                //判断是否有任务
                hasEvents = events();
                //如果添加的任务大于零，那么进行立即获取select，处理掉任务，防止任务堆积
                if (wakeupCounter.getAndSet(-1) > 0) {
                    //if we are here, means we have other stuff to do
                    //do a non blocking select
                    keyCount = selector.selectNow();
                } else {
                    //如果没有啥任务，默认最大select时间为1s
                    keyCount = selector.select(selectorTimeout);
                }
                //设置为零
                wakeupCounter.set(0);
            }
            //如果要求关闭，那么处理调用任务队列中的任务，然后关闭
            if (close) {
                events();
                timeout(0, false);
                try {
                    selector.close();
                } catch (IOException ioe) {
                    log.error(sm.getString("endpoint.nio.selectorCloseFail"), ioe);
                }
                break;
            }
        } catch (Throwable x) {
            ExceptionUtils.handleThrowable(x);
            log.error("",x);
            continue;
        }
        //either we timed out or we woke up, process events first
        if ( keyCount == 0 ) hasEvents = (hasEvents | events());

        Iterator<SelectionKey> iterator =
            keyCount > 0 ? selector.selectedKeys().iterator() : null;
        // Walk through the collection of ready keys and dispatch
        // any active event.
        while (iterator != null && iterator.hasNext()) {
            SelectionKey sk = iterator.next();
            NioSocketWrapper attachment = (NioSocketWrapper)sk.attachment();
            // Attachment may be null if another thread has called
            // cancelledKey()
            if (attachment == null) {
                iterator.remove();
            } else {
                iterator.remove();
                //处理
                processKey(sk, attachment);
            }
        }//while

        //process timeouts
        timeout(keyCount,hasEvents);
    }//while

    getStopLatch().countDown();
}

处理key

protected void org.apache.tomcat.util.net.NioEndpoint.Poller.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;
                            // Read goes before write
                            if (sk.isReadable()) {
                                //(*1*)
                                if (!processSocket(attachment, SocketEvent.OPEN_READ, true)) {
                                    closeSocket = true;
                                }
                            }
                           。。。。。。
                           
                           

我们还是直接跳到处理http请求协议的方法吧

public SocketState org.apache.coyote.http11.Http11Processor.service(SocketWrapperBase<?> socketWrapper)
        throws IOException {
        RequestInfo rp = request.getRequestProcessor();
        rp.setStage(org.apache.coyote.Constants.STAGE_PARSE);

        // Setting up the I/O
        //关联SocketWrapperBase
        setSocketWrapper(socketWrapper);
        //初始化输入缓冲
        inputBuffer.init(socketWrapper);
        //初始化输出缓冲
        outputBuffer.init(socketWrapper);

        // Flags
        keepAlive = true;
        openSocket = false;
        readComplete = true;
        boolean keptAlive = false;
        SendfileState sendfileState = SendfileState.DONE;

        while (!getErrorState().isError() && keepAlive && !isAsync() && upgradeToken == null &&
                sendfileState == SendfileState.DONE && !endpoint.isPaused()) {

            // Parsing the request header
            try {
                //解析请求协议
                if (!inputBuffer.parseRequestLine(keptAlive)) {
                    //读取失败时判断是否需要升级
                    if (inputBuffer.getParsingRequestLinePhase() == -1) {
                        return SocketState.UPGRADING;
                        //是否认为请求读取结束
                    } else if (handleIncompleteRequestLineRead()) {
                        break;
                    }
                }
                。。。。。。
            }

            //如果端点已经停止，那么设置服务不可用
            if (endpoint.isPaused()) {
                    // 503 - Service unavailable
                    response.setStatus(503);
                    setErrorState(ErrorState.CLOSE_CLEAN, null);
                } else {
                    keptAlive = true;
                    // Set this every time in case limit has been changed via JMX
                    //设置请求头个数
                    request.getMimeHeaders().setLimit(endpoint.getMaxHeaderCount());
                    //解析请求头
                    if (!inputBuffer.parseHeaders()) {
                        // We've read part of the request, don't recycle it
                        // instead associate it with the socket
                        //如果没有解析完成，也就是数据还没有完全发送过来，那么标识保持这个socket不关闭
                        openSocket = true;
                        //设置读取完成标识为false
                        readComplete = false;
                        //跳出循环，期待下次的通道读取事件
                        break;
                    }
                    。。。。。。
                }
            } 

            。。。。。。

            if (!getErrorState().isError()) {
                // Setting up filters, and parse some request headers
                //记录RequestInfo阶段为准备阶段
                rp.setStage(org.apache.coyote.Constants.STAGE_PREPARE);
                try {
                    //准备请求，内部主要是对解析请求头等信息做进一步的处理
                    prepareRequest();
                } catch (Throwable t) {
                    ExceptionUtils.handleThrowable(t);
                    if (log.isDebugEnabled()) {
                        log.debug(sm.getString("http11processor.request.prepare"), t);
                    }
                    // 500 - Internal Server Error
                    response.setStatus(500);
                    setErrorState(ErrorState.CLOSE_CLEAN, t);
                    getAdapter().log(request, response, 0);
                }
            }
            //设置是否需要长连接
            if (maxKeepAliveRequests == 1) {
                keepAlive = false;
            } else if (maxKeepAliveRequests > 0 &&
                    socketWrapper.decrementKeepAlive() <= 0) {
                keepAlive = false;
            }

            // Process the request in the adapter
            if (!getErrorState().isError()) {
                try {
                    //变更请求阶段为服务阶段，表示可以开始提供服务了
                    rp.setStage(org.apache.coyote.Constants.STAGE_SERVICE);
                    //开始调用容器，通过排管一直调用到servletWrapper
                    getAdapter().service(request, response);
                    
                } catch (Throwable t) {
                   
                }
            }

           。。。。。。
    }

解析请求协议

boolean org.apache.coyote.http11.Http11InputBuffer.parseRequestLine(boolean keptAlive) throws IOException {

        // check state
        if (!parsingRequestLine) {
            return true;
        }
        //
        // Skipping blank lines
        //parsingRequestLinePhase表示解析请求协议的阶段
        if (parsingRequestLinePhase < 2) {
            byte chr = 0;
            do {

                // Read new bytes if needed
                //如果解析的缓冲的开始位置大于等于上限位置，默认tomcat在没有读取任何数据的时候设置的position为零，limit也为零
                if (byteBuffer.position() >= byteBuffer.limit()) {
                    if (keptAlive) {
                        // Haven't read any request data yet so use the keep-alive
                        // timeout.
                        //设置读取超时时间
                        wrapper.setReadTimeout(wrapper.getEndpoint().getKeepAliveTimeout());
                    }
                    //从通道读取数据
                    if (!fill(false)) {
                        // A read is pending, so no longer in initial state
                        //如果读取到了值，那么设置读取阶段为1
                        parsingRequestLinePhase = 1;
                        return false;
                    }
                    // At least one byte of the request has been received.
                    // Switch to the socket timeout.
                    wrapper.setReadTimeout(wrapper.getEndpoint().getConnectionTimeout());
                }
                if (!keptAlive && byteBuffer.position() == 0 && byteBuffer.limit() >= CLIENT_PREFACE_START.length - 1) {
                    boolean prefaceMatch = true;
                    //是否匹配http2协议头
                    for (int i = 0; i < CLIENT_PREFACE_START.length && prefaceMatch; i++) {
                        if (CLIENT_PREFACE_START[i] != byteBuffer.get(i)) {
                            prefaceMatch = false;
                        }
                    }
                    if (prefaceMatch) {
                        // HTTP/2 preface matched
                        parsingRequestLinePhase = -1;
                        return false;
                    }
                }
                // Set the start time once we start reading data (even if it is
                // just skipping blank lines)
                if (request.getStartTime() < 0) {
                    request.setStartTime(System.currentTimeMillis());
                }
                //获取第一个字符，如果是换行符，那么继续读取，主要是用于跳过空白行
                chr = byteBuffer.get();
            } while ((chr == Constants.CR) || (chr == Constants.LF));
            //因为上面的get方法会使的position加1，这里需要调回去
            byteBuffer.position(byteBuffer.position() - 1);
            //设置解析请求开始位置，刚开始的时候这个位置是零
            parsingRequestLineStart = byteBuffer.position();
            //设置为阶段2
            parsingRequestLinePhase = 2;
            if (log.isDebugEnabled()) {
                log.debug("Received ["
                        + new String(byteBuffer.array(), byteBuffer.position(), byteBuffer.remaining(), StandardCharsets.ISO_8859_1) + "]");
            }
        }
        //阶段2
        if (parsingRequestLinePhase == 2) {
            //
            // Reading the method name
            // Method name is a token
            //
            boolean space = false;
            while (!space) {
                // Read new bytes if needed
                //如果数据已经被处理，或者还未读取，那么尝试从通道中读取数据，以便接下来的处理
                if (byteBuffer.position() >= byteBuffer.limit()) {
                    if (!fill(false)) // request line parsing
                        return false;
                }
                // Spec says method name is a token followed by a single SP but
                // also be tolerant of multiple SP and/or HT.
                int pos = byteBuffer.position();
                byte chr = byteBuffer.get();
                //一直循环读取到的字符，一直寻找到空格或者table符
                if (chr == Constants.SP || chr == Constants.HT) {
                    space = true;
                    //设置消息字节，内部维护字节块，通过偏移地址和结束地址来表示真正需要用的数据
                    //这里截取的是请求方法
                    request.method().setBytes(byteBuffer.array(), parsingRequestLineStart,
                            pos - parsingRequestLineStart);
                //其他情况，判断是否是{或者}这种类型，如果在解析方法时出现这种字符，那么抛出错误
                } else if (!HttpParser.isToken(chr)) {
                    byteBuffer.position(byteBuffer.position() - 1);
                    throw new IllegalArgumentException(sm.getString("iib.invalidmethod"));
                }
            }
            //设置解析阶段为3，表示解析方法阶段的结束
            parsingRequestLinePhase = 3;
        }
        //第三阶段，此阶段主要是跳过空格和table
        if (parsingRequestLinePhase == 3) {
            // Spec says single SP but also be tolerant of multiple SP and/or HT
            boolean space = true;
            while (space) {
                // Read new bytes if needed
                //如果没有数据，那么尝试从通道中读取数据，确保有数据可以继续处理，返回直接返回false，等待下次通道的read事件
                if (byteBuffer.position() >= byteBuffer.limit()) {
                    if (!fill(false)) // request line parsing
                        return false;
                }
                byte chr = byteBuffer.get();
                //直到不是空格或者table
                if (!(chr == Constants.SP || chr == Constants.HT)) {
                    space = false;
                    byteBuffer.position(byteBuffer.position() - 1);
                }
            }
            parsingRequestLineStart = byteBuffer.position();
            parsingRequestLinePhase = 4;
        }
        //第四阶段：解析uri和queryString
        if (parsingRequestLinePhase == 4) {
            // Mark the current buffer position

            int end = 0;
            //
            // Reading the URI
            //
            boolean space = false;
            while (!space) {
                // Read new bytes if needed
                ///如果没有数据，那么尝试从通道中读取数据，确保有数据可以继续处理，返回直接返回false，等待下次通道的read事件
                if (byteBuffer.position() >= byteBuffer.limit()) {
                    if (!fill(false)) // request line parsing
                        return false;
                }
                int pos = byteBuffer.position();
                byte chr = byteBuffer.get();
                //循环读取到空白符合table符号，如果读取到了这些符号，那么本阶段结束，也就是查询字符串已经读取完毕
                if (chr == Constants.SP || chr == Constants.HT) {
                    space = true;
                    end = pos;
                    //换行符，表示到头了
                } else if (chr == Constants.CR || chr == Constants.LF) {
                    // HTTP/0.9 style request
                    parsingRequestLineEol = true;
                    space = true;
                    end = pos;
                    //如果读取到了问号，恭喜，可以解析uri和查询参数了
                } else if (chr == Constants.QUESTION && parsingRequestLineQPos == -1) {
                    parsingRequestLineQPos = pos;
                    //如果读取到了问号并且确认它就是问号，如果不是，那么抛错
                } else if (parsingRequestLineQPos != -1 && !httpParser.isQueryRelaxed(chr)) {
                    // %nn decoding will be checked at the point of decoding
                    throw new IllegalArgumentException(sm.getString("iib.invalidRequestTarget"));
                } else if (httpParser.isNotRequestTargetRelaxed(chr)) {
                    // This is a general check that aims to catch problems early
                    // Detailed checking of each part of the request target will
                    // happen in Http11Processor#prepareRequest()
                    throw new IllegalArgumentException(sm.getString("iib.invalidRequestTarget"));
                }
            }
            //是否读取到了问号
            if (parsingRequestLineQPos >= 0) {
                //圈定查询参数范围
                request.queryString().setBytes(byteBuffer.array(), parsingRequestLineQPos + 1,
                        end - parsingRequestLineQPos - 1);
                //圈定uri范围
                request.requestURI().setBytes(byteBuffer.array(), parsingRequestLineStart,
                        parsingRequestLineQPos - parsingRequestLineStart);
            } else {
                //圈定uri范围
                request.requestURI().setBytes(byteBuffer.array(), parsingRequestLineStart,
                        end - parsingRequestLineStart);
            }
            parsingRequestLinePhase = 5;
        }
        //第五阶段：跳过空白符
        if (parsingRequestLinePhase == 5) {
            // Spec says single SP but also be tolerant of multiple and/or HT
            boolean space = true;
            while (space) {
                // Read new bytes if needed
                if (byteBuffer.position() >= byteBuffer.limit()) {
                    if (!fill(false)) // request line parsing
                        return false;
                }
                byte chr = byteBuffer.get();
                if (!(chr == Constants.SP || chr == Constants.HT)) {
                    space = false;
                    byteBuffer.position(byteBuffer.position() - 1);
                }
            }
            parsingRequestLineStart = byteBuffer.position();
            parsingRequestLinePhase = 6;

            // Mark the current buffer position
            end = 0;
        }
        //第6阶段：解析协议
        if (parsingRequestLinePhase == 6) {
            //
            // Reading the protocol
            // Protocol is always "HTTP/" DIGIT "." DIGIT
            //一直读取到行的结尾
            while (!parsingRequestLineEol) {
                // Read new bytes if needed
                if (byteBuffer.position() >= byteBuffer.limit()) {
                    if (!fill(false)) // request line parsing
                        return false;
                }

                int pos = byteBuffer.position();
                byte chr = byteBuffer.get();
                //回车符
                if (chr == Constants.CR) {
                    end = pos;
                    //换行符
                } else if (chr == Constants.LF) {
                    if (end == 0) {
                        end = pos;
                    }
                    //标记读取的行已经结束
                    parsingRequestLineEol = true;
                    //是否是协议字符，比如http/1.1
                } else if (!HttpParser.isHttpProtocol(chr)) {
                    throw new IllegalArgumentException(sm.getString("iib.invalidHttpProtocol"));
                }
            }
            //圈定协议字符串范围
            if ((end - parsingRequestLineStart) > 0) {
                request.protocol().setBytes(byteBuffer.array(), parsingRequestLineStart,
                        end - parsingRequestLineStart);
            } else {
                //如果没有协议，设置为空字符串
                request.protocol().setString("");
            }
            //重置解析的行尾false，用于下次解析
            parsingRequestLine = false;
            //解析阶段重置为0
            parsingRequestLinePhase = 0;
            //行结束标识重置为false
            parsingRequestLineEol = false;
            //行读取的字符小标位置重置为零
            parsingRequestLineStart = 0;
            return true;
        }
        throw new IllegalStateException(
                "Invalid request line parse phase:" + parsingRequestLinePhase);
    }

上面的代码中有这么一个类HttpParser，下面是它的静态块

 static {
        //ARRAY_SIZE = 128
        for (int i = 0; i < ARRAY_SIZE; i++) {
            // Control> 0-31, 127
            if (i < 32 || i == 127) {
                IS_CONTROL[i] = true;
            }

            // Separator
            if (    i == '(' || i == ')' || i == '<' || i == '>'  || i == '@'  ||
                    i == ',' || i == ';' || i == ':' || i == '\\' || i == '\"' ||
                    i == '/' || i == '[' || i == ']' || i == '?'  || i == '='  ||
                    i == '{' || i == '}' || i == ' ' || i == '\t') {
                IS_SEPARATOR[i] = true;
            }

            // Token: Anything 0-127 that is not a control and not a separator
            if (!IS_CONTROL[i] && !IS_SEPARATOR[i] && i < 128) {
                IS_TOKEN[i] = true;
            }

            // Hex: 0-9, a-f, A-F
            if ((i >= '0' && i <='9') || (i >= 'a' && i <= 'f') || (i >= 'A' && i <= 'F')) {
                IS_HEX[i] = true;
            }

            // Not valid for HTTP protocol
            // "HTTP/" DIGIT "." DIGIT
            if (i == 'H' || i == 'T' || i == 'P' || i == '/' || i == '.' || (i >= '0' && i <= '9')) {
                IS_HTTP_PROTOCOL[i] = true;
            }

            if (i >= '0' && i <= '9') {
                IS_NUMERIC[i] = true;
            }

            if (i >= 'a' && i <= 'z' || i >= 'A' && i <= 'Z') {
                IS_ALPHA[i] = true;
            }

            if (IS_ALPHA[i] || IS_NUMERIC[i] || i == '-' || i == '.' || i == '_' || i == '~') {
                IS_UNRESERVED[i] = true;
            }

            if (i == '!' || i == '$' || i == '&' || i == '\'' || i == '(' || i == ')' || i == '*' ||
                    i == '+' || i == ',' || i == ';' || i == '=') {
                IS_SUBDELIM[i] = true;
            }

            // userinfo    = *( unreserved / pct-encoded / sub-delims / ":" )
            if (IS_UNRESERVED[i] || i == '%' || IS_SUBDELIM[i] || i == ':') {
                IS_USERINFO[i] = true;
            }

            // The characters that are normally not permitted for which the
            // restrictions may be relaxed when used in the path and/or query
            // string
            if (i == '\"' || i == '<' || i == '>' || i == '[' || i == '\\' || i == ']' ||
                    i == '^' || i == '`'  || i == '{' || i == '|' || i == '}') {
                IS_RELAXABLE[i] = true;
            }
        }

        String prop = System.getProperty("tomcat.util.http.parser.HttpParser.requestTargetAllow");
        if (prop != null) {
            for (int i = 0; i < prop.length(); i++) {
                char c = prop.charAt(i);
                if (c == '{' || c == '}' || c == '|') {
                    REQUEST_TARGET_ALLOW[c] = true;
                } else {
                    log.warn(sm.getString("http.invalidRequestTargetCharacter",
                            Character.valueOf(c)));
                }
            }
        }

        DEFAULT = new HttpParser(null, null);
    }

对应字符的位置的数组值为true，如果我们要判断某些字符是否表示http协议，那么可以通过对应的IS_HTTP_PROTOCOL数组类判断，如果连续都是它，那么就是http协议了，总结一下上面一段代码所做的事情，假设有以下请求

GET /index.html?name=xxx&password=123456 HTTP/1.1
Host: www.xxxx.com
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Encoding: gzip, deflate, sdch
Accept-Language: zh-CN,zh;q=0.8,en;q=0.6

请求体数据

当触发read事件时，tomcat需要对这个请求的http协议进行解析，首先先解析协议，分以下阶段解析：

• 第一阶段：循环跳过空白符
• 第二阶段：解析方法，比如这里的GET方法
• 第三阶段：跳过空白符
• 第四阶段：解析uri和查询字段，这里的uri就是/index.html，查询字段就是name=xxx&password=123456
• 第五阶段：跳过空白符
• 第六阶段：解析协议，这里就是HTTP/1.1

如果在读取的过程中，数据不够，无法完整的读取完开始行，那么将socket状态设置为SocketState.LONG，tomcat重新注册读事件，等待下次触发read事件

好了，接下来继续看到org.apache.coyote.http11.Http11Processor的service(SocketWrapperBase<?>)方法中解析请求的方法

boolean org.apache.coyote.http11.Http11InputBuffer.parseHeaders() throws IOException {
    if (!parsingHeader) {
        throw new IllegalStateException(sm.getString("iib.parseheaders.ise.error"));
    }
    //设置请求头解析状态为还有更多的请求头需要解析
    HeaderParseStatus status = HeaderParseStatus.HAVE_MORE_HEADERS;

    do {
        //解析请求头
        status = parseHeader();
        //如果缓冲区读取的请求头已经超过最大限制，抛错，如果剩余容量不够存下socketReadBufferSize个字节，那么也会抛错错误
        if (byteBuffer.position() > headerBufferSize || byteBuffer.capacity() - byteBuffer.position() < socketReadBufferSize) {
            throw new IllegalArgumentException(sm.getString("iib.requestheadertoolarge.error"));
        }
    } while (status == HeaderParseStatus.HAVE_MORE_HEADERS);
    //表示读取完成
    if (status == HeaderParseStatus.DONE) {
        parsingHeader = false;
        //将最后的写入位置position，设置为结束位置
        end = byteBuffer.position();
        return true;
    } else {
        return false;
    }
}

解析请求头逻辑

private HeaderParseStatus org.apache.coyote.http11.Http11InputBuffer.parseHeader() throws IOException {

    //
    // Check for blank line
    //

    byte chr = 0;
    //请求头解析位置，在构建Http11InputBuffer的构造器中，赋了初始值为HeaderParsePosition.HEADER_START
    while (headerParsePos == HeaderParsePosition.HEADER_START) {

        // Read new bytes if needed
        if (byteBuffer.position() >= byteBuffer.limit()) {
            //尝试从通道中读取数据
            if (!fill(false)) {// parse header
                headerParsePos = HeaderParsePosition.HEADER_START;
                //没有读取到数据时，设置解析状态为需要更多的数据
                return HeaderParseStatus.NEED_MORE_DATA;
            }
        }
        //获取字符
        chr = byteBuffer.get();
        //如果是回车符，跳过，期待下一个换行符
        if (chr == Constants.CR) {
            // Skip
            //如果读取到了换行符，表示请求头解析结束，根据http协议的规范，请求结束后会有一个空行表示结束
        } else if (chr == Constants.LF) {
            return HeaderParseStatus.DONE;
            //其他字符
        } else {
            //复位被get吞掉的字符
            byteBuffer.position(byteBuffer.position() - 1);
            //跳出循环
            break;
        }

    }
    //
    if (headerParsePos == HeaderParsePosition.HEADER_START) {
        // Mark the current buffer position
        //标记当前解析的位置
        headerData.start = byteBuffer.position();
        //设置解析点为处理请求头名字
        headerParsePos = HeaderParsePosition.HEADER_NAME;
    }

    //
    // Reading the header name
    // Header name is always US-ASCII
    //
    //解析请求头name
    while (headerParsePos == HeaderParsePosition.HEADER_NAME) {

        // Read new bytes if needed
        if (byteBuffer.position() >= byteBuffer.limit()) {
            if (!fill(false)) { // parse header
                return HeaderParseStatus.NEED_MORE_DATA;
            }
        }

        int pos = byteBuffer.position();
        chr = byteBuffer.get();
        //如果是冒号
        if (chr == Constants.COLON) {
            //那么读取请求头值的开始
            headerParsePos = HeaderParsePosition.HEADER_VALUE_START;
            //记录请求头名字，然后返回与其相对的MimeHeaderField的value（buffer）对象
            headerData.headerValue = headers.addValue(byteBuffer.array(), headerData.start,
                    pos - headerData.start);
            pos = byteBuffer.position();
            // Mark the current buffer position
            //记录当前冒号的位置
            headerData.start = pos;
            headerData.realPos = pos;
            headerData.lastSignificantChar = pos;
            break;
            //如果不是普通字符，a-zA-Z，像数字啊，（，？，：,@等字符就不属于token字符
            //如果不是token字符，那么跳过这行
        } else if (!HttpParser.isToken(chr)) {
            // Non-token characters are illegal in header names
            // Parsing continues so the error can be reported in context
            headerData.lastSignificantChar = pos;
            byteBuffer.position(byteBuffer.position() - 1);
            // skipLine() will handle the error
            return skipLine();
        }

        // chr is next byte of header name. Convert to lowercase.
        //将大写的字符，设置为小写的字符
        if ((chr >= Constants.A) && (chr <= Constants.Z)) {
            byteBuffer.put(pos, (byte) (chr - Constants.LC_OFFSET));
        }
    }

    // Skip the line and ignore the header
    //如果是跳过状态，那么跳过行，为什么在这里又要判断一遍，因为从通道读取的字符不一定是完整的
    //下次通道触发读取事件的时候可以接着这个状态执行
    if (headerParsePos == HeaderParsePosition.HEADER_SKIPLINE) {
        return skipLine();
    }

    //
    // Reading the header value (which can be spanned over multiple lines)
    //
    //开始处理值
    while (headerParsePos == HeaderParsePosition.HEADER_VALUE_START ||
           headerParsePos == HeaderParsePosition.HEADER_VALUE ||
           headerParsePos == HeaderParsePosition.HEADER_MULTI_LINE) {

        if (headerParsePos == HeaderParsePosition.HEADER_VALUE_START) {
            // Skipping spaces
            //跳过空白符
            while (true) {
                // Read new bytes if needed
                if (byteBuffer.position() >= byteBuffer.limit()) {
                    if (!fill(false)) {// parse header
                        // HEADER_VALUE_START
                        return HeaderParseStatus.NEED_MORE_DATA;
                    }
                }

                chr = byteBuffer.get();
                //如果不是空格和table符，break，并设置解析点为处理值
                if (!(chr == Constants.SP || chr == Constants.HT)) {
                    headerParsePos = HeaderParsePosition.HEADER_VALUE;
                    byteBuffer.position(byteBuffer.position() - 1);
                    break;
                }
            }
        }
        if (headerParsePos == HeaderParsePosition.HEADER_VALUE) {
            
            // Reading bytes until the end of the line
            //标识是否读到行的末尾
            boolean eol = false;
            while (!eol) {

                // Read new bytes if needed
                if (byteBuffer.position() >= byteBuffer.limit()) {
                    if (!fill(false)) {// parse header
                        // HEADER_VALUE
                        return HeaderParseStatus.NEED_MORE_DATA;
                    }
                }

                chr = byteBuffer.get();
                //回车
                if (chr == Constants.CR) {
                    // Skip
                //换行符
                } else if (chr == Constants.LF) {
                    eol = true;
                    //如果是空白字符，有人说了，上面不是已经跳过空白符了吗？
                    //注意，上面跳过的是：与值之间的空白符，未跳过值后面的空白符，比如Host:    www.b    aidu.  com    \r\n
                    //它只是跳过了Host:与www之间的空白符
                } else if (chr == Constants.SP || chr == Constants.HT) {
                    //重新填充数据
                    byteBuffer.put(headerData.realPos, chr);
                    //实际位置（何为实际位置，就是去除空白后的位置，空白不认为是实际的位置）
                    headerData.realPos++;
                } else {
                    //覆盖空白符，填充实际位置
                    byteBuffer.put(headerData.realPos, chr);
                    headerData.realPos++;
                    //记录上次能够读取到非空白字符的位置
                    //值得注意，像上面的www.b    aidu.  com，对于realPos会记录到\r\n的前面空白符位置
                    //但是lastSignificantChar记录的却是m的真实位置
                    headerData.lastSignificantChar = headerData.realPos;
                }
            }

            // Ignore whitespaces at the end of the line
            //这地方挺有意思的，上面刚分析完www.b    aidu.  com    \r\n这种字符，它的realPos会指定到\r的前面的空白符字符的位置
            //这里就是直接咔嚓变成了com的这个m的位置，但是记住byteBuffer中依然储存了com后面的空白字符
            headerData.realPos = headerData.lastSignificantChar;

            // Checking the first character of the new line. If the character
            // is a LWS, then it's a multiline header
            //新的一行
            headerParsePos = HeaderParsePosition.HEADER_MULTI_LINE;
        }
        // Read new bytes if needed
        //如果没有值可读了，那么尝试从通道中读取值，如果没有读取到值，那么返回，等待下次通道的读事件发生
        if (byteBuffer.position() >= byteBuffer.limit()) {
            if (!fill(false)) {// parse header
                // HEADER_MULTI_LINE
                return HeaderParseStatus.NEED_MORE_DATA;
            }
        }

        chr = byteBuffer.get(byteBuffer.position());
        if (headerParsePos == HeaderParsePosition.HEADER_MULTI_LINE) {
            //如果不是空白符，那么可以肯定我们这次读取的字符超过了一行，那么可以从头开始继续解析下一行
            if ((chr != Constants.SP) && (chr != Constants.HT)) {
                headerParsePos = HeaderParsePosition.HEADER_START;
                break;
            } else {
                // Copying one extra space in the buffer (since there must
                // be at least one space inserted between the lines)
                //其他情况，继续记录空白符
                byteBuffer.put(headerData.realPos, chr);
                headerData.realPos++;
                headerParsePos = HeaderParsePosition.HEADER_VALUE_START;
            }
        }
    }
    // Set the header value
    //设置请求头值，headerData.start记录的为当前冒号所在的位置，长度为上次获取到的非空白字符位置减去冒号的位置
    headerData.headerValue.setBytes(byteBuffer.array(), headerData.start,
            headerData.lastSignificantChar - headerData.start);
    //复位（本次读取结束，需要复位数据，以便下次读取的开始）
    headerData.recycle();
    return HeaderParseStatus.HAVE_MORE_HEADERS;
}

解析请求头，分为这么几个解析状态：

• HeaderParseStatus.DONE：表示解析完成
• HeaderParseStatus.HAVE_MORE_HEADERS：表示还有请求头需要继续解析
• HeaderParseStatus.NEED_MORE_DATA：表示数据不够，需要继续监听read事件获取数据

解析位置有这么几个状态：

• HeaderParsePosition.HEADER_START：表示某行请求头的开始，如果是请求头结束的那一行，那么这个阶段就会读取到回车换行符，解析状态修改为HeaderParseStatus.DONE
• HeaderParsePosition.HEADER_NAME：这个阶段表示读取请求头的名字，比如请求头名字host
• HeaderParsePosition.HEADER_VALUE_START：这个阶段是读取完请求头名之后的一个阶段，这个阶段主要用于跳过冒号和请求头值之间的空白符
• HeaderParsePosition.HEADER_VALUE：这个阶段开始读取请求头值，会去除右边的空白符
• HeaderParsePosition.HEADER_MULTI_LINE：这个阶段表示我们已经解析完一行请求头了，可以检查是否继续读下一行，如果数据够的话，break，重新进入HEADER_START阶段
• HeaderParsePosition.HEADER_SKIPLINE：跳过某行，一般出现非法字符的时候，这行会被跳过

读取完请求头后，设置请求头的结束位置，这个位置又是请求体的开始位置

当tomcat解析完http协议后，需要对解析好的数据做进一步的处理

private void org.apache.coyote.http11.Http11Processor.prepareRequest() {

    http11 = true;
    http09 = false;
    contentDelimitation = false;
    //是否支持ssl请求
    if (endpoint.isSSLEnabled()) {
        //设置请求协议为https
        request.scheme().setString("https");
    }
    //获取协议数据块
    MessageBytes protocolMB = request.protocol();
    //判断是否为http1.1
    if (protocolMB.equals(Constants.HTTP_11)) {
        http11 = true;
        protocolMB.setString(Constants.HTTP_11);
    } else if (protocolMB.equals(Constants.HTTP_10)) {
        http11 = false;
        keepAlive = false;
        protocolMB.setString(Constants.HTTP_10);
    } else if (protocolMB.equals("")) {
        // HTTP/0.9
        http09 = true;
        http11 = false;
        keepAlive = false;
    } else {
        // Unsupported protocol
        http11 = false;
        // Send 505; Unsupported HTTP version
        //设置错误码，不支持的http版本
        response.setStatus(505);
        setErrorState(ErrorState.CLOSE_CLEAN, null);
        if (log.isDebugEnabled()) {
            log.debug(sm.getString("http11processor.request.prepare")+
                      " Unsupported HTTP version \""+protocolMB+"\"");
        }
    }
    //获取请求头
    MimeHeaders headers = request.getMimeHeaders();

    // Check connection header
    //获取connect请求头属性
    MessageBytes connectionValueMB = headers.getValue(Constants.CONNECTION);
    if (connectionValueMB != null) {
        ByteChunk connectionValueBC = connectionValueMB.getByteChunk();
        //connect的值中是否包含close字符串，如果包含，那么长连接设置为false
        if (findBytes(connectionValueBC, Constants.CLOSE_BYTES) != -1) {
            keepAlive = false;
            //是否包含keep-alive字符串
        } else if (findBytes(connectionValueBC,
                             Constants.KEEPALIVE_BYTES) != -1) {
            //设置长连接
            keepAlive = true;
        }
    }
    
    if (http11) {
        //对这个属性不了解，跳过
        MessageBytes expectMB = headers.getValue("expect");
        if (expectMB != null) {
            if (expectMB.indexOfIgnoreCase("100-continue", 0) != -1) {
                inputBuffer.setSwallowInput(false);
                request.setExpectation(true);
            } else {
                response.setStatus(HttpServletResponse.SC_EXPECTATION_FAILED);
                setErrorState(ErrorState.CLOSE_CLEAN, null);
            }
        }
    }

    // Check user-agent header
    //处理user-agent属性
    if (restrictedUserAgents != null && (http11 || keepAlive)) {
        MessageBytes userAgentValueMB = headers.getValue("user-agent");
        // Check in the restricted list, and adjust the http11
        // and keepAlive flags accordingly
        if(userAgentValueMB != null) {
            String userAgentValue = userAgentValueMB.toString();
            if (restrictedUserAgents != null &&
                    restrictedUserAgents.matcher(userAgentValue).matches()) {
                http11 = false;
                keepAlive = false;
            }
        }
    }


    // Check host header
    MessageBytes hostValueMB = null;
    try {
        //获取host属性
        hostValueMB = headers.getUniqueValue("host");
    } catch (IllegalArgumentException iae) {
        // Multiple Host headers are not permitted
        // 400 - Bad request
        response.setStatus(400);
        setErrorState(ErrorState.CLOSE_CLEAN, null);
        if (log.isDebugEnabled()) {
            log.debug(sm.getString("http11processor.request.multipleHosts"));
        }
    }
    //如果没有指定从何处来的请求，抛出400，错误的请求
    if (http11 && hostValueMB == null) {
        // 400 - Bad request
        response.setStatus(400);
        setErrorState(ErrorState.CLOSE_CLEAN, null);
        if (log.isDebugEnabled()) {
            log.debug(sm.getString("http11processor.request.noHostHeader"));
        }
    }

    // Check for an absolute-URI less the query string which has already
    // been removed during the parsing of the request line
    //处理uri
    ByteChunk uriBC = request.requestURI().getByteChunk();
    byte[] uriB = uriBC.getBytes();
    //http开头
    if (uriBC.startsWithIgnoreCase("http", 0)) {
        int pos = 4;
        // Check for https
        //https开头
        if (uriBC.startsWithIgnoreCase("s", pos)) {
            pos++;
        }
        // Next 3 characters must be "://"
        //http(s)://开头
        if (uriBC.startsWith("://", pos)) {
            pos += 3;
            //uri在数据块中的偏移位置
            int uriBCStart = uriBC.getStart();

            // '/' does not appear in the authority so use the first
            // instance to split the authority and the path segments
            //寻找到http(s)://后面字符的第一个/
            int slashPos = uriBC.indexOf('/', pos);
            // '@' in the authority delimits the userinfo
            //获取at的位置，一般邮箱地址会这个
            int atPos = uriBC.indexOf('@', pos);
            if (slashPos > -1 && atPos > slashPos) {
                // First '@' is in the path segments so no userinfo
                atPos = -1;
            }
            如果没有/,比如请求地址为https://www.baidu.com，那么设置uri为/
            if (slashPos == -1) {
                slashPos = uriBC.getLength();
                // Set URI as "/". Use 6 as it will always be a '/'.
                // 01234567
                // http://
                // https://
                request.requestURI().setBytes(uriB, uriBCStart + 6, 1);
            } else {
                //其他情况，比如：https://www.baidu.com/index,那么uri为/index
                request.requestURI().setBytes(uriB, uriBCStart + slashPos, uriBC.getLength() - slashPos);
            }

            // Skip any user info
            //跳过用户信息
            if (atPos != -1) {
                // Validate the userinfo
                for (; pos < atPos; pos++) {
                    byte c = uriB[uriBCStart + pos];
                    if (!HttpParser.isUserInfo(c)) {
                        // Strictly there needs to be a check for valid %nn
                        // encoding here but skip it since it will never be
                        // decoded because the userinfo is ignored
                        response.setStatus(400);
                        setErrorState(ErrorState.CLOSE_CLEAN, null);
                        if (log.isDebugEnabled()) {
                            log.debug(sm.getString("http11processor.request.invalidUserInfo"));
                        }
                        break;
                    }
                }
                // Skip the '@'
                pos = atPos + 1;
            }

            if (http11) {
                // Missing host header is illegal but handled above
                if (hostValueMB != null) {
                    // Any host in the request line must be consistent with
                    // the Host header
                    //请求头中的host属性与url中解析的host不同
                    if (!hostValueMB.getByteChunk().equals(
                            uriB, uriBCStart + pos, slashPos - pos)) {
                            //是否允许不匹配的情况
                        if (allowHostHeaderMismatch) {
                            // The requirements of RFC 2616 are being
                            // applied. If the host header and the request
                            // line do not agree, the request line takes
                            // precedence
                            hostValueMB = headers.setValue("host");
                            //以url中的host为准
                            hostValueMB.setBytes(uriB, uriBCStart + pos, slashPos - pos);
                        } else {
                            // The requirements of RFC 7230 are being
                            // applied. If the host header and the request
                            // line do not agree, trigger a 400 response.
                            //不允许的话，只能报错了
                            response.setStatus(400);
                            setErrorState(ErrorState.CLOSE_CLEAN, null);
                            if (log.isDebugEnabled()) {
                                log.debug(sm.getString("http11processor.request.inconsistentHosts"));
                            }
                        }
                    }
                }
            } else {
                // Not HTTP/1.1 - no Host header so generate one since
                // Tomcat internals assume it is set
                //不是http1.1协议的情况，host的值从url中获取
                hostValueMB = headers.setValue("host");
                hostValueMB.setBytes(uriB, uriBCStart + pos, slashPos - pos);
            }
        } else {
            //设置错误编码
            response.setStatus(400);
            setErrorState(ErrorState.CLOSE_CLEAN, null);
            if (log.isDebugEnabled()) {
                log.debug(sm.getString("http11processor.request.invalidScheme"));
            }
        }
    }

    // Validate the characters in the URI. %nn decoding will be checked at
    // the point of decoding.
    for (int i = uriBC.getStart(); i < uriBC.getEnd(); i++) {
        //校验uri的字符，对于一些不规范的uri，返回400错误码
        if (!httpParser.isAbsolutePathRelaxed(uriB[i])) {
            response.setStatus(400);
            setErrorState(ErrorState.CLOSE_CLEAN, null);
            if (log.isDebugEnabled()) {
                log.debug(sm.getString("http11processor.request.invalidUri"));
            }
            break;
        }
    }

    // Input filter setup
    //获取读取数据的过滤器
    InputFilter[] inputFilters = inputBuffer.getFilters();

    // Parse transfer-encoding header
    if (http11) {
        //解析转换编码请求头属性
        MessageBytes transferEncodingValueMB = headers.getValue("transfer-encoding");
        if (transferEncodingValueMB != null) {
            String transferEncodingValue = transferEncodingValueMB.toString();
            // Parse the comma separated list. "identity" codings are ignored
            int startPos = 0;
            int commaPos = transferEncodingValue.indexOf(',');
            String encodingName = null;
            while (commaPos != -1) {
                //然后添加编码转换过滤器，在读取数据的时候会进行编码
                encodingName = transferEncodingValue.substring(startPos, commaPos);
                addInputFilter(inputFilters, encodingName);
                startPos = commaPos + 1;
                commaPos = transferEncodingValue.indexOf(',', startPos);
            }
            encodingName = transferEncodingValue.substring(startPos);
            addInputFilter(inputFilters, encodingName);
        }
    }

    // Parse content-length header
    //如果请求中携带了数据，比如post方法的表达，json，文件流等
    long contentLength = request.getContentLengthLong();
    if (contentLength >= 0) {
        if (contentDelimitation) {
            // contentDelimitation being true at this point indicates that
            // chunked encoding is being used but chunked encoding should
            // not be used with a content length. RFC 2616, section 4.4,
            // bullet 3 states Content-Length must be ignored in this case -
            // so remove it.
            headers.removeHeader("content-length");
            request.setContentLength(-1);
        } else {
            inputBuffer.addActiveFilter(inputFilters[Constants.IDENTITY_FILTER]);
            contentDelimitation = true;
        }
    }

    // Validate host name and extract port if present
    //解析主机和端口
    parseHost(hostValueMB);

    if (!contentDelimitation) {
        // If there's no content length
        // (broken HTTP/1.0 or HTTP/1.1), assume
        // the client is not broken and didn't send a body
        //设置void过滤器，将不读取到任何数据
        inputBuffer.addActiveFilter(inputFilters[Constants.VOID_FILTER]);
        contentDelimitation = true;
    }

    if (getErrorState().isError()) {
        getAdapter().log(request, response, 0);
    }
}

以下是时序图：