Tomcat处理http请求之源码分析_Tomcat

1 请求包装处理

tomcat组件connector在启动的时候会监听端口。以jioendpoint为例，在其acceptor类中：

protected class acceptor extends abstractendpoint.acceptor {
    @override
    public void run() {
        while (running) {
            ……
            try {
                //当前连接数
                countuporawaitconnection();
                socket socket = null;
                try {
                    //取出队列中的连接请求
                    socket = serversocketfactory.acceptsocket(serversocket);
                } catch (ioexception ioe) {
                    countdownconnection();
                }
                if (running && !paused && setsocketoptions(socket)) {
                    //处理请求
                    if (!processsocket(socket)) {
                        countdownconnection();
                        closesocket(socket);
                    }
                } else {
                    countdownconnection();
                    // close socket right away
                    closesocket(socket);
                }
            } 
            ……
        }
    }
}

在上面的代码中，socket = serversocketfactory.acceptsocket(serversocket);与客户端建立连接，将连接的socket交给processsocket(socket)来处理。在processsocket中，对socket进行包装一下交给线程池来处理：

protected boolean processsocket(socket socket) {
    try {
        socketwrapper<socket> wrapper = new socketwrapper<socket>(socket);
        wrapper.setkeepaliveleft(getmaxkeepaliverequests());
        wrapper.setsecure(issslenabled());
        //交给线程池处理连接
        getexecutor().execute(new socketprocessor(wrapper));
    } 
    ……
    return true;
}

线程池处理的任务socketproccessor，通过代码分析：

protected class socketprocessor implements runnable {
    protected socketwrapper<socket> socket = null;
    protected socketstatus status = null;
    @override
    public void run() {
        boolean launch = false;
        synchronized (socket) {
            socketstate state = socketstate.open;
            try {
                serversocketfactory.handshake(socket.getsocket());
            } 
            ……
            if ((state != socketstate.closed)) {
                //委派给handler来处理
                if (status == null) {
                    state = handler.process(socket, socketstatus.open_read);
                } else {
                    state = handler.process(socket,status);
                }
            }}}
            ……
}

即在socketprocessor中，将socket交给handler处理，这个handler就是在http11protocol的构造方法中赋值的http11connectionhandler，在该类的父类process方法中通过请求的状态，来创建http11processor处理器进行相应的处理，切到http11proccessor的父类abstracthttp11proccessor中。

public socketstate process(socketwrapper 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);
    while (!geterrorstate().iserror() && keepalive && !comet && !isasync() &&
            upgradeinbound == null &&
            httpupgradehandler == null && !endpoint.ispaused()) {
        ……
        if (!geterrorstate().iserror()) {
            // setting up filters, and parse some request headers
            rp.setstage(org.apache.coyote.constants.stage_prepare);
            try {
                //请求预处理
                preparerequest();
            } 
            ……
        }
        ……
        if (!geterrorstate().iserror()) {
            try {
                rp.setstage(org.apache.coyote.constants.stage_service);
                //交由适配器处理
                adapter.service(request, response);
                if(keepalive && !geterrorstate().iserror() && (
                        response.geterrorexception() != null ||
                                (!isasync() &&
                                statusdropsconnection(response.getstatus())))) {
                    seterrorstate(errorstate.close_clean, null);
                }
                setcomettimeouts(socketwrapper);
            } 
        }
    }
    ……
}

可以看到request和response的生成，从socket中获取请求数据，keep-alive处理，数据包装等等信息，最后交给了coyoteadapter的service方法

2 请求传递给container

在coyoteadapter的service方法中，主要有2个任务：

•第一个是org.apache.coyote.request和
org.apache.coyote.response到继承自httpservletrequest的org.apache.catalina.connector.request和org.apache.catalina.connector.response转换，和context，wrapper定位。

•第二个是将请求交给standardenginevalve处理。

public void service(org.apache.coyote.request req,
                        org.apache.coyote.response res) {
    ……
    postparsesuccess = postparserequest(req, request, res, response);
    ……
    connector.getservice().getcontainer().getpipeline().getfirst().invoke(request, response);
    ……
}

在postparserequest方法中代码片段：

connector.getmapper().map(servername, decodeduri, version,
                                      request.getmappingdata());
request.setcontext((context) request.getmappingdata().context);
request.setwrapper((wrapper) request.getmappingdata().wrapper);

request通过uri的信息找到属于自己的context和wrapper。而这个mapper保存了所有的容器信息，不记得的同学可以回到connector的startinternal方法中，最有一行代码是mapperlistener.start(); 在mapperlistener的start()方法中，

public void startinternal() throws lifecycleexception {
    setstate(lifecyclestate.starting);
    finddefaulthost();
    engine engine = (engine) connector.getservice().getcontainer();
    addlisteners(engine);
    container[] conhosts = engine.findchildren();
    for (container conhost : conhosts) {
        host host = (host) conhost;
        if (!lifecyclestate.new.equals(host.getstate())) {
            registerhost(host);
        }
    }
}

mapperlistener.startinternal()方法将所有container容器信息保存到了mapper中。那么，现在初始化把所有容器都添加进去了，如果容器变化了将会怎么样？这就是上面所说的监听器的作用，容器变化了，mapperlistener作为监听者。他的生成图示