1、實例

1.1、定義一個Service接口

public interface Service {

    void init(Configuration config);
    void start();
    void stop();
}

1.2、定義一個AbstractService抽象類

public abstract class AbstractService implements Service {

    private volatile Configuration config;

    @Override
    public void init(Configuration conf) {
        serviceInit(config);
    }

    @Override
    public void start() {
        serviceStart();
    }

    @Override
    public void stop() {
        serviceStop();
    }

    protected void serviceInit(Configuration conf) {
        if (conf != config) {
            setConfig(conf);
        }
    }

    protected void serviceStart() {

    }

    protected void serviceStop() {

    }

    protected void setConfig(Configuration conf) {
        this.config = conf;
    }
}

1.3、定義一個CompositeService組合Service

public class CompositeService extends AbstractService{

    private final List<Service> serviceList = new ArrayList<>();


    protected void serviceInit(Configuration conf) {
        List<Service> services = getServices();

        for (Service service : services) {
            service.init(conf);
        }
        super.serviceInit(conf);
    }

    protected void serviceStart() {
        List<Service> services = getServices();

        for (Service service : services) {
            service.start();
        }
        super.serviceStart();
    }

    protected void serviceStop() {
        super.serviceStop();
    }


    protected boolean addIfService(Object object) {
        if (object instanceof Service) {
            addService((Service) object);
            return true;
        } else {
            return false;
        }
    }

    public List<Service> getServices() {
        synchronized (serviceList) {
            return new ArrayList<Service>(serviceList);
        }
    }

    protected void addService(Service service) {
        synchronized (serviceList) {
            serviceList.add(service);
        }
    }
}

1.4、定義一個AsyncDispatcher組件

public class AsyncDispatcher extends AbstractService  {

    @Override
    protected void serviceInit(Configuration conf) {
        super.serviceInit(conf);
        System.out.println("AsyncDispatcher init...");
    }

    @Override
    protected void serviceStart() {
        super.serviceStart();
        System.out.println("AsyncDispatcher start...");
    }

    protected void dispatch(String event) {
        // 業務邏輯
    }
}

1.5、定義一個ResourceManager組件

public class ResourceManager extends CompositeService {

    public static void main(String[] args) {

        Configuration conf = new Configuration();

        ResourceManager resourceManager =  new ResourceManager();
        resourceManager.init(conf);
        resourceManager.start();
    }


    @Override
    protected void serviceInit(Configuration conf) {
        System.out.println("ResourceManager服務初始化...");

        AsyncDispatcher dispatcher = new AsyncDispatcher();
        addIfService(dispatcher);

        super.serviceInit(conf);
    }

    @Override
    protected void serviceStart() {
        System.out.println("ResourceManager服務啓動...");
        super.serviceStart();
    }
}

1.6、運行結果如下 :

ResourceManager服務初始化...
AsyncDispatcher init...
ResourceManager服務啓動...
AsyncDispatcher start...

2、圖示

3、總結

兩個方向來説，就是説組件是一個普通的服務組件，還是組合服務組件。如果是普通的服務組件，比如説
AsyncDispatcher就是一個普通的服務組件，它繼承了AbstractService，那其實就是直接重新自己的serviceInit和serviceStart方法即可，然後調用它的init和start方法就可以完成初始化和啓動
當時針對ResourceManager這種組件，它裏面是有其他子組件的，比如説AsyncDispatcher、RMApplicationHistoryWriter(當然，這個組件又是一個組件Service組件，那就説明它裏面還有子service)。這種情況下其實就是在調用init、start的時候當然會調用本類重寫的serviceInit或serviceStart方法，但是記住，本類重寫的serviceInit還會調用super.serviceInit或super.serviceStart方法，這就走到CompositeService中對應的serviceInit、serviceStart。從而調用子組件的init、start方法