Spring Bean 的初始化是在 Spring 容器 refresh() 时进行的。

Spring 容器 refresh 时会调用 finishBeanFactoryInitialization() 来初始化所有非延迟加载的 bean。

1 org.springframework.context.support.AbstractApplicationContext.refresh()
2     --> org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization // 初始化bean(延迟加载除外)
3         --> org.springframework.beans.factory.config.ConfigurableListableBeanFactory.preInstantiateSingletons()
4             --> org.springframework.beans.factory.support.AbstractBeanFactory.getBean
5                 --> org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean
6                     --> org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean // 创建 bean(实例化 bean)

1. org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean

  1 protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
  2
  3     final String beanName = transformedBeanName(name);
  4     Object bean;
  5
  6     // Eagerly check singleton cache for manually registered singletons.
  7     Object sharedInstance = getSingleton(beanName);
  8     if (sharedInstance != null && args == null) {
  9         bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
 10     }
 11
 12     else {
 13         // Fail if we're already creating this bean instance:
 14         // We're assumably within a circular reference.
 15         if (isPrototypeCurrentlyInCreation(beanName)) {
 16             throw new BeanCurrentlyInCreationException(beanName);
 17         }
 18
 19         // Check if bean definition exists in this factory.
 20         // 在 parentBeanFactory 中如果存在 beanName,则直接返回父容器里面的 bean
 21         BeanFactory parentBeanFactory = getParentBeanFactory();
 22         if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
 23             // Not found -> check parent.
 24             String nameToLookup = originalBeanName(name);
 25             if (parentBeanFactory instanceof AbstractBeanFactory) {
 26                 return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
 27                         nameToLookup, requiredType, args, typeCheckOnly);
 28             }
 29             else if (args != null) {
 30                 // Delegation to parent with explicit args.
 31                 return (T) parentBeanFactory.getBean(nameToLookup, args);
 32             }
 33             else if (requiredType != null) {
 34                 // No args -> delegate to standard getBean method.
 35                 return parentBeanFactory.getBean(nameToLookup, requiredType);
 36             }
 37             else {
 38                 return (T) parentBeanFactory.getBean(nameToLookup);
 39             }
 40         }
 41
 42         if (!typeCheckOnly) {
 43             markBeanAsCreated(beanName);
 44         }
 45
 46         try {
 47             final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
 48             checkMergedBeanDefinition(mbd, beanName, args);
 49
 50             // Guarantee initialization of beans that the current bean depends on.
 51             // 初始化当前 bean 依赖的 bean
 52             String[] dependsOn = mbd.getDependsOn();
 53             if (dependsOn != null) {
 54                 for (String dep : dependsOn) {
 55                     if (isDependent(beanName, dep)) {
 56                         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
 57                                 "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
 58                     }
 59                     registerDependentBean(dep, beanName);
 60                     try {
 61                         // getBean() 会再递归调用 doGetBean(),以确保所依赖的 bean 全部初始化
 62                         getBean(dep);
 63                     }
 64                     catch (NoSuchBeanDefinitionException ex) {
 65                         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
 66                                 "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
 67                     }
 68                 }
 69             }
 70
 71             // Create bean instance.
 72             if (mbd.isSingleton()) { // 单例类型的 bean
 73                 sharedInstance = getSingleton(beanName, () -> {
 74                     try {
 75                         // 创建 bean 的实例
 76                         return createBean(beanName, mbd, args);
 77                     }
 78                     catch (BeansException ex) {
 79                         // Explicitly remove instance from singleton cache: It might have been put there
 80                         // eagerly by the creation process, to allow for circular reference resolution.
 81                         // Also remove any beans that received a temporary reference to the bean.
 82                         destroySingleton(beanName);
 83                         throw ex;
 84                     }
 85                 });
 86                 // 如果 bean 为 FactoryBean 的话,则调用 FactoryBean.getObject() 来创建 bean 实例
 87                 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
 88             }
 89
 90             else if (mbd.isPrototype()) { // 原型类型的 bean
 91                 // It's a prototype -> create a new instance.
 92                 Object prototypeInstance = null;
 93                 try {
 94                     beforePrototypeCreation(beanName);
 95                     prototypeInstance = createBean(beanName, mbd, args);
 96                 }
 97                 finally {
 98                     afterPrototypeCreation(beanName);
 99                 }
100                 bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
101             }
102
103             else { // 其他 scope 类型的 bean
104                 String scopeName = mbd.getScope();
105                 final Scope scope = this.scopes.get(scopeName);
106                 if (scope == null) {
107                     throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
108                 }
109                 try {
110                     Object scopedInstance = scope.get(beanName, () -> {
111                         beforePrototypeCreation(beanName);
112                         try {
113                             return createBean(beanName, mbd, args);
114                         }
115                         finally {
116                             afterPrototypeCreation(beanName);
117                         }
118                     });
119                     bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
120                 }
121                 catch (IllegalStateException ex) {
122                     throw new BeanCreationException(beanName,
123                             "Scope '" + scopeName + "' is not active for the current thread; consider " +
124                             "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
125                             ex);
126                 }
127             }
128         }
129         catch (BeansException ex) {
130             cleanupAfterBeanCreationFailure(beanName);
131             throw ex;
132         }
133     }
134
135     // Check if required type matches the type of the actual bean instance.
136     if (requiredType != null && !requiredType.isInstance(bean)) {
137         try {
138             T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
139             if (convertedBean == null) {
140                 throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
141             }
142             return convertedBean;
143         }
144         catch (TypeMismatchException ex) {
145             throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
146         }
147     }
148     return (T) bean;
149 }

2. org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean

 1 protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
 2         throws BeanCreationException {
 3
 4     RootBeanDefinition mbdToUse = mbd;
 5
 6     // Make sure bean class is actually resolved at this point, and
 7     // clone the bean definition in case of a dynamically resolved Class
 8     // which cannot be stored in the shared merged bean definition.
 9     Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
10     if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
11         mbdToUse = new RootBeanDefinition(mbd);
12         mbdToUse.setBeanClass(resolvedClass);
13     }
14
15     // Prepare method overrides.
16     try {
17         mbdToUse.prepareMethodOverrides();
18     }
19     catch (BeanDefinitionValidationException ex) {
20         throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), beanName, "Validation of method overrides failed", ex);
21     }
22
23     try {
24         // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
25         // BeanPostProcessor 可以创建一个代理 bean 返回
26         // 执行 InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation
27         // 执行 InstantiationAwareBeanPostProcessor.postProcessAfterInitialization
28         Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
29         if (bean != null) {
30             return bean;
31         }
32     }
33     catch (Throwable ex) {
34         throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "BeanPostProcessor before instantiation of bean failed", ex);
35     }
36
37     try {
38         // 创建 bean 
39         Object beanInstance = doCreateBean(beanName, mbdToUse, args);
40         return beanInstance;
41     }
42     catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
43         // A previously detected exception with proper bean creation context already,
44         // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
45         throw ex;
46     }
47     catch (Throwable ex) {
48         throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
49     }
50 }

3. org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean

  1 protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException {
  2
  3     // Instantiate the bean.
  4     BeanWrapper instanceWrapper = null;
  5     if (mbd.isSingleton()) {
  6         instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  7     }
  8     if (instanceWrapper == null) {
  9         // 创建 bean 的实例:通过默认构造函数反射生成、通过配置的构造函数生成(构造方法注入)、通过 factoryMethod 生成
 10         // 最终会生成一个 BeanWrapper
 11         instanceWrapper = createBeanInstance(beanName, mbd, args);
 12     }
 13     final Object bean = instanceWrapper.getWrappedInstance();
 14     Class<?> beanType = instanceWrapper.getWrappedClass();
 15     if (beanType != NullBean.class) {
 16         mbd.resolvedTargetType = beanType;
 17     }
 18
 19     // Allow post-processors to modify the merged bean definition.
 20     synchronized (mbd.postProcessingLock) {
 21         if (!mbd.postProcessed) {
 22             try {
 23                 // 允许 post-processors 修改 bean 的定义
 24                 // 执行 MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition
 25                 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
 26             }
 27             catch (Throwable ex) {
 28                 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
 29                         "Post-processing of merged bean definition failed", ex);
 30             }
 31             mbd.postProcessed = true;
 32         }
 33     }
 34
 35     // Eagerly cache singletons to be able to resolve circular references
 36     // even when triggered by lifecycle interfaces like BeanFactoryAware.
 37     boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
 38     if (earlySingletonExposure) {
 39         if (logger.isTraceEnabled()) {
 40             logger.trace("Eagerly caching bean '" + beanName +
 41                     "' to allow for resolving potential circular references");
 42         }
 43         addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
 44     }
 45
 46     // Initialize the bean instance.
 47     Object exposedObject = bean;
 48     try {
 49         // 填充 bean 属性,处理属性注入:@Value, @Autowired, @Resource 等
 50         populateBean(beanName, mbd, instanceWrapper);
 51         // 初始化 bean:执行 aware 方法,BeanPostProcessor,初始化方法
 52         exposedObject = initializeBean(beanName, exposedObject, mbd);
 53     }
 54     catch (Throwable ex) {
 55         if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
 56             throw (BeanCreationException) ex;
 57         }
 58         else {
 59             throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
 60         }
 61     }
 62
 63     if (earlySingletonExposure) {
 64         Object earlySingletonReference = getSingleton(beanName, false);
 65         if (earlySingletonReference != null) {
 66             if (exposedObject == bean) {
 67                 exposedObject = earlySingletonReference;
 68             }
 69             else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
 70                 String[] dependentBeans = getDependentBeans(beanName);
 71                 Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
 72                 for (String dependentBean : dependentBeans) {
 73                     if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
 74                         actualDependentBeans.add(dependentBean);
 75                     }
 76                 }
 77                 if (!actualDependentBeans.isEmpty()) {
 78                     throw new BeanCurrentlyInCreationException(beanName,
 79                             "Bean with name '" + beanName + "' has been injected into other beans [" +
 80                             StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
 81                             "] in its raw version as part of a circular reference, but has eventually been " +
 82                             "wrapped. This means that said other beans do not use the final version of the " +
 83                             "bean. This is often the result of over-eager type matching - consider using " +
 84                             "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
 85                 }
 86             }
 87         }
 88     }
 89
 90     // Register bean as disposable.
 91     try {
 92         registerDisposableBeanIfNecessary(beanName, bean, mbd);
 93     }
 94     catch (BeanDefinitionValidationException ex) {
 95         throw new BeanCreationException(
 96                 mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
 97     }
 98
 99     return exposedObject;
100 }
12-16 20:44
查看更多