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类的构造方法中可以看到。