基于之前案例的感性认识，Tomcat连接器模块源码解读1---连接器的运行

　　背景：本篇的内容主体是Connector连接器，暂不明确其在Tomcat中与其他容器的关系，但可以前述案例为标的物，把Connector理解为运行在多线程下，等待获取客户端socket并交由HttpProcessor进行处理的Object。那么关注点就是在Tomcat中完整的Connector及其所关联的组件的关系，整个模块的相关流程。上篇中的疑问仍留，Response请求头 属性怎样填充？如何填充？不知道在这里有没有解答。

• 　   catalina.jar包org.apache.catalina.Connector接口

package org.apache.catalina;

import org.apache.catalina.Container;
import org.apache.catalina.LifecycleException;
import org.apache.catalina.Request;
import org.apache.catalina.Response;
import org.apache.catalina.Service;
import org.apache.catalina.net.ServerSocketFactory;

public interface Connector {
    Container getContainer();

    void setContainer(Container arg0);

    boolean getEnableLookups();

    void setEnableLookups(boolean arg0);

    ServerSocketFactory getFactory();

    void setFactory(ServerSocketFactory arg0);

    String getInfo();

    int getRedirectPort();

    void setRedirectPort(int arg0);

    String getScheme();

    void setScheme(String arg0);

    boolean getSecure();

    void setSecure(boolean arg0);

    Service getService();

    void setService(Service arg0);

    Request createRequest();

    Response createResponse();

    void initialize() throws LifecycleException;
}

　　类关系：可以看到接口import了Container、Request、Response、Service、ServerSocketFactory，因此它们将或依赖或聚合在该类中，是该类分解出去的组成部分。它们将　　　　　　在实现类中被其声明为属性；接口中定义的方法，由于版本问题源码中没有文档注释，Service/ServiceScoketFactory等在前述案例中没有使用到的类的具体作用不得　　　　　　而知，仅仅是抽象层面的依赖关系，并不足以获取更多的信息。还需要有方法体，来分析对象之间的动态关系，下面是其实现类。

• catalina.jar包org.apache.catalina.connector.Http.HttpConnector类

package org.apache.catalina.connector.http;

import java.io.IOException;
import java.net.BindException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.security.AccessControlException;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.util.Stack;
import java.util.Vector;
import org.apache.catalina.Connector;
import org.apache.catalina.Container;
import org.apache.catalina.Lifecycle;
import org.apache.catalina.LifecycleException;
import org.apache.catalina.LifecycleListener;
import org.apache.catalina.Logger;
import org.apache.catalina.Request;
import org.apache.catalina.Response;
import org.apache.catalina.Service;
import org.apache.catalina.connector.http.HttpProcessor;
import org.apache.catalina.connector.http.HttpRequestImpl;
import org.apache.catalina.connector.http.HttpResponseImpl;
import org.apache.catalina.net.DefaultServerSocketFactory;
import org.apache.catalina.net.ServerSocketFactory;
import org.apache.catalina.util.LifecycleSupport;
import org.apache.catalina.util.StringManager;

public final class HttpConnector implements Connector, Lifecycle, Runnable {
    private Service service = null;
    private int acceptCount = 10;
    private String address = null;
    private int bufferSize = 2048;
    protected Container container = null;
    private Vector created = new Vector();
    private int curProcessors = 0;
    private int debug = 0;
    private boolean enableLookups = false;
    private ServerSocketFactory factory = null;
    private static final String info = "org.apache.catalina.connector.http.HttpConnector/1.0";
    protected LifecycleSupport lifecycle = new LifecycleSupport(this);
    protected int minProcessors = 5;
    private int maxProcessors = 20;
    private int connectionTimeout = '';
    private int port = 8080;
    private Stack processors = new Stack();
    private String proxyName = null;
    private int proxyPort = 0;
    private int redirectPort = 443;
    private String scheme = "http";
    private boolean secure = false;
    private ServerSocket serverSocket = null;
    private StringManager sm = StringManager.getManager("org.apache.catalina.connector.http");
    private boolean initialized = false;
    private boolean started = false;
    private boolean stopped = false;
    private Thread thread = null;
    private String threadName = null;
    private Object threadSync = new Object();
    private boolean allowChunking = true;
    private boolean tcpNoDelay = true;

    public Service getService() {
        return this.service;
    }

    public void setService(Service service) {
        this.service = service;
    }

    public int getConnectionTimeout() {
        return this.connectionTimeout;
    }

    public void setConnectionTimeout(int connectionTimeout) {
        this.connectionTimeout = connectionTimeout;
    }

    public int getAcceptCount() {
        return this.acceptCount;
    }

    public void setAcceptCount(int count) {
        this.acceptCount = count;
    }

    public boolean isChunkingAllowed() {
        return this.allowChunking;
    }

    public boolean getAllowChunking() {
        return this.isChunkingAllowed();
    }

    public void setAllowChunking(boolean allowChunking) {
        this.allowChunking = allowChunking;
    }

    public String getAddress() {
        return this.address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public boolean isAvailable() {
        return this.started;
    }

    public int getBufferSize() {
        return this.bufferSize;
    }

    public void setBufferSize(int bufferSize) {
        this.bufferSize = bufferSize;
    }

    public Container getContainer() {
        return this.container;
    }

    public void setContainer(Container container) {
        this.container = container;
    }

    public int getCurProcessors() {
        return this.curProcessors;
    }

    public int getDebug() {
        return this.debug;
    }

    public void setDebug(int debug) {
        this.debug = debug;
    }

    public boolean getEnableLookups() {
        return this.enableLookups;
    }

    public void setEnableLookups(boolean enableLookups) {
        this.enableLookups = enableLookups;
    }

    public ServerSocketFactory getFactory() {
        if (this.factory == null) {
            synchronized (this) {
                this.factory = new DefaultServerSocketFactory();
            }
        }

        return this.factory;
    }

    public void setFactory(ServerSocketFactory factory) {
        this.factory = factory;
    }

    public String getInfo() {
        return "org.apache.catalina.connector.http.HttpConnector/1.0";
    }

    public int getMinProcessors() {
        return this.minProcessors;
    }

    public void setMinProcessors(int minProcessors) {
        this.minProcessors = minProcessors;
    }

    public int getMaxProcessors() {
        return this.maxProcessors;
    }

    public void setMaxProcessors(int maxProcessors) {
        this.maxProcessors = maxProcessors;
    }

    public int getPort() {
        return this.port;
    }

    public void setPort(int port) {
        this.port = port;
    }

    public String getProxyName() {
        return this.proxyName;
    }

    public void setProxyName(String proxyName) {
        this.proxyName = proxyName;
    }

    public int getProxyPort() {
        return this.proxyPort;
    }

    public void setProxyPort(int proxyPort) {
        this.proxyPort = proxyPort;
    }

    public int getRedirectPort() {
        return this.redirectPort;
    }

    public void setRedirectPort(int redirectPort) {
        this.redirectPort = redirectPort;
    }

    public String getScheme() {
        return this.scheme;
    }

    public void setScheme(String scheme) {
        this.scheme = scheme;
    }

    public boolean getSecure() {
        return this.secure;
    }

    public void setSecure(boolean secure) {
        this.secure = secure;
    }

    public boolean getTcpNoDelay() {
        return this.tcpNoDelay;
    }

    public void setTcpNoDelay(boolean tcpNoDelay) {
        this.tcpNoDelay = tcpNoDelay;
    }

    public Request createRequest() {
        HttpRequestImpl request = new HttpRequestImpl();
        request.setConnector(this);
        return request;
    }

    public Response createResponse() {
        HttpResponseImpl response = new HttpResponseImpl();
        response.setConnector(this);
        return response;
    }

    void recycle(HttpProcessor processor) {
        this.processors.push(processor);
    }

    private HttpProcessor createProcessor() {
        Stack arg0 = this.processors;
        synchronized (arg0) {
            HttpProcessor arg1;
            if (this.processors.size() > 0) {
                arg1 = (HttpProcessor) this.processors.pop();
                return arg1;
            } else if (this.maxProcessors > 0 && this.curProcessors < this.maxProcessors) {
                arg1 = this.newProcessor();
                return arg1;
            } else if (this.maxProcessors < 0) {
                arg1 = this.newProcessor();
                return arg1;
            } else {
                arg1 = null;
                return arg1;
            }
        }
    }

    private void log(String message) {
        Logger logger = this.container.getLogger();
        String localName = this.threadName;
        if (localName == null) {
            localName = "HttpConnector";
        }

        if (logger != null) {
            logger.log(localName + " " + message);
        } else {
            System.out.println(localName + " " + message);
        }

    }

    private void log(String message, Throwable throwable) {
        Logger logger = this.container.getLogger();
        String localName = this.threadName;
        if (localName == null) {
            localName = "HttpConnector";
        }

        if (logger != null) {
            logger.log(localName + " " + message, throwable);
        } else {
            System.out.println(localName + " " + message);
            throwable.printStackTrace(System.out);
        }

    }

    private HttpProcessor newProcessor() {
        HttpProcessor processor = new HttpProcessor(this, this.curProcessors++);
        if (processor instanceof Lifecycle) {
            try {
                processor.start();
            } catch (LifecycleException arg2) {
                this.log("newProcessor", arg2);
                return null;
            }
        }

        this.created.addElement(processor);
        return processor;
    }

    private ServerSocket open() throws IOException, KeyStoreException, NoSuchAlgorithmException, CertificateException,
            UnrecoverableKeyException, KeyManagementException {
        ServerSocketFactory factory = this.getFactory();
        if (this.address == null) {
            this.log(this.sm.getString("httpConnector.allAddresses"));

            try {
                return factory.createSocket(this.port, this.acceptCount);
            } catch (BindException arg4) {
                throw new BindException(arg4.getMessage() + ":" + this.port);
            }
        } else {
            try {
                InetAddress e = InetAddress.getByName(this.address);
                this.log(this.sm.getString("httpConnector.anAddress", this.address));

                try {
                    return factory.createSocket(this.port, this.acceptCount, e);
                } catch (BindException arg5) {
                    throw new BindException(arg5.getMessage() + ":" + this.address + ":" + this.port);
                }
            } catch (Exception arg6) {
                this.log(this.sm.getString("httpConnector.noAddress", this.address));

                try {
                    return factory.createSocket(this.port, this.acceptCount);
                } catch (BindException arg3) {
                    throw new BindException(arg3.getMessage() + ":" + this.port);
                }
            }
        }
    }

    public void run() {
        while (true) {
            Object socket;
            if (!this.stopped) {
                label81 : {
                    socket = null;

                    Socket socket1;
                    try {
                        socket1 = this.serverSocket.accept();
                        if (this.connectionTimeout > 0) {
                            socket1.setSoTimeout(this.connectionTimeout);
                        }

                        socket1.setTcpNoDelay(this.tcpNoDelay);
                    } catch (AccessControlException arg19) {
                        this.log("socket accept security exception", arg19);
                        continue;
                    } catch (IOException arg20) {
                        IOException e = arg20;

                        try {
                            Object ioe = this.threadSync;
                            synchronized (ioe) {
                                if (this.started && !this.stopped) {
                                    this.log("accept error: ", e);
                                }

                                if (!this.stopped) {
                                    this.serverSocket.close();
                                    this.serverSocket = this.open();
                                }
                                continue;
                            }
                        } catch (IOException arg12) {
                            this.log("socket reopen, io problem: ", arg12);
                            break label81;
                        } catch (KeyStoreException arg13) {
                            this.log("socket reopen, keystore problem: ", arg13);
                            break label81;
                        } catch (NoSuchAlgorithmException arg14) {
                            this.log("socket reopen, keystore algorithm problem: ", arg14);
                            break label81;
                        } catch (CertificateException arg15) {
                            this.log("socket reopen, certificate problem: ", arg15);
                            break label81;
                        } catch (UnrecoverableKeyException arg16) {
                            this.log("socket reopen, unrecoverable key: ", arg16);
                            break label81;
                        } catch (KeyManagementException arg17) {
                            this.log("socket reopen, key management problem: ", arg17);
                            break label81;
                        }
                    }

                    HttpProcessor processor = this.createProcessor();
                    if (processor == null) {
                        try {
                            this.log(this.sm.getString("httpConnector.noProcessor"));
                            socket1.close();
                        } catch (IOException arg18) {
                            ;
                        }
                        continue;
                    }

                    processor.assign(socket1);
                    continue;
                }
            }

            socket = this.threadSync;
            synchronized (socket) {
                this.threadSync.notifyAll();
                return;
            }
        }
    }

    private void threadStart() {
        this.log(this.sm.getString("httpConnector.starting"));
        this.thread = new Thread(this, this.threadName);
        this.thread.setDaemon(true);
        this.thread.start();
    }

    private void threadStop() {
        this.log(this.sm.getString("httpConnector.stopping"));
        this.stopped = true;

        try {
            this.threadSync.wait(5000L);
        } catch (InterruptedException arg1) {
            ;
        }

        this.thread = null;
    }

    public void addLifecycleListener(LifecycleListener listener) {
        this.lifecycle.addLifecycleListener(listener);
    }

    public LifecycleListener[] findLifecycleListeners() {
        return this.lifecycle.findLifecycleListeners();
    }

    public void removeLifecycleListener(LifecycleListener listener) {
        this.lifecycle.removeLifecycleListener(listener);
    }

    public void initialize() throws LifecycleException {
        if (this.initialized) {
            throw new LifecycleException(this.sm.getString("httpConnector.alreadyInitialized"));
        } else {
            this.initialized = true;
            Object eRethrow = null;

            try {
                this.serverSocket = this.open();
            } catch (IOException arg7) {
                this.log("httpConnector, io problem: ", arg7);
                eRethrow = arg7;
            } catch (KeyStoreException arg8) {
                this.log("httpConnector, keystore problem: ", arg8);
                eRethrow = arg8;
            } catch (NoSuchAlgorithmException arg9) {
                this.log("httpConnector, keystore algorithm problem: ", arg9);
                eRethrow = arg9;
            } catch (CertificateException arg10) {
                this.log("httpConnector, certificate problem: ", arg10);
                eRethrow = arg10;
            } catch (UnrecoverableKeyException arg11) {
                this.log("httpConnector, unrecoverable key: ", arg11);
                eRethrow = arg11;
            } catch (KeyManagementException arg12) {
                this.log("httpConnector, key management problem: ", arg12);
                eRethrow = arg12;
            }

            if (eRethrow != null) {
                throw new LifecycleException(this.threadName + ".open", (Throwable) eRethrow);
            }
        }
    }

    public void start() throws LifecycleException {
        if (this.started) {
            throw new LifecycleException(this.sm.getString("httpConnector.alreadyStarted"));
        } else {
            this.threadName = "HttpConnector[" + this.port + "]";
            this.lifecycle.fireLifecycleEvent("start", (Object) null);
            this.started = true;
            this.threadStart();

            while (this.curProcessors < this.minProcessors
                    && (this.maxProcessors <= 0 || this.curProcessors < this.maxProcessors)) {
                HttpProcessor processor = this.newProcessor();
                this.recycle(processor);
            }

        }
    }

    public void stop() throws LifecycleException {
        if (!this.started) {
            throw new LifecycleException(this.sm.getString("httpConnector.notStarted"));
        } else {
            this.lifecycle.fireLifecycleEvent("stop", (Object) null);
            this.started = false;

            for (int i = this.created.size() - 1; i >= 0; --i) {
                HttpProcessor processor = (HttpProcessor) this.created.elementAt(i);
                if (processor instanceof Lifecycle) {
                    try {
                        processor.stop();
                    } catch (LifecycleException arg5) {
                        this.log("HttpConnector.stop", arg5);
                    }
                }
            }

            Object arg7 = this.threadSync;
            synchronized (arg7) {
                if (this.serverSocket != null) {
                    try {
                        this.serverSocket.close();
                    } catch (IOException arg4) {
                        ;
                    }
                }

                this.threadStop();
            }

            this.serverSocket = null;
        }
    }
}

　　代码分析：由于没有main方法，仅从代码无法了解到程序的入口在哪里，现在只需要知道initialize（）方法在启动服务器时会被调用.但是是谁调用？其他方法又归谁调用？

　　　　           既然是实现lifycie接口并被在统一的生命周期中管理，初始化，启动，那么createRequest之类的公开方法又什么作用？

　　　　　　　文章作者谈到，由于该类是实现了lifecycle接口，因此服务器启动时会由统一的生命周期管理程序initialize()、start()该类的实例。并且被启动程序run()。

　　　　　　　public void initialize() throws LifecycleException {// 获取serverSocket
       　　　　　　　　 if (this.initialized) {//状态判断
           　　　　　　　　　 throw new LifecycleException(this.sm.getString("httpConnector.alreadyInitialized"));
      　　　　　　　　　} else {
           　　　　　　　　 　this.initialized = true;//标识初始状态
           　　　　　　　　　 Object eRethrow = null;  
           　　　　　　　 try {
               　　　　　　　　　 this.serverSocket = this.open();  //执行open过程，给serverSocket填充对象
           　　　　　　　　 } catch (IOException arg7) {
              　　　　　　　　　 this.log("httpConnector, io problem: ", arg7);
              　　　　　　　　　 eRethrow = arg7;
           　　　　　　　　 } catch (KeyStoreException arg8) {
            　　　　　　　　　    this.log("httpConnector, keystore problem: ", arg8);
                                               eRethrow = arg8;
           　　　　　　　    } catch (NoSuchAlgorithmException arg9) {
                　　　　　　          this.log("httpConnector, keystore algorithm problem: ", arg9);
                                               eRethrow = arg9;
            　　　　　　　　} catch (CertificateException arg10) {
                　　　　　　　　　this.log("httpConnector, certificate problem: ", arg10);
               　　　　　　　　　 eRethrow = arg10;
           　　　　　　　　 } catch (UnrecoverableKeyException arg11) {
               　　　　　　　　　this.log("httpConnector, unrecoverable key: ", arg11);
              　　　　　　　　　 eRethrow = arg11;
            　　　　　　　   } catch (KeyManagementException arg12) {
               　　　　　　　　   this.log("httpConnector, key management problem: ", arg12);
             　　　　　　　　     eRethrow = arg12;
         　　　　　　　   }
          　　　　　　 if (eRethrow != null) {
             　　　　　　　　   throw new LifecycleException(this.threadName + ".open", (Throwable) eRethrow);
        　　　　　　　    }
       　　　　 　　}
  　　　　 　　 }

　　　　　　   this.open()如下：

　　　　　　   private ServerSocket open() throws IOException, KeyStoreException, NoSuchAlgorithmException, CertificateException,
            　　　　　　　　　　　　　　　　　　　　UnrecoverableKeyException, KeyManagementException {//作为一个过程而存在。
       　　　　　　　 ServerSocketFactory factory = this.getFactory();
      　　　　　　　  if (this.address == null) {
         　　　　　　　　  this.log(this.sm.getString("httpConnector.allAddresses"));
           　　　　　　　　 try {
               　　　　　　　　　　 return factory.createSocket(this.port, this.acceptCount);//利用工厂类创建，忽略！
         　　　　　　  　　 } catch (BindException arg4) {
              　　　　　　　　 　　 throw new BindException(arg4.getMessage() + ":" + this.port);
           　　　　　　　　 }
      　　　　　　     } else {
            　　　　　　　　try {
               　　　　　　　　　　 InetAddress e = InetAddress.getByName(this.address);//根据主机名获取其IP地址,为null则本机ip
              　　　　　　　　 　　 this.log(this.sm.getString("httpConnector.anAddress", this.address));
             　　　　　　　 　　  try {
                  　　　　　　　　　 　　 return factory.createSocket(this.port, this.acceptCount, e);//传递端口、数量、地址返回ServerSocket
               　　　　　　　　　　 } catch (BindException arg5) {
                  　　　　　　　　　　　  throw new BindException(arg5.getMessage() + ":" + this.address + ":" + this.port);
               　　　　　　　　　　 }
           　　　　　　　　 } catch (Exception arg6) {
             　　　　　　   this.log(this.sm.getString("httpConnector.noAddress", this.address)); //本类中的log()过程，不对外公开，不关注
               　　　　　　 try {
                   　　　　　　 return factory.createSocket(this.port, this.acceptCount);
               　　　　　　 } catch (BindException arg3) {
                    　　　　　　throw new BindException(arg3.getMessage() + ":" + this.port);
                　　　　　　}
          　　　　　　  }
      　　　　　　 }
 　　　　　　 }

　　　　　　总结：以上的inintialize方法用来创建serverSocket,由前面第3个案例演进为运行在生命周期管理的某个过程中，并且完善了异常处理和日志输出。

　　　　　　public void start() throws LifecycleException {//创建HttpProcessor池
        　　　　　　if (this.started) {//确保在生命周期中只被启动一次
           　　　　　　　　 throw new LifecycleException(this.sm.getString("httpConnector.alreadyStarted"));
      　　　　　　  } else {//
           　　　　　　　　 this.threadName = "HttpConnector[" + this.port + "]";//为该服务线程命名
           　　　　　　　　 this.lifecycle.fireLifecycleEvent("start", (Object) null);
           　　　　　　　　 this.started = true;//更新状态
           　　　　　　　　 this.threadStart();//启动线程
           　　　　 while (this.curProcessors < this.minProcessors && (this.maxProcessors <= 0 || this.curProcessors < this.maxProcessors)) {

　　　　　　　　　　　 //当前HttpProcessor数量小于最小数量且最大数量为0或当前数量小于最大数量，即反复创建最小数量的HttpProcessor并保存
               　　　　　　    HttpProcessor processor = this.newProcessor();
               　　　　　   　 this.recycle(processor);//压入本类的processors栈中，即该类有一个httpProcessor池，来处理来自多客户的多个socket
            　　　　　　　　　　  }
      　　　　　　 }
  　　　　　　}

　　　　　    private void threadStart() {//线程启动过程
       　　　　　　 this.log(this.sm.getString("httpConnector.starting"));//打印日志
       　　　　　　 this.thread = new Thread(this, this.threadName);//创建新线程
       　　　　　　 this.thread.setDaemon(true);//标记线程，不关注
       　　　　　　 this.thread.start();//启动线程
   　　　　　  } 　

　　　　　    public final void setDaemon(boolean on) {//来自thread类，不过多关心线程
       　　　　　　 checkAccess();
       　　　　　    if (isAlive()) {
            　　　　　　　throw new IllegalThreadStateException();
        　　　　　　}
        　　　　　　daemon = on;
    　　　　　 }

　　　　　　private HttpProcessor newProcessor() {
       　　　　　　 HttpProcessor processor = new HttpProcessor(this, this.curProcessors++);  //创建HttpProcessor依赖该连接器对象
       　　　　　　 if (processor instanceof Lifecycle) {
           　　　　    try {
                　　　　　　processor.start();
           　　　　　 } catch (LifecycleException arg2) {
               　　　　　　 this.log("newProcessor", arg2);
               　　　　　　 return null;
            　　　　  }
       　　　　　　 }
      　　　　　　  this.created.addElement(processor); //created是一个Vector，存储Http处理器
       　　　　　　 return processor; //返回后Http处理器又被压入称为Processors的Stack中
    　　　　　}

　　　　　　总结：init后创建了serverSocket，start后创建HttpProcessor对象填充processor池。静态关系来看，HttpProcessor类的与该类是依赖关系，该类的其他公共方法用来　　　　　　　　   被HttpProcessor调用，比如创建res/req对象等，之前的案例中穿件res/req的工作是交给HttpProcessor的，但是现在由连接器（该类）创建。为了便于分析，现　　　　　　　　   在可以假想inintialize()和start()以及下面的run()方法不在该类中，而是在一个主程序中，当这个主程序创建了serversocket,创建且填充了HttpProcessor池，并启　　　　　　　　   动池中某一个HttpProcessor的处理程序之前，把Connector对象传递给被依赖的HttpProcessor，Connector一方面存储着serverSocket等，一方面提供一些公开　　　　　　　　  方法给HttpProcessor对象。其实该类还被其他的如res/req等所依赖，和这些类的关系在对应类中再一一分析，接下来阅读run()方法。

　　　　　　public void run() {
       　　　　　　 while (true) {//循环
           　　　　　　 Object socket;
           　　　　　　 if (!this.stopped) {
               　　　　　　　　 label81 : {
                   　　　　　　　　 socket = null;
                    　　　　　　　　Socket socket1;
                   　　　　　　　　 try {
                       　　　　　　　　　　　　 socket1 = this.serverSocket.accept();//等待请求
                       　　　　　　　　　　　　 if (this.connectionTimeout > 0) {
                           　　　　　　　　　　　　　　 socket1.setSoTimeout(this.connectionTimeout);
                      　　　　　　　　　　　　  }
                       　　　　　　　　　　　　 socket1.setTcpNoDelay(this.tcpNoDelay);
                   　　　　　　　　　　 } catch (AccessControlException arg19) {
                       　　　　　　　　　　　　 this.log("socket accept security exception", arg19);
                       　　　　　　　　　　　　 continue;
                   　　　　　　　　　　 } catch (IOException arg20) {
                      　　　　　　　　　　　　  IOException e = arg20;
                      　　　　　　  try {
                          　　　　　　　　　　    Object ioe = this.threadSync;
                           　　　　　　　　　　   synchronized (ioe) {
                               　　　　　　　　　　　　 if (this.started && !this.stopped) {
                                   　　　　　　　　　　　　　　 this.log("accept error: ", e);
                              　　　　　　　　　　　　  }
                               　　　　　　　　　　　　 if (!this.stopped) {
                                  　　　　　　　　　　　　　　  this.serverSocket.close();
                                   　　　　　　　　　　　　　　 this.serverSocket = this.open();
                               　　　　　　　　　　　　 }
                               　　　　　　　　　　 continue;
                           　　　　　　　 　　}
                       　　　　　　　　 } catch (IOException arg12) {
                           　　　　　　　　　　 this.log("socket reopen, io problem: ", arg12);
                            　　　　　　　　　　break label81;
                       　　　　　　　　 } catch (KeyStoreException arg13) {
                          　　　　　　　　　　  this.log("socket reopen, keystore problem: ", arg13);
                           　　　　　　　　　　 break label81;
                       　　　　　　　　 } catch (NoSuchAlgorithmException arg14) {
                           　　　　　　　　　　 this.log("socket reopen, keystore algorithm problem: ", arg14);
                           　　　　　　　　　　 break label81;
                        　　　　　　　　} catch (CertificateException arg15) {
                           　　　　　　　　　　 this.log("socket reopen, certificate problem: ", arg15);
                           　　　　　　　　　　 break label81;
                       　　　　　　　　 } catch (UnrecoverableKeyException arg16) {
                           　　　　　　　　　　 this.log("socket reopen, unrecoverable key: ", arg16);
                           　　　　　　　　　　 break label81;
                       　　　　　　　　 } catch (KeyManagementException arg17) {
                           　　　　　　　　　　 this.log("socket reopen, key management problem: ", arg17);
                           　　　　　　　　　　 break label81;
                       　　　　　　　　 }
                   　　　　　　 }
                  　　　　　　  HttpProcessor processor = this.createProcessor();//
                   　　　　　　 if (processor == null) {
                       　　　　　　 try {
                           　　　　　　 this.log(this.sm.getString("httpConnector.noProcessor"));
                           　　　　　　 socket1.close();
                       　　　　　　　 } catch (IOException arg18) {
                           　　　　　　　　　　 ;
                       　　　　　　　 }
                       　　　　　　　 continue;
                    　　　　　　｝
                   　　　　　　 processor.assign(socket1);//留在processor中分析
                    　　　　　　continue;
                　　　　　　}
           　　　　　 }
           　　　　 socket = this.threadSync;
           　　　　 synchronized (socket) {
                　　　this.threadSync.notifyAll();
                　　　return;
            　　　　　　　　}
        　　　　　　}
    　　　　　}

　　　　　　private HttpProcessor createProcessor() {//从池中弹出HttpProcessor对象
       　　　　　　 Stack arg0 = this.processors;
        　　　　　　synchronized (arg0) {
           　　　　　　　　 HttpProcessor arg1;
           　　　　　　　　 if (this.processors.size() > 0) {
                　　　　　　　　　　arg1 = (HttpProcessor) this.processors.pop();
               　　　　　　　　　　 return arg1;
           　　　　　　　　 } else if (this.maxProcessors > 0 && this.curProcessors < this.maxProcessors) {
                　　　　　　　　　　arg1 = this.newProcessor();
               　　　　　　　　　　 return arg1;
            　　　　　　　　} else if (this.maxProcessors < 0) {
               　　　　　　　　　　 arg1 = this.newProcessor();
               　　　　　　　　　　 return arg1;
           　　　　　　　　 } else {
               　　　　　　　　　　 arg1 = null;
               　　　　　　　　　　 return arg1;
            　　　　　　　　　　}
      　　　　　　　　　 }
    　　　　　　　　}

　　　　　　总结：最后该类中的剩下就是和生命周期相关的还有stop方法，暂时略去不关注，学习生命周期相关知识时自然会解读。上面的run()方法主要循环等待链接，一旦有　　　　　　　　       Http连接到来就把套接字分配给HttpProcessor，由其进行处理。之前的案例中，只要把socket对象传递给Processor并让其执行处理，但是这里的HttpProcessor　　　　　　　　　对象的创建为什么还要依赖Connector呢？