聊一下 Spring 的 SmartLifecycle 使用

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

最近在学习过程中碰到一个比较有意思的Spring特性，就是 SmartLifecycle ，这个可以很轻松的融合进 Spring 生命周期

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public interface SmartLifecycle extends Lifecycle, Phased {
    int DEFAULT_PHASE = Integer.MAX_VALUE;

    default boolean isAutoStartup() {
        return true;
    }

    default void stop(Runnable callback) {
        this.stop();
        callback.run();
    }

    default int getPhase() {
        return Integer.MAX_VALUE;
    }
}

接口继承了 org.springframework.context.Lifecycle 跟 org.springframework.context.Phased
其中默认实现了 isAutoStartup , 并且默认是返回 true，所以相对于 Lifecycle 能更智能些自动启动
然后 Lifecycle 这个接口就比较简单，只有几个接口

1
2
3
4
5
6
7
public interface Lifecycle {
    void start();

    void stop();

    boolean isRunning();
}

我们可以是实现下这个接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Component
public class MySmartLifecycle implements SmartLifecycle {

    private volatile boolean isRunning;

    @Override
    public void start() {
        System.out.println("my smart life cycle start");
        isRunning = true;
    }

    @Override
    public void stop() {
        System.out.println("my smart life cycle end");
        isRunning = false;
    }

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

这个 bean 会在 Spring 启动后被自动调用 start 方法

这个就是在不深入 bean 的生命周期，并且是在 bean 已经都初始化以后调用
同样会在 spring 容器关闭时调用 stop 方法

如果有此类的需求就可以扩展此接口实现
而这个其实是在 spring 生命周期中的 finishRefresh 方法中进行调用

1
2
3
4
5
6
7
8
9
10
protected void finishRefresh() {
    this.clearResourceCaches();
    this.initLifecycleProcessor();
    this.getLifecycleProcessor().onRefresh();
    this.publishEvent((ApplicationEvent)(new ContextRefreshedEvent(this)));
    if (!NativeDetector.inNativeImage()) {
        LiveBeansView.registerApplicationContext(this);
    }

}

调用了 LifecycleProcessor 的 onRefresh 方法

1
2
3
4
public void onRefresh() {
    this.startBeans(true);
    this.running = true;
}

这其中就会调用 start 方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
private void startBeans(boolean autoStartupOnly) {
    // 获取这些bean
    Map<String, Lifecycle> lifecycleBeans = this.getLifecycleBeans();
    Map<Integer, LifecycleGroup> phases = new TreeMap();
    lifecycleBeans.forEach((beanName, bean) -> {
        if (!autoStartupOnly || bean instanceof SmartLifecycle && ((SmartLifecycle)bean).isAutoStartup()) {
            int phase = this.getPhase(bean);
            ((LifecycleGroup)phases.computeIfAbsent(phase, (p) -> {
                return new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
            })).add(beanName, bean);
        }

    });
    if (!phases.isEmpty()) {
        phases.values().forEach(LifecycleGroup::start);
    }

}

会先判断 isAutoStartup，然后将不同周期加入分组，然后再循环调用start