Tomcat源码解析(三)：service服务组件

前面详细解析了Server服务器组件的主要功能机制，其主要管理Service服务的生命周期，StandardServer的初始化方法实际调用每个Service的初始化方法，而StandardServer的启动方法实际调用每个Service服务的启动方法。

Service接口的默认实现类是StandardService，StandardService由StandardServer管理，而StandardService主要管理当前Service服务的连接器(Connector)组件和容器(Container)组件，包括子组件的初始化、启动以及关闭等功能。Service引入主要为了向外提供统一的服务，并且方便管理连接器和容器，一个Service可以有多个连接器，连接不同协议请求，但是只能有一个容器。

Service接口的主要方法围绕其子组件展开，包含连接器和容器的管理

public interface Service {
    // 当前Sevice管理的容器
    public Container getContainer();
    // 设置当前Service的容器
    public void setContainer(Container container);

    // Service的name属性
    public String getName();
    public void setName(String name);

    // Service所属Server
    public Server getServer();
    public void setServer(Server server);

	// 添加Connector    
    public void addConnector(Connector connector);

    // 初始化方法
    public void initialize() throws LifecycleException;
}

Service的默认实现类是StandardService，其继承关系如下：

StandardService主要功能：

1、统一管理多个Connector连接器，包括启动、关闭等操作

2、管理Container容器的启动、关闭等操作

查看StandardService的主要属性如下

    // 所属Server
    private Server server = null;
    // 连接器组件
    private Connector connectors[] = new Connector[0];
    // 容器组件
    private Container container = null;

    // 是否初始化、启动
    private boolean initialized = false;
    private boolean started = false;

    // 生命周期管理工具
    private LifecycleSupport lifecycle = new LifecycleSupport(this);

StandService将所有连接器存储在数组中，同时也握有Container容器和Server的引用，接下来看下其对连接器和容器的更新操作

setContainer()方法，更新Service的容器

public void setContainer(Container container) {
	// 将原container握有的Service引用置空
    Container oldContainer = this.container;
    if ((oldContainer != null) && (oldContainer instanceof Engine))
        ((Engine) oldContainer).setService(null);
   	// 更新container    
    this.container = container;
    if ((this.container != null) && (this.container instanceof Engine))
        ((Engine) this.container).setService(this);
    // 如果原容器已经启动，则启动新容器    
    if (started && (this.container != null) &&
        (this.container instanceof Lifecycle)) {
        ((Lifecycle) this.container).start();
    }
    // 更新连接器对容器的引用操作
    synchronized (connectors) {
        for (int i = 0; i < connectors.length; i++)
            connectors[i].setContainer(this.container);
    }
    // 如果原容器已经启动，则关闭
    if (started && (oldContainer != null) &&
        (oldContainer instanceof Lifecycle)) {
        ((Lifecycle) oldContainer).stop();
    }
}

addConnector()方法，新增连接器操作

public void addConnector(Connector connector) {
    synchronized (connectors) {
    	// 更新Connector属性
        connector.setContainer(this.container);
        connector.setService(this);
        // 先复制connectors，对新数组增加新Connector，再同步回connectors
        // 类似CopyOnWriterArrayList
        Connector results[] = new Connector[connectors.length + 1];
        System.arraycopy(connectors, 0, results, 0, connectors.length);
        results[connectors.length] = connector;
        connectors = results;
        // 如果已经初始化或者已经启动，则同样初始化或启动新增Connector
        if (initialized) {
            connector.initialize();
        }
        if (started && (connector instanceof Lifecycle)) {
            ((Lifecycle) connector).start();
        }
    }
}

接下来查看其生命周期相关方法

initialize()方法，Server服务器执行initialize()方法时，依次调用Service的initialize()方法

public void initialize() throws LifecycleException {
    if (initialized)
        throw new LifecycleException (
            sm.getString("standardService.initialize.initialized"));
    initialized = true;

    // 初始化所有连接器Connectors
    synchronized (connectors) {
        for (int i = 0; i < connectors.length; i++) {
            connectors[i].initialize();
        }
    }
}

start()方法，同样也是Server服务器依次调用每个Service服务的启动方法start()，此处首先启动容器，之后启动连接器，防止连接器先启动，出现连接器工作了但是服务器不能提供服务。

public void start() throws LifecycleException {

    // 防止重复启动
    if (started) {
        throw new LifecycleException
            (sm.getString("standardService.start.started"));
    }

    // 触发相关事件，通知监听器
    lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);
    lifecycle.fireLifecycleEvent(START_EVENT, null);
    // 更新started属性
    started = true;

    // 首先启动容器Container
    if (container != null) {
        synchronized (container) {
            if (container instanceof Lifecycle) {
                ((Lifecycle) container).start();
            }
        }
    }

    // 其次启动所有连接器Connector
    synchronized (connectors) {
        for (int i = 0; i < connectors.length; i++) {
            if (connectors[i] instanceof Lifecycle)
                ((Lifecycle) connectors[i]).start();
        }
    }

    // 触发相关事件，通知监听器
    lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);
}

stop()方法，相反操作，触发相关事件通知监听器，同时先关闭连接器，其次管理容器。

Service本身功能也相对简单，主要对子组件连接器和容器的启动和关闭进行统一管理。