开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> Spring源码系列：Bean的加载 -> 正文阅读

[Java知识库]Spring源码系列：Bean的加载

前言

在我们前面两章，我们讲完了Spring如何加载、解析资源文件以及如何将其转化为BeanDefinition的（标签的解析）流程。那么接下来我们来看下Bean的一个加载过程。我们来从这段代码为切入口：

public static void main(String[] args) {
	ClassPathResource resource = new ClassPathResource("test.xml");
	DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
	XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
	reader.loadBeanDefinitions(resource);

	GetNameTest getNameTest = (GetNameTest) factory.getBean("getNameTest");
	getNameTest.getName();
}

一. Bean的加载

Spring中对于bean的加载功能，普遍的调用方式为factory.getBean(beanName);那我们来看下这个方法到底做了什么事情，再根据每一个步骤进行展开来细说。

GetNameTest getNameTest = (GetNameTest) factory.getBean("getNameTest");
↓↓↓↓↓↓
public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
	@Override
	public Object getBean(String name) throws BeansException {
		return doGetBean(name, null, null, false);
	}
	↓↓↓↓↓↓
	protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
			throws BeansException {
		// 1.提取对应的beanName
		String beanName = transformedBeanName(name);
		Object beanInstance;

		// 2.检查缓存中或者实例工厂中是否有对应的实例
		/**
		 * 背景：在创建单例bean的时候，存在依赖注入的情况。
		 * 目的：为了避免循环依赖的产生，Spring再创建bean的时候，并不会等待bean创建完成，而是会在 bean 创建完成之前提早曝光这个 ObjectFactory。
		 * 即：将 ObjectFactory 加入到Map缓存中，下一个bean创建的时候，若需要依赖上一个bean，那么就可以直接使用这个 ObjectFactory 对象。
		 * 缓存：this.singletonObjects
		 * 提前暴露的单利工厂。this.singletonFactories。其还有另外一个熟悉的名称：三级工厂。具体的分析，在下文展开
		 */
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			if (logger.isTraceEnabled()) {
				if (isSingletonCurrentlyInCreation(beanName)) {
					logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
							"' that is not fully initialized yet - a consequence of a circular reference");
				}
				else {
					logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
				}
			}
			// 3.返回对应的实例，因为有时候如BeanFactory的情况，并不是直接返回实例本身。而是返回指定方法返回的实例对象。
			beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			// 4.若出现循环依赖的情况，则抛异常
			/**
			 * A类、B类必须为单例
			 * A类有B对象作为其属性。
			 * B类有A对象作为其属性。
			 */
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			// 5.若BeanDefinitionMap中（存储已经加载好的类）不包含beanName。那么尝试从父BeanDefinition中去检测。即父工厂
			BeanFactory parentBeanFactory = getParentBeanFactory();
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				String nameToLookup = originalBeanName(name);
				if (parentBeanFactory instanceof AbstractBeanFactory abf) {
					return abf.doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
				}
				// 递归到beanFactory中去寻找。
				else if (args != null) {
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
				else if (requiredType != null) {
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
				else {
					return (T) parentBeanFactory.getBean(nameToLookup);
				}
			}
			// 6.若不是仅仅做类型检查。那么就是创建bean。这里做一个mark（标记），做记录。
			if (!typeCheckOnly) {
				markBeanAsCreated(beanName);
			}

			StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
					.tag("beanName", name);
			try {
				if (requiredType != null) {
					beanCreation.tag("beanType", requiredType::toString);
				}
				// 7.我们从Spring解析标签的过程中可以得知。XML的一些具体配置都存储于 GenericBeanDefinition 中
				// 这里则是将 GenericBeanDefinition 转化为 RootBeanDefinition。
				// 若指定的 beanName 是子Bean的话，还会合并父子BeanDefinition。
				RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				// 8.检测合并后的类型。合并后的BeanDefinition肯定不是AbstractBeanDefinition，若是，则其肯定是abstract类型的，此时抛异常
				checkMergedBeanDefinition(mbd, beanName, args);

				// 9.若存在依赖，那么开始递归实例化依赖的Bean。（属性注入（包括实例化））
				String[] dependsOn = mbd.getDependsOn();
				if (dependsOn != null) {
					for (String dep : dependsOn) {
						if (isDependent(beanName, dep)) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
						}
						registerDependentBean(dep, beanName);
						try {
							getBean(dep);
						}
						catch (NoSuchBeanDefinitionException ex) {
							throw new BeanCreationException(mbd.getResourceDescription(), beanName,
									"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
						}
					}
				}

				// 10.若依赖都注入完了。就开始实例化本身，创建单例模式，注意这里是第一次实例化（因为单例缓存中不存在，才会走到该分支）
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, () -> {
						try {
							return createBean(beanName, mbd, args);
						}
						catch (BeansException ex) {
							destroySingleton(beanName);
							throw ex;
						}
					});
					beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
				}
				else if (mbd.isPrototype()) {
					// 多例，创建个新的实例
					Object prototypeInstance = null;
					try {
						beforePrototypeCreation(beanName);
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						afterPrototypeCreation(beanName);
					}
					beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}
				else {
					// 或者根据指定的scope进行实例化
					String scopeName = mbd.getScope();
					if (!StringUtils.hasLength(scopeName)) {
						throw new IllegalStateException("No scope name defined for bean '" + beanName + "'");
					}
					Scope scope = this.scopes.get(scopeName);
					if (scope == null) {
						throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
					}
					try {
						Object scopedInstance = scope.get(beanName, () -> {
							beforePrototypeCreation(beanName);
							try {
								return createBean(beanName, mbd, args);
							}
							finally {
								afterPrototypeCreation(beanName);
							}
						});
						beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
					}
					catch (IllegalStateException ex) {
						throw new ScopeNotActiveException(beanName, scopeName, ex);
					}
				}
			}
			catch (BeansException ex) {
				// ...
			}
			finally {
				beanCreation.end();
			}
		}
		// 11.检查需要的类型是否符合bean的实际类型
		return adaptBeanInstance(name, beanInstance, requiredType);
	}
}

上述代码可以做个总结，其大致步骤如下：

转换对应beanName，传入的参数可能是别名、FactoryBean。因此需要进行进一步的转换解析。
尝试从缓存中加载单例，若有，则可以直接返回。
bean的实例化。
检测ParentBeanFactory，进行递归。
循环依赖检查。
将 GenericBeanDefinition 转化为 RootBeanDefinition，若当前bean为子bean，则合并父子BeanDefinition。
寻找依赖，对依赖项进行递归注入。
针对不同的scope进行bean的创建。
类型转换。

大胆点，我们再简化一下，Bean的一个加载三步走：

Bean的实例化。
Bean的相关依赖注入。
Bean的初始化。

对应写出个伪代码：

Object dfs(beanName){
	// 1.实例化
	Object bean = getBeanInstance(beanName);
	// 2.递归依赖注入（若存在）
	String[] depends = getDependsOn(bean);
	for(String name:depends){
		dfs(name);
	}
	// 3.初始化
	return initBean(bean);
}

1.1 FactoryBean的使用

背景：Spring通过反射机制利用bean的class属性指定实现类来实例化bean。但是传统的方式下，需要在<bean>标签里面配置大量的信息，而XML配置的这种方式是有局限性的。 若可以通过编码的方式来进行实例化，就能更加自由地实例化一些复杂的bean。FactoryBean这个接口就是用来让用户定制自定义实例化的逻辑的。

public interface FactoryBean<T> {
	String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";
	// 返回由FactoryBean创建的bean实例，如果isSingleton()返回true
	// 那么该实例则会放到单例缓存池里面。
	@Nullable
	T getObject() throws Exception;
	// 返回FactoryBean创建的bean实例的类型
	@Nullable
	Class<?> getObjectType();
	// 返回由 FactoryBean 创建的bean实例的作用域，是singleton还是prototype
	default boolean isSingleton() {
		return true;
	}
}

若配置文件中的<bean>标签的class属性配置的实现类是FactoryBean的实现类的时候，那么通过getBean()返回的则是FactoryBean.getObject()方法返回的对象。相当于其代理了getBean的方法。

案例：FactoryBean的使用和定义

项目结构如下：
在这里插入图片描述
User类：

public class User {
	private String name;
	private String address;

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

UserFactoryBean类，需要实现FactoryBean类，进行自定义加载Bean。

import org.springframework.beans.factory.FactoryBean;

public class UserFactoryBean implements FactoryBean<User> {
	private String userInfo;
	@Override
	public User getObject() throws Exception {
		User user = new User();
		String[] infos = userInfo.split(",");
		user.setName(infos[0]);
		user.setAddress(infos[1]);
		return user;
	}

	@Override
	public Class<User> getObjectType() {
		return User.class;
	}

	@Override
	public boolean isSingleton() {
		return false;
	}

	public String getUserInfo() {
		return userInfo;
	}

	public void setUserInfo(String userInfo) {
		this.userInfo = userInfo;
	}
}

user.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xsi:schemaLocation="
   	http://www.springframework.org/schema/beans
   	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
	<bean id="user" class="com.mytest.factorytest.UserFactoryBean">
		<property name="userInfo" value="你好,上海"/>
	</bean>

</beans>

Test类：

public class Test {
	public static void main(String[] args) {
		DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
		XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);

		ClassPathResource resource = new ClassPathResource("/factorytest/user.xml");
		reader.loadBeanDefinitions(resource);

		User user = (User) factory.getBean("user");
		System.out.println(user.getName());
		System.out.println(user.getAddress());
	}
}

代码运行结果如下：
在这里插入图片描述
可见确实如上文所说FactoryBean.getObject()方法代理了getBean()方法，负责Bean的加载。

1.2 缓存中获取单例Bean

Spring在获取bean的时候，会先从单例缓存中去尝试获取，若还没有，则再去singletonFactories中加载。

我们来看下这个方法：Object sharedInstance = getSingleton(beanName);

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
	public Object getSingleton(String beanName) {
		// true设置为：允许早期依赖（就是我们说的，为了避免循环依赖，不等bean创建完成就会将创建bean的ObjectFactory提早曝光）
		return getSingleton(beanName, true);
	}
	↓↓↓↓↓↓
	@Nullable
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		// 1.先检查一级缓存中是否存在，若存在，则直接返回。这里的bean都是已经创建完成的。
		Object singletonObject = this.singletonObjects.get(beanName);
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			// 2.尝试从二级缓存中获取，这里的bean都是完成实例化，但是没有进行属性注入和初始化的对象或者代理对象
			singletonObject = this.earlySingletonObjects.get(beanName);
			if (singletonObject == null && allowEarlyReference) {
				synchronized (this.singletonObjects) {
					singletonObject = this.singletonObjects.get(beanName);
					if (singletonObject == null) {
						singletonObject = this.earlySingletonObjects.get(beanName);
						if (singletonObject == null) {
							// 3.singletonFactories：提前暴露的单例工厂，二级缓存中存储的对象，就是从该工厂中获取到的对象
							ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
							if (singletonFactory != null) {
								// 4.创建bean
								singletonObject = singletonFactory.getObject();
								// 5.earlySingletonObjects和singletonFactories互斥
								this.earlySingletonObjects.put(beanName, singletonObject);
								this.singletonFactories.remove(beanName);
							}
						}
					}
				}
			}
		}
		return singletonObject;
	}
}

我们可以看出来，这里Spring有三级的缓存，用来解决循环依赖问题，具体的在下文展开。在此先解释下几种缓存代表的意义：

singletonObjects：保存beanName和bean实例（初始化完成的）之间的关系。
earlySingletonObjects：同样保存beanName和bean实例之间的关系。循环对象依赖列表，用于存储那些发生了循环依赖的对象。
singletonFactories：保存beanName和创建bean的工厂ObjectFactory之间的关系。注意和前两者的区别，其存储的并不是bean，而是负责创建它的工厂。

1.2.1 Spring解决循环依赖的原理☆

接下来我会用大篇幅来讲这个循环依赖的问题，也希望尽量将这一块难题啃下来，也方便日后自己复习，这里参考了这位博主的文章（第二次看了）

我们先来看下循环依赖的一个示意图：这里的类都是单例。
在这里插入图片描述
或者是更简单粗暴的：

@Component
public class A{
	@Autowired
	private A a;
}

那么在这种情况下，就是所谓的循环依赖了。

我们以A，B两个类之间的依赖来讲解Spring解决循环依赖的过程。
整体过程如下：

实例化A。
对A的属性B进行注入。
对B进行实例化。
对B进行属性注入。
B完成初始化方法。
A注入完成。则完成初始化方法。

(1) 以A类的角度来观察bean的加载过程。

Spring先对A进行实例化（第一次），那么最终最终会走代码中的第十步：

if (mbd.isSingleton()) {
	sharedInstance = getSingleton(beanName, () -> {
		try {
			return createBean(beanName, mbd, args);
		}
		catch (BeansException ex) {
			destroySingleton(beanName);
			throw ex;
		}
	});
	beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

该代码走的则是getSingleton的重载方法：

getSingleton(String beanName, ObjectFactory<?> singletonFactory)

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
	Assert.notNull(beanName, "Bean name must not be null");
	synchronized (this.singletonObjects) {
		// 1.同样先去单例缓存中去拿
		Object singletonObject = this.singletonObjects.get(beanName);
		if (singletonObject == null) {
			// ..日志记录等
			// 2.在创建单例对象之前先做一个标记处理。将beanName放入singletonsCurrentlyInCreation集合中。
			// 代表这个bean正在被创建中，如果一个单例Bean被多次创建，那么会在这里抛出异常
			beforeSingletonCreation(beanName);
			boolean newSingleton = false;
			boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
			if (recordSuppressedExceptions) {
				this.suppressedExceptions = new LinkedHashSet<>();
			}
			try {
				// 3.这里则执行外部传入的参数，是一个lambda表达式，调用上文的createBean方法
				singletonObject = singletonFactory.getObject();
				newSingleton = true;
			}
			// ...catch
			finally {
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = null;
				}
				// 3.创建完成后，将对应的beanName从singletonsCurrentlyInCreation中删除
				afterSingletonCreation(beanName);
			}
			if (newSingleton) {
				// 4.添加到一级缓存中，注意到这一步为止，该单例bena已经创建完成了。即完成了初始化了。
				addSingleton(beanName, singletonObject);
			}
		}
		return singletonObject;
	}
}

从代码中我们可以发现，类的实例化由singletonObject = singletonFactory.getObject();来完成。我们又知道，外部传入的lambda表达式只执行了createBean方法。我们来跟进：

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
		implements AutowireCapableBeanFactory {
	protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
		// ...省略
		try {
			Object beanInstance = doCreateBean(beanName, mbdToUse, args);
			// ...
			return beanInstance;
		}
		// ...catch
	}
	
	protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
			// 创建实例
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		Object bean = instanceWrapper.getWrappedInstance();
		Class<?> beanType = instanceWrapper.getWrappedClass();
		if (beanType != NullBean.class) {
			mbd.resolvedTargetType = beanType;
		}
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			// log...
			// 先将beanName->工厂方法，加入到三级缓存中，因为可能会发生循环依赖
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}
		// 三级缓存中添加完成后，在进行属性注入和初始化
		Object exposedObject = bean;
		try {
			// 属性注入
			populateBean(beanName, mbd, instanceWrapper);
			// 初始化
			exposedObject = initializeBean(beanName, exposedObject, mbd);
		}
		if (earlySingletonExposure) {
			// 这里再一次调用了getSingleton方法，并且禁用了三级缓存。
			// 在属性注入阶段，B的属性注入阶段中，已经将A从三级缓存工厂取出，并加入到了二级缓存。
			// 因此这里取出来的是A的一个代理对象。
			Object earlySingletonReference = getSingleton(beanName, false);
			// ...
		}
	}
}

在这里做个总结，A类的加载做了什么事情getBean(beanNameA)开始：

A完成了实例化。
将beanNameA对应的工厂方法加入到了三级缓存。
A完成属性注入populateBean(beanName, mbd, instanceWrapper);。
A完成初始化exposedObject = initializeBean(beanName, exposedObject, mbd);。

那么对于B类的加载，则发生在A类加载阶段的第三步：属性注入阶段。

注意：属性注入阶段对于A类的属性B而言，也只不过是完成了三个步骤：实例化、B类的属性注入、初始化。

(2) 以B类的角度来观察bean的加载过程。

对于B而言，其加载同样是从getBean(beanNameB)开始的，同样的：

B完成了实例化。
将beanNameB对应的工厂方法加入到了三级缓存。
此时发现B类下面有个A属性，那么对A进行属性注入。 开始调用getBean(beanNameA)。
B完成初始化。

但是，这里的getBean则会走不同的分支了，我们这里可以接上1.1节源码的第二步：Object sharedInstance = getSingleton(beanName);（与A类的加载过程进行区分，参数传的不一样，并且在A类的加载过程中，已经将相关的工厂加入到了三级缓存中了。）此时跟进代码，我们会走入该环节：
在这里插入图片描述
结合上述代码，我们可以发现注入到B中的A对象是通过addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));提前暴露出去的，我们来跟进下getEarlyBeanReference：

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
		implements AutowireCapableBeanFactory {
	// 获取后置处理器，即通过@EnableAspectJAutoProxy注解导入的AnnotationAwareAspectJAutoProxyCreator对象
	protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
		Object exposedObject = bean;
		// 若有AOP的相关配置逻辑，才会走这段代码，若没有，本代码实则上并没有什么作用。也就是说三级工厂在无AOP的情况下是没有实质作用的。
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
				exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);
			}
		}
		return exposedObject;
	}
}

那么在无AOP的情况下：

虽然加载B的时候，给B注入了一个未完成初始化的对象A，但是A将其引用加入到了三级缓存。
因此注入到B中的是A的一个引用。在B完成初始化后，会根据这个引用对A进行初始化。

在开启AOP的情况下，则会走代码exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);：

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
		implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
	@Override
	public Object getEarlyBeanReference(Object bean, String beanName) {
		Object cacheKey = getCacheKey(bean.getClass(), beanName);
		this.earlyProxyReferences.put(cacheKey, bean);
		// 若需要代理，返回代理对象。
		// 若不需要代理，则返回当前这个bean。
		return wrapIfNecessary(bean, beanName, cacheKey);
	}
}

总结下就是：
在这里插入图片描述
注意：

初始化的时候我们都是对类本身进行初始化，但是在上述过程中，如容器给B在这里插入代码片类的注入的属性是A的代理对象，但是不管是cglib还是jdk代理，内部都存储一个目标类的引用。而A的代理对象就是A的一个引用。因此代理对象完成了初始化，A类自然而然完成了初始化。
只用二级缓存可以吗？为什么非要用三级缓存去存储一个工厂对象呢？若没有三级缓存，那么在B加载环节，就需要其相关属性完成AOP代理。而Spring希望AOP在bena初始化之后再进行。 因此，通过一个三级缓存，返回一个代理对象（没有完成AOP操作的），让bean之间完成初始化操作并解决循环依赖问题。最后再遵循Spring的原则，进行AOP代理。

1.2.2 小结

getBean有两种用途：

生成Bean，并将其工厂方法存入三级缓存。
从单例缓存中去获取bean。

此外，我们可以发现，二级缓存就能够实现解决Spring循环依赖的需求，而三级缓存的存在仅仅是提供了一个能够生成代理对象的工厂方法。 那么其目的是什么？

假设我们没有三级缓存，我们的对象并且是单例的。若A对象依赖的B对象存在AOP机制，即B对象需要被代理。那么在属性注入的时候，再加入二级缓存之前都需要被代理。这并不合适。 那么如果能够通过第三方的工厂方法，生成一个代理对象丢给二级缓存，就能解决这个问题。

问题来了：为何在存在AOP的情况下，我的实例再加入二级缓存之前就一定要完成代理呢？

Spring在创建对象的过程中，不知道对象什么时候会被代理， 因此无论当前对象是否需要被代理，总是会提前生成一个普通对象。
若二级缓存中存入的是半成品对象（只完成了实例化的），那么当被引用的时候，若发现了存在AOP代理，那么Spring又需要为其创建一个代理对象并返回。此时，二级缓存中的对象和代理对象并不是一个对象。

那么请问：代理对象和二级缓存中的对象不是一个东西，引用不同。那么这种情况下完成对代理对象的初始化之后，原对象完成了吗？

没有，那么通过三级缓存，直接将代理对象（其引用和Spring想要加载的bean的引用是同一个）返回给二级缓存。那么此时即满足AOP的代理条件，又能够满足Spring的一个初始化过程。

言归正传，到此为止，在讲解bean的循环依赖的过程中，其实已经顺带把bean加载的一个过程给过了一遍。但是里面的一些方法我们还没有详细的去了解。

1.3 从bean的实例中获取对象

我们在getBean方法中可以发现，getObjectForBeanInstance这个方法调用了多次。在这两种大情况下，都会调用该方法：

从缓存中加载bean。
根据不同的scope策略加载bean。

而该方法的目的就是为了检测bean的正确性。主要用于检测当前bean是否是FactoryBean类型的bean。 如果是，则会调用对应实例中的getObject()方法作为返回值（参考1.1小节的案例）。我们可以从侧面发现，无论从缓存中还是策略加载的bean都是最原始的bean。我们还需要做进一步的处理，来看下其源码：

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
	protected Object getObjectForBeanInstance(
			Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {

		// 1.若指定的name是工厂相关的，并且&开头
		if (BeanFactoryUtils.isFactoryDereference(name)) {
			if (beanInstance instanceof NullBean) {
				return beanInstance;
			}
			// 若不是 FactoryBean 类型，则验证不通过。前后if矛盾
			if (!(beanInstance instanceof FactoryBean)) {
				throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
			}
			if (mbd != null) {
				mbd.isFactoryBean = true;
			}
			// 若是 FactoryBean ,我们就用它创建实例。
			return beanInstance;
		}
		// 2.若是bean本身，则直接返回
		if (!(beanInstance instanceof FactoryBean)) {
			return beanInstance;
		}
		Object object = null;
		if (mbd != null) {
			mbd.isFactoryBean = true;
		}
		else {
			// 3.尝试从缓存中加载bean
			object = getCachedObjectForFactoryBean(beanName);
		}
		if (object == null) {
			// 4.若是BeanFactory类型的实例。且缓存中不存在
			FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
			// 5.在所有已经加载的bean中检测，是否存在相同的bean
			if (mbd == null && containsBeanDefinition(beanName)) {
				mbd = getMergedLocalBeanDefinition(beanName);
			}
			// 6.是否是用户定义的，而非程序本身定义。
			boolean synthetic = (mbd != null && mbd.isSynthetic());
			// 7.核心代码，获取实例对象。
			object = getObjectFromFactoryBean(factory, beanName, !synthetic);
		}
		return object;
	}
}

再从最后一步的核心代码出发，来看下展开的源码：

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
	// 1.若是单例模式
	if (factory.isSingleton() && containsSingleton(beanName)) {
		// 2.锁住singletonObjects对象，一级缓存
		synchronized (getSingletonMutex()) {
			// 3.factoryBeanObjectCache存储一些已经创建好的，并且由factoryBean创建出来的bean。
			Object object = this.factoryBeanObjectCache.get(beanName);
			if (object == null) {
				object = doGetObjectFromFactoryBean(factory, beanName);
				// 发生循环引用时可能也会有提早暴露的对象（代理）
				Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
				if (alreadyThere != null) {
					object = alreadyThere;
				}
				else {
					// 若需要对bean进行后续处理
					if (shouldPostProcess) {
						// 若该bean还在创建过程中，则不做处理直接返回
						if (isSingletonCurrentlyInCreation(beanName)) {
							return object;
						}
						// 创建bean前预处理
						beforeSingletonCreation(beanName);
						try {
							object = postProcessObjectFromFactoryBean(object, beanName);
						}
						catch (Throwable ex) {
							throw new BeanCreationException(beanName,
									"Post-processing of FactoryBean's singleton object failed", ex);
						}
						finally {
							// 创建bean后处理
							afterSingletonCreation(beanName);
						}
					}
					if (containsSingleton(beanName)) {
						this.factoryBeanObjectCache.put(beanName, object);
					}
				}
			}
			return object;
		}
	}
	else {
		Object object = doGetObjectFromFactoryBean(factory, beanName);
		if (shouldPostProcess) {
			try {
				object = postProcessObjectFromFactoryBean(object, beanName);
			}
			catch (Throwable ex) {
				throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
			}
		}
		return object;
	}
}

可以发现最外层的if/else分支，都调用了doGetObjectFromFactoryBean方法：

private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {
	Object object;
	try {
		// 权限验证
		if (System.getSecurityManager() != null) {
			AccessControlContext acc = getAccessControlContext();
			try {
				object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
			}
			catch (PrivilegedActionException pae) {
				throw pae.getException();
			}
		}
		else {
			object = factory.getObject();
		}
	}
	// catch..
	// ...
	return object;
}

可以发现无论怎么样，都会执行FactoryBean的getObject方法来获取实例对象。本小节实质上并不是特别复杂，通过简化也就是：

检验beanInstance对象，他是bean类型还是FactoryBean类型的实例？
若是FactoryBean类型的，并且以&为开头，说明用户希望直接获取工厂实例而非工厂方法创建出来的实例对象。
若是bean类型，直接返回。
若是FactoryBean类型，不以&开头，那么就调用其getObject()方法并返回实例。
并且根据条件（是否用户创建），来对该bean实例进行后续处理。即后处理器的调用。

Spring在获取bean的时候有这么一个规则：尽可能保证所有bean初始化完成后都会调用注册的BeanPostProcessor的postProcessAfterInitialization方法进行处理。

紧接着，我们需要将注意力几种在Bean的一个创建过程。即实例化、属性注入、初始化的这么一个过程。

1.4 Bean的创建☆

上述文章中，一大片篇幅其实都是在讲Spring如何从缓存中加载Bean（1.2节）以及如何将原始bean进行转换的（1.3节）。但是我们都没有具体的去看过Spring在第一次的时候（无缓存）是怎么创建Bean的。

一切还是该从这段代码走起，来再回忆一遍：

if (mbd.isSingleton()) {
	sharedInstance = getSingleton(beanName, () -> {
		try {
			return createBean(beanName, mbd, args);
		}
		catch (BeansException ex) {
			destroySingleton(beanName);
			throw ex;
		}
	});
	beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

createBean则是创建Bean的入口函数，最终的实现在AbstractAutowireCapableBeanFactory类中完成：

@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
		throws BeanCreationException {
	// ...
	RootBeanDefinition mbdToUse = mbd;

	// 1.锁定class，根据设置的class属性或者根据className来解析
	Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
	if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
		mbdToUse = new RootBeanDefinition(mbd);
		mbdToUse.setBeanClass(resolvedClass);
	}

	// 2.验证和准备覆盖的方法。
	try {
		mbdToUse.prepareMethodOverrides();
	}
	// ...catch
	try {
		// 3.提供机会，用BeanPostProcessors返回的代理对象来替代实例
		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
		if (bean != null) {
			return bean;
		}
	}
	// ...catch

	try {
		// 4.创建bean
		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		if (logger.isTraceEnabled()) {
			logger.trace("Finished creating instance of bean '" + beanName + "'");
		}
		return beanInstance;
	}
	// ...catch
}

一共有4步：

根据设置的class属性或者根据className来解析Class。
对override属性进行标记验证。如XML配置中的lookup-method和replaced-method标签。
应用初始化前的后处理器，解析指定的bean是否存在初始化前的短路操作。
创建bean。

1.4.1 处理override属性

XML配置中的lookup-method和replaced-method标签。经过Spring容器的读取和转换后，将其存放在BeanDefinition中的methodOverrides属性中，而下面的操作就是针对该属性来进行的。

mbdToUse.prepareMethodOverrides();
↓↓↓↓↓
public void prepareMethodOverrides() throws BeanDefinitionValidationException {
	// 判断methodOverrides是否为空
	if (hasMethodOverrides()) {
		// 遍历处理
		getMethodOverrides().getOverrides().forEach(this::prepareMethodOverride);
	}
}
↓↓↓↓↓
protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {
	// 获取对应类中和该名称同名的方法的个数
	int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());
	// 若没有，抛出异常，说明XML配置肯定出问题啦，配置了一个不存在的方法
	if (count == 0) {
		throw new BeanDefinitionValidationException(
				"Invalid method override: no method with name '" + mo.getMethodName() +
				"' on class [" + getBeanClassName() + "]");
	}
	else if (count == 1) {
		// 标记methodOverride暂时没有被覆盖，避免参数类型检查带来的开销
		mo.setOverloaded(false);
	}
}

在后续bean实例化的阶段，若检查到对应的methodOverride属性，则会动态的为当前bean生成代理，并使用拦截器为bean做增强处理（下文介绍）。

1.4.2 实例化的前置处理

Spring-AOP的功能就是基于此进行的，我们来看下这个方法的调用入口：

Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
// 为什么要加这个判断？
// 若经过前置处理的返回结果不是null，那么我们就将其替代原有的bean，直接返回。以达到逻辑增强的插拔效果。
if (bean != null) {
	return bean;
}

来看下resolveBeforeInstantiation方法的源码：

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
		implements AutowireCapableBeanFactory {

	@Nullable
	protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
		Object bean = null;
		// 没被处理过的情况下
		if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
			if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
				Class<?> targetType = determineTargetType(beanName, mbd);
				if (targetType != null) {
					// 调用 InstantiationAwareBeanPostProcessor 的 postProcessBeforeInstantiation 方法
					bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
					if (bean != null) {
						// 调用 BeanPostProcessor 的 postProcessAfterInitialization方法
						bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
					}
				}
			}
			mbd.beforeInstantiationResolved = (bean != null);
		}
		return bean;
	}
}

备注：

postProcessBeforeInstantiation方法：在Bean的自定义初始化方法之前执行。
postProcessAfterInitialization方法：在Bean的自定义初始化方法之后执行。

紧接着就是最后一个步骤了：

Object beanInstance = doCreateBean(beanName, mbdToUse, args);

代码的展开在上文已经有提及，本章只围绕着三个重点来讲：

createBeanInstance()：创建实例。
populateBean()：属性注入。
initializeBean()：初始化。

1.4.3 bean实例的创建

源码如下：

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
	// 1.根据Class属性来解析Class
	Class<?> beanClass = resolveBeanClass(mbd, beanName);

	if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
		throw new BeanCreationException(mbd.getResourceDescription(), beanName,
				"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
	}
	// 2.一个bean的回调函数，用来代替工厂方法。 若不为空，那么调用回调函数并直接将结果返回。
	Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
	if (instanceSupplier != null) {
		return obtainFromSupplier(instanceSupplier, beanName);
	}
	// 3.若工厂方法不为空，那么使用工厂方法来进行初始化。
	// 若RootBeanDefinition中配置了factoryMethodName属性，说明配置文件中配置了factory-method的方法
	if (mbd.getFactoryMethodName() != null) {
		return instantiateUsingFactoryMethod(beanName, mbd, args);
	}

	boolean resolved = false;// 构造函数是否解析过
	boolean autowireNecessary = false;// 构造函数其中的参数是否解析过
	if (args == null) {
		// 由于一个类中可能有多种构造函数，每个构造函数有着不同的参数。因此需要锁定构造函数
		synchronized (mbd.constructorArgumentLock) {
			// resolvedConstructorOrFactoryMethod ：一个用于缓存 已解析的构造函数或者工厂方法。
			// 因为构造函数的多样性，定位到一个准确的构造函数并进行实例化是一个耗时的过程，因此采用缓存来标记。
			if (mbd.resolvedConstructorOrFactoryMethod != null) {
				resolved = true;
				// constructorArgumentsResolved属性：标记这个构造函数参数已经解析过了
				autowireNecessary = mbd.constructorArgumentsResolved;
			}
		}
	}
	// 若已经解析过，那么使用解析好的构造函数
	if (resolved) {
		if (autowireNecessary) {
			return autowireConstructor(beanName, mbd, null, null);
		}else {
			// 使用默认的构造函数
			return instantiateBean(beanName, mbd);
		}
	}

	// 根据参数来解析构造函数
	Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
	if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
			mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
		// 构造函数注入
		return autowireConstructor(beanName, mbd, ctors, args);
	}

	// 构造函数注入
	ctors = mbd.getPreferredConstructors();
	if (ctors != null) {
		return autowireConstructor(beanName, mbd, ctors, null);
	}

	// 若以上都不命中，则使用默认构造来创建
	return instantiateBean(beanName, mbd);
}

总结下就是：

通过反射来解析Class对象并校验。
若配置了回调函数，那么直接调用并返回。
若配置了factory-method，则调用并返回。
否则，就调用其构造函数进行初始化（带参数），同时用了缓存进行优化。
若都没有，则调用默认的构造函数并返回。

同时我们可以注意到，代码中除了第二、第三点这样的特殊情况。对于实例的创建分为了两大类：

构造函数注入（带构造函数参数）：autowireConstructor。
通用实例化（无参构造）：instantiateBean。

(1) autowireConstructor解析

源码如下：

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
	protected BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd, @Nullable Constructor<?>[] ctors, @Nullable Object[] explicitArgs) {
		return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
	}
	↓↓↓↓↓↓
	public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
			@Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) {

		BeanWrapperImpl bw = new BeanWrapperImpl();
		this.beanFactory.initBeanWrapper(bw);

		Constructor<?> constructorToUse = null;
		ArgumentsHolder argsHolderToUse = null;
		Object[] argsToUse = null;
		// explicitArgs由调用getBean方法的时候传入
		if (explicitArgs != null) {
			argsToUse = explicitArgs;
		}
		else {
			// 若getBean调用的时候，并没有传入相关的参数，那么会尝试去配置文件中寻找
			Object[] argsToResolve = null;
			// 同理，这里用了缓存去存放解析好的构造函数参数
			synchronized (mbd.constructorArgumentLock) {
				constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
				if (constructorToUse != null && mbd.constructorArgumentsResolved) {
					// Found a cached constructor...
					argsToUse = mbd.resolvedConstructorArguments;
					if (argsToUse == null) {
						argsToResolve = mbd.preparedConstructorArguments;
					}
				}
			}
			/**
			 * 若缓存中存在，那么对参数值进行转换。
			 * 例如构造函数A(int a,int b)，而配置文件中配的是字符串("1","2")
			 * 那么该方法调用后，结果转化为(1,2)
			 */
			if (argsToResolve != null) {
				argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve);
			}
		}
		// 若缓存中没有
		if (constructorToUse == null || argsToUse == null) {
			// 若getBean的时候传了构造相关参数，则使用它
			Constructor<?>[] candidates = chosenCtors;
			// 若没有传入，则通过反射来获取相关的构造器
			if (candidates == null) {
				Class<?> beanClass = mbd.getBeanClass();
				try {
					candidates = (mbd.isNonPublicAccessAllowed() ?
							beanClass.getDeclaredConstructors() : beanClass.getConstructors());
				}
				// catch...
			}
			// 调用无参构造
			if (candidates.length == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
				Constructor<?> uniqueCandidate = candidates[0];
				if (uniqueCandidate.getParameterCount() == 0) {
					synchronized (mbd.constructorArgumentLock) {
						mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
						mbd.constructorArgumentsResolved = true;
						mbd.resolvedConstructorArguments = EMPTY_ARGS;
					}
					bw.setBeanInstance(instantiate(beanName, mbd, uniqueCandidate, EMPTY_ARGS));
					return bw;
				}
			}

			// 是否需要解析构造函数
			boolean autowiring = (chosenCtors != null ||
					mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
			ConstructorArgumentValues resolvedValues = null;

			int minNrOfArgs;
			if (explicitArgs != null) {
				minNrOfArgs = explicitArgs.length;
			}
			else {
				// 提取配置文件中配置的构造函数参数
				ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
				// 创建一个用于装在 cargs 的一个对象
				resolvedValues = new ConstructorArgumentValues();
				// 能够解析到的参数个数
				minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
			}
			// 对给定的构造函数进行排序，public类型的构造函数优先。非public的构造则根据参数个数降序排序
			AutowireUtils.sortConstructors(candidates);
			int minTypeDiffWeight = Integer.MAX_VALUE;
			Set<Constructor<?>> ambiguousConstructors = null;
			Deque<UnsatisfiedDependencyException> causes = null;

			for (Constructor<?> candidate : candidates) {
				// 每个构造函数对应的参数个数
				int parameterCount = candidate.getParameterCount();
				// 若缓存中存在已经解析好的构造函数，同时 解析好的参数的个数（不重复） >当前构造函数所需的参数个数
				// 说明当前构造函数无需继续解析，跳出循环即可
				if (constructorToUse != null && argsToUse != null && argsToUse.length > parameterCount) {
					break;
				}
				// 个数不相等，跳过本次循环
				if (parameterCount < minNrOfArgs) {
					continue;
				}

				ArgumentsHolder argsHolder;
				Class<?>[] paramTypes = candidate.getParameterTypes();
				// resolvedValues存储了上文读取XML配置的一些参数配置
				if (resolvedValues != null) {
					try {
						// 注释上获取参数名称
						String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, parameterCount);
						if (paramNames == null) {
							// 获取参数名称处理器。
							ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
							if (pnd != null) {
								// 获取指定构造函数的参数名称
								paramNames = pnd.getParameterNames(candidate);
							}
						}
						// 根据名称和数据类型创建参数的持有者。
						argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames,
								getUserDeclaredConstructor(candidate), autowiring, candidates.length == 1);
					}
					// catch...
				}
				else {
					// Explicit arguments given -> arguments length must match exactly.
					if (parameterCount != explicitArgs.length) {
						continue;
					}
					// 若构造函数没有参数
					argsHolder = new ArgumentsHolder(explicitArgs);
				}
				// 检验是否存在具有不确定性的构造函数。例如不同构造函数的参数为父子关系。
				int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
						argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
				// 若满足，说明当前的构造函数是最匹配的一个，那么它将作为最终的构造函数来调用。
				if (typeDiffWeight < minTypeDiffWeight) {
					constructorToUse = candidate;
					argsHolderToUse = argsHolder;
					argsToUse = argsHolder.arguments;
					minTypeDiffWeight = typeDiffWeight;
					ambiguousConstructors = null;
				}
				else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
					if (ambiguousConstructors == null) {
						ambiguousConstructors = new LinkedHashSet<>();
						ambiguousConstructors.add(constructorToUse);
					}
					ambiguousConstructors.add(candidate);
				}
			}

			if (constructorToUse == null) {
				if (causes != null) {
					UnsatisfiedDependencyException ex = causes.removeLast();
					for (Exception cause : causes) {
						this.beanFactory.onSuppressedException(cause);
					}
					throw ex;
				}
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"Could not resolve matching constructor on bean class [" + mbd.getBeanClassName() + "] " +
						"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
			}
			else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) {
				throw new BeanCreationException(mbd.getResourceDescription(), beanName,
						"Ambiguous constructor matches found on bean class [" + mbd.getBeanClassName() + "] " +
						"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
						ambiguousConstructors);
			}
			// 到这里，构造函数已经解析完成了，同时将其加入到缓存中。
			if (explicitArgs == null && argsHolderToUse != null) {
				argsHolderToUse.storeCache(mbd, constructorToUse);
			}
		}

		Assert.state(argsToUse != null, "Unresolved constructor arguments");
		// 将构建的实例加入到BeanWrapper中
		bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
		return bw;
	}
}

代码有点长，让我们来做个概括：

1.确定构造函数参数explicitArgs：

先看调用getBean()的时候是否传了参数，传了则使用它。
若未传参数，看缓存中是否存在已经解析好的，若有，则使用它。
若前两者都没有，则去XML配置文件中读取。

2.确定构造函数。根据构造函数的参数来匹配对应的构造函数。匹配的过程中会对构造函数进行排序：

public修饰的在前。
其余的根据参数个数进行排序。

3.转换对应的参数类型，确保类型正确。

4.检验构造函数的不确定性。

5.根据实例化的策略和最终确定的构造函数（包括参数）进行实例化Bean。

(2) instantiateBean解析

protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd) {
	try {
		Object beanInstance;
		if (System.getSecurityManager() != null) {
			// 根据实例化策略直接进行实例化
			beanInstance = AccessController.doPrivileged(
					(PrivilegedAction<Object>) () -> getInstantiationStrategy().instantiate(mbd, beanName, this),
					getAccessControlContext());
		}
		else {
			beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, this);
		}
		// 将实例化完成的对象封装为BeanWrapper
		BeanWrapper bw = new BeanWrapperImpl(beanInstance);
		// 初始化wrapper
		initBeanWrapper(bw);
		return bw;
	}
	// ..catch
}

我们可以发现，两种构造解析，最终对实例进行实例化的时候，都会调用instantiate()方法。我们来看下这个方法做了什么事情：

public class SimpleInstantiationStrategy implements InstantiationStrategy {
	@Override
	public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
		// 如果有 需要覆盖 或者 动态替换的方法 。即lookup和replaced方法
		// 那么需要使用cglib进行动态代理，因为其可以再创建代理的同时将动态方法插入类中。
		// 若没有，则通过 反射 进行实例化就可以。
		if (!bd.hasMethodOverrides()) {
			Constructor<?> constructorToUse;
			synchronized (bd.constructorArgumentLock) {
				constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
				if (constructorToUse == null) {
					final Class<?> clazz = bd.getBeanClass();
					if (clazz.isInterface()) {
						throw new BeanInstantiationException(clazz, "Specified class is an interface");
					}
					try {
						if (System.getSecurityManager() != null) {
							constructorToUse = AccessController.doPrivileged(
									(PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
						}
						else {
							constructorToUse = clazz.getDeclaredConstructor();
						}
						bd.resolvedConstructorOrFactoryMethod = constructorToUse;
					}
					// ..catch
				}
			}
			return BeanUtils.instantiateClass(constructorToUse);
		}
		else {
			// cglib动态代理
			return instantiateWithMethodInjection(bd, beanName, owner);
		}
	}
}

总结下就是实例化分为两种情况：

正常通过反射进行实例创建。
若有 需要覆盖 或者 动态替换的方法。即lookup和replaced方法。则进行cglib动态代理。

1.4.4 属性注入

接下来我们来讲下创建Bean过程中的第二个重要环节，属性注入。其入口为populateBean()函数：

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
		implements AutowireCapableBeanFactory {
	protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
		// 若beanWrapper为null，都不需要属性注入了。若XML配置了相关属性，则需要抛异常。因为不能给一个null对象进行属性注入。
		if (bw == null) {
			if (mbd.hasPropertyValues()) {
				throw new BeanCreationException(
						mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
			} else {
				return;
			}
		}
		// 给InstantiationAwareBeanPostProcessor最后一次机会，在设置属性之前来改变bean
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
				if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
					return;
				}
			}
		}

		PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

		int resolvedAutowireMode = mbd.getResolvedAutowireMode();
		// Spring的自动注入有两种方式，根据type。根据name
		if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
			MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
			// 根据名称自动注入
			if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
				autowireByName(beanName, mbd, bw, newPvs);
			}
			// 根据type自动注入
			if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
				autowireByType(beanName, mbd, bw, newPvs);
			}
			pvs = newPvs;
		}
		// 后处理器是否已经初始化
		boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
		// 是否需要依赖检查
		boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

		PropertyDescriptor[] filteredPds = null;
		if (hasInstAwareBpps) {
			if (pvs == null) {
				pvs = mbd.getPropertyValues();
			}
			for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
				PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
				if (pvsToUse == null) {
					if (filteredPds == null) {
						filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
					}
					// 对所有属性进行后处理
					pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
					if (pvsToUse == null) {
						return;
					}
				}
				pvs = pvsToUse;
			}
		}
		// 依赖检查
		if (needsDepCheck) {
			if (filteredPds == null) {
				filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
			}
			checkDependencies(beanName, mbd, filteredPds, pvs);
		}

		if (pvs != null) {
			// 将解析得到的属性封装到bean中
			applyPropertyValues(beanName, mbd, bw, pvs);
		}
	}
}

对上述流程总结下就是：

判断是否需要对Bean进行相关的填充。
根据Name/Type提取依赖的bean，并存储于PropertyValues实例中。
在填充属性前，通过InstantiationAwareBeanPostProcessor处理器对各个属性再进行处理。
将最终填充好的属性放到BeanWrapper中。

我们需要关注的是依赖的提取和处理操作，使用过@Autowired和@Resource注解的人我们都知道，一个是根据类型来属性注入，一个是根据名称来属性注入。那么碰巧的是，正好可以在这里对其原理做一个大概的了解。

(1) 根据Name自动注入

autowireByName(beanName, mbd, bw, newPvs);
↓↓↓↓↓↓
protected void autowireByName(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
	// 寻找bw中存储的 需要依赖注入的属性
	String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
	for (String propertyName : propertyNames) {
		if (containsBean(propertyName)) {
			// 递归初始化bean，根据bean的名称
			Object bean = getBean(propertyName);
			pvs.add(propertyName, bean);
			// 注册依赖
			registerDependentBean(propertyName, beanName);
			if (logger.isTraceEnabled()) {
				logger.trace("Added autowiring by name from bean name '" + beanName +
						"' via property '" + propertyName + "' to bean named '" + propertyName + "'");
			}
		}
		else {
			// log..
		}
	}
}

共三步：

找到需要依赖的属性。
递归根据名称来调用getBean(name)方法进行初始化。
注册依赖（实际就是将对应的依赖名称保存到Set集合中）。

由于getBean方法又是我们整篇文章要讲述的，因此我们只需要知道根据名称自动注入的过程中，存在getBean方法的递归调用即可。

(2) 根据Type自动注入

autowireByType(beanName, mbd, bw, newPvs);
↓↓↓↓↓↓
protected void autowireByType(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
	TypeConverter converter = getCustomTypeConverter();
	if (converter == null) {
		converter = bw;
	}

	Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
	// 1.同样，寻找bw需要依赖注入的属性
	String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
	for (String propertyName : propertyNames) {
		try {
			PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
			if (Object.class != pd.getPropertyType()) {
				// 探测指定属性的set方法
				MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
				boolean eager = !(bw.getWrappedInstance() instanceof PriorityOrdered);
				DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
				/**
				 * 解析beanName匹配的值，并存储在 autowiredBeanNames 集合中。当属性存在多个bean的时候。例如
				 *        @Autowired
				 *        private List<A> list;
				 * 那么此时会将所有匹配A类的bean注入进来
				 */
				Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
				if (autowiredArgument != null) {
					pvs.add(propertyName, autowiredArgument);
				}
				// 递归注册依赖
				for (String autowiredBeanName : autowiredBeanNames) {
					registerDependentBean(autowiredBeanName, beanName);
					// log..
				}
				autowiredBeanNames.clear();
			}
		} catch (BeansException ex) {
			throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
		}
	}
}

概括下就是：

寻找bw中需要依赖注入的属性。
遍历这些属性，寻找匹配的bean。
递归注册依赖。

和通过Name注入的方式不同的是第二步，我们来看下寻找类型匹配的方法做了什么操作：

Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
↓↓↓↓↓↓
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
		implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
	public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

		descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
		// 若依赖的bean是Optional类型的
		if (Optional.class == descriptor.getDependencyType()) {
			return createOptionalDependency(descriptor, requestingBeanName);
		}
		// 若依赖的bean是ObjectFactory类型的
		else if (ObjectFactory.class == descriptor.getDependencyType() ||
				ObjectProvider.class == descriptor.getDependencyType()) {
			return new DependencyObjectProvider(descriptor, requestingBeanName);
		}
		else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
			return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
		}
		// 通用处理逻辑
		else {
			Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(
					descriptor, requestingBeanName);
			if (result == null) {
				result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
			}
			return result;
		}
	}
}

我们来看下通用的处理逻辑doResolveDependency：

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
		implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
	public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
		// 设置当前的 descriptor，其中存储了方法参数等信息。作为当前的切入点。
		InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
		try {
			Object shortcut = descriptor.resolveShortcut(this);
			if (shortcut != null) {
				return shortcut;
			}
			// 从 descriptor 中获取属性类型
			Class<?> type = descriptor.getDependencyType();
			// 支持注解@Value
			Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
			if (value != null) {
				if (value instanceof String) {
					String strVal = resolveEmbeddedValue((String) value);
					BeanDefinition bd = (beanName != null && containsBean(beanName) ?
							getMergedBeanDefinition(beanName) : null);
					value = evaluateBeanDefinitionString(strVal, bd);
				}
				TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
				try {
					return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());
				}
				catch (UnsupportedOperationException ex) {
					// A custom TypeConverter which does not support TypeDescriptor resolution...
					return (descriptor.getField() != null ?
							converter.convertIfNecessary(value, type, descriptor.getField()) :
							converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
				}
			}
			// 处理一些集合的注入
			Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
			if (multipleBeans != null) {
				return multipleBeans;
			}
			// 查找符合注入类型的bean
			Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);
			if (matchingBeans.isEmpty()) {
				// 当符合条件的bean是空的，但是注入的属性又是存在的，那么此时抛异常
				if (isRequired(descriptor)) {
					raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
				}
				return null;
			}

			String autowiredBeanName;
			Object instanceCandidate;
			// 若查找到多个符合注入类型的bean
			if (matchingBeans.size() > 1) {
				// 过滤，找到最优的beanName
				autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor);
				if (autowiredBeanName == null) {
					// 同样，找不到最优的beanName，但是注入的属性又是必须的，同样抛异常
					// 或者注入的属性非必须，未过滤前就有多个注入类型的bean。但是注入的属性不是集合，那么同样抛异常。
					// 毕竟除集合外，怎么会有一个属性对应多个注入的bean呢？
					if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
						return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
					}
					else {
						return null;
					}
				}
				// 根据beanName获取的最优解，来创建属性实例的一个候选者instanceCandidate
				instanceCandidate = matchingBeans.get(autowiredBeanName);
			}
			else {
				// 若存在了一对一的情况，那么也不需要去寻找匹配了，直接就用当前的就可以了。
				Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();
				autowiredBeanName = entry.getKey();
				instanceCandidate = entry.getValue();
			}

			if (autowiredBeanNames != null) {
				autowiredBeanNames.add(autowiredBeanName);
			}
			if (instanceCandidate instanceof Class) {
				// 调用了getBean，进行初始化
				instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this);
			}
			Object result = instanceCandidate;
			if (result instanceof NullBean) {
				if (isRequired(descriptor)) {
					raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor);
				}
				result = null;
			}
			if (!ClassUtils.isAssignableValue(type, result)) {
				throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass());
			}
			return result;
		}
		finally {
			ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
		}
	}
}

概括下：

对@Value注解、集合等类型的bean做特殊处理。
findAutowireCandidates查找符合注入类型的bean 。
通过determineAutowireCandidate过滤，找到最优的bean的候选者。
对候选者进行初始化。

我们来大概了解下上述的两个方法：

protected Map<String, Object> findAutowireCandidates(
			@Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor) {
	// 获取给定类型的所有beanName，包括在父工厂中定义的beanName
	String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
			this, requiredType, true, descriptor.isEager());
	Map<String, Object> result = CollectionUtils.newLinkedHashMap(candidateNames.length);
	// 先尝试从缓存中寻找。这里的 resolvableDependencies 是已经解析过的缓存，
	for (Map.Entry<Class<?>, Object> classObjectEntry : this.resolvableDependencies.entrySet()) {
		Class<?> autowiringType = classObjectEntry.getKey();
		if (autowiringType.isAssignableFrom(requiredType)) {
			Object autowiringValue = classObjectEntry.getValue();
			autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType);
			if (requiredType.isInstance(autowiringValue)) {
				result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue);
				break;
			}
		}
	}
	/**
	 * isSelfReference：判断是否是自引用。即注入的属性是类本身
	 * isAutowireCandidate：判断是否有资格作为依赖注入的候选者
	 * @Bean(autowireCandidate = false)注解的bean就没有资格
	 */
	for (String candidate : candidateNames) {
		if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) {
			addCandidateEntry(result, candidate, descriptor, requiredType);
		}
	}
	// 没有符合注入属性类型的beanName
	if (result.isEmpty()) {
		// 注入的属性是否是bean的集合类型
		boolean multiple = indicatesMultipleBeans(requiredType);
		// 使用 备用的依赖描述器 再去获取一遍符合注入属性类型的beanName
		DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch();
		for (String candidate : candidateNames) {
			if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, fallbackDescriptor) &&
					(!multiple || getAutowireCandidateResolver().hasQualifier(descriptor))) {
				addCandidateEntry(result, candidate, descriptor, requiredType);
			}
		}
		// 若此时发现还是没有找到符合类型的beanName并且不是集合类型，考虑到自引用的存在
		if (result.isEmpty() && !multiple) {
			for (String candidate : candidateNames) {
				if (isSelfReference(beanName, candidate) &&
						(!(descriptor instanceof MultiElementDescriptor) || !beanName.equals(candidate)) &&
						isAutowireCandidate(candidate, fallbackDescriptor)) {
					addCandidateEntry(result, candidate, descriptor, requiredType);
				}
			}
		}
	}
	return result;
}

以及determineAutowireCandidate过滤：

protected String determineAutowireCandidate(Map<String, Object> candidates, DependencyDescriptor descriptor) {
	// 1.获取代注入的属性类型
	Class<?> requiredType = descriptor.getDependencyType();
	// 2.匹配候选bean中是否存在@Primary
	String primaryCandidate = determinePrimaryCandidate(candidates, requiredType);
	// 3.若匹配成功直接返回
	if (primaryCandidate != null) {
		return primaryCandidate;
	}
	// 4.匹配失败，则通过@Priority进行优先级匹配，值越小，优先级越高
	String priorityCandidate = determineHighestPriorityCandidate(candidates, requiredType);
	if (priorityCandidate != null) {
		return priorityCandidate;
	}
	// 5.若前两者都匹配失败，则匹配beanName是否一致
	for (Map.Entry<String, Object> entry : candidates.entrySet()) {
		String candidateName = entry.getKey();
		Object beanInstance = entry.getValue();
		if ((beanInstance != null && this.resolvableDependencies.containsValue(beanInstance)) ||
				matchesBeanName(candidateName, descriptor.getDependencyName())) {
			return candidateName;
		}
	}
	// 6.否则匹配失败，返回null
	return null;
}

总结下就是：
第一点：如何查找符合注入条件的bean？

先从已经解析好的缓存中寻找是否存在。
否则检查自引用和排除不符合的bean。过滤@Qualifier。以及过滤@Bean(autowireCandidate = false)注解的bean。
将符合条件的封装起来，放到集合matchingBeans中。

第二点：如何在集合matchingBeans中匹配到最优解？

匹配@Primary。
匹配@Priority进行优先级匹配，值越小，优先级越高
匹配beanName是否一致。

那么这些最优解得到后，完成初始化的工作，那么属性注入的工作也就完成了。最后一步，我们来看下初始化的过程。

1.4.5 初始化

配置bean的时候，有一个init-method属性，这个属性的作用是bean在实例化前调用其指定的方法来完成初始化工作。

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
	if (System.getSecurityManager() != null) {
		AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
			// 1.1执行aware方法
			invokeAwareMethods(beanName, bean);
			return null;
		}, getAccessControlContext());
	} else {
		// 1.2对特殊的bean进行处理，例如：Aware、BeanClassLoaderAware、BeanFactoryAware
		invokeAwareMethods(beanName, bean);
	}

	Object wrappedBean = bean;
	if (mbd == null || !mbd.isSynthetic()) {
		// 2.应用后处理
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
	}

	try {
		// 3.执行用户自定义的init方法
		invokeInitMethods(beanName, wrappedBean, mbd);
	} 
	// ..catch
	if (mbd == null || !mbd.isSynthetic()) {
		// 应用后处理
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}

	return wrappedBean;
}

(1) Aware的使用

案例如下：
在这里插入图片描述
User类：

public class User {
	void getName(){
		System.out.println("User");
	}
}

UserAware类：需要实现接口BeanFactoryAware

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;

public class UserAware implements BeanFactoryAware {
	private BeanFactory beanFactory;
	@Override
	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
		this.beanFactory=beanFactory;
	}

	void testAware(){
		User user = (User) beanFactory.getBean("user");
		user.getName();
	}
}

Test类：

public class Test {
	public static void main(String[] args) {
		BeanFactory factory = new DefaultListableBeanFactory();
		XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader((BeanDefinitionRegistry) factory);

		ClassPathResource resource = new ClassPathResource("/aware/test.xml");
		reader.loadBeanDefinitions(resource);

		UserAware user = (UserAware) factory.getBean("userAware");
		user.testAware();
	}
}

test.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xsi:schemaLocation="
   	http://www.springframework.org/schema/beans
   	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
	<bean id="userAware" class="com.mytest.aware.UserAware">
	</bean>

	<bean id="user" class="com.mytest.aware.User">
	</bean>
</beans>

结果如下：
在这里插入图片描述
什么意思呢？就是说：

Spring加载了一些 实现了Aware接口的bean 后，可以取得一些相对应的资源。
例如实现BeanFactoryAware接口，那么在初始化后，Spring容器会注入BeanFactory的实例。
因此testAware方法中，通过beanFactory实例调用getBean是可行的。

(2) 处理器的使用

初始化源码中，我们可以发现wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);这段代码执行了两遍，我们来看下他干了什么事情：

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException {
	// 代码很简单，递归地调用BeanPostProcessor实现类的postProcessBeforeInitialization方法而已。
	// 并将其返回结果作为替代来返回。	
	Object result = existingBean;
	for (BeanPostProcessor processor : getBeanPostProcessors()) {
		Object current = processor.postProcessBeforeInitialization(result, beanName);
		if (current == null) {
			return result;
		}
		result = current;
	}
	return result;
}

而至于BeanPostProcessor处理器，本文就不多展开啦，无非就是在Spring调用自定义的初始化方法的前后时机，允许通过处理器来调用指定的逻辑，实现插拔。

调用自定义初始化方法前：BeanPostProcessor.postProcessBeforeInitialization()
调用自定义初始化方法后：BeanPostProcessor.postProcessAfterInitialization()

(3) 自定义init方法调用

调用入口为

invokeInitMethods(beanName, wrappedBean, mbd);
↓↓↓↓↓↓
protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
			throws Throwable {
	// 1.检查是否为InitializingBean，是则调用afterPropertiesSet方法
	// 因为Bean可能实现了InitializingBean接口，并且重写了afterPropertiesSet方法。
	boolean isInitializingBean = (bean instanceof InitializingBean);
	if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
		if (logger.isTraceEnabled()) {
			logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
		}
		if (System.getSecurityManager() != null) {
			try {
				AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
					((InitializingBean) bean).afterPropertiesSet();
					return null;
				}, getAccessControlContext());
			} 
			// ..catch
		} else {
			// 属性初始化后的处理
			((InitializingBean) bean).afterPropertiesSet();
		}
	}

	if (mbd != null && bean.getClass() != NullBean.class) {
		String initMethodName = mbd.getInitMethodName();
		if (StringUtils.hasLength(initMethodName) &&
				!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
				!mbd.isExternallyManagedInitMethod(initMethodName)) {
			// 2.调用用户指定的自定义初始化方法。
			invokeCustomInitMethod(beanName, bean, mbd);
		}
	}
}

总结：

初始化方法中我们可以发现，主要调用了两个方法（注意顺序）
若Bean实现了InitializingBean接口，那么调用其afterPropertiesSet方法。
最后调用自定义的init-method方法。

二. 大总结（带流程图）☆

Bean的加载的流程如下getBean()开始：

1.根据beanName尝试去缓存中加载。

三级缓存的目的：在AOP调用的时候解决循环依赖问题。存放的是可以生成代理对象或者本身的工厂方法。

2.调用getObjectForBeanInstance方法检测bean的正确性。主要用于检测当前bean是否是FactoryBean类型的bean 。若是FactoryBean类型，则需要调用其getObject方法来返回对象。

3.开始创建Bean，调用createBean方法分为三大步骤：

创建实例：
createBeanInstance()，返回BeanWrapper对象。实例化的方式：

若配置了回调函数，那么直接调用并返回。
若配置了factory-method，则调用并返回。
否则，就调用其构造函数进行初始化（带参数）

而构造函数初始化的过程：

确定构造函数参数explicitArgs：
确定构造函数。
转换对应的参数类型，确保类型正确。以及检验构造函数的不确定性。
根据实例化的策略和最终确定的构造函数（包括参数）进行实例化Bean。
若是无参构造，则通过反射来实例化对象。若有覆盖方法（lookup和replaced），则通过cglib动态代理。

属性注入：

1.根据Name自动注入：

找到需要依赖的属性。
递归根据名称来调用getBean(name)方法进行初始化。
注册依赖（实际就是将对应的依赖名称保存到Set集合中）。

2.根据Type自动注入：

寻找bw中需要依赖注入的属性。
遍历这些属性，寻找匹配的bean，其中的过程包括：查找、过滤

1.先从已经解析好的缓存中寻找是否存在。

2.否则检查自引用和排除不符合的bean。过滤@Qualifier。以及过滤@Bean(autowireCandidate = false)注解的bean。
3.将符合条件的封装起来，放到集合matchingBeans中。
4.过滤操作则看是否配置了@Primary以及@Priority的大小。