tomcat7--container

tomcat 7 启动时 先 启动catalina ，利用 digester 工具包来解析server.xml 创建 server ；

server 包含 service 

service 包含 container 和 Connector ；

container 的体系从高到低 依次为 engine > host >context>wrapper。

server 启动 service代码如下：

@Override    protected void startInternal() throws LifecycleException {        fireLifecycleEvent(CONFIGURE_START_EVENT, null);        setState(LifecycleState.STARTING);        globalNamingResources.start();                // Start our defined Services        synchronized (services) {            for (int i = 0; i < services.length; i++) {                services[i].start();            }        }    }

（这里为什么要同步呢？ 看起来启动server 是在main线程进行的。）

依次启动service ，service启动代码如下：

@Override    protected void startInternal() throws LifecycleException {        if(log.isInfoEnabled())            log.info(sm.getString("standardService.start.name", this.name));        setState(LifecycleState.STARTING);        // Start our defined Container first        if (container != null) {            synchronized (container) {                container.start();            }        }        synchronized (executors) {            for (Executor executor: executors) {                executor.start();            }        }        // Start our defined Connectors second        synchronized (connectors) {            for (Connector connector: connectors) {                try {                    // If it has already failed, don't try and start it                    if (connector.getState() != LifecycleState.FAILED) {                        connector.start();                    }                } catch (Exception e) {                    log.error(sm.getString(                            "standardService.connector.startFailed",                            connector), e);                }            }        }    }

先启动的是container：

container 体系如下 ： 

container 容器有4中实现，级别从高到低为 engine >host  >context >wapper。所有的 容器均继承 containerBase 。

containerbase 包含一个 pipeline 和  startStopExecutor 任务执行器 ；

 每个容器调用containerbase 的方法启动，containerbase 启动代码如下：

        // Start our child containers, if any        Container children[] = findChildren();        List<Future<Void>> results = new ArrayList<Future<Void>>();        for (int i = 0; i < children.length; i++) {            results.add(startStopExecutor.submit(new StartChild(children[i])));        }

results.add(startStopExecutor.submit(new StartChild(children[i])));

这里用到了 threadpoolExcuter 封装的线程池，封装成任务执行器；把每一个注册的子容器提交给一个任务执行器来启动

private static class StartChild implements Callable<Void> {        private Container child;        public StartChild(Container child) {            this.child = child;        }        @Override        public Void call() throws LifecycleException {            child.start();            return null;        }    }

每一个 startChild 线程启动一个container，这是递归调用的，子容器又会启动子容器，最底层的容器最先启动完成。

然后等待直到每一个子容器启动完成：

 for (Future<Void> result : results) {            try {                result.get();            } catch (Exception e) {                log.error(sm.getString("containerBase.threadedStartFailed"), e);                fail = true;            }        }

子容器全部启动完成之后，启动 pipeline

// Start the Valves in our pipeline (including the basic), if any        if (pipeline instanceof Lifecycle)            ((Lifecycle) pipeline).start();

containerbase 持有一个standardPipeline，pipeline 也持有自己所在容器的引用

 /**     * The Pipeline object with which this Container is associated.     */    protected Pipeline pipeline = new StandardPipeline(this);

pipeline启动代码如下：pipeline会先启动server.xml自定义的Valve ，最后启动 basic Valve。

 @Override    protected synchronized void startInternal() throws LifecycleException {        // Start the Valves in our pipeline (including the basic), if any        Valve current = first;        if (current == null) {            current = basic;        }        while (current != null) {            if (current instanceof Lifecycle)                ((Lifecycle) current).start();            current = current.getNext();        }        setState(LifecycleState.STARTING);    }

basic Valve 是容器初始化时绑定给pipeline的：

standardEngine 的初始化代码如下：

 /**     * Create a new StandardEngine component with the default basic Valve.     */    public StandardEngine() {        super();        pipeline.setBasic(new StandardEngineValve());        /* Set the jmvRoute using the system property jvmRoute */        try {            setJvmRoute(System.getProperty("jvmRoute"));        } catch(Exception ex) {            log.warn(sm.getString("standardEngine.jvmRouteFail"));        }        // By default, the engine will hold the reloading thread        backgroundProcessorDelay = 10;    }

可见，engine 容器的 pipeline绑定的 basic Valve 就是 StandardEngineValve 。

StandardEngineValve 就是一个实例，不包含任何别的组件了，因此Valve 的start() 只是设置一个启动状态，然后什么也不做。

当创建各级容器实例的时候，（创建容器实例在 Catalina 启动Server 之前就完成了。）

1. StandardHost  给子容器 context 绑定了一个监听器。

/**     * Add a child Container, only if the proposed child is an implementation     * of Context.     *     * @param child Child container to be added     */    @Override    public void addChild(Container child) {        child.addLifecycleListener(new MemoryLeakTrackingListener());        if (!(child instanceof Context))            throw new IllegalArgumentException                (sm.getString("standardHost.notContext"));        super.addChild(child);    }

这个监听器当context启动完成之后，把context 的 classLoader 绑定到host 。记录内存泄漏用。。（控制台用的。。）

2.  Engine

 在Catalina 创建默认的StandardEngine 时，同时也将自己的classLoader 传递给了 StandardEngine, 也就是CommonClassLoader。

3. Contetxt

当使用Digetser创建 Context 时， Context 会创建一个 WabAppLoader 的实例，这个loader 是支持热部署的。

当 Digester 实例化 Context 之后， 还会调用 Context  的 setLoader() 方法，这个方法里启动了WebAppLoader ,调用 它的StartInternal() 方法。

 // Construct a class loader based on our current repositories list        try {            classLoader = createClassLoader();            classLoader.setResources(container.getResources());            classLoader.setDelegate(this.delegate);            classLoader.setSearchExternalFirst(searchExternalFirst);            if (container instanceof StandardContext) {                classLoader.setAntiJARLocking(                        ((StandardContext) container).getAntiJARLocking());                classLoader.setClearReferencesStatic(                        ((StandardContext) container).getClearReferencesStatic());                classLoader.setClearReferencesStopThreads(                        ((StandardContext) container).getClearReferencesStopThreads());                classLoader.setClearReferencesStopTimerThreads(                        ((StandardContext) container).getClearReferencesStopTimerThreads());                classLoader.setClearReferencesHttpClientKeepAliveThread(                        ((StandardContext) container).getClearReferencesHttpClientKeepAliveThread());            }            for (int i = 0; i < repositories.length; i++) {                classLoader.addRepository(repositories[i]);            }            // Configure our repositories            setRepositories();            setClassPath();            setPermissions();            ((Lifecycle) classLoader).start();

首先创建一个WebAppClassLoader ,这个才是  WebappLoader 这个组件持有的真正的类加载器。

这里那么它的父类加载器是谁呢？ 想想上面提到的 Engine 容器的设置的 classLoader ，就是这个Catalina 传递的 CommomClassLoader了。

        if (parentClassLoader == null) {            parentClassLoader = container.getParentClassLoader();        }

CommomClassLoader 加载所有Server 都能访问的类库

一个 WebappClassLoader 加载一个 webapp 

server 是在main 线程运行的，service 也是在main 线程运行的，(待续)