Tomcat 系列篇五-介绍下 Service 启动过程

发表于 分类于 ， ， 阅读次数： 阅读次数： Disqus：

这里开始介绍下 Service 的启动过程，Tomcat 的启动过程中

1
2
3
4
public void start() throws LifecycleException {
    getServer();
    server.start();
}

getServer之前讲到过

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public Server getServer() {

    if (server != null) {
        return server;
    }

    System.setProperty("catalina.useNaming", "false");

    server = new StandardServer();

    initBaseDir();

    // Set configuration source
    ConfigFileLoader.setSource(new CatalinaBaseConfigurationSource(new File(basedir), null));

    server.setPort( -1 );

    Service service = new StandardService();
    service.setName("Tomcat");
    server.addService(service);
    return server;
}

会 new 一个StandardService，添加到 server 里，然后进行启动
而这个外面的 server.start 其实调用的是 org.apache.catalina.Lifecycle#start,
里面是一个 Lifecycle 的接口，这个接口被很多 Tomcat 的组件实现，其实都共用了 Lifecycle 的机制
然后 Lifecycle 里面会根据状态，调用实际的实现层的 startInternal 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
@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 (engine != null) {
            synchronized (engine) {
                engine.start();
            }
        }

        synchronized (executors) {
            for (Executor executor: executors) {
                executor.start();
            }
        }

        mapperListener.start();

        // Start our defined Connectors second
        synchronized (connectorsLock) {
            for (Connector connector: connectors) {
                // If it has already failed, don't try and start it
                if (connector.getState() != LifecycleState.FAILED) {
                    connector.start();
                }
            }
        }
    }

这里会先设置状态，这个状态也有点东西，可以后面再讲，因为里面有个状态事件的触发
然后是启动 Engine，也就是 container，在这里就是 StandardEngine，先不深入去讲里面做了啥，后面讲 StandardEngine 的启动过程会讲，然后是启动线程池了，对于 StandardService 是没有线程池要启动的，或者是 springboot 集成的这个 Tomcat 中不需要，接着就是 mapperListener 的启动，这里其实是给 container 这种添加 listener，用来监听事件，做处理
然后就是启动 connector，connector 的启动就是之前说的，里面会启动 protocolHandler，这里还是一样的通过 Lifecycle 的接口，再通过 Lifecycle 的模板方法调用实际的 connector 实现 startInternal 方法，这也是 Tomcat 的一大特点，关于 Tomcat 也是个很大的课题，后面可能还会调整下组织结构，对新同学更友好一点。
值得注意的还有两个
第一个是添加 connector，先是锁一下，设置 connector 的 Service，然后 connectors 是个数组，这里进行了重新申请一个数组，然后进行拷贝，再把新添加的放到数组最后，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Override
public void addConnector(Connector connector) {

    synchronized (connectorsLock) {
        connector.setService(this);
        Connector results[] = new Connector[connectors.length + 1];
        System.arraycopy(connectors, 0, results, 0, connectors.length);
        results[connectors.length] = connector;
        connectors = results;
    }

    try {
        if (getState().isAvailable()) {
            connector.start();
        }
    } catch (LifecycleException e) {
        throw new IllegalArgumentException(
                sm.getString("standardService.connector.startFailed", connector), e);
    }

    // Report this property change to interested listeners
    support.firePropertyChange("connector", null, connector);
}

然后是判断当前的状态是否可用，如果可用就启动 connector, 最后触发下 connector 的变更事件
还有一个是设置Engine，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

@Override
public void setContainer(Engine engine) {
    Engine oldEngine = this.engine;
    if (oldEngine != null) {
        oldEngine.setService(null);
    }
    this.engine = engine;
    if (this.engine != null) {
        this.engine.setService(this);
    }
    if (getState().isAvailable()) {
        if (this.engine != null) {
            try {
                this.engine.start();
            } catch (LifecycleException e) {
                log.error(sm.getString("standardService.engine.startFailed"), e);
            }
        }
        // Restart MapperListener to pick up new engine.
        try {
            mapperListener.stop();
        } catch (LifecycleException e) {
            log.error(sm.getString("standardService.mapperListener.stopFailed"), e);
        }
        try {
            mapperListener.start();
        } catch (LifecycleException e) {
            log.error(sm.getString("standardService.mapperListener.startFailed"), e);
        }
        if (oldEngine != null) {
            try {
                oldEngine.stop();
            } catch (LifecycleException e) {
                log.error(sm.getString("standardService.engine.stopFailed"), e);
            }
        }
    }

    // Report this property change to interested listeners
    support.firePropertyChange("container", oldEngine, this.engine);
}

前面两步是把第一个的 engine 的 service 设置为 null，然后第二个 engine 也就是新的这个的 service 设置成当前的 service，然后也是判断状态，启动 engine，接着是重启 mapperListener，先关闭再启动，最后是关闭老的 engine，最后的最后就是触发 container 变更事件。