spring擴展接口解析2--生命周期LifeCycle接口

前言

Spring容器本身是有生命周期的，比如容器啟動則開始生命和容器關閉則結束生命，如果想讓Spring容器管理的bean也同樣有生命周期的話，比如數據庫連接對象，當容器啟動時，連接bean生命周期開啟，當容器關閉時，連接bean生命周期結束。

此時就可以用到Spring提供的一個擴展接口--Lifecycle接口

一、Lifecycle接口定義

Lifecycle接口一共定義了三個方法，分別如下：

public interface Lifecycle {

        /**
         * 生命周期開始
         */
        void start();

        /**
         * 生命周期結束
         */
        void stop();

        /**
         * 判斷當前bean是否是開始狀態
         */
        boolean isRunning();

    }

 

start()：表示開啟該對象的生命周期

stop()：表示結束該對象的生命周期

isRunning()：判斷當前對象的生命周期是否時開始狀態

從接口的方法上很好理解，主要是開始和結束當前對象的生命周期，以及判斷當前對象生命周期的狀態。

 

二、Lifecycle接口的擴展LifecycleProcessor接口

Spring中提供了Lifecycle接口的子接口 LifecycleProcessor，從字面意思上看是Lifecycle接口的處理器，LifecycleProcessor接口定義如下：

public interface LifecycleProcessor extends Lifecycle {

    /**
     * 刷新容器,自動開始生命周期
     */
    void onRefresh();

    /**
     * 關閉容器,自動結束生命周期
     */
    void onClose();

}

 

三、Spring容器的生命周期

Spring容器是有生命周期的，因為Spring容器抽象類AbstractApplicationContext實現了Lifecycle接口，實現代碼如下：

LifecycleProcessor getLifecycleProcessor() throws IllegalStateException {
        if (this.lifecycleProcessor == null) {
            throw new IllegalStateException("LifecycleProcessor not initialized - " +
                    "call 'refresh' before invoking lifecycle methods via the context: " + this);
        }
        return this.lifecycleProcessor;
    }

 

@Override
    public void start() {
        getLifecycleProcessor().start();
        publishEvent(new ContextStartedEvent(this));
    }

    @Override
    public void stop() {
        getLifecycleProcessor().stop();
        publishEvent(new ContextStoppedEvent(this));
    }

    @Override
    public boolean isRunning() {
        return (this.lifecycleProcessor != null && this.lifecycleProcessor.isRunning());
    }

 

從源碼看出，AbstractApplicationContext的start和stop方法完全委托給了內部的LifecycleProcessor來執行的。而LifecycleProcessor的初始化是在AbstractactApplicationContext初始化時進行的

AbstractApplicationContext初始化時，當容器全部初始化完畢之后會執行finishRefresh方法表示整個容器刷新完成了，執行邏輯如下：

protected void finishRefresh() {
        // Clear context-level resource caches (such as ASM metadata from scanning).
        clearResourceCaches();

        //初始化LifecycleProcessor對象
        initLifecycleProcessor();

        //調用LifecycleProcessor對象的onRefresh()方法
        getLifecycleProcessor().onRefresh();

        // Publish the final event.
        publishEvent(new ContextRefreshedEvent(this));

        // Participate in LiveBeansView MBean, if active.
        LiveBeansView.registerApplicationContext(this);
    }

 

在finishRefresh方法中首先是初始化了內部的LifecycleProcessor對象，然后調用了該對象的onRefresh()方法，而初始化LifecycleProcessor方法的邏輯也不復雜，首先是從BeanFactory中找到自定義的LifecycleProcessor，如果沒有用戶自定義的，則創建一個默認的LifecycleProcessor實現類DefaultLifecycleProcessor對象，源碼如下：

protected void initLifecycleProcessor() {
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
/** 如果BeanFactory中有自定義的LifecycleProcessor的bean,則直接用自定義的*/
        if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
            this.lifecycleProcessor = beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
            if (logger.isTraceEnabled()) {
                logger.trace("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
            }
        }
        else {
/** 如果沒有自定義，則創建默認的實現類DefaultLifecycleProcesor*/
            DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
14             defaultProcessor.setBeanFactory(beanFactory);
15             this.lifecycleProcessor = defaultProcessor;
            beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
            if (logger.isTraceEnabled()) {
                logger.trace("No '" + LIFECYCLE_PROCESSOR_BEAN_NAME + "' bean, using " +
                        "[" + this.lifecycleProcessor.getClass().getSimpleName() + "]");
            }
        }
    }

 

接下來在分析下默認的LifecycleProcessor的處理邏輯，實現了LifecycleProcessor接口的實現源碼如下：

       /**
    * 執行startBeans(false)方法開啟所有實現了Lifecycle接口的bean的生命周期
     */
    @Override
    public void start() {
        startBeans(false);
        this.running = true;
    }

    /**
     * 執行stopBeans()方法關閉所有實現了Lifecycle接口的bean的生命周期
     */
    @Override
    public void stop() {
 stopBeans();
        this.running = false;
    }

    @Override
    public void onRefresh() {
        startBeans(true);
        this.running = true;
    }

    @Override
    public void onClose() {
        stopBeans();
        this.running = false;
    }

    @Override
    public boolean isRunning() {
        return this.running;
    }

 

可以看出實現邏輯也不復雜，start()方法和onRefresh()方法分別都是執行了startBeans方法；stop方法和onClose方法都是執行了stopBeans方法，並且內部有一個running屬性用於表示當前的生命周期狀態。

所以核心邏輯都是在startBeans和stopBeans兩個方法中。

startBeans源碼解析：

/** 開始bean的生命周期
     * @param autoStartupOnly:自動開啟還是手動開啟
     * */
    private void startBeans(boolean autoStartupOnly) {
        /**
         * 1.調用getLifecycleBeans方法獲取所有實現了Lifecycle接口的bean
         *  實現邏輯就是調用BeanFactory的getBeanNamesForType(LifeCycle.class)方法來獲取所有bean
         * */
        Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
        Map<Integer, LifecycleGroup> phases = new HashMap<>();
        /**
         * 2.遍歷所有Lifecycle的bean,按不同階段進行分組,同組的封裝為LifecycleGroup對象
         * */
        lifecycleBeans.forEach((beanName, bean) -> {
            if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
                int phase = getPhase(bean);
                LifecycleGroup group = phases.get(phase);
                if (group == null) {
                    group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
                    phases.put(phase, group);
                }
                group.add(beanName, bean);
            }
        });
        /**
         * 3.遍歷所有LifecycleGroup,調用LifecycleGroup的start方法
         * */
        if (!phases.isEmpty()) {
            List<Integer> keys = new ArrayList<>(phases.keySet());
            Collections.sort(keys);
            for (Integer key : keys) {
                phases.get(key).start();
            }
        }
    }

 

主要分成以下三步：

第一步：從BeanFactory中獲取所有實現了Lifecycle接口的bean

第二步：遍歷所有實現了Lifecycle接口的bean，按不同階段進行分組，同一組的bean封裝成LifecycleGroup對象

第三步：遍歷所有組，調用LifecycleGroup對象的start方法

LifecycleGroup對象的start方法源碼如下：

public void start() {
            if (this.members.isEmpty()) {
                return;
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Starting beans in phase " + this.phase);
            }
/** 將Lifecycle對象進行排序*/
            Collections.sort(this.members);
/** 遍歷調用doStart方法開啟Lifecycle對象的生命周期*/
            for (LifecycleGroupMember member : this.members) {
                doStart(this.lifecycleBeans, member.name, this.autoStartupOnly);
            }
        }

 

private void doStart(Map<String, ? extends Lifecycle> lifecycleBeans, String beanName, boolean autoStartupOnly) {
        /**
         * 1.根據beanName從集合中獲取Lifecycle對象並移除
         * */
        Lifecycle bean = lifecycleBeans.remove(beanName);
        if (bean != null && bean != this) {
            /**
             * 2.如果有依賴,則先開啟依賴bean的生命周期
             * */
            String[] dependenciesForBean = getBeanFactory().getDependenciesForBean(beanName);
            for (String dependency : dependenciesForBean) {
                doStart(lifecycleBeans, dependency, autoStartupOnly);
            }
            if (!bean.isRunning() &&
                    (!autoStartupOnly || !(bean instanceof SmartLifecycle) || ((SmartLifecycle) bean).isAutoStartup())) {
                try {
                    /**
                     * 3.調用Lifecycle對象的start方法開啟生命周期
                     * */
                    bean.start();
                }
                catch (Throwable ex) {
                    throw new ApplicationContextException("Failed to start bean '" + beanName + "'", ex);
                }
            }
        }
    }

 

總結：

startBeans整體邏輯如下：

1、從BeanFactory中獲取所有實現了Lifecycle接口的bean

2、將所有Lifecycle按階段進行分組

3、遍歷所有階段的組，遍歷每個組內的所有Lifecycle對象，如果Lifecycle對象有依賴bean就先開啟依賴bean的生命周期，然后直接執行Lifecycle對象的start方法

 

同理，stopBeans的整體邏輯和startBeans完全一樣，只不過一個是執行LifeCycle的start方法一個是執行LifeCycle的stop方法。

四、Lifecycle接口的擴展SmartLifecycle接口

SmartLifecycle接口繼承之Lifecycle接口和Phased接口，源碼如下：

public interface SmartLifecycle extends Lifecycle, Phased {

    /**
     * 默認優先級,Integer的最大值
     */
    int DEFAULT_PHASE = Integer.MAX_VALUE;


    /**
     * 是否自動啟動,默認為true
     */
    default boolean isAutoStartup() {
        return true;
    }

    /**
     * 默認直接執行stop方法,並執行回調方法
     */
    default void stop(Runnable callback) {
        stop();
        callback.run();
    }

    /**
     * 獲取優先級,啟動時值越小越先啟動；停止時值越小越后停止
     */
    @Override
    default int getPhase() {
        return DEFAULT_PHASE;
    }

}

 

SmartLifecycle接口有一個優先級，如果沒有實現SmartLifecycle接口的其他的Lifecycle的優先級為0，啟動的時候按phase的值從小到大執行；關閉的時候按phase的值從大到小執行。

isAutoStartup()方法表示Spring容器刷新的時候自動執行start()方法，返回true表示會；返回false則不會,那么就需要手動調用start方法才可以執行。

Spring容器初始化完成之后，會調用LifecycleProcessor的onRefresh方法刷新整個上下文，但是此時的AbstractApplicationContext實際上還並沒有執行start方法，但是如果有bean需要在Spring容器刷新的時候就調用start方法，那么就可以使用SmartLifecycle，

當SmartLifecycle接口的isAutoStartup方法返回true時表示只要Spring容器刷新了就會調用該bean的start方法，否則必須要等到Spring容器執行了start方法之后才會執行SmartLifecycle對象的start方法。

測試案例如下：

定義兩個bean,一個設置isAutoStartup為true,一個為false

public class AutoBean implements SmartLifecycle {

    boolean running;

    public boolean isAutoStartup() {
        return true;
    }

    @Override
    public void start() {
        System.out.println("AutoBean 執行start方法");
        running = true;
    }

    @Override
    public void stop() {
        System.out.println("AutoBean 執行stop方法");
        running = false;
    }

    @Override
    public boolean isRunning() {
        return running;
    }
}

public class NoAutoBean implements SmartLifecycle {

    boolean running;

    public boolean isAutoStartup() {
        return false;
    }

    @Override
    public void start() {
        System.out.println("NoAutoBean 執行start方法");
        running = true;
    }

    @Override
    public void stop() {
        System.out.println("NoAutoBean 執行stop方法");
        running = false;
    }

    @Override
    public boolean isRunning() {
        return running;
    }
}

 

測試代碼如下：

 public static void main(String[] args) throws Exception {
        System.out.println("---->初始化Spring容器");
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        System.out.println("---->啟動Spring容器");
        context.start();
        System.out.println("---->關閉Spring容器");
        context.stop();
    }

 

測試代碼中，先初始化Spring容器，然后啟動Spring容器，最后在關閉Spring容器，測試結果如下：

---->初始化Spring容器
AutoBean 執行start方法
---->啟動Spring容器
NoAutoBean 執行start方法
---->關閉Spring容器
AutoBean 執行stop方法
NoAutoBean 執行stop方法

 從結果可以看出，當SmartLifecycle的isAutoStartup為true時，只要Spring容器刷新了就會自動執行start方法，而isAutoStartup為false時，只有當容器執行了start方法之后才會執行start方法

所以如果想要Lifecycle對象隨着Spring容器初始化之后就開啟，就可以采用實現SmartLifecycle接口的方式。

五、總結

1、Lifecycle接口用於實現bean的生命周期，執行start方法開啟生命周期；執行stop方法結束生命周期

2、ApplicationContext通過LifecycleProcessor來管理所有bean的生命周期，當Spring容器啟動或者刷新時，都會調用容器中所有實現了Lifecycle接口的bean的start方法，關閉時調用所有實現了Lifecycle接口的bean的stop方法

3、SmartLifecycle可以實現異步回調執行stop方法，用於結束生命周期之前的收尾業務邏輯處理；並且可以設置是否在容器刷新時自動開啟生命周期