Spring中Bean的实例化过程

先看一个简单的Bean的实例化过程，使用默认的构造函数

@Service
public class UserService {
	public void query(){
		System.out.println("query");
	}
}

从AbstractApplicationContext#refresh中的finishBeanFactoryInitialization(beanFactory)进入
AbstractApplicationContext # finishBeanFactoryInitialization

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // Initialize conversion service for this context.
    // 1.初始化此上下文的转换服务
    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));
    }
 
    // Register a default embedded value resolver if no bean post-processor
    // (such as a PropertyPlaceholderConfigurer bean) registered any before:
    // at this point, primarily for resolution in annotation attribute values.
    // 2.如果beanFactory之前没有注册嵌入值解析器，则注册默认的嵌入值解析器：主要用于注解属性值的解析。
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
            @Override
            public String resolveStringValue(String strVal) {
                return getEnvironment().resolvePlaceholders(strVal);
            }
        });
    }
 
    // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
    // 3.初始化LoadTimeWeaverAware Bean实例对象
    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.
    // 4.冻结所有bean定义，注册的bean定义不会被修改或进一步后处理，因为马上要创建 Bean 实例对象了
    beanFactory.freezeConfiguration();
 
    // Instantiate all remaining (non-lazy-init) singletons.
    // 5.实例化所有剩余（非懒加载）单例对象
    beanFactory.preInstantiateSingletons();
}

2、从第5步进入DefaultListableBeanFactory # preInstantiateSingletons

@Override
public void preInstantiateSingletons() throws BeansException {
    if (this.logger.isDebugEnabled()) {
        this.logger.debug("Pre-instantiating singletons in " + this);
    }
 
    // Iterate over a copy to allow for init methods which in turn register new bean definitions.
    // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
    // 1.创建beanDefinitionNames的副本beanNames用于后续的遍历，以允许init等方法注册新的bean定义
    List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
 
    // Trigger initialization of all non-lazy singleton beans...
    // 2.遍历beanNames，触发所有非懒加载单例 bean的初始化
    for (String beanName : beanNames) {
        // 3.获取beanName对应的 MergedBeanDefinition
        RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
        // 4.bd对应的Bean实例：不是抽象类 && 是单例 && 不是懒加载
        if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
            // 5.判断beanName对应的bean是否为FactoryBean
            if (isFactoryBean(beanName)) {
                // 5.1 通过beanName获取FactoryBean实例
                // 通过getBean(&beanName)拿到的是FactoryBean本身；通过getBean(beanName)拿到的是FactoryBean创建的Bean实例
                final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
                // 5.2 判断这个FactoryBean是否希望急切的初始化
                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) {
                    // 5.3 如果希望急切的初始化，则通过beanName获取bean实例
                    getBean(beanName);
                }
            } else {
                // 6.如果beanName对应的bean不是FactoryBean，只是普通Bean，通过beanName获取bean实例
                getBean(beanName);
            }
        }
    }
    //省略部分代码

this.beanDefinitionNames 定义在DefaultListableBeanFactory中


AbstractBeanFactory # getBean(java.lang.String)

AbstractBeanFactory # doGetBean

DefaultSingletonBeanRegistry # getSingleton，从下面的代码中可以看出返回值为null

简单看一下DefaultSingletonBeanRegistry # isSingletonCurrentlyInCreation

singletonsCurrentlyInCreation定义在DefaultSingletonBeanRegistry 中，是一个Set集合，用于存放当前正在创建的Bean的名称

回到 AbstractBeanFactory # doGetBean

isPrototypeCurrentlyInCreation(beanName)这个方法还有点不明确，后面再讨论

AbstractBeanFactory # doGetBean继续往下执行到if(!typeCheckOnly)判断

进入判断的方法，将UserService的BD从mergedBeanDefinitions中移除，将beanName：userService添加到alreadyCreated集合中，至于这些BD在什么时候被加入到mergedBeanDefinitions，有空回头再看看前面的代码
AbstractBeanFactory # clearMergedBeanDefinition

AbstractBeanFactory # doGetBean继续向下执行到getMergedLocalBeanDefinition

最后返回一个bd，从mergedBeanDefinitions中拿，没有，又从beanDefinitionMap中拿，那前面为啥删除呢？…

checkMergedBeanDefinition() 会检查是否是抽象的，是就会抛出异常

执行到这一行就是真正的去创建一个Bean