容器初始化總體流程

九

• 初始化conversion service
• 對(duì)LoadTimeWeaverAware接口bean進(jìn)行實(shí)例化，依賴(lài)注入等初始化
• 凍結(jié)配置，beanDefinition不可再修改
• 預(yù)實(shí)例化非lazy-init配置的單例bean

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // Initialize conversion service for this context.
    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
            beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
        beanFactory.setConversionService(
                beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    }

    // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    for (String weaverAwareName : weaverAwareNames) {
        getBean(weaverAwareName);
    }

    // Stop using the temporary ClassLoader for type matching.
    beanFactory.setTempClassLoader(null);

    // Allow for caching all bean definition metadata, not expecting further changes.
    beanFactory.freezeConfiguration();

    // Instantiate all remaining (non-lazy-init) singletons.
    beanFactory.preInstantiateSingletons();
}

9.1 非lazy-init

• 1 遍歷beanDefinitionNames數(shù)組，
• 2 獲取name對(duì)應(yīng)的beanDefinition，對(duì)于單例bean，沒(méi)abstract，且為這是lazy-init屬性的，則進(jìn)行初始化.
• 3 對(duì)于工廠bean，&＋bean name表示工廠bean本身，根據(jù)名字獲取對(duì)應(yīng)beanDefinition， getBean()初始化bean實(shí)例，依賴(lài)注入
• 4 非工廠bean， getBean()初始化bean實(shí)例，依賴(lài)注入
• 5 遍歷name，獲取單例bean對(duì)象中SmartInitializingSingleton接口類(lèi)型的對(duì)象。
• 6 調(diào)用接口方法，在所有單例bean實(shí)例化完成后，進(jìn)行一些后置處理

public void preInstantiateSingletons() throws BeansException {
    if (this.logger.isDebugEnabled()) {
        this.logger.debug("Pre-instantiating singletons in " + this);
    }

    List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);

    // Trigger initialization of all non-lazy singleton beans...
    for (String beanName : beanNames) {//1
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);//2
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {//2
            if (isFactoryBean(beanName)) {//3
                final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
                boolean isEagerInit;
                if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                    isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
                        @Override
                        public Boolean run() {
                            return ((SmartFactoryBean<?>) factory).isEagerInit();
                        }
                    }, getAccessControlContext());
                }
                else {
                    isEagerInit = (factory instanceof SmartFactoryBean &&
                            ((SmartFactoryBean<?>) factory).isEagerInit());
                }
                if (isEagerInit) {
                    getBean(beanName);
                }
            }
            else {//4
                getBean(beanName);
            }
        }
    }

    // Trigger post-initialization callback for all applicable beans...
    for (String beanName : beanNames) {
        Object singletonInstance = getSingleton(beanName);
        if (singletonInstance instanceof SmartInitializingSingleton) {//5
            final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged(new PrivilegedAction<Object>() {
                    @Override
                    public Object run() {
                        smartSingleton.afterSingletonsInstantiated();
                        return null;
                    }
                }, getAccessControlContext());
            }
            else {
                smartSingleton.afterSingletonsInstantiated();//6
            }
        }
    }
}

十 容器初始化完成函數(shù)

• 初始化生命周期管理器
• 刷新生命周期接口bean
• 發(fā)送容器更新完成事件
• 注冊(cè)mbean

protected void finishRefresh() {
    // Initialize lifecycle processor for this context.
    initLifecycleProcessor();

    // Propagate refresh to lifecycle processor first.
    getLifecycleProcessor().onRefresh();

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

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

10.1 生命周期管理bean自動(dòng)啟動(dòng)

• 獲取Lifecycle接口實(shí)現(xiàn)bean
• 遍歷配置自動(dòng)啟動(dòng)的bean
• 獲取bean生命周期階段，同階段放到一個(gè)組中
• 按階段依次調(diào)用bean的start函數(shù)，啟動(dòng)bean。

private void startBeans(boolean autoStartupOnly) {
    Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
    Map<Integer, LifecycleGroup> phases = new HashMap<Integer, LifecycleGroup>();
    for (Map.Entry<String, ? extends Lifecycle> entry : lifecycleBeans.entrySet()) {
        Lifecycle bean = entry.getValue();
        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(entry.getKey(), bean);
        }
    }
    if (phases.size() > 0) {
        List<Integer> keys = new ArrayList<Integer>(phases.keySet());
        Collections.sort(keys);
        for (Integer key : keys) {
            phases.get(key).start();
        }
    }
}