Spring源码情操陶冶-AbstractApplicationContext#finishBeanFactoryInitialization

承接前文Spring源码情操陶冶-AbstractApplicationContext#registerListeners
约定web.xml配置的contextClass为默认值XmlWebApplicationContext

AbstractRefreshableWebApplicationContext#finishBeanFactoryInitialization()

笔者直接去查看相应的的源码

    /**
     * Finish the initialization of this context's bean factory,
     * initializing all remaining singleton beans.
     */
    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();
    }

从上述的注释可知，spring会提前初始化那些作用域为singleton类型的bean对象，当然并不包括lazy-init属性的bean对象

DefaultListableBeanFactory#preInstantiateSingletons()

具体实现preInstantiateSingletons()方法便只有DefaultListableBeanFactory类，直接去翻阅代码

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

        //获取解析过的所有beanNames
        List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);

        // Trigger initialization of all non-lazy singleton beans...
        for (String beanName : beanNames) {
            //获取对应的RootBeanDefinition，其内部就含有BeanDefinition
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            //非抽象、单例模式、非lay-init，满足以上条件的进入到实例化(默认情况下Bean为singleton单例模式)
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                //对FactoryBean的类型实例化
                if (isFactoryBean(beanName)) {
                    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 {
                    //getBean方法主要进行了对相应的beanName的实例化
                    getBean(beanName);
                }
            }
        }
        // Trigger post-initialization callback for all applicable beans...
        for (String beanName : beanNames) {
            //获取上述的实例化的静态对象，如果为SmartInitializingSingleton的实现类进行afterSingletonInstantiated()方法调用
            Object singletonInstance = getSingleton(beanName);
            if (singletonInstance instanceof SmartInitializingSingleton) {
                final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged(new PrivilegedAction<Object>() {
                        @Override
                        public Object run() {
                            smartSingleton.afterSingletonsInstantiated();
                            return null;
                        }
                    }, getAccessControlContext());
                }
                else {
                                        //会调用InitializingBean的afterPropertiesSet()方法
                    smartSingleton.afterSingletonsInstantiated();
                }
            }
        }

笔者提示这里的实例化指的是对beanFactory中beanName对应的RootBeanDefinition中的beanClass进行准确的实例化，包括属性以及方法复用等等，主要是通过DefaultListableBeanFactory#getBean()方法，因为其很复杂，我们后续再分析

需要注意的是，默认情况下Bean对象的作用域一般为singleton，所以默认情况下bean工厂上的bean都会进行实例化。除了以下情况先不参与
1.使用@Lazy注解修饰Bean对象，指定@Lazy(value=true)

2.使用@Scope注解修饰Bean对象，指定@Scope(value="prototype")

小结

1. 主要是实例化RootDefinition中的beanClass类，并完成相应的属性设置，方法调用等等(默认情况下Bean的Scope类型为singleton单例模式)。即使当中的属性如果没有提前被初始化的话，其也会被调用getBean()方法来进行初始化后再被设置

2. 调用所有实现InitializingBean接口的afterPropertiesSet()方法

3. 调用BeanPostProcessors接口，比如postProcessBeforeInitialization()和postProcessAfterInitialization()实例化前后方法。其中涉及@Resource、@Autowired等注解的解析并进行相应的实例注入

4. 此处插一句：BeanPostProcessors接口处理，优先处理InstantiationAwareBeanPostProcessor.class接口实现类，一旦其内部方法postProcessBeforeInstantiation(Class,String)执行后返回null，则不执行postProcessAfterInitialization()方法；随后处理其他BeanPostProcessor接口的postProcessBeforeInitialization()和postProcessAfterInitialization()方法

附上springBean的生命周期图(含lazy-init的Bean)

Bean销毁的触发机制：

1.实例化@Scope(value="singleton")类型的Bean对象过程中(默认)，如果出现异常则会执行AbstractBeanFactory#destorySingleton()方法，当然也支持直接调用

2.在上述销毁的过程中也会去默认执行@Scope(value="prototype")类型Bean的close/destory()方法(倘若存在)

3.同样在上述的销毁过程中，如果对应的Bean对象为DisposableBean类型，则会调用destory()方法来进行销毁操作

Bean对象中指定Scope为singleton和prototype的小区别

1.前者是指定Bean对象为单例模式， 即初始化一次后便会保存在内存中，专门由相应的集合去保存；后者则是实例模式，在主动销毁以及被动被回收之后再获取的时候则会被新建

2.前者是Spring的默认模式，后者是需要用户去指定的。前者比较节省资源

3.前者在销毁的过程中也会波及至后者的销毁

下节预告

Spring源码情操陶冶-AbstractApplicationContext#finishRefresh

转载于:https://www.cnblogs.com/question-sky/p/6850309.html