Spring启动流程（十二）——完成刷新

protected void finishRefresh() {
    // 为上下文初始化生命周期处理器
    initLifecycleProcessor();

    // 将刷新事件传播到生命周期处理器
    getLifecycleProcessor().onRefresh();

    // 发布刷新完毕事件到对应的监听器
    publishEvent(new ContextRefreshedEvent(this));

    // 注册Mbean
    LiveBeansView.registerApplicationContext(this);
}

Spring使用BeanPostProcessor来处理可以找到的任何接口实现并调用具体的方法。如果需要自定义功能或其他生命周期行为，Spring并不提供现成的功能，需要自己实现BeanPostProcessor。
除了初始化和销毁回调外，Bean对象还可以实现Lifecycle接口，以便这些Bean可以在容器自身的生命周期驱动下进行start和stop过程。Lifecycle接口为具有生命周期要求的对象定义了基本方法。
当ApplicationContext接收到开始和停止信号时，它会调用那些关联到在该上下文中的所有Lifecycle实现类（如：启动和停止某些后台进程）。

解码解读

org.springframework.context.support.AbstractApplicationContext

// 初始化生命周期处理器
protected void initLifecycleProcessor() {
    // 获取BeanFactory
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    // 判断BeanFactory中是否已经定义过lifecycleProcessor
    if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
        // 如果定义过lifecycleProcessor，则使用beanFactory中的定义给lifecycleProcessor赋值
        this.lifecycleProcessor =
            beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
        if (logger.isDebugEnabled()) {
            // 日志打印
        }
    }
    else {
        // 如果BeanFactory中没有定义lifecycleProcessor，则构造一个DefaultLifecycleProcessor
        DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
        // 设置defaultProcessor的BeanFactory
        defaultProcessor.setBeanFactory(beanFactory);
        this.lifecycleProcessor = defaultProcessor;
        // 将defaultProcessor以单例的形式注册到BeanFactory的生命周期管理器
        beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
        if (logger.isDebugEnabled()) {
            logger.debug("Unable to locate LifecycleProcessor with name '" +
                         LIFECYCLE_PROCESSOR_BEAN_NAME +
                         "': using default [" + this.lifecycleProcessor + "]");
        }
    }
}

org.springframework.context.support.DefaultLifecycleProcessor

private void startBeans(boolean autoStartupOnly) {
    // 获取所有的Lifecycle接口实现类
    Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
    // 按phase进行分组存储
    Map<Integer, LifecycleGroup> phases = new HashMap<Integer, LifecycleGroup>();
    for (Map.Entry<String, ? extends Lifecycle> entry : lifecycleBeans.entrySet()) {
        Lifecycle bean = entry.getValue();
        // 如果参数autoStartupOnly不等于true，或者bean是SmartLifecycle实现类并且autoStartup=true
        // autoStartupOnly=true  代表本次刷新为自动启动，触发所有自动启动的SmartLifecycle实现类
        // autoStartupOnly=false 代表本次刷新为显式调用，触发所有的Lifecycle实现类启动
        if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
            // 获取Lifecycle Bean的phase，phase默认为0
            int phase = getPhase(bean);
            // 根据phase获取对应的分组
            LifecycleGroup group = phases.get(phase);
            if (group == null) {
                // 如果没有分组，则新建一个分组
                group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
                // 把phase和对应的group放入到集合
                phases.put(phase, group);
            }
            // 把对应的Lifecycle Bean放到对应的分组中
            group.add(entry.getKey(), bean);
        }
    }
    // 遍历分组后的集合
    if (!phases.isEmpty()) {
        List<Integer> keys = new ArrayList<Integer>(phases.keySet());
        // 根据分组phase进行排序
        Collections.sort(keys);
        for (Integer key : keys) {
            // 根据分组顺序依次启动Lifecycle Bean
            phases.get(key).start();
        }
    }
}

// 遍历集合成员，执行Lifecycle实现类的start()函数回调
public void start() {
    if (this.members.isEmpty()) {
        return;
    }
    if (logger.isInfoEnabled()) {
        logger.info("Starting beans in phase " + this.phase);
    }
    // 对分组内的member进行排序
    Collections.sort(this.members);
    for (LifecycleGroupMember member : this.members) {
        if (this.lifecycleBeans.containsKey(member.name)) {
            // 启动Lifecycle Bean
            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) {
        // 根据beanName获取相应的依赖Bean
        String[] dependenciesForBean = this.beanFactory.getDependenciesForBean(beanName);
        // 遍历依赖Bean
        for (String dependency : dependenciesForBean) {
            // 递归。先回调依赖Bean的start函数（如果依赖Bean是Lifecycle实现类）
            doStart(lifecycleBeans, dependency, autoStartupOnly);
        }

        if (!bean.isRunning() &&
            (!autoStartupOnly || !(bean instanceof SmartLifecycle) || ((SmartLifecycle) bean).isAutoStartup())) {
            if (logger.isDebugEnabled()) {
                // 打印日志
            }
            try {
                // 执行Lifecycle实现类的start()函数回调
                bean.start();
            }
            catch (Throwable ex) {
                throw new ApplicationContextException("Failed to start bean '" + beanName + "'", ex);
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Successfully started bean '" + beanName + "'");
            }
        }
    }
}