tomcat源码分析 JIoEndpoint SocketProcessor处理过程

当JIoEndpoint接受到请求时，生成SocketProcessor实例，SocketProcessor实现了Runnable接口。

我们稍微看一下SocketProcessor的run方法做了什么事情。

1、设置SocketState状态为SocketState.OPEN，这是一个枚举类。

SocketState state = SocketState.OPEN;

2、对socket进行一些额外处理，事实上只有在ssl的情况下，才会有额外处理。

   如抛出异常，则设置状态值为SocketState.CLOSED

// SSL handshake
serverSocketFactory.handshake(socket.getSocket());

3、刚开始接收到请求时处理

    

if ((state != SocketState.CLOSED)) {
                        if (status == null) {
                            state = handler.process(socket, SocketStatus.OPEN);
                        } else {
                            state = handler.process(socket,status);
                        }
                    }

4、交由org.apache.coyote.http11.Http11Protocol.Http11ConnectionHandler 来处理socket请求

　Http11ConnectionHandler 会先获取一个Http11Processor实例，如有必要，创建一个。

   然后根据当前状态，选择Http11Processor相应方式来处理socket。

do {
                    if (status == SocketStatus.DISCONNECT &&
                            !processor.isComet()) {
                        // Do nothing here, just wait for it to get recycled
                        // Don't do this for Comet we need to generate an end
                        // event (see BZ 54022)
                    } else if (processor.isAsync() ||
                            state == SocketState.ASYNC_END) {
                        state = processor.asyncDispatch(status);
                    } else if (processor.isComet()) {
                        state = processor.event(status);
                    } else if (processor.isUpgrade()) {
                        state = processor.upgradeDispatch();
                    } else {
                        state = processor.process(socket);
                    }
    
                    if (state != SocketState.CLOSED && processor.isAsync()) {
                        state = processor.asyncPostProcess();
                    }

                    if (state == SocketState.UPGRADING) {
                        // Get the UpgradeInbound handler
                        UpgradeInbound inbound = processor.getUpgradeInbound();
                        // Release the Http11 processor to be re-used
                        release(socket, processor, false, false);
                        // Create the light-weight upgrade processor
                        processor = createUpgradeProcessor(socket, inbound);
                        inbound.onUpgradeComplete();
                    }
                } while (state == SocketState.ASYNC_END ||
                        state == SocketState.UPGRADING);

   当跳出循环之后，再根据状态值选择release还是longPoll

    release收回Http11Processor实例，longPoll则将以socket为key, processor为值放对map中，以做下一步处理。

5、再根据handler的处理结果，来决定下一步的处理。

   录为OPEN, UPGRADING, UPGRADED时，则设置launch=true。

if (state == SocketState.OPEN ||
                            state == SocketState.UPGRADING  ||
                            state == SocketState.UPGRADED){
    socket.setKeptAlive(true);
    socket.access();
    launch = true;
} 

6、当状态为LONG，则表示连接还持续，请求还需要再处理。类似于文件上传的这类请求。 

if (state == SocketState.LONG) {
                        socket.access(); 
                        waitingRequests.add(socket);
                    }

7、最终进入finally代码块

    当状态为lauch，则需要进一步处理请求。

if (launch) {
                        try {
                            getExecutor().execute(new SocketProcessor(socket, SocketStatus.OPEN));
                        } catch (RejectedExecutionException x) {
                            ///.......
                        }
                    }