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方法，用于结束生命周期之前的收尾业务逻辑处理；并且可以设置是否在容器刷新时自动开启生命周期