Spring IOC 初始化刷新流程十二：finishRefresh()

Spring IOC 初始化刷新流程：https://www.cnblogs.com/jhxxb/p/13609289.html

方法源码

public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {
    protected void finishRefresh() {
        // Clear context-level resource caches (such as ASM metadata from scanning).
        // 这个是 Spring5.0 之后才有的方法
        // 表示清除一些 resourceCaches,如 doc 说，清楚 context 级别的资源缓存，比如 ASM 的元数据
        clearResourceCaches();

        // Initialize lifecycle processor for this context.
        // 初始化所有的 LifecycleProcessor
        // 在 Spring 中还提供了 Lifecycle 接口， Lifecycle 中包含 start/stop 方法，实现此接口后 Spring 会保证在启动的时候调用其 start 方法开始生命周期，
        // 并在 Spring 关闭的时候调用 stop 方法来结束生命周期，通常用来配置后台程序，在启动后一直运行（如对 MQ 进行轮询等）。ApplicationContext 的初始化最后正是保证了这一功能的实现。
        initLifecycleProcessor();

        // Propagate refresh to lifecycle processor first.
        // 上面注册好的处理器，这里就拿出来，调用它的 onRefresh 方法
        getLifecycleProcessor().onRefresh();

        // Publish the final event.
        // 发布容器刷新的事件
        publishEvent(new ContextRefreshedEvent(this));

        // Participate in LiveBeansView MBean, if active.
        // 和 MBeanServer 和 MBean 有关的。相当于把当前容器上下文，注册到 MBeanServer 里面去。
        // 这样子，MBeanServer 持有了容器的引用，就可以拿到容器的所有内容了，也就让 Spring 支持到了 MBean 的相关功能
        LiveBeansView.registerApplicationContext(this);
    }

    protected void initLifecycleProcessor() {
        // 当 ApplicationContext 启动或停止时，它会通过 LifecycleProcessor 来与所有声明的 Bean 的周期做状态更新，而在 LifecycleProcessor 的使用前首先需要初始化。
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) { // 如果工厂里已经存在 LifecycleProcessor，那就拿出来，把值放上去 this.lifecycleProcessor
            this.lifecycleProcessor = beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
            if (logger.isTraceEnabled()) {
                logger.trace("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
            }
        }
        else { // 一般情况下，都会注册上这个默认的处理器 DefaultLifecycleProcessor
            DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
            defaultProcessor.setBeanFactory(beanFactory);
            this.lifecycleProcessor = defaultProcessor;
            // 直接注册成单例 Bean 进去容器里
            beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
            if (logger.isTraceEnabled()) {
                logger.trace("No '" + LIFECYCLE_PROCESSOR_BEAN_NAME + "' bean, using " + "[" + this.lifecycleProcessor.getClass().getSimpleName() + "]");
            }
        }
    }

Spring 中的 Lifecycle 接口

public interface Lifecycle {
    void start();
    void stop();
    boolean isRunning();
}

public interface SmartLifecycle extends org.springframework.context.Lifecycle, org.springframework.context.Phased {
    int DEFAULT_PHASE = Integer.MAX_VALUE;

    // 是否伴随这容器的启动而启动
    // true：表示容器 refreshed 它就会启动了
    // false：必须显示的执行它的 start() 才行
    default boolean isAutoStartup() {
        return true;
    }

    // 相比于 Lifecycle 的 stop，增加了回调函数
    default void stop(Runnable callback) {
        stop();
        callback.run();
    }

    @Override
    default int getPhase() {
        return DEFAULT_PHASE;
    }
}

public interface LifecycleProcessor extends Lifecycle {
    void onRefresh();
    void onClose();
}

public interface Phased {
    // 权重值
    int getPhase();
}

getLifecycleProcessor().onRefresh()

stopBeans 基本同 startBeans，只是顺序是倒序的

public class DefaultLifecycleProcessor implements LifecycleProcessor, BeanFactoryAware {
    /**
     * 只有这个方法才是容器启动时候自动会调用的，其余都不是
     * 它默认只会执行实现了 SmartLifecycle 接口并且 isAutoStartup = true 的 Bean 的 start 方法
     */
    @Override
    public void onRefresh() {
        startBeans(true);
        this.running = true;
    }

    /**
     * autoStartupOnly：是否仅支持自动启动
     * true：只支持伴随容器启动（Bean 必须实现了 SmartLifecycle 接口且 isAutoStartup 为 true 才行）
     * false：表示无所谓。都会执行 Bean 的 start 方法
     */
    private void startBeans(boolean autoStartupOnly) {
        // 拿到所有的实现了 Lifecycle/SmartLifecycle 的，已经在 IOC 容器里面的单例 Bean 们（备注：不包括自己 this，也就是说处理器自己不包含进去）
        // 这里若我们自己没有定义过实现 Lifecycle 的 Bean，这里就是空的
        Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
        // phases 这个 Map，表示按照 phase 值，把这个 Bean 进行分组，最后分组执行
        Map<Integer, LifecycleGroup> phases = new HashMap<>();
        lifecycleBeans.forEach((beanName, bean) -> {
            // 若 Bean 实现了 SmartLifecycle 接口并且标注是 AutoStartup，或者强制要求自动自行的（autoStartupOnly = true）
            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);
                }
                // 添加到 phase 值相同的组分组
                group.add(beanName, bean);
            }
        });
        if (!phases.isEmpty()) {
            List<Integer> keys = new ArrayList<>(phases.keySet());
            // 此处有个根据 key 从小到大的排序，然后一个个的调用它们的 start 方法
            Collections.sort(keys);
            for (Integer key : keys) {
                // 这里调用 LifecycleGroup#start()
                phases.get(key).start();
            }
        }
    }

    private class LifecycleGroup {
        public void start() {
            if (this.members.isEmpty()) {
                return;
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Starting beans in phase " + this.phase);
            }
            // 按照权重值进行排序，若没有实现 Smart 接口的，权重值都为 0
            Collections.sort(this.members);
            for (LifecycleGroupMember member : this.members) {
                // 一次执行这些 Bean 的 start 方法
                doStart(this.lifecycleBeans, member.name, this.autoStartupOnly);
            }
        }
    }

    private void doStart(Map<String, ? extends Lifecycle> lifecycleBeans, String beanName, boolean autoStartupOnly) {
        Lifecycle bean = lifecycleBeans.remove(beanName);
        if (bean != null && bean != this) {
            // 控制 Bean 的依赖关系
            String[] dependenciesForBean = getBeanFactory().getDependenciesForBean(beanName);
            for (String dependency : dependenciesForBean) {
                doStart(lifecycleBeans, dependency, autoStartupOnly);
            }
            if (!bean.isRunning() && (!autoStartupOnly || !(bean instanceof SmartLifecycle) || ((SmartLifecycle) bean).isAutoStartup())) {
                if (logger.isTraceEnabled()) {
                    logger.trace("Starting bean '" + beanName + "' of type [" + bean.getClass().getName() + "]");
                }
                try {
                    // 执行 Bean 的 start 方法
                    bean.start();
                } catch (Throwable ex) {
                    throw new ApplicationContextException("Failed to start bean '" + beanName + "'", ex);
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Successfully started bean '" + beanName + "'");
                }
            }
        }
    }

    private class LifecycleGroupMember implements Comparable<LifecycleGroupMember> {
        private final String name;
        private final Lifecycle bean;

        LifecycleGroupMember(String name, Lifecycle bean) {
            this.name = name;
            this.bean = bean;
        }

        @Override
        public int compareTo(org.springframework.context.support.DefaultLifecycleProcessor.LifecycleGroupMember other) {
            int thisPhase = getPhase(this.bean);
            int otherPhase = getPhase(other.bean);
            return Integer.compare(thisPhase, otherPhase);
        }
    }

Lifecycle 这个接口并不能直接使用。因为 DefaultLifecycleProcessor 的 onRefresh 方法传值为 autoStartupOnly = true：表示只有实现了 SmartLifecycle 的 Bean 才会调用 start 方法，因为实现了 SmartLifecycle 接口会有一个 phase 值，根据上面源码会根据此值分组执行。

autoStartupOnly = false 则只要是 Lifecycle 的实现既可以被调用，我们会给其默认的 phase。

所以，我们要想要这个功能，要实现 SmartLifecycle，而不是 Lifecycle 接口

事件发布

// ApplicationContext 是有发布事件能力的
public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {
    @Override
    public void publishEvent(ApplicationEvent event) {
        publishEvent(event, null);
    }

    @Override
    public void publishEvent(Object event) {
        publishEvent(event, null);
    }

    protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
        Assert.notNull(event, "Event must not be null");

        // Decorate event as an ApplicationEvent if necessary
        ApplicationEvent applicationEvent;
        if (event instanceof ApplicationEvent) {
            applicationEvent = (ApplicationEvent) event;
        } else { // 最终会被包装成 ApplicationEvent 的事件类型，带有一个 Payload 而已
            applicationEvent = new PayloadApplicationEvent<>(this, event);
            if (eventType == null) {
                eventType = ((PayloadApplicationEvent<?>) applicationEvent).getResolvableType();
            }
        }

        // Multicast right now if possible - or lazily once the multicaster is initialized
        // 如果早期事件已经被初始化了，那就先放进早期事件里，否则 esle 那里，就直接发送事件了
        if (this.earlyApplicationEvents != null) {
            this.earlyApplicationEvents.add(applicationEvent);
        } else {
            // 拿到多播器，发送这个事件
            getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
        }

        // Publish event via parent context as well...
        if (this.parent != null) { // 这里注意：如果存在父容器，那父容器也会发送一个事件
            if (this.parent instanceof AbstractApplicationContext) {
                ((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
            } else {
                this.parent.publishEvent(event);
            }
        }
    }

// refresh() 中 initApplicationEventMulticaster() 添加进 IOC 的
public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {
    @Override
    public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
        ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
        Executor executor = getTaskExecutor();
        for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
            if (executor != null) {
                executor.execute(() -> invokeListener(listener, event));
            }
            else {
                invokeListener(listener, event);
            }
        }
    }