1、源码解析
getBean(name)是在IOC容器的顶级接口BeanFactory中定义，由其子类AbstractBeanFactory实现的方法。是IOC容器启动过程中的核心方法。核心方法流程 getBean -> doGetBean -> createBean -> doCreateBean。1.1、getBean：入口方法
1 // 根据beanName获取bean实例
2 public Object getBean(String name) throws BeansException {
3 // 此方法是实际获取bean的方法，也是触发依赖注入的方法
4 return doGetBean(name, null, null, false);
5 }
1.2、doGetBean：实际获取bean的方法
1 // 获取指定的bean实例
2 protected <T> T doGetBean(
3 String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
4 throws BeansException {
5
6 // 提取对应的beanName，当bean对象实现FactoryBean接口之后就会变成&beanName，同时如果存在别名，需要把别名进行转换
7 String beanName = transformedBeanName(name);
8 Object bean;
9 // 提前检查单例缓存中是否有手动注册的单例对象，跟循环依赖有关联，此处涉及三级缓存
10 Object sharedInstance = getSingleton(beanName);
11 // 如果bean的单例对象找到了，且没有创建bean实例时要使用的参数
12 if (sharedInstance != null && args == null) {
13 // 此处省略日志代码 ...
14 // 返回对象的实例，当你实现了FactoryBean接口的对象，需要获取具体的对象的时候就需要此方法来进行获取
15 bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
16 }
17 else {
18 // 当对象都是单例的时候会尝试解决循环依赖的问题，但是原型模式下如果存在循环依赖的情况，那么直接抛出异常
19 if (isPrototypeCurrentlyInCreation(beanName)) {
20 throw new BeanCurrentlyInCreationException(beanName);
21 }
22 // 如果bean定义不存在，就检查父工厂是否有
23 BeanFactory parentBeanFactory = getParentBeanFactory();
24 // 如果beanDefinitionMap中也就是在所有已经加载的类中不包含beanName，那么就尝试从父容器中获取
25 if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
26 // 获取name对应的规范名称【全类名】，如果name前面有'&'，则会返回'&'+规范名称【全类名】
27 String nameToLookup = originalBeanName(name);
28 // 如果父工厂是AbstractBeanFactory的实例
29 if (parentBeanFactory instanceof AbstractBeanFactory) {
30 // 调用父工厂的doGetBean方法，就是该方法。【递归】
31 return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
32 nameToLookup, requiredType, args, typeCheckOnly);
33 }
34 else if (args != null) {
35 // 如果有创建bean实例时要使用的参数，使用显示参数委派给父工厂
36 // 使用父工厂获取该bean对象，通bean全类名和创建bean实例时要使用的参数
37 return (T) parentBeanFactory.getBean(nameToLookup, args);
38 }
39 else if (requiredType != null) {
40 // 没有创建bean实例时要使用的参数 -> 委托给标准的getBean方法。
41 // 使用父工厂获取该bean对象,通bean全类名和所需的bean类型
42 return parentBeanFactory.getBean(nameToLookup, requiredType);
43 }
44 else {
45 // 使用父工厂获取bean，通过bean全类名
46 return (T) parentBeanFactory.getBean(nameToLookup);
47 }
48 }
49 // 如果不是做类型检查，那么表示要创建bean，此处在集合中做一个记录
50 if (!typeCheckOnly) {
51 // 为beanName标记为已经创建（或将要创建）
52 markBeanAsCreated(beanName);
53 }
54 try {
55 // 此处做了BeanDefinition对象的转换，当我们从xml文件中加载beandefinition对象的时候，封装的对象是GenericBeanDefinition,
56 // 此处要做类型转换，如果是子类bean的话，会合并父类的相关属性
57 RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
58 // 检查mbd的合法性，不合格会引发验证异常
59 checkMergedBeanDefinition(mbd, beanName, args);
60 // 如果存在依赖的bean的话，那么则优先实例化依赖的bean
61 String[] dependsOn = mbd.getDependsOn();
62 if (dependsOn != null) {
63 // 如果存在依赖，则需要递归实例化依赖的bean
64 for (String dep : dependsOn) {
65 // 如果beanName已注册依赖于dependentBeanName的关系
66 if (isDependent(beanName, dep)) {
67 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
68 "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
69 }
70 // 注册各个bean的依赖关系，方便进行销毁
71 registerDependentBean(dep, beanName);
72 try {
73 // 递归优先实例化被依赖的Bean
74 getBean(dep);
75 }
76 // 捕捉为找到BeanDefinition异常：'beanName'依赖于缺少的bean'dep'
77 catch (NoSuchBeanDefinitionException ex) {
78 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
79 "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
80 }
81 }
82 }
83 // 创建单例bean的实例对象
84 if (mbd.isSingleton()) {
85 // 返回以beanName的(原始)单例对象，如果尚未注册，则使用singletonFactory创建并注册一个对象:
86 sharedInstance = getSingleton(beanName, () -> {
87 try {
88 // 为给定的合并后BeanDefinition(和参数)创建一个bean实例
89 return createBean(beanName, mbd, args);
90 }
91 catch (BeansException ex) {
92 // 显示地从单例缓存中删除实例：它可能是由创建过程急切地放在那里，以允许循环引用解析。还要删除
93 // 接收到该Bean临时引用的任何Bean
94 // 销毁给定的bean。如果找到相应的一次性Bean实例，则委托给destoryBean
95 destroySingleton(beanName);
96 throw ex;
97 }
98 });
99 // 从beanInstance中获取公开的Bean对象，主要处理beanInstance是FactoryBean对象的情况，如果不是
100 // FactoryBean会直接返回beanInstance实例
101 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
102 }
103 // 原型模式的bean对象创建
104 else if (mbd.isPrototype()) {
105 // 原型 -> 创建一个新实例
106 // 定义prototype实例
107 Object prototypeInstance = null;
108 try {
109 // 创建Prototype对象前的准备工作，默认实现将beanName添加到prototypesCurrentlyInCreation中
110 beforePrototypeCreation(beanName);
111 // 为mbd(和参数)创建一个bean实例
112 prototypeInstance = createBean(beanName, mbd, args);
113 }
114 finally {
115 // 创建完prototype实例后的回调，默认是将beanName从prototypesCurrentlyInCreation移除
116 afterPrototypeCreation(beanName);
117 }
118 // 从beanInstance中获取公开的Bean对象，主要处理beanInstance是FactoryBean对象的情况，如果不是
119 // FactoryBean会直接返回beanInstance实例
120 bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
121 }
122 else {
123 // 指定的scope上实例化bean
124 String scopeName = mbd.getScope();
125 if (!StringUtils.hasLength(scopeName)) {
126 throw new IllegalStateException("No scope name defined for bean '" + beanName + "'");
127 }
128 // 从scopes中获取scopeName对于的Scope对象
129 Scope scope = this.scopes.get(scopeName);
130 // 如果scope为null
131 if (scope == null) {
132 // 抛出非法状态异常：没有名为'scopeName'的scope注册
133 throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
134 }
135 try {
136 // 从scope中获取beanName对应的实例对象
137 Object scopedInstance = scope.get(beanName, () -> {
138 // 创建Prototype对象前的准备工作，默认实现 将beanName添加到prototypesCurrentlyInCreation中
139 beforePrototypeCreation(beanName);
140 try {
141 // 为mbd(和参数)创建一个bean实例
142 return createBean(beanName, mbd, args);
143 }
144 finally {
145 // 创建完prototype实例后的回调，默认是将beanName从prototypesCurrentlyInCreation移除
146 afterPrototypeCreation(beanName);
147 }
148 });
149 // 从beanInstance中获取公开的Bean对象，主要处理beanInstance是FactoryBean对象的情况，如果不是
150 // FactoryBean会直接返回beanInstance实例
151 bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
152 }
153 catch (IllegalStateException ex) {
154 // 捕捉非法状态异常
155 // 抛出Bean创建异常：作用域 'scopeName' 对于当前线程是不活动的；如果您打算从单个实例引用它，请考虑为此
156 // beanDefinition一个作用域代理
157 throw new BeanCreationException(beanName,
158 "Scope '" + scopeName + "' is not active for the current thread; consider " +
159 "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
160 ex);
161 }
162 }
163 }
164 catch (BeansException ex) {
165 // 捕捉获取Bean对象抛出的Bean异常
166 // 在Bean创建失败后，对缓存的元数据执行适当的清理
167 cleanupAfterBeanCreationFailure(beanName);
168 throw ex;
169 }
170 }
171
172 // 检查requiredType是否与实际Bean实例的类型匹配
173 // 如果requiredType不为null&&bean不是requiredType的实例
174 if (requiredType != null && !requiredType.isInstance(bean)) {
175 try {
176 // 获取此BeanFactory使用的类型转换器，将bean转换为requiredType
177 T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
178 // 如果convertedBean为null
179 if (convertedBean == null) {
180 // 抛出Bean不是必要类型的异常
181 throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
182 }
183 // 返回convertedBean
184 return convertedBean;
185 }
186 catch (TypeMismatchException ex) {
187 if (logger.isTraceEnabled()) {
188 logger.trace("Failed to convert bean '" + name + "' to required type '" +
189 ClassUtils.getQualifiedName(requiredType) + "'", ex);
190 }
191 throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
192 }
193 }
194 // 将bean返回出去
195 return (T) bean;
196 }
1、获取真实的beanName;
2、根据BeanName检查单例对象缓存中是否有已经注册好的单例对象，若缓存中已注册，返回注册实例；若缓存中没有，则通过createBean方法创建对象;
·缓存中已注册beanName对应的单例对象
判断bean实例是否为FactoryBean类型？如果bean实例不是FactoryBean类型，直接返回beanInstance；如果是FactoryBean类型，通过FactoryBean的getObject()回调方法获取bean实例(此处可拓展)，注册到一级缓存singletonObjects中、FactoryBean对象的缓存factoryBeanObjectCache中(再次通过getBean获取bean实例时，方便从factoryBeanObjectCache缓存中获取)。
·缓存中未注册beanName对应的单例对象
1、如果正在创建的bean是原型的，则抛出异常，创建流程终止；
2、若当前容器的beanDefinitionMap中所有已加载的类不包含beanName的bean实例，若当前容器的父容器parentBeanFactory存在，尝试从父容器中获取beanName对应的bean实例，执行父容器parentBeanFactory的getBean方法；
3、将beanName标记为已创建，Set类型的alreadyCreated集合中不存在此beanName，则将beanName添加进此集合中；
4、将从xml文件中加载GenericBeanDefinition对象的时候转换为RootBeanDefinition,并且合并父类的相关属性(getMergedLocalBeanDefinition)；
5、优先实例化依赖的bean;
6、创建beanName的bean实例
·对象创建分为三种场景：创建单例对象、创建原型对象、创建指定scope的对象。
原型对象的创建，在创建前需要将beanName加入从prototypesCurrentlyInCreation中，创建完成后需要将beanName从prototypesCurrentlyInCreation移除，这步操作的原因，请看1。
·此处通过函数式接口ObjectFactory的getObject回调方法执行创建对象的核心方法createBean。
1 // 返回以给定名称注册的(原始)单例对象，如果尚未注册，则创建并注册一个对象
2 public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
3 // 使用单例对象的高速缓存Map作为锁，保证线程同步
4 synchronized (this.singletonObjects) {
5 // 从单例对象的高速缓存Map中获取beanName对应的单例对象
6 Object singletonObject = this.singletonObjects.get(beanName);
7 // 如果单例对象获取不到
8 if (singletonObject == null) {
9 ...
10 // 创建单例之前的回调,默认实现将单例注册为当前正在创建中
11 beforeSingletonCreation(beanName);
12 // 表示生成了新的单例对象的标记，默认为false，表示没有生成新的单例对象
13 boolean newSingleton = false;
14 ...
15 try {
16 // 从单例工厂中获取对象
17 singletonObject = singletonFactory.getObject();
18 // 生成了新的单例对象的标记为true，表示生成了新的单例对象
19 newSingleton = true;
20 }
21 ...
22 finally {
23 ...
24 // 创建单例后的回调,默认实现将单例标记为不在创建中
25 afterSingletonCreation(beanName);
26 }
27 // 生成了新的单例对象
28 if (newSingleton) {
29 // 将beanName和singletonObject的映射关系添加到该工厂的单例缓存中:
30 addSingleton(beanName, singletonObject);
31 }
32 }
33 // 返回该单例对象
34 return singletonObject;
35 }
36 }
在执行singletonFactory.getObject();步骤时，执行createBean回调方法。
1.3、createBean：创建bean入口
createBean是抽象类AbstractAutowireCapableBeanFactory的核心方法，用于实例化bean、初始化bean、初始化bean的后置处理等。 1 // 创建一个bean实例，为实例填充属性，执行后置处理
2 protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
3 throws BeanCreationException {
4 if (logger.isTraceEnabled()) {
5 logger.trace("Creating instance of bean '" + beanName + "'");
6 }
7 // 获取BeanDefinition对象
8 RootBeanDefinition mbdToUse = mbd;
9 // 锁定class，根据设置的class属性或者根据className来解析class 通过反射获取Class对象
10 Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
11 // 进行条件筛选，重新赋值RootBeanDefinition,并设置BeanClass属性
12 if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
13 // 重新创建一个RootBeanDefinition对象
14 mbdToUse = new RootBeanDefinition(mbd);
15 // 设置BeanClass属性值
16 mbdToUse.setBeanClass(resolvedClass);
17 }
18 // 验证及准备覆盖的方法,lookup-method replace-method，当需要创建的bean对象中包含了lookup-method和replace-method标签的时候，会产生覆盖操作
19 // lookup-method 解决问题：单例对象A，A持有原型对象B，此时需要用到lookup-method
20 try {
21 mbdToUse.prepareMethodOverrides();
22 }
23 catch (BeanDefinitionValidationException ex) {
24 throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
25 beanName, "Validation of method overrides failed", ex);
26 }
27
28 try {
29 // 给BeanPostProcessors一个机会来返回代理来替代真正的实例，应用实例化前的前置处理器,
30 // 用户自定义动态代理的方式，针对于当前的被代理类需要经过标准的代理流程来创建对象
31 // 可做自定义拓展用于初始化、实例化前后的处理，返回一个代理对象
32 Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
33 if (bean != null) {
34 return bean;
35 }
36 }
37 catch (Throwable ex) {
38 throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
39 "BeanPostProcessor before instantiation of bean failed", ex);
40 }
41 try {
42 // 实际创建bean的调用
43 Object beanInstance = doCreateBean(beanName, mbdToUse, args);
44 if (logger.isTraceEnabled()) {
45 logger.trace("Finished creating instance of bean '" + beanName + "'");
46 }
47 return beanInstance;
48 }
49 catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
50 throw ex;
51 }
52 catch (Throwable ex) {
53 throw new BeanCreationException(
54 mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
55 }
56 }
1、获取beanName的Class对象；
2、若Class对象存在，将RootBeanDefinition深拷贝一份，变量名mbdToUse，做属性赋值，设置BeanClass属性值；
3、验证及准备覆盖的方法,lookup-method replace-method；
4、实例化前的前置处理器，此处在AOP会调用，返回的是代理对象(涉及动态代理会执行AbstractAutoProxyCreator.postProcessBeforeInstantiation()方法)。
5、执行实际创建bean的方法doCreateBean。
1.4、doCreateBean：实际创建bean的方法
1 // 实际创建bean的方法
2 protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
3 throws BeanCreationException {
4 // 这个beanWrapper是用来持有创建出来的bean对象的
5 BeanWrapper instanceWrapper = null;
6 // 获取factoryBean实例缓存
7 if (mbd.isSingleton()) {
8 // 如果是单例对象，从factorybean实例缓存中移除当前bean定义信息
9 instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
10 }
11 // 没有就创建实例
12 if (instanceWrapper == null) {
13 // 根据执行bean使用对应的策略创建新的实例，如，工厂方法，构造函数主动注入、简单初始化
14 instanceWrapper = createBeanInstance(beanName, mbd, args);
15 }
16 // 从包装类中获取原始bean
17 Object bean = instanceWrapper.getWrappedInstance();
18 // 获取具体的bean对象的Class属性
19 Class<?> beanType = instanceWrapper.getWrappedClass();
20 // 如果不等于NullBean类型，那么修改目标类型
21 if (beanType != NullBean.class) {
22 mbd.resolvedTargetType = beanType;
23 }
24
25 // 允许beanPostProcessor去修改合并的beanDefinition, 注册bean的相关注解(如@Autowird, @Resource等)
26 synchronized (mbd.postProcessingLock) {
27 if (!mbd.postProcessed) {
28 try {
29 // MergedBeanDefinitionPostProcessor后置处理器修改合并bean的定义
30 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
31 }
32 catch (Throwable ex) {
33 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
34 "Post-processing of merged bean definition failed", ex);
35 }
36 mbd.postProcessed = true;
37 }
38 }
39
40 // 判断当前bean是否需要提前曝光：单例&允许循环依赖&当前bean正在创建中，检测循环依赖
41 boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
42 isSingletonCurrentlyInCreation(beanName));
43 if (earlySingletonExposure) {
44 if (logger.isTraceEnabled()) {
45 logger.trace("Eagerly caching bean '" + beanName +
46 "' to allow for resolving potential circular references");
47 }
48 // 为避免后期循环依赖，可以在bean初始化完成前将创建实例的ObjectFactory加入工厂
49 addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
50 }
51
52 // 初始化bean实例
53 Object exposedObject = bean;
54 try {
55 // 对bean的属性进行填充，将各个属性值注入，其中，可能存在依赖于其他bean的属性，则会递归初始化依赖的bean
56 populateBean(beanName, mbd, instanceWrapper);
57 // 执行初始化逻辑
58 exposedObject = initializeBean(beanName, exposedObject, mbd);
59 }
60 catch (Throwable ex) {
61 if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
62 throw (BeanCreationException) ex;
63 }
64 else {
65 throw new BeanCreationException(
66 mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
67 }
68 }
69 // ... 省略部分代码
70 // 一次性注册bean
71 try {
72 registerDisposableBeanIfNecessary(beanName, bean, mbd);
73 }
74 catch (BeanDefinitionValidationException ex) {
75 throw new BeanCreationException(
76 mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
77 }
78
79 return exposedObject;
80 }
1、要创建的对象是单例的，则从factorybean实例缓存中移除当前bean定义信息，重新创建；
2、createBeanInstance(beanName, mbd, args);创建bean实例，如果factorybean实例缓存没有当前的bean定义信息，根据bean使用对应的策略创建新的实例，如，工厂方法，构造函数主动注入、简单初始化； 1 protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
2 // Make sure bean class is actually resolved at this point.
3 // 确认需要创建的bean实例的类可以实例化
4 Class<?> beanClass = resolveBeanClass(mbd, beanName);
5
6 // 判断当前beanDefinition中是否包含实例供应器，此处相当于一个回调方法，利用回调方法来创建bean
7 Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
8 if (instanceSupplier != null) {
9 return obtainFromSupplier(instanceSupplier, beanName);
10 }
11
12 // 如果工厂方法不为空则使用工厂方法初始化策略
13 if (mbd.getFactoryMethodName() != null) {
14 return instantiateUsingFactoryMethod(beanName, mbd, args);
15 }
16
17 // 一个类可能有多个构造器，所以Spring得根据参数个数、类型确定需要调用的构造器
18 // 在使用构造器创建实例后，Spring会将解析过后确定下来的构造器或工厂方法保存在缓存中，避免再次创建相同bean时再次解析
19
20 // 标记下，防止重复创建同一个bean
21 boolean resolved = false;
22 // 是否需要自动装配
23 boolean autowireNecessary = false;
24 // 如果没有参数
25 if (args == null) {
26 // 因为一个类可能由多个构造函数，所以需要根据配置文件中配置的参数或传入的参数来确定最终调用的构造函数。
27 // 因为判断过程会比较，所以spring会将解析、确定好的构造函数缓存到BeanDefinition中的resolvedConstructorOrFactoryMethod字段中。
28 // 在下次创建相同对象时，直接从RootBeanDefinition中的属性resolvedConstructorOrFactoryMethod缓存的值获取，避免再次解析
29 synchronized (mbd.constructorArgumentLock) {
30 if (mbd.resolvedConstructorOrFactoryMethod != null) {
31 resolved = true;
32 autowireNecessary = mbd.constructorArgumentsResolved;
33 }
34 }
35 }
36 // 有构造参数的或者工厂方法
37 if (resolved) {
38 // 构造器有参数
39 if (autowireNecessary) {
40 // 构造函数自动注入
41 return autowireConstructor(beanName, mbd, null, null);
42 }
43 else {
44 // 使用默认构造函数构造
45 return instantiateBean(beanName, mbd);
46 }
47 }
48
49 // Candidate constructors for autowiring?
50 // 从bean后置处理器中为自动装配寻找构造方法, 有且仅有一个有参构造或者有且仅有@Autowired注解构造
51 Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
52 // 1、存在可选构造方法 或
53 // 2、自动装配模型为构造函数自动装配 或
54 // 3、给BeanDefinition中设置了构造参数值 或
55 // 4、有参与构造函数参数列表的参数
56 if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
57 mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
58 return autowireConstructor(beanName, mbd, ctors, args);
59 }
60
61 // Preferred constructors for default construction?
62 // 找出最合适的默认构造方法
63 ctors = mbd.getPreferredConstructors();
64 if (ctors != null) {
65 // 构造函数自动注入
66 return autowireConstructor(beanName, mbd, ctors, null);
67 }
68
69 // No special handling: simply use no-arg constructor.
70 // 使用默认无参构造函数创建对象，如果没有无参构造且存在多个有参构造且没有@AutoWired注解构造，会报错
71 return instantiateBean(beanName, mbd);
72 }
·获取beanName的Class对象，若有Supplier、FactoryMethod的实现，则直接通过此实现创建bean的实例并返回对象封装类。
·使用构造函数自动装配的方式，创建bean实例并返回对象封装类 ·实例化beanName的核心方法： instantiateBean(beanName, mbd); -> SimpleInstantiationStrategy.instantiate 若有方法重载的，就需要用cglib来动态代理，如果没有就直接获取默认构造方法实例化 默认构造器方式实例化的核心代码:1 // 通过反射实例化 2 BeanUtils.instantiateClass(constructorToUse);
cglib动态代理实例化的核心代码:
1 // cglib动态代理实例化 2 instantiateWithMethodInjection(bd, beanName, owner);由此可见，bean实例化的核心技术是 反射 3、applyMergedBeanDefinitionPostProcessors处理常用注解信息，并将注解元数据设置到beanDefinition中; ·CommonAnnotationBeanPostProcessor的生命周期方法(@PostConstruct、@PreDestroy)； ·Resource注解信息；
1 // CommonAnnotationBeanPostProcessor处理类
2 @Override
3 public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
4 // 处理@PostConstruct和@PreDestroy注解
5 super.postProcessMergedBeanDefinition(beanDefinition, beanType, beanName);
6 //找出beanType所有被@Resource标记的字段和方法封装到InjectionMetadata中
7 InjectionMetadata metadata = findResourceMetadata(beanName, beanType, null);
8 metadata.checkConfigMembers(beanDefinition);
9 }
·AutowiredAnnotationBeanPostProcessor的Autowired和Value注解信息。
1 /*
2 * 处理合并的bean定义信息
3 * 1、解析@Autowired等注解然后转换
4 * 2、把注解信息转换为InjectionMetadata然后缓存到上面的injectionMetadataCache里面
5 */
6 @Override
7 public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
8 // 解析Autowired注解并缓存
9 InjectionMetadata metadata = findAutowiringMetadata(beanName, beanType, null);
10 metadata.checkConfigMembers(beanDefinition);
11 }
4、判断正在创建的bean是否允许循环依赖，若允许，则在bean初始化完成前将创建实例的ObjectFactory加入工厂。
5、populateBean为bean实例填充属性。
1 protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
2 // ...
3
4 // 给任何实现了InstantiationAwareBeanPostProcessors的子类机会去修改bean的状态再设置属性之前，可以被用来支持类型的字段注入
5 // 否是"synthetic"。一般是指只有AOP相关的pointCut配置或者Advice配置才会将 synthetic设置为true
6 // 如果mdb是不是'syntheic'且工厂拥有InstantiationAwareBeanPostProcessor
7 if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
8 //遍历工厂中的BeanPostProcessor对象
9 for (BeanPostProcessor bp : getBeanPostProcessors()) {
10 //如果 bp 是 InstantiationAwareBeanPostProcessor 实例
11 if (bp instanceof InstantiationAwareBeanPostProcessor) {
12 InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
13 // postProcessAfterInstantiation：一般用于设置属性
14 if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
15 return;
16 }
17 }
18 }
19 }
20
21 //如果mdb有PropertyValues就获取其PropertyValues
22 PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
23
24 // 获取 mbd 的 自动装配模式
25 int resolvedAutowireMode = mbd.getResolvedAutowireMode();
26 // 如果 自动装配模式 为 按名称自动装配bean属性 或者 按类型自动装配bean属性
27 if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
28 //MutablePropertyValues：PropertyValues接口的默认实现。允许对属性进行简单操作，并提供构造函数来支持从映射 进行深度复制和构造
29 MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
30 // Add property values based on autowire by name if applicable.
31 // 根据autotowire的名称(如适用)添加属性值
32 if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
33 autowireByName(beanName, mbd, bw, newPvs);
34 }
35 // Add property values based on autowire by type if applicable.
36 // 根据自动装配的类型(如果适用)添加属性值
37 if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
38 //通过bw的PropertyDescriptor属性类型，查找出对应的Bean对象，将其添加到newPvs中
39 autowireByType(beanName, mbd, bw, newPvs);
40 }
41 //让pvs重新引用newPvs,newPvs此时已经包含了pvs的属性值以及通过AUTOWIRE_BY_NAME，AUTOWIRE_BY_TYPE自动装配所得到的属性值
42 pvs = newPvs;
43 }
44
45 //工厂是否拥有InstiationAwareBeanPostProcessor
46 boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
47 //mbd.getDependencyCheck()，默认返回 DEPENDENCY_CHECK_NONE，表示 不检查
48 //是否需要依赖检查
49 boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
50
51 //经过筛选的PropertyDesciptor数组,存放着排除忽略的依赖项或忽略项上的定义的属性
52 PropertyDescriptor[] filteredPds = null;
53 //如果工厂拥有InstiationAwareBeanPostProcessor,那么处理对应的流程，
54 // 主要是对几个注解的赋值工作包含的两个关键子类是CommonAnnoationBeanPostProcessor,AutowiredAnnotationBeanPostProcessor
55 // 主要是针对@Autowired等注解的处理
56 if (hasInstAwareBpps) {
57 //如果pvs为null
58 if (pvs == null) {
59 //尝试获取mbd的PropertyValues
60 pvs = mbd.getPropertyValues();
61 }
62 //遍历工厂内的所有后置处理器
63 for (BeanPostProcessor bp : getBeanPostProcessors()) {
64 if (bp instanceof InstantiationAwareBeanPostProcessor) {
65 //将bp 强转成 InstantiationAwareBeanPostProcessor 对象
66 InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
67 //postProcessProperties:在工厂将给定的属性值应用到给定Bean之前，对它们进行后处理，不需要任何属性扫描符。该回调方法在未来的版本会被删掉。
68 // -- 取而代之的是 postProcessPropertyValues 回调方法。
69 // 让ibp对pvs增加对bw的Bean对象的propertyValue，或编辑pvs的proertyValue
70 PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
71 //如果pvs为null
72 if (pvsToUse == null) {
73 //如果filteredPds为null
74 if (filteredPds == null) {
75 //mbd.allowCaching:是否允许缓存，默认时允许的。缓存除了可以提高效率以外，还可以保证在并发的情况下，返回的PropertyDesciptor[]永远都是同一份
76 //从bw提取一组经过筛选的PropertyDesciptor,排除忽略的依赖项或忽略项上的定义的属性
77 filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
78 }
79 //postProcessPropertyValues:一般进行检查是否所有依赖项都满足，例如基于"Require"注释在 bean属性 setter，
80 // -- 替换要应用的属性值，通常是通过基于原始的PropertyValues创建一个新的MutablePropertyValue实例， 添加或删除特定的值
81 // -- 返回的PropertyValues 将应用于bw包装的bean实例 的实际属性值（添加PropertyValues实例到pvs 或者 设置为null以跳过属性填充）
82 //回到ipd的postProcessPropertyValues方法
83 pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
84 //如果pvsToUse为null，将终止该方法精致，以跳过属性填充
85 if (pvsToUse == null) {
86 return;
87 }
88 }
89 //让pvs引用pvsToUse
90 pvs = pvsToUse;
91 }
92 }
93 }
94 // ...
95
96 //如果pvs不为null
97 if (pvs != null) {
98 //应用给定的属性值，解决任何在这个bean工厂运行时其他bean的引用。必须使用深拷贝，所以我们 不会永久地修改这个属性
99 applyPropertyValues(beanName, mbd, bw, pvs);
100 }
101 }
·若有实现了InstantiationAwareBeanPostProcessors的子类，则可优先修改bean；
·根据设置的自动装配模式，可通过名称或类型做装配；
·处理注解注入的bean属性内容。
6、initializeBean初始化bean实例。
1 protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
2 // 如果安全管理器不为空
3 if (System.getSecurityManager() != null) {
4 // 以特权的方式执行回调bean中的Aware接口方法
5 AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
6 invokeAwareMethods(beanName, bean);
7 return null;
8 }, getAccessControlContext());
9 }
10 else {
11 // Aware接口处理器，调用BeanNameAware、BeanClassLoaderAware、beanFactoryAware
12 invokeAwareMethods(beanName, bean);
13 }
14
15 Object wrappedBean = bean;
16 //如果mdb不为null || mbd不是"synthetic"。一般是指只有AOP相关的prointCut配置或者Advice配置才会将 synthetic设置为true
17 if (mbd == null || !mbd.isSynthetic()) {
18 // 将BeanPostProcessors应用到给定的现有Bean实例，调用它们的postProcessBeforeInitialization初始化方法。
19 // 返回的Bean实例可能是原始Bean包装器
20 wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
21 }
22
23 try {
24 //调用初始化方法，先调用bean的InitializingBean接口方法，后调用bean的自定义初始化方法
25 // 通过反射执行
26 invokeInitMethods(beanName, wrappedBean, mbd);
27 }
28 catch (Throwable ex) {
29 //捕捉调用初始化方法时抛出的异常，重新抛出Bean创建异常：调用初始化方法失败
30 throw new BeanCreationException(
31 (mbd != null ? mbd.getResourceDescription() : null),
32 beanName, "Invocation of init method failed", ex);
33 }
34 //如果mbd为null || mbd不是"synthetic"
35 if (mbd == null || !mbd.isSynthetic()) {
36 // 将BeanPostProcessors应用到给定的现有Bean实例，调用它们的postProcessAfterInitialization方法。
37 // 返回的Bean实例可能是原始Bean包装器
38 wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
39 }
40
41 //返回包装后的Bean
42 return wrappedBean;
43 }
·执行Aware处理器接口；
· 将BeanPostProcessors应用到给定的现有Bean实例，调用postProcessBeforeInitialization初始化方法； · 通过反射执行初始化方法； · 通过反射执行初始化方法； · 调用初始化后的后置处理器 - postProcessAfterInitialization方法。