tomcat解析(十六)对客户端请求的处理

前面我们讲到,或者你也可以在server.xml的注释中看到,Connector类是用于接收用户请求并返回处理结果的,整个服务启动及处理过程均在Connector的start方法里,而其实际的内容在于其挂有的ProtocolHandler对象,启动过程会调用其start方法,该方法又会调用到JIoEndpoint的start方法,该方法如下:
 public void start() throws Exception { // Initialize socket if not done before if (!initialized) { init(); } if (!running) { running = true; paused = false; // Create worker collection if (executor == null) { workers = new WorkerStack(maxThreads); } // Start acceptor threads for (int i = 0; i < acceptorThreadCount; i++) { Thread acceptorThread = new Thread(new Acceptor(), getName() + "-Acceptor-" + i); acceptorThread.setPriority(threadPriority); acceptorThread.setDaemon(daemon); acceptorThread.start(); } } } 

    实质上是启动了N个线程,线程又是怎么处理的呢,看一下Acceptor类的run方法即可
    /** * Server socket acceptor thread. */ protected class Acceptor implements Runnable { /** * The background thread that listens for incoming TCP/IP connections and * hands them off to an appropriate processor. */ public void run() { // Loop until we receive a shutdown command while (running) { // Loop if endpoint is paused while (paused) { try { Thread.sleep(1000); } catch (InterruptedException e) { // Ignore } } // Accept the next incoming connection from the server socket try { Socket socket = serverSocketFactory.acceptSocket(serverSocket); serverSocketFactory.initSocket(socket); // Hand this socket off to an appropriate processor if (!processSocket(socket)) { // Close socket right away try { socket.close(); } catch (IOException e) { // Ignore } } }catch ( IOException x ) { if ( running ) log.error(sm.getString("endpoint.accept.fail"), x); } catch (Throwable t) { log.error(sm.getString("endpoint.accept.fail"), t); } // The processor will recycle itself when it finishes } } } 

    对于每一个Acceptor线程,均会不断地调用ServerSocket.accept方法来接受客户端的请求,最后调用processSocket方法处理该socket
    /** * Process given socket. */ protected boolean processSocket(Socket socket) { try { if (executor == null) { getWorkerThread().assign(socket); } else { executor.execute(new SocketProcessor(socket)); } } catch (Throwable t) { // This means we got an OOM or similar creating a thread, or that // the pool and its queue are full log.error(sm.getString("endpoint.process.fail"), t); return false; } return true; } 

    由于executor为空,因此将执行getWorkerThread().assign(socket);
    /** * Return a new worker thread, and block while to worker is available. */ protected Worker getWorkerThread() { // Allocate a new worker thread Worker workerThread = createWorkerThread(); while (workerThread == null) { try { synchronized (workers) { workers.wait(); } } catch (InterruptedException e) { // Ignore } workerThread = createWorkerThread(); } return workerThread; } 

/** * Create (or allocate) and return an available processor for use in * processing a specific HTTP request, if possible. If the maximum * allowed processors have already been created and are in use, return * <code>null</code> instead. */ protected Worker createWorkerThread() { synchronized (workers) { if (workers.size() > 0) { curThreadsBusy++; return workers.pop(); } if ((maxThreads > 0) && (curThreads < maxThreads)) { curThreadsBusy++; if (curThreadsBusy == maxThreads) { log.info(sm.getString("endpoint.info.maxThreads", Integer.toString(maxThreads), address, Integer.toString(port))); } return (newWorkerThread()); } else { if (maxThreads < 0) { curThreadsBusy++; return (newWorkerThread()); } else { return (null); } } } }

尽管在start方法里已对workers进行了初始化,但这里并不直接返回栈中Worker对象,可看一下WorkerStack类
    public class WorkerStack { protected Worker[] workers = null; protected int end = 0; public WorkerStack(int size) { workers = new Worker[size]; } /** * Put the object into the queue. If the queue is full (for example if * the queue has been reduced in size) the object will be dropped. * * @param object the object to be appended to the queue (first * element). */ public void push(Worker worker) { if (end < workers.length) { workers[end++] = worker; } else { curThreads--; } } /** * Get the first object out of the queue. Return null if the queue * is empty. */ public Worker pop() { if (end > 0) { return workers[--end]; } return null; } /** * Get the first object out of the queue, Return null if the queue * is empty. */ public Worker peek() { return workers[end]; } /** * Is the queue empty? */ public boolean isEmpty() { return (end == 0); } /** * How many elements are there in this queue? */ public int size() { return (end); } /** * Resize the queue. If there are too many objects in the queue for the * new size, drop the excess. * * @param newSize */ public void resize(int newSize) { Worker[] newWorkers = new Worker[newSize]; int len = workers.length; if (newSize < len) { len = newSize; } System.arraycopy(workers, 0, newWorkers, 0, len); workers = newWorkers; } } 

    在JIoEndpoint.start()中,是直接调用该类的构造方法的:
    public WorkerStack(int size) {
        workers = new Worker[size];
    }
    直接调用这个方法并不会引起end变量的变化,因此此时end还是为0,在调用workers.size的时候返回的是end的值,因此此时会被认为是0,因此此时会走下面这段代码:
    if ((maxThreads > 0) && (curThreads < maxThreads)) { curThreadsBusy++; if (curThreadsBusy == maxThreads) { log.info(sm.getString("endpoint.info.maxThreads", Integer.toString(maxThreads), address, Integer.toString(port))); } return (newWorkerThread()); } else { if (maxThreads < 0) { curThreadsBusy++; return (newWorkerThread()); } else { return (null); } }  

    maxThreads是支持的最大线程数, curThreads是现在已有的线程数,很明显,如果maxThreads如果小于0,则没有限制,如果curThreads>=maxThreads,则已超过了限制,也不会重新生成新的线程,其它情况则会生成新的线程,看newWorkerThread方法如下:
    /** * Create and return a new processor suitable for processing HTTP * requests and returning the corresponding responses. */ protected Worker newWorkerThread() { Worker workerThread = new Worker(); workerThread.start(); return (workerThread); } Worker类如下: protected class Worker implements Runnable { protected Thread thread = null; protected boolean available = false; protected Socket socket = null; /** * Process an incoming TCP/IP connection on the specified socket. Any * exception that occurs during processing must be logged and swallowed. * <b>NOTE</b>: This method is called from our Connector's thread. We * must assign it to our own thread so that multiple simultaneous * requests can be handled. * * @param socket TCP socket to process */ synchronized void assign(Socket socket) { // Wait for the Processor to get the previous Socket while (available) { try { wait(); } catch (InterruptedException e) { } } // Store the newly available Socket and notify our thread this.socket = socket; available = true; notifyAll(); } /** * Await a newly assigned Socket from our Connector, or <code>null</code> * if we are supposed to shut down. */ private synchronized Socket await() { // Wait for the Connector to provide a new Socket while (!available) { try { wait(); } catch (InterruptedException e) { } } // Notify the Connector that we have received this Socket Socket socket = this.socket; available = false; notifyAll(); return (socket); } /** * The background thread that listens for incoming TCP/IP connections and * hands them off to an appropriate processor. */ public void run() { // Process requests until we receive a shutdown signal while (running) { // Wait for the next socket to be assigned Socket socket = await(); if (socket == null) continue; // Process the request from this socket if (!setSocketOptions(socket) || !handler.process(socket)) { // Close socket try { socket.close(); } catch (IOException e) { } } // Finish up this request socket = null; recycleWorkerThread(this); } } /** * Start the background processing thread. */ public void start() { thread = new Thread(this); thread.setName(getName() + "-" + (++curThreads)); thread.setDaemon(true); thread.start(); } }     
    线程运行时会监查socket变量是否为空,是的话等待,之后运行其assign方法将获取到的socket赋予当前线程实例的socket变量后调用setSocketOptions及handler.process对其进行处理;setSocketOptions只设置一些socket的属性值,并无具体解析过程,真正的处理过程为后者,因此我们再来分析一下后者如何处理的;
    在Http11Protocol类的init方法中对JIoEndpoint对象进行了设置,其中便有设置其handler对象的调用,且其handler为Http11ConnectionHandler实例,但你如果看一下该类所实现的接口又会被雷到,其实现的接口为Handler,而该接口是JIoEndpoint里的一个内部公共接口,而Http11ConnectionHandler类是Http11Protocol的内部类,OMG.从代码风格来看似乎后期的这些处理与前期的一些解析工作大相径庭啊,应该是出自不同人之手的.废话少话,下面我们继续讲一下如何处理客户请求,看Http11ConnectionHandler.process(注意该类为Http11Protocol的内部类哦)方法,如下:
    public boolean process(Socket socket) { Http11Processor processor = recycledProcessors.poll(); try { if (processor == null) { processor = createProcessor(); } if (processor instanceof ActionHook) { ((ActionHook) processor).action(ActionCode.ACTION_START, null); } if (proto.secure && (proto.sslImplementation != null)) { processor.setSSLSupport (proto.sslImplementation.getSSLSupport(socket)); } else { processor.setSSLSupport(null); } processor.process(socket); return false; } catch(java.net.SocketException e) { // SocketExceptions are normal Http11Protocol.log.debug (sm.getString ("http11protocol.proto.socketexception.debug"), e); } catch (java.io.IOException e) { // IOExceptions are normal Http11Protocol.log.debug (sm.getString ("http11protocol.proto.ioexception.debug"), e); } // Future developers: if you discover any other // rare-but-nonfatal exceptions, catch them here, and log as // above. catch (Throwable e) { // any other exception or error is odd. Here we log it // with "ERROR" level, so it will show up even on // less-than-verbose logs. Http11Protocol.log.error (sm.getString("http11protocol.proto.error"), e); } finally { // if(proto.adapter != null) proto.adapter.recycle(); // processor.recycle(); if (processor instanceof ActionHook) { ((ActionHook) processor).action(ActionCode.ACTION_STOP, null); } recycledProcessors.offer(processor); } return false; } 

        recycledProcessors是一个ConcurrentLinkedQueue<Http11Processor>对象,这个类不熟,这里先不讲,看似不是很影响内容,看一下后面的createProcessor方法,如下:
        protected Http11Processor createProcessor() { Http11Processor processor = new Http11Processor(proto.maxHttpHeaderSize, proto.endpoint); processor.setAdapter(proto.adapter); processor.setMaxKeepAliveRequests(proto.maxKeepAliveRequests); processor.setKeepAliveTimeout(proto.keepAliveTimeout); processor.setTimeout(proto.timeout); processor.setDisableUploadTimeout(proto.disableUploadTimeout); processor.setCompressionMinSize(proto.compressionMinSize); processor.setCompression(proto.compression); processor.setNoCompressionUserAgents(proto.noCompressionUserAgents); processor.setCompressableMimeTypes(proto.compressableMimeTypes); processor.setRestrictedUserAgents(proto.restrictedUserAgents); processor.setSocketBuffer(proto.socketBuffer); processor.setMaxSavePostSize(proto.maxSavePostSize); processor.setServer(proto.server); register(processor); return processor; } 

        可以看到产生的是一个Http11Processor对象,然后最后调用其process方法,该对象又持有proto.endpoint对象,即JIoEndpoint类的实例,因为该类内容较多,因此对该类的分析将放到下一篇文章.

另外此处需要注意的是在Connector.start里调用protocolHandler.start()后还有一段代码如下:
if( this.domain != null ) { mapperListener.setDomain( domain ); //mapperListener.setEngine( service.getContainer().getName() ); mapperListener.init(); try { ObjectName mapperOname = createObjectName(this.domain,"Mapper"); if (log.isDebugEnabled()) log.debug(sm.getString( "coyoteConnector.MapperRegistration", mapperOname)); Registry.getRegistry(null, null).registerComponent (mapper, mapperOname, "Mapper"); } catch (Exception ex) { log.error(sm.getString ("coyoteConnector.protocolRegistrationFailed"), ex); } }
这一段代码主要功能是初始化mapperListener,包含的工作主要是将找到的所有Host,Context,Wrapper等加入Mapper实例里,这样可以通过Mapper类统一匹配客户端请求是对应到哪个Context,Wrapper及Servlet进行处理的,我们后续可以在处理客户端请求2中看到相应的调用