tomcat启动(Ⅶ)请求处理--Processor.process(SocketWrapper<S> socketWrapper)

tomcat启动(六)Catalina分析-StandardServer.start()

上一篇分析到：Http11NioProcessor.process(SocketWrapper<S> socketWrapper)会将请求进行转换成生成request,和response对象，然后调用CoyoteAdapter.service(request,response)传递请求给对应的上下文

初始化构造方法

public Http11NioProcessor(int maxHttpHeaderSize, boolean rejectIllegalHeaderName,

            NioEndpoint endpoint, int maxTrailerSize, Set<String> allowedTrailerHeaders,

            int maxExtensionSize, int maxSwallowSize)

Http11NioProcessor这个对象生成是由createProcessor(）生成了

org.apache.coyote.http11.Http11NioProtocol.Http11ConnectionHandler.createProcessor()

@Override

        public Http11NioProcessor createProcessor() {

            Http11NioProcessor processor = new Http11NioProcessor(

                    proto.getMaxHttpHeaderSize(), proto.getRejectIllegalHeaderName(),

                    (NioEndpoint)proto.endpoint, proto.getMaxTrailerSize(),

                    proto.getAllowedTrailerHeadersAsSet(), proto.getMaxExtensionSize(),

                    proto.getMaxSwallowSize());

            proto.configureProcessor(processor);

            register(processor);

            return processor;

        }

构造参数都是由proto对象提供，这个对象是表示Http11NioProtocol

para1:

private int maxHttpHeaderSize = 8 * 1024;

para2:

private boolean rejectIllegalHeaderName = false;

para3:

NioEndpoint ；略。

para4：以尾部为标题的最大大小，字节为单位

private int maxTrailerSize = 8192;

para5:允许通过尾部发送的标头名称。它们以小写形式存储。

private Set<String> allowedTrailerHeaders =

            Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>());

para6:分块编码中扩展信息的最大大小

private int maxExtensionSize = 8192;

para7:Maximum amount of request body to swallow

private int maxSwallowSize = 2 * 1024 * 1024;

再看下构造方法里究竟干了神马

Http11NioProcessor

public Http11NioProcessor(int maxHttpHeaderSize, boolean rejectIllegalHeaderName,

            NioEndpoint endpoint, int maxTrailerSize, Set<String> allowedTrailerHeaders,

            int maxExtensionSize, int maxSwallowSize) {

        super(endpoint);

        inputBuffer = new InternalNioInputBuffer(request, maxHttpHeaderSize,

                rejectIllegalHeaderName);

        request.setInputBuffer(inputBuffer);

        outputBuffer = new InternalNioOutputBuffer(response, maxHttpHeaderSize);

        response.setOutputBuffer(outputBuffer);

        initializeFilters(maxTrailerSize, allowedTrailerHeaders, maxExtensionSize, maxSwallowSize);

    }

super(endpoint)

public AbstractHttp11Processor(AbstractEndpoint<S> endpoint) {

        super(endpoint);

        userDataHelper = new UserDataHelper(getLog());

    }

继续super(endpoint)

public AbstractProcessor(AbstractEndpoint<S> endpoint) {

        this.endpoint = endpoint;

        asyncStateMachine = new AsyncStateMachine(this);

        request = new Request();

        response = new Response();

        response.setHook(this);

        request.setResponse(response);

        request.setHook(this);

    }

到这里就可以知道了。原来就是初始化org.apache.coyote.Request、org.apache.coyote.Response、InternalNioInputBuffer、InternalNioOutputBuffer对象

InputBuffer和request匹配。OutputBuffer和response匹配。

注意：

request.setInputBuffer(inputBuffer);

request关联的inputbuffer对象与我们线程接收到的socket相关联。这里相当于完成的request初始化。最后会传递到对应的context

初始化完后，接着看Http11NioProcessor.process

/**

     * Process pipelined HTTP requests using the specified input and output

     * streams.

     *

     * @param socketWrapper Socket from which the HTTP requests will be read

     *               and the HTTP responses will be written.

     *

     * @throws IOException error during an I/O operation

     */

    @Override

    public SocketState process(SocketWrapper<S> socketWrapper){

        RequestInfo rp = request.getRequestProcessor();

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

    // Setting up the I/O解析阶段

        setSocketWrapper(socketWrapper);

        getInputBuffer().init(socketWrapper, endpoint);

        getOutputBuffer().init(socketWrapper, endpoint);

    。

    。

    。

if (!getErrorState().isError()) {

                // Setting up filters, and parse some request headers

、、准备阶段                rp.setStage(org.apache.coyote.Constants.STAGE_PREPARE);

                try {

                    prepareRequest();

                }

。

。

。

// Process the request in the adapter

            if (!getErrorState().isError()) {

                try {

、、、请求处理阶段                    rp.setStage(org.apache.coyote.Constants.STAGE_SERVICE);

                    getAdapter().service(request, response);

。

。

。

// Finish the handling of the request

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

    endRequest();

。

。

。后面阶段省略

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

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

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

从解析阶段

getInputBuffer().init(socketWrapper, endpoint);从socket中获取inputBuffer,初始化一个SocketInputBuffer对象来执行doRead（）进行读操作
getOutputBuffer().init(socketWrapper, endpoint);从socket中获取outputBuffer，初始化一个SocketOutputBuffer对象来执行doWrite（）进行写操作

请求处理阶段。（重点）

getAdapter().service(request, response);

到这里就是将请求转发到对应context处理的。请求初始化在Http11NioProcessor类的构造方法中可以看到。

巴特西

tomcat启动(Ⅶ)请求处理--Processor.process(SocketWrapper<S> socketWrapper)

最新文章

热门文章