Tomcat请求解析-请求行和请求头

一、前言

文章：https://www.cnblogs.com/runnable/p/12905401.html中介绍了Tomcat处理一次请求的大致过程，其中包括请求接收、请求数据处理以及请求响应。接下来用两篇文章详细分析请求数据解析：请求行和请求头的读取、请求体的读取。

在分析请求数据处理之前，再次回顾一下2个概念

1、Tomcat中用于读取socket数据的缓冲区buf。它是一个字节数组，默认长度8KB。有2个重要的位置下标：pos和lastValid，pos标记下次读取位置，lastValid标记有效数据最后位置。

 图中4种情况分别对应：初始数组；刚从操作系统中读取数据到buf；Tomcat解析过程中，已经读取第一位字节；本次从操作系统读取的数据已经全部解析完。

Tomcat中对请求数据的处理，其实就是重复这四个这个过程，把数据从操作系统读取到Tomcat缓存，然后逐个字节进行解析。我们后面详细分析。

2、字节块(ByteChunk)，一种数据结构。有三个重要属性：字节数组buff，start，end。我们从三个属性可以看出，字节块是利用两个下标，标记了一个字节数组中的一段字节。在数据被使用时才把标记的字节转换成字符串，且相同的字节段，如果已经有字符串对应，则会共用该字符串。这样做最大的好处是提高效率、减少内存使用。如下图标记了字节块下标1-4的字节。

3、HTTP请求数据格式如下

整个请求数据的解析过程实际就是根据HTTP规范逐个字节分析，最终转换成请求对象的过程，因此有必要对HTTP格式有了解

下面我们进入主题，通过源码分析请求行和请求头的解析过程

首先进入HTTP11处理器中处理请求的入口：

@Override
    public SocketState process(SocketWrapper<S> socketWrapper)
        throws IOException {
        RequestInfo rp = request.getRequestProcessor();
        rp.setStage(org.apache.coyote.Constants.STAGE_PARSE);

        // Setting up the I/O
        setSocketWrapper(socketWrapper);
        /**
         * 设置socket的InputStream和OutStream，供后面读取数据和响应使用
         */
        getInputBuffer().init(socketWrapper, endpoint);
        getOutputBuffer().init(socketWrapper, endpoint);

        // Flags
        keepAlive = true;
        comet = false;
        openSocket = false;
        sendfileInProgress = false;
        readComplete = true;
        if (endpoint.getUsePolling()) {
            keptAlive = false;
        } else {
            keptAlive = socketWrapper.isKeptAlive();
        }

        /**
         * 长连接相关，判断当前socket是否继续处理接下来的请求
         */
        if (disableKeepAlive()) {
            socketWrapper.setKeepAliveLeft(0);
        }

        /**
         * 处理socket中的请求，在长连接的模式下，每次循环表示一个HTTP请求
         */
        while (!getErrorState().isError() && keepAlive && !comet && !isAsync() &&
                upgradeInbound == null &&
                httpUpgradeHandler == null && !endpoint.isPaused()) {

            // Parsing the request header
            try {
                /**
                 * 1、设置socket超时时间
                 * 2、第一次从socket中读取数据
                 */
                setRequestLineReadTimeout();

                /**
                 * 读取请求行
                 */
                if (!getInputBuffer().parseRequestLine(keptAlive)) {
                    if (handleIncompleteRequestLineRead()) {
                        break;
                    }
                }

                // Process the Protocol component of the request line
                // Need to know if this is an HTTP 0.9 request before trying to
                // parse headers.
                prepareRequestProtocol();

                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());
                    // 设置做多可设置cookie数量
                    request.getCookies().setLimit(getMaxCookieCount());
                    // Currently only NIO will ever return false here
                    // Don't parse headers for HTTP/0.9
                    /**
                     * 读取请求头
                     */
                    if (!http09 && !getInputBuffer().parseHeaders()) {
                        // We've read part of the request, don't recycle it
                        // instead associate it with the socket
                        openSocket = true;
                        readComplete = false;
                        break;
                    }
                    if (!disableUploadTimeout) {
                        setSocketTimeout(connectionUploadTimeout);
                    }
                }
            } catch (IOException e) {
                if (getLog().isDebugEnabled()) {
                    getLog().debug(
                            sm.getString("http11processor.header.parse"), e);
                }
                setErrorState(ErrorState.CLOSE_NOW, e);
                break;
            } catch (Throwable t) {
                ExceptionUtils.handleThrowable(t);
                UserDataHelper.Mode logMode = userDataHelper.getNextMode();
                if (logMode != null) {
                    String message = sm.getString(
                            "http11processor.header.parse");
                    switch (logMode) {
                        case INFO_THEN_DEBUG:
                            message += sm.getString(
                                    "http11processor.fallToDebug");
                            //$FALL-THROUGH$
                        case INFO:
                            getLog().info(message, t);
                            break;
                        case DEBUG:
                            getLog().debug(message, t);
                    }
                }
                // 400 - Bad Request
                response.setStatus(400);
                setErrorState(ErrorState.CLOSE_CLEAN, t);
                getAdapter().log(request, response, 0);
            }

            if (!getErrorState().isError()) {
                // Setting up filters, and parse some request headers
                rp.setStage(org.apache.coyote.Constants.STAGE_PREPARE);
                try {
                    prepareRequest();
                } catch (Throwable t) {
                    ExceptionUtils.handleThrowable(t);
                    if (getLog().isDebugEnabled()) {
                        getLog().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);
                    /**
                     * 将封装好的请求和响应对象,交由容器处理
                     * service-->host-->context-->wrapper-->servlet
                     * 这里非常重要，我们所写的servlet代码正是这里在调用，它遵循了Servlet规范
                     * 这里处理完，代表程序员开发的servlet已经执行完毕
                     */
                    adapter.service(request, response);
                    // Handle when the response was committed before a serious
                    // error occurred.  Throwing a ServletException should both
                    // set the status to 500 and set the errorException.
                    // If we fail here, then the response is likely already
                    // committed, so we can't try and set headers.
                    if(keepAlive && !getErrorState().isError() && (
                            response.getErrorException() != null ||
                                    (!isAsync() &&
                                    statusDropsConnection(response.getStatus())))) {
                        setErrorState(ErrorState.CLOSE_CLEAN, null);
                    }
                    setCometTimeouts(socketWrapper);
                } catch (InterruptedIOException e) {
                    setErrorState(ErrorState.CLOSE_NOW, e);
                } catch (HeadersTooLargeException e) {
                    getLog().error(sm.getString("http11processor.request.process"), e);
                    // The response should not have been committed but check it
                    // anyway to be safe
                    if (response.isCommitted()) {
                        setErrorState(ErrorState.CLOSE_NOW, e);
                    } else {
                        response.reset();
                        response.setStatus(500);
                        setErrorState(ErrorState.CLOSE_CLEAN, e);
                        response.setHeader("Connection", "close"); // TODO: Remove
                    }
                } catch (Throwable t) {
                    ExceptionUtils.handleThrowable(t);
                    getLog().error(sm.getString("http11processor.request.process"), t);
                    // 500 - Internal Server Error
                    response.setStatus(500);
                    setErrorState(ErrorState.CLOSE_CLEAN, t);
                    getAdapter().log(request, response, 0);
                }
            }

            // Finish the handling of the request
            rp.setStage(org.apache.coyote.Constants.STAGE_ENDINPUT);

            if (!isAsync() && !comet) {
                if (getErrorState().isError()) {
                    // If we know we are closing the connection, don't drain
                    // input. This way uploading a 100GB file doesn't tie up the
                    // thread if the servlet has rejected it.
                    getInputBuffer().setSwallowInput(false);
                } else {
                    // Need to check this again here in case the response was
                    // committed before the error that requires the connection
                    // to be closed occurred.
                    checkExpectationAndResponseStatus();
                }
                /**
                 * 请求收尾工作
                 * 判断请求体是否读取完毕，没有则读取完毕，并修正pos
                 * 请求体读取分为两种：
                 * 1、程序员读取：在servlet中有程序员主动读取，这种方式读取数据不一定读取完整数据，取决于业务需求
                 * 2、Tomcat自己读取：如果servlet中没有读取，或者没有读取完全，则Tomcat负责读取剩余的请求体
                 * 1和2的差别在于，2中仅仅把数据从操作系统读取到buf中，尽管也用了字节块做标记，但是不会做其他的事情，而1中还会把字节块标记的数据拷贝到目标数组中
                 * 这个方法就是处理情况2中的请求体读取逻辑
                 */
                endRequest();
            }

            rp.setStage(org.apache.coyote.Constants.STAGE_ENDOUTPUT);

            // If there was an error, make sure the request is counted as
            // and error, and update the statistics counter
            if (getErrorState().isError()) {
                response.setStatus(500);
            }
            request.updateCounters();

            if (!isAsync() && !comet || getErrorState().isError()) {
                if (getErrorState().isIoAllowed()) {
                    /**
                     * 根据修正完的pos和lastValid,初始化数组下标，以便继续处理下一次请求
                     * 两种情况
                     * 1、读取请求体刚好读取完，将pos=lastValid=0，即都指向buf数组第一个位置，重新读取数据
                     * 2、读取请求体多读出了下次请求的数据，这个时候需要将下个请求的数据移动到buf数组头，以便处理下个请求
                     * 注意，buf数组中的数据没有删除，是直接覆盖，从而达到对buf数组的重复使用
                     */
                    getInputBuffer().nextRequest();
                    getOutputBuffer().nextRequest();
                }
            }

            if (!disableUploadTimeout) {
                if(endpoint.getSoTimeout() > 0) {
                    setSocketTimeout(endpoint.getSoTimeout());
                } else {
                    setSocketTimeout(0);
                }
            }

            rp.setStage(org.apache.coyote.Constants.STAGE_KEEPALIVE);

            if (breakKeepAliveLoop(socketWrapper)) {
                break;
            }
        }

        rp.setStage(org.apache.coyote.Constants.STAGE_ENDED);

        if (getErrorState().isError() || endpoint.isPaused()) {
            return SocketState.CLOSED;
        } else if (isAsync() || comet) {
            return SocketState.LONG;
        } else if (isUpgrade()) {
            return SocketState.UPGRADING;
        } else if (getUpgradeInbound() != null) {
            return SocketState.UPGRADING_TOMCAT;
        } else {
            if (sendfileInProgress) {
                return SocketState.SENDFILE;
            } else {
                if (openSocket) {
                    if (readComplete) {
                        return SocketState.OPEN;
                    } else {
                        return SocketState.LONG;
                    }
                } else {
                    return SocketState.CLOSED;
                }
            }
        }
    }

 分析：

上述方法展示整个请求处理的核心过程，其中52行开始处理请求行：getInputBuffer().parseRequestLine(keptAlive)

二、请求行解析

具体方法如下：

/**
     * Read the request line. This function is meant to be used during the
     * HTTP request header parsing. Do NOT attempt to read the request body
     * using it.
     *
     * @throws IOException If an exception occurs during the underlying socket
     * read operations, or if the given buffer is not big enough to accommodate
     * the whole line.
     */
    /**
     * 读取请求行方法
     * 请求行格式如下：
     * ========================================
     * 请求方法 空格 URL 空格 协议版本 回车换行
     * ========================================
     * @param useAvailableDataOnly
     * @return
     * @throws IOException
     */
    @Override
    public boolean parseRequestLine(boolean useAvailableDataOnly)

        throws IOException {

        int start = 0;

        //
        // Skipping blank lines
        //

        /**
         * 过滤掉回车(CR)换行(LF)符，确定start位置
         */
        do {

            // Read new bytes if needed
            if (pos >= lastValid) {
                if (!fill())
                    throw new EOFException(sm.getString("iib.eof.error"));
            }
            // 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记录第一个非CRLF字节，后面读取请求头的时候用到
             */
            chr = buf[pos++];
        } while (chr == Constants.CR || chr == Constants.LF);

        pos--;

        // Mark the current buffer position
        start = pos;

        //
        // Reading the method name
        // Method name is a token
        //

        boolean space = false;

        /**
         * 读取HTT请求方法：get/post/put....
         */
        while (!space) {

            // Read new bytes if needed
            if (pos >= lastValid) {
                if (!fill())
                    throw new EOFException(sm.getString("iib.eof.error"));
            }

            // Spec says method name is a token followed by a single SP but
            // also be tolerant of multiple SP and/or HT.
            if (buf[pos] == Constants.SP || buf[pos] == Constants.HT) {
                space = true;
                /**
                 * 设置HTTP请求方法，这里没有直接设置字符串，而是用了字节块ByteChunk
                 * ByteChunk中包含一个字节数据类型的属性buff，此处的setBytes方法就是将buff指向Tomcat的缓存buf。然后start和end标记为
                 * 此处方法的后两个入参，也就是将请求方法在buf中标记了出来，但是没有转换成字符串，等到使用的时候再使用ByteBuffer.wap方法
                 * 转换成字符串，且标记hasStrValue=true，如果再次获取就直接拿转换好的字符串，不用再次转换。效率考虑？牛逼！
                 * 因此，就算后面由于请求体过长，Tomcat重新开辟新的数组buf读取请求体。原buf也不会被GC，因为ByteChunk中的buff引用了原buf数组
                 * 什么时候原数组才会被GC？本次请求结束，request对象被GC后。。。
                 */
                request.method().setBytes(buf, start, pos - start);
            } else if (!HttpParser.isToken(buf[pos])) {
                String invalidMethodValue = parseInvalid(start, buf);
                throw new IllegalArgumentException(sm.getString("iib.invalidmethod", invalidMethodValue));
            }

            pos++;

        }

        // Spec says single SP but also be tolerant of multiple SP and/or HT
        /**
         * 过滤请求方法后面的空格(SP或者HT)
         */
        while (space) {
            // Read new bytes if needed
            if (pos >= lastValid) {
                if (!fill())
                    throw new EOFException(sm.getString("iib.eof.error"));
            }
            if (buf[pos] == Constants.SP || buf[pos] == Constants.HT) {
                pos++;
            } else {
                space = false;
            }
        }

        // Mark the current buffer position
        start = pos;
        int end = 0;
        int questionPos = -1;

        //
        // Reading the URI
        //

        boolean eol = false;

        /**
         * 读取URL
         */
        while (!space) {

            // Read new bytes if needed
            if (pos >= lastValid) {
                if (!fill())
                    throw new EOFException(sm.getString("iib.eof.error"));
            }

            /**
             * CR后面没有LF，不是HTTP0.9，抛异常
             */
            if (buf[pos -1] == Constants.CR && buf[pos] != Constants.LF) {
                // CR not followed by LF so not an HTTP/0.9 request and
                // therefore invalid. Trigger error handling.
                // Avoid unknown protocol triggering an additional error
                request.protocol().setString(Constants.HTTP_11);
                String invalidRequestTarget = parseInvalid(start, buf);
                throw new IllegalArgumentException(sm.getString("iib.invalidRequestTarget", invalidRequestTarget));
            }

            // Spec says single SP but it also says be tolerant of HT
            if (buf[pos] == Constants.SP || buf[pos] == Constants.HT) {
                /**
                 * 遇到空格(SP或者HT)，URL读取结束
                 */
                space = true;
                end = pos;
            } else if (buf[pos] == Constants.CR) {
                // HTTP/0.9 style request. CR is optional. LF is not.
            } else if (buf[pos] == Constants.LF) {
                // HTTP/0.9 style request
                // Stop this processing loop
                space = true;
                // Set blank protocol (indicates HTTP/0.9)
                request.protocol().setString("");
                // Skip the protocol processing
                eol = true;
                if (buf[pos - 1] == Constants.CR) {
                    end = pos - 1;
                } else {
                    end = pos;
                }
            } else if ((buf[pos] == Constants.QUESTION) && (questionPos == -1)) {
                questionPos = pos;
            } else if (questionPos != -1 && !httpParser.isQueryRelaxed(buf[pos])) {
                // %nn decoding will be checked at the point of decoding
                String invalidRequestTarget = parseInvalid(start, buf);
                throw new IllegalArgumentException(sm.getString("iib.invalidRequestTarget", invalidRequestTarget));
            } else if (httpParser.isNotRequestTargetRelaxed(buf[pos])) {
                // This is a general check that aims to catch problems early
                // Detailed checking of each part of the request target will
                // happen in AbstractHttp11Processor#prepareRequest()
                String invalidRequestTarget = parseInvalid(start, buf);
                throw new IllegalArgumentException(sm.getString("iib.invalidRequestTarget", invalidRequestTarget));
            }
            pos++;
        }
        /**
         * 读取HTTP URL
         */
        request.unparsedURI().setBytes(buf, start, end - start);
        if (questionPos >= 0) {
            /**
             * 当有请求入参的时候
             * 读取入参字符串
             * 读取URI
             */
            request.queryString().setBytes(buf, questionPos + 1,
                                           end - questionPos - 1);
            request.requestURI().setBytes(buf, start, questionPos - start);
        } else {
            /**
             * 没有请求入参的时候，直接读取URI
             */
            request.requestURI().setBytes(buf, start, end - start);
        }

        // Spec says single SP but also says be tolerant of multiple SP and/or HT
        while (space && !eol) {
            // Read new bytes if needed
            if (pos >= lastValid) {
                if (!fill())
                    throw new EOFException(sm.getString("iib.eof.error"));
            }
            if (buf[pos] == Constants.SP || buf[pos] == Constants.HT) {
                pos++;
            } else {
                space = false;
            }
        }

        // Mark the current buffer position
        start = pos;
        end = 0;

        //
        // Reading the protocol
        // Protocol is always "HTTP/" DIGIT "." DIGIT
        //
        /**
         * 读取HTTP协议版本
         */
        while (!eol) {

            // Read new bytes if needed
            if (pos >= lastValid) {
                if (!fill())
                    throw new EOFException(sm.getString("iib.eof.error"));
            }

            if (buf[pos] == Constants.CR) {
                // Possible end of request line. Need LF next.
            } else if (buf[pos - 1] == Constants.CR && buf[pos] == Constants.LF) {
                end = pos - 1;
                eol = true;
            } else if (!HttpParser.isHttpProtocol(buf[pos])) {
                String invalidProtocol = parseInvalid(start, buf);
                throw new IllegalArgumentException(sm.getString("iib.invalidHttpProtocol", invalidProtocol));
            }

            pos++;

        }

        /**
         * 字节块标记协议版本
         */
        if ((end - start) > 0) {
            request.protocol().setBytes(buf, start, end - start);
        }

        /**
         * 如果没有协议版本，无法处理请求，抛异常
         */
        if (request.protocol().isNull()) {
            throw new IllegalArgumentException(sm.getString("iib.invalidHttpProtocol"));
        }

        return true;
    }

 在这个方法中，其实就是请求行请求方法、url、协议版本这几个部分的读取。

分析：

34-50行：这个while循环是过滤行首的回车换行符，只要是回车换行符下标pos就往后移动一位，直到不是回车换行符，跳出循环。由于这里是先执行pos++，所以如果不满足条件，pos需要后移一位，也就是真正开始读取请求方法的位置，标记为start。

37-40行：这里是非常关键的几行代码，几乎贯穿整个请求处理部分。Tomcat接收请求，就是在接收客户端的请求数据，数据经过网络传输到Tomcat所在的服务操作系统缓冲区，Tomcat从操作系统读取到自己的缓冲区buf中。这几行代码主要就是干这个事情的。前面我们介绍了字节数在buf是通过pos和lastValid控制读取的。37行判断当pos>=lastValid，表示buf数组中读取自操作系统的数据已经解析完毕，调用fill()方法再次从操作系统读取。代码如下：

@Override
    protected boolean fill(boolean block) throws IOException {

        int nRead = 0;

        /**
         * 这个核心就是读取socket中数据到缓冲区buf中，循环读取，2种情况
         * 1、请求行和请求头：不能超过缓冲区大小(默认8kb)，如果超过，则抛异常，读完后将parsingHeader设置为false
         * 2、请求行：没有任何大小限制，循环读取，如果剩下的少于4500个字节，则会重新创建buf数组，从头开始读取，直到读完位置，注意！buf原先引用的数组们，等待GC
         */
        if (parsingHeader) {

            /**
             * 从socket中读取数据大于tomcat中缓冲区buf的长度，直接抛异常,这里有两点
             * 1、这个就是我们很多时候很多人说的，get请求url不能过长的原因，其实是header和url等总大小不能超过8kb
             * 2、这里的buf非常总要，它是InternalInputBuffer的属性，是一个字节数据，用户暂存从socket中读取的数据，比如：请求行，请求头、请求体
             */
            if (lastValid == buf.length) {
                throw new IllegalArgumentException
                    (sm.getString("iib.requestheadertoolarge.error"));
            }

            // 将socket中的数据读到缓冲区buf中，注意！这里就是BIO之所以难懂的关键所在，它会阻塞！
            // 这个方法会阻塞，如果没有数据可读，则会一直阻塞，有数据，则移动lastValid位置
            nRead = inputStream.read(buf, pos, buf.length - lastValid);
            if (nRead > 0) {
                lastValid = pos + nRead;
            }

        } else {
            /**
             * parsingHeader==false，请求行和请求头已经读取完毕，开始读取请求体
             */

            if (buf.length - end < 4500) {
                // In this case, the request header was really large, so we allocate a
                // brand new one; the old one will get GCed when subsequent requests
                // clear all references
                /**
                 * 如果Tomcat缓存区buf读取完请求行和请求头后，剩余长度不足4500(可配置)，新创建一个字节数组buf用于读取请求体
                 * 为什么要这么做，应该是考虑到如果剩余的数据长度较小，每次从操作系统缓存区读取的字节就比较少，读取次数就比较多？
                 * 注意，buf原先指向的字节数据会白GC么？应该不会，因为请求行和请求头有许多字节块(ByteChunk)指向了旧字节数据。
                 * 什么时候才会被GC？应该是一起request处理完毕后。
                 */
                buf = new byte[buf.length];
                end = 0;
            }
            /**
             * 这里的end是请求头数据的后一位，从这里开始读取请求体数据。
             * 从操作系统读取数据到buf中，下标pos开始，lastValid结束
             * 注意：这里每次读取请求体数据的时候都会把pos重置为end(请求头数据的后一位)!!!!!
             * 表示什么？
             * 请求体数据每一次从操作系统缓存中读取到buf，然后读取到程序员自己的数组后，在下次再次从操作系统读取数据到buf时，就会把之前读取的请求体数据覆盖掉
             * 也就是从end位置开始，后面的数据都只能读取一次，这个很重要！！！
             * 为什么这么做？我的理解是因为请求体数据可以很大，为了单个请求不占用太大内存，所以设计成了覆盖的模式，真是秒啊！
             */
            pos = end;
            lastValid = pos;

            /**
             * 原则上这个方法要么阻塞着，要么nRead>0
             */
            nRead = inputStream.read(buf, pos, buf.length - lastValid);
            if (nRead > 0) {
                lastValid = pos + nRead;
            }

        }

        /**
         * 注意，这里不出意外，只能返回true
          */
        return (nRead > 0);

    }

 这个方法由两部分逻辑组成：parsingHeader=true或者false，这个变量表示读取的请求行和请求头，还是读取的请求体。变量名有点歧义，并不是只包含请求头，而是请求行和请求头。

11-30行：读取请求行和请求头数据，逻辑很简单：从操作系统读取数据到字节数组buf中，后移lastValid下标到buf数组最后一个字节的位置。在Tomcat解析完这部分数据后，会把parsingHeader置为false，且用end下标指向请求头后一个字节，以便后续可以读取请求体数据。

35-66行：读取请求体数据，逻辑比请求行和请求头读取稍微复杂点：判断buf数组剩余字节长度是否大于4500，反之重新创建数组。每次读取pos和lastValid都置为end，然后读取数据到buf数组中，lastValid后移。由于请求体数据可能比较大，且理论上没有上限限制，为了减少读取次数，buf剩余空间不能过小。每次读取数据到buf中，都是存放在end位置开始，每次都是覆盖上一次读取的数据，所以我们可以大胆猜测，请求体数据只能读取一次，程序员自己如果需要多次使用，必须自行保存。我想这是为了减少内存使用吧，你们看呢？

还有一个关键点：25行和63行代码：nRead = inputStream.read(buf, pos, buf.length - lastValid)，这行代码是从操作系统读取字节，接触过socket编程的都知道read方法这里可能会阻塞的，当操作系统缓存中当前没有数据可读，等待网络传输的时候，read方法阻塞，直到有数据返回后再继续。

回到读取请求行的代码。确定好了start位置后，开始读取请求方法。

67-95行：又是一个while循环，当遇到SP或者HT时，表示请求方法已经读取完毕。

87行：将start到pos前一位用字节块进行标记，只是标记，并不会转换成字符串。具体代码：

/**
     * Sets the buffer to the specified subarray of bytes.
     *
     * @param b the ascii bytes
     * @param off the start offset of the bytes
     * @param len the length of the bytes
     */
    public void setBytes(byte[] b, int off, int len) {
        buff = b;
        start = off;
        end = start + len;
        isSet = true;
        hasHashCode = false;
    }

101-112行：继续过滤掉SP或者HT，重置start，为读取URL做准备。

128-184行：读取所有的URL字节，遇到空格退出，这里并没有标记URL.

188-203行：根据上面得出的位置标记，利用字节块对URI、URL、参数分别进行标记。

206-217行：再次对空格进行过滤，重置start，准备读取协议版本。

230-250行：读取剩余字节，遇到连续的两个字节CRLF，确定请求行结束位置。

256行：使用字节块标记协议版本。

自此，请求行解析完毕，每个部分都已经利用专门的字节块(ByteChunk)进行标记。我们看到每个循环里面都会调用fill()方法从操作系统读取数据到Tomcat缓冲区中，一次请求数据的传输不一定能够传输完毕，所以Tomcat中要始终保持读取数据的状态，这个是关键，一定要理解，否则就无法理解Tomcat对请求数据的解析过程。

 三、请求头解析

再次回到处理请求的入口代码中：其中79行开始处理请求头：getInputBuffer().parseHeaders()。

/**
     * Parse the HTTP headers.
     */
    @Override
    public boolean parseHeaders()
        throws IOException {
        /**
         * 请求行和请求头读取的标志，如果不是请求行和请求头，进入此方法，抛异常
         */
        if (!parsingHeader) {
            throw new IllegalStateException(
                    sm.getString("iib.parseheaders.ise.error"));
        }

        /**
         * 读取请求头，循环执行，每次循环读取请求头的一个key:value对
         */
        while (parseHeader()) {
            // Loop until we run out of headers
        }

        /**
         * 请求头读取完毕，标志变为false，end=pos,标志此处是请求行和请求头读取完毕的位置
         */
        parsingHeader = false;
        end = pos;
        return true;
    }

 整个parseHearders方法比较简单，分三部分逻辑：1、判断是否parsingHeader=true，不是的话抛异常。2、while循环。3、处理完毕parsingHeader=false，end=pos，为读取请求体做准备。

重点关注第二部分的循环，18行代码：while (parseHeader())。仅仅是一个循环，没有方法体。这里其实每次循环都是试图读取一个请求头的key:value对。代码如下：

/**
     * 读取请求头信息，注意：每次调用该方法，完成一个键值对读取，也即下面格式中的一行请求头
     * 请求头格式如下
     * ===================================
     * key:空格(SP)value回车(CR)换行(LF)
     * ...
     * key:空格(SP)value回车(CR)换行(LF)
     * 回车(CR)换行(LF)
     * ===================================
     *
     * Parse an HTTP header.
     *
     * @return false after reading a blank line (which indicates that the
     * HTTP header parsing is done
     */
    @SuppressWarnings("null") // headerValue cannot be null
    private boolean parseHeader() throws IOException {

        /**
         * 此循环主要是在每行请求头信息开始前，确定首字节的位置
         */
        while (true) {

            // Read new bytes if needed
            /**
             * Tomcat缓存buf中没有带读取数据，重新从操作系统读取一批
             */
            if (pos >= lastValid) {
                if (!fill())
                    throw new EOFException(sm.getString("iib.eof.error"));
            }

            /**
             * 这里的chr最开始是在读取请求行时赋值，赋予它请求行第一个非空格字节
             */
            prevChr = chr;
            chr = buf[pos];

            /**
             * 首位置是回车符(CR)，有2种情况：
             * 1、CR+(~LF) 首次先往后移动一个位置，试探第二个位置是否是LF，如果是则进入情况2；如果不是,则回退pos。key首字节可以是CR，但第2个字节不能是LF，因为行CRLF是请求头结束标志
             * 2、CR+LF 请求头结束标志，直接结束请求头读取
             * 首位置不是CR，直接结束循环，开始读取key
             */
            if (chr == Constants.CR && prevChr != Constants.CR) {
                /**
                 * 每次while循环首次进入这个if分支preChr都不是CR，如果当前位置pos是CR，则往后移动一位，根据后一位情况决定后续操作
                 * 如果后一位是LF，直接直接请求头读取
                 * 如果后一位不是LF,pos回退一位，用作key。
                 */
                // Possible start of CRLF - process the next byte.
            } else if (prevChr == Constants.CR && chr == Constants.LF) {
                /**
                 * 请求头结束,注意是请求头结束，不是当前键值对结束，请求头结束标志：没有任何其他数据，直接CRLF
                 */
                pos++;
                return false;
            } else {
                /**
                 * 如果当前行的首字节不是CR，直接break，开始读取key
                 * 如果当前行首字节是CR，但是第二字节不是LF，pos回退1位，开始读取key
                 */
                if (prevChr == Constants.CR) {
                    // Must have read two bytes (first was CR, second was not LF)
                    pos--;
                }
                break;
            }

            pos++;
        }

        // Mark the current buffer position
        /**
         * 标记当前键值对行开始位置
         */
        int start = pos;
        int lineStart = start;

        //
        // Reading the header name
        // Header name is always US-ASCII
        //

        /**
         * colon标记冒号的位置
         */
        boolean colon = false;
        MessageBytes headerValue = null;

        /**
         * 读取key，直到当前字节是冒号(:)跳出循环，pos指向冒号后一个字节
         */
        while (!colon) {

            // Read new bytes if needed
            /**
             * 获取缓冲区数据
             */
            if (pos >= lastValid) {
                if (!fill())
                    throw new EOFException(sm.getString("iib.eof.error"));
            }


            if (buf[pos] == Constants.COLON) {
                /**
                 * 当前字节是冒号，colon=true,当前循环执行完后，结束循环
                 * 在Tomcat缓冲区buf字节数组中标记出头信息的名称key：
                 * 每个key:value对中有2个MessageBytes对象，每个MessageBytes对象中都有字节块ByteChunk，用来标记buf中的字节段
                 */
                colon = true;
                headerValue = headers.addValue(buf, start, pos - start);
            } else if (!HttpParser.isToken(buf[pos])) {
                // Non-token characters are illegal in header names
                // Parsing continues so the error can be reported in context
                // skipLine() will handle the error
                /**
                 * 非普通字符，比如：(,?,:等，跳过这行
                 */
                skipLine(lineStart, start);
                return true;
            }

            /**
             * 大写字符转换成小写字符，chr记录key中最后一个有效字节
             */
            chr = buf[pos];
            if ((chr >= Constants.A) && (chr <= Constants.Z)) {
                buf[pos] = (byte) (chr - Constants.LC_OFFSET);
            }

            /**
             * 下标自增，继续下次循环
             */
            pos++;

        }

        // Mark the current buffer positio
        /**
         * 重置start，开始读取请求头值value
         */
        start = pos;
        int realPos = pos;

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

        boolean eol = false;
        boolean validLine = true;

        while (validLine) {

            boolean space = true;

            // Skipping spaces
            /**
             * 跳过空格(SP)和制表符(HT)
             */
            while (space) {

                // Read new bytes if needed
                if (pos >= lastValid) {
                    if (!fill())
                        throw new EOFException(sm.getString("iib.eof.error"));
                }

                if ((buf[pos] == Constants.SP) || (buf[pos] == Constants.HT)) {
                    pos++;
                } else {
                    space = false;
                }

            }

            int lastSignificantChar = realPos;

            // Reading bytes until the end of the line
            /**
             *
             */
            while (!eol) {

                // Read new bytes if needed
                if (pos >= lastValid) {
                    if (!fill())
                        throw new EOFException(sm.getString("iib.eof.error"));
                }

                /**
                 * prevChr首次为chr=:,之后为上一次循环的chr
                 * chr为当前pos位置的字节
                 */
                prevChr = chr;
                chr = buf[pos];
                if (chr == Constants.CR) {
                    /**
                     * 当前字节是回车符，直接下次循环，看下个字节是否是LF
                     */
                    // Possible start of CRLF - process the next byte.
                } else if (prevChr == Constants.CR && chr == Constants.LF) {
                    /**
                     * 当前字节是LF,前一个字节是CR，请求头当前key:value行读取结束
                     */
                    eol = true;
                } else if (prevChr == Constants.CR) {
                    /**
                     * 如果前一字节是CR，当前位置字节不是LF，则本key:value对无效，删除！
                     * 直接返回true，读取下一个key:value对
                     */
                    // Invalid value
                    // Delete the header (it will be the most recent one)
                    headers.removeHeader(headers.size() - 1);
                    skipLine(lineStart, start);
                    return true;
                } else if (chr != Constants.HT && HttpParser.isControl(chr)) {
                    // Invalid value
                    // Delete the header (it will be the most recent one)
                    headers.removeHeader(headers.size() - 1);
                    skipLine(lineStart, start);
                    return true;
                } else if (chr == Constants.SP) {
                    /**
                     * 当前位置空格，位置后移一位
                     */
                    buf[realPos] = chr;
                    realPos++;
                } else {
                    /**
                     * 当前位置常规字符，位置后移一位，标记最后字符
                     */
                    buf[realPos] = chr;
                    realPos++;
                    lastSignificantChar = realPos;
                }

                pos++;

            }

            realPos = lastSignificantChar;

            // Checking the first character of the new line. If the character
            // is a LWS, then it's a multiline header

            // Read new bytes if needed
            if (pos >= lastValid) {
                if (!fill())
                    throw new EOFException(sm.getString("iib.eof.error"));
            }

            /**
             * 特殊逻辑：
             * 当前key:value对读取完后，
             * 如果紧接着的是SP(空格)或则HT(制表符),表示当前value读取并未结束，是多行的，将eol=false，继续读取，直到CRLF.
             * 如果紧接着不是SP和HT，那vaLine=false,跳出循环，value读取完毕
             */
            byte peek = buf[pos];
            if (peek != Constants.SP && peek != Constants.HT) {
                validLine = false;
            } else {
                eol = false;
                // Copying one extra space in the buffer (since there must
                // be at least one space inserted between the lines)
                buf[realPos] = peek;
                realPos++;
            }

        }

        // Set the header value
        /**
         * 使用新的字节块BytChunk标记当前key:value对的value
         */
        headerValue.setBytes(buf, start, realPos - start);

        return true;

    }

 22-71行：每行请求头开始读取前，确定首字节的位置。详细逻辑比较复杂，请看代码注释

94-138行：读取请求头key的数据，直到遇到冒号为止，这里同样使用了字节块来标记。

144-结尾：首先重置start，然后再次过滤空格，直到遇到联系的CRLF表示当前key:value结束。请求头value数据同样也使用了字节块来做标记。

读取value有个特殊逻辑：

260-271行：当前请求头value读取完毕后，如果紧接着是空格，表示当前请求头的值有多个，将eol=false，继续循环读取，直到CRLF。这种情况一般很很少使用，了解就好。

至此，已经完整分析了一次HTTP请求中请求行和请求头的详细读取过程。重点要理解Tomcat中的缓存缓冲区，以及IO读取数据的方式。最后按照HTTP规范解析，这个过程比较底层，也比较绕，需要有耐心，下篇文章我们继续开始请求体的处理，敬请关注！

再次强调：以上源码都是基于Tomcat7，且是BIO模型。