spring启动流程 (2) Bean实例化流程

本文通过阅读Spring源码，分析Bean实例化流程。
Bean实例化入口

上一篇文章已经介绍，Bean实例化入口在AbstractApplicationContext类的finishBeanFactoryInitialization方法：

1. protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
2.         // Initialize conversion service for this context.
3.         if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
4.                         beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
5.                 beanFactory.setConversionService(
6.                                 beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
7.         }
9.         // Register a default embedded value resolver if no bean post-processor
10.         // (such as a PropertyPlaceholderConfigurer bean) registered any before:
11.         // at this point, primarily for resolution in annotation attribute values.
12.         if (!beanFactory.hasEmbeddedValueResolver()) {
13.                 beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
14.         }
16.         // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
17.         String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
18.         for (String weaverAwareName : weaverAwareNames) {
19.                 getBean(weaverAwareName);
20.         }
22.         // Stop using the temporary ClassLoader for type matching.
23.         beanFactory.setTempClassLoader(null);
25.         // Allow for caching all bean definition metadata, not expecting further changes.
26.         beanFactory.freezeConfiguration();
28.         // Instantiate all remaining (non-lazy-init) singletons.
29.         // 实例化Bean
30.         beanFactory.preInstantiateSingletons();
31. }

复制代码

Bean实例化流程

1. public void preInstantiateSingletons() throws BeansException {
3.         // Iterate over a copy to allow for init methods which in turn register new bean definitions.
4.         // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
5.         List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
7.         // Trigger initialization of all non-lazy singleton beans...
8.         for (String beanName : beanNames) {
9.                 RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
10.                 // 判断非抽象，单例且非懒加载
11.                 if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
12.                         // 判断FactoryBean
13.                         if (isFactoryBean(beanName)) {
14.                                 // 使用"&beanName"格式作为beanName去创建Bean实例
15.                                 Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
16.                                 if (bean instanceof FactoryBean) {
17.                                         FactoryBean<?> factory = (FactoryBean<?>) bean;
18.                                         boolean isEagerInit;
19.                                         if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
20.                                                 isEagerInit = AccessController.doPrivileged(
21.                                                                 (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
22.                                                                 getAccessControlContext());
23.                                         } else {
24.                                                 isEagerInit = (factory instanceof SmartFactoryBean &&
25.                                                                 ((SmartFactoryBean<?>) factory).isEagerInit());
26.                                         }
27.                                         if (isEagerInit) {
28.                                                 getBean(beanName);
29.                                         }
30.                                 }
31.                         } else {
32.                                 // 普通的Bean
33.                                 getBean(beanName);
34.                         }
35.                 }
36.         }
38.         // Trigger post-initialization callback for all applicable beans...
39.         // 此分支暂时不做分析
40.         for (String beanName : beanNames) {
41.                 Object singletonInstance = getSingleton(beanName);
42.                 if (singletonInstance instanceof SmartInitializingSingleton) {
43.                         SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
44.                         if (System.getSecurityManager() != null) {
45.                                 AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
46.                                         smartSingleton.afterSingletonsInstantiated();
47.                                         return null;
48.                                 }, getAccessControlContext());
49.                         } else {
50.                                 smartSingleton.afterSingletonsInstantiated();
51.                         }
52.                 }
53.         }
54. }

复制代码

getBean(beanName)方法

1. public Object getBean(String name) throws BeansException {
2.         return doGetBean(name, null, null, false);
3. }
5. protected <T> T doGetBean(
6.                 String name, Class<T> requiredType, Object[] args, boolean typeCheckOnly)
7.                 throws BeansException {
9.         // 去除name的&前缀
10.         String beanName = transformedBeanName(name);
11.         Object bean;
13.         // 依次从singletonObjects, earlySingletonObjects, singletonFactories获取单例Bean
14.         // 如果找到了就不需要创建了
15.         Object sharedInstance = getSingleton(beanName);
16.         if (sharedInstance != null && args == null) {
17.                 // Get the object for the given bean instance,
18.                 // either the bean instance itself or its created object in case of a FactoryBean.
19.                 // name参数是调用getBean方法时传递的原始BeanName，可能前缀&符用于获取FactoryBean实例
20.                 // beanName参数是去除&符前缀后的BeanName
21.                 bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
22.         } else {
23.                 // Fail if we're already creating this bean instance:
24.                 // We're assumably within a circular reference.
25.                 if (isPrototypeCurrentlyInCreation(beanName)) {
26.                         throw new BeanCurrentlyInCreationException(beanName);
27.                 }
29.                 // 如果当前BeanFactory没有指定Bean则从父级BeanFactory获取Bean实例
30.                 BeanFactory parentBeanFactory = getParentBeanFactory();
31.                 if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
32.                         // Not found -> check parent.
33.                         String nameToLookup = originalBeanName(name);
34.                         if (parentBeanFactory instanceof AbstractBeanFactory) {
35.                                 return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
36.                                                 nameToLookup, requiredType, args, typeCheckOnly);
37.                         } else if (args != null) {
38.                                 // Delegation to parent with explicit args.
39.                                 return (T) parentBeanFactory.getBean(nameToLookup, args);
40.                         } else if (requiredType != null) {
41.                                 // No args -> delegate to standard getBean method.
42.                                 return parentBeanFactory.getBean(nameToLookup, requiredType);
43.                         } else {
44.                                 return (T) parentBeanFactory.getBean(nameToLookup);
45.                         }
46.                 }
48.                 // whether the instance is obtained for a type check, not for actual use
49.                 if (!typeCheckOnly) {
50.                         markBeanAsCreated(beanName);
51.                 }
53.                 try {
54.                         RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
55.                         checkMergedBeanDefinition(mbd, beanName, args);
57.                         // 创建DependsOn的Bean
58.                         String[] dependsOn = mbd.getDependsOn();
59.                         if (dependsOn != null) {
60.                                 for (String dep : dependsOn) {
61.                                         // 判断循环依赖
62.                                         if (isDependent(beanName, dep)) {
63.                                                 throw new BeanCreationException(
64.                             mbd.getResourceDescription(), beanName, "循环依赖");
65.                                         }
66.                                         registerDependentBean(dep, beanName);
67.                                         try {
68.                                                 getBean(dep);
69.                                         } catch (NoSuchBeanDefinitionException ex) {
70.                                                 throw new BeanCreationException(
71.                             mbd.getResourceDescription(), beanName, "依赖的Bean不存在", ex);
72.                                         }
73.                                 }
74.                         }
76.                         // 此分支获取单例Bean
77.                         if (mbd.isSingleton()) {
78.                                 sharedInstance = getSingleton(beanName, () -> {
79.                                         try {
80.                                                 return createBean(beanName, mbd, args);
81.                                         } catch (BeansException ex) {
82.                                                 // Explicitly remove instance from singleton cache: It might have been put there
83.                                                 // eagerly by the creation process, to allow for circular reference resolution.
84.                                                 // Also remove any beans that received a temporary reference to the bean.
85.                                                 destroySingleton(beanName);
86.                                                 throw ex;
87.                                         }
88.                                 });
89.                                 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
90.                         } else if (mbd.isPrototype()) {
91.                                 // 此分支获取Prototype类型的Bean
92.                                 Object prototypeInstance = null;
93.                                 try {
94.                                         beforePrototypeCreation(beanName);
95.                                         prototypeInstance = createBean(beanName, mbd, args);
96.                                 } finally {
97.                                         afterPrototypeCreation(beanName);
98.                                 }
99.                                 bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
100.                         } else {
101.                                 String scopeName = mbd.getScope();
102.                                 if (!StringUtils.hasLength(scopeName)) {
103.                                         throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
104.                                 }
105.                                 Scope scope = this.scopes.get(scopeName);
106.                                 if (scope == null) {
107.                                         throw new IllegalStateException("No Scope registered for scope name");
108.                                 }
109.                                 try {
110.                                         Object scopedInstance = scope.get(beanName, () -> {
111.                                                 beforePrototypeCreation(beanName);
112.                                                 try {
113.                                                         return createBean(beanName, mbd, args);
114.                                                 } finally {
115.                                                         afterPrototypeCreation(beanName);
116.                                                 }
117.                                         });
118.                                         bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
119.                                 } catch (IllegalStateException ex) {
120.                                         throw new BeanCreationException(
121.                         beanName, "Scope is not active for the current thread", ex);
122.                                 }
123.                         }
124.                 } catch (BeansException ex) {
125.                         cleanupAfterBeanCreationFailure(beanName);
126.                         throw ex;
127.                 }
128.         }
130.         // 类型转换
131.         if (requiredType != null && !requiredType.isInstance(bean)) {
132.                 try {
133.                         T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
134.                         if (convertedBean == null) {
135.                                 throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
136.                         }
137.                         return convertedBean;
138.                 } catch (TypeMismatchException ex) {
139.                         throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
140.                 }
141.         }
142.         return (T) bean;
143. }

复制代码

创建/获取单例Bean

1. sharedInstance = getSingleton(beanName, () -> {
2.         try {
3.                 return createBean(beanName, mbd, args);
4.         } catch (BeansException ex) {
5.                 // Explicitly remove instance from singleton cache: It might have been put there
6.                 // eagerly by the creation process, to allow for circular reference resolution.
7.                 // Also remove any beans that received a temporary reference to the bean.
8.                 destroySingleton(beanName);
9.                 throw ex;
10.         }
11. });
12. bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

复制代码

getSingleton

返回指定beanName的(原始)单例对象，如果没有则创建一个新对象：

1. public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
2.         synchronized (this.singletonObjects) {
3.                 Object singletonObject = this.singletonObjects.get(beanName);
4.                 if (singletonObject == null) {
5.                         // Singleton bean creation not allowed while singletons of this factory are in destruction
6.                         // (Do not request a bean from a BeanFactory in a destroy method implementation!)
7.                         if (this.singletonsCurrentlyInDestruction) {
8.                                 throw new BeanCreationNotAllowedException(beanName, "");
9.                         }
10.                         beforeSingletonCreation(beanName);
11.                         boolean newSingleton = false;
12.                         boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
13.                         if (recordSuppressedExceptions) {
14.                                 this.suppressedExceptions = new LinkedHashSet<>();
15.                         }
16.                         try {
17.                                 // 此处需要返回去看createBean(beanName, mbd, args)的代码
18.                                 singletonObject = singletonFactory.getObject();
19.                                 newSingleton = true;
20.                         } catch (IllegalStateException ex) {
21.                                 // Has the singleton object implicitly appeared in the meantime ->
22.                                 // if yes, proceed with it since the exception indicates that state.
23.                                 singletonObject = this.singletonObjects.get(beanName);
24.                                 if (singletonObject == null) {
25.                                         throw ex;
26.                                 }
27.                         } catch (BeanCreationException ex) {
28.                                 if (recordSuppressedExceptions) {
29.                                         for (Exception suppressedException : this.suppressedExceptions) {
30.                                                 ex.addRelatedCause(suppressedException);
31.                                         }
32.                                 }
33.                                 throw ex;
34.                         } finally {
35.                                 if (recordSuppressedExceptions) {
36.                                         this.suppressedExceptions = null;
37.                                 }
38.                                 afterSingletonCreation(beanName);
39.                         }
40.                         if (newSingleton) {
41.                                 // 将创建的单例放入单例池
42.                                 addSingleton(beanName, singletonObject);
43.                         }
44.                 }
45.                 return singletonObject;
46.         }
47. }
49. protected void addSingleton(String beanName, Object singletonObject) {
50.         synchronized (this.singletonObjects) {
51.                 this.singletonObjects.put(beanName, singletonObject);
52.                 this.singletonFactories.remove(beanName);
53.                 this.earlySingletonObjects.remove(beanName);
54.                 this.registeredSingletons.add(beanName);
55.         }
56. }

复制代码

createBean

创建Bean实例、填充属性、调用后置处理器等：

1. protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args)
2.                 throws BeanCreationException {
4.         RootBeanDefinition mbdToUse = mbd;
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.         }
15.         // Prepare method overrides.
16.         try {
17.                 mbdToUse.prepareMethodOverrides();
18.         } catch (BeanDefinitionValidationException ex) {
19.                 throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
20.                                 beanName, "Validation of method overrides failed", ex);
21.         }
23.         try {
24.                 // 调用BeanPostProcessor处理器
25.                 // 调用postProcessBeforeInstantiation方法
26.                 Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
27.                 // 如果后置处理器返回了Bean实例则直接返回
28.                 if (bean != null) {
29.                         return bean;
30.                 }
31.         } catch (Throwable ex) {
32.                 throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
33.                                 "BeanPostProcessor before instantiation of bean failed", ex);
34.         }
36.         try {
37.                 Object beanInstance = doCreateBean(beanName, mbdToUse, args);
38.                 return beanInstance;
39.         } catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
40.                 // A previously detected exception with proper bean creation context already,
41.                 // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
42.                 throw ex;
43.         } catch (Throwable ex) {
44.                 throw new BeanCreationException(
45.                                 mbdToUse.getResourceDescription(), beanName,
46.                                 "Unexpected exception during bean creation", ex);
47.         }
48. }
50. protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
51.                 throws BeanCreationException {
53.         // Instantiate the bean.
54.         BeanWrapper instanceWrapper = null;
55.         if (mbd.isSingleton()) {
56.                 instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
57.         }
58.         if (instanceWrapper == null) {
59.                 // 创建实例，使用BeanWrapper包装
60.                 // 构造方法的@Autowired也在这里面实现
61.                 instanceWrapper = createBeanInstance(beanName, mbd, args);
62.         }
63.         Object bean = instanceWrapper.getWrappedInstance();
64.         Class<?> beanType = instanceWrapper.getWrappedClass();
65.         if (beanType != NullBean.class) {
66.                 mbd.resolvedTargetType = beanType;
67.         }
69.         // Allow post-processors to modify the merged bean definition.
70.         synchronized (mbd.postProcessingLock) {
71.                 if (!mbd.postProcessed) {
72.                         try {
73.                                 // 调用MergedBeanDefinitionPostProcessor处理器
74.                                 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
75.                         } catch (Throwable ex) {
76.                                 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
77.                                                 "Post-processing of merged bean definition failed", ex);
78.                         }
79.                         mbd.postProcessed = true;
80.                 }
81.         }
83.         // 这里使用三级缓存封装了一段代码，解决循环依赖问题
84.         // 这段代码会执行SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReference方法
85.         // 依赖这个Bean的其他Bean在填充属性时，调用getSingleton时会执行getEarlyBeanReference方法
86.         // 此时可以对这个Bean实例做一些事情，比如创建AOP代理
87.         // 之后会将修改之后的对象放入到二级缓存
88.         boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
89.                         isSingletonCurrentlyInCreation(beanName));
90.         if (earlySingletonExposure) {
91.                 addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
92.         }
94.         // Initialize the bean instance.
95.         Object exposedObject = bean;
96.         try {
97.                 // Populate the bean instance in the given BeanWrapper
98.                 // with the property values from the bean definition.
99.                 // 1. 调用InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation方法
100.                 // 2. 依赖注入
101.                 populateBean(beanName, mbd, instanceWrapper);
102.                 // Initialize the given bean instance, applying factory
103.                 // callbacks as well as init methods and bean post processors.
104.                 // 1. invokeAwareMethods
105.                 // 2. 调用BeanPostProcessor的postProcessBeforeInitialization
106.                 // 3. InitializingBean的afterPropertiesSet和initMethod
107.                 // 4. 调用BeanPostProcessor的postProcessAfterInitialization
108.                 exposedObject = initializeBean(beanName, exposedObject, mbd);
109.         } catch (Throwable ex) {
110.                 if (ex instanceof BeanCreationException &&
111.             beanName.equals(((BeanCreationException) ex).getBeanName())) {
112.                         throw (BeanCreationException) ex;
113.                 } else {
114.                         throw new BeanCreationException(
115.                                         mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
116.                 }
117.         }
119.         if (earlySingletonExposure) {
120.                 // 获取提前暴露的Bean实例
121.                 Object earlySingletonReference = getSingleton(beanName, false);
122.                 if (earlySingletonReference != null) {
123.                         if (exposedObject == bean) {
124.                                 // 使用提前暴露的Bean替换当前Bean
125.                                 exposedObject = earlySingletonReference;
126.                         } else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
127.                                 String[] dependentBeans = getDependentBeans(beanName);
128.                                 Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
129.                                 for (String dependentBean : dependentBeans) {
130.                                         if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
131.                                                 actualDependentBeans.add(dependentBean);
132.                                         }
133.                                 }
134.                                 if (!actualDependentBeans.isEmpty()) {
135.                                         throw new BeanCurrentlyInCreationException(beanName, "");
136.                                 }
137.                         }
138.                 }
139.         }
141.         // Register bean as disposable.
142.         try {
143.                 registerDisposableBeanIfNecessary(beanName, bean, mbd);
144.         } catch (BeanDefinitionValidationException ex) {
145.                 throw new BeanCreationException(
146.                                 mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
147.         }
149.         return exposedObject;
150. }

复制代码

创建Prototype类型的Bean

1. // It's a prototype -> create a new instance.
2. Object prototypeInstance = null;
3. try {
4.         // 把beanName注册到ThreadLocal prototypesCurrentlyInCreation中
5.         beforePrototypeCreation(beanName);
6.         // 这里的逻辑与singleton一样了
7.         prototypeInstance = createBean(beanName, mbd, args);
8. } finally {
9.         // 把beanName从ThreadLocal prototypesCurrentlyInCreation清除
10.         afterPrototypeCreation(beanName);
11. }
12. bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！