说明：本文只介绍简单的bean实例化过程，没有注入，没有代理等等
实例
代码
@Service
public class GoodsService {
public List<String> list() {
return Arrays.asList("apple");
}
}
@Configuration
@ComponentScan("com.yunfan.bean.instantiation.simple")
public class SimpleConfig {
}
public class MainTest {
public static void main(String[] args) {
AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(SimpleConfig.class);
GoodsService goodsService = (GoodsService) applicationContext.getBean("goodsService");
System.out.println(goodsService.list());
}
}
运行结果
> Task :spring-study:MainTest.main()
[apple]
spring Bean 实例化过程
本文只针对 实例 中 GoodsService 实例化过程进行描述，实例化前简单描述：spring 把 GoodsService 类信息保存到BeanDefinition，实例化时从BeanDefinition中读取类信息进行实例化
1、实例化开始
首先打开spring源码 DefaultListableBeanFactory 类的preInstantiateSingletons 方法 , 全路径：org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons
@Override
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
// 获取所有BeanDefinition的集合
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
// 触发所有非惰性单例bean的初始化…
for (String beanName : beanNames) {
// 获取beanName对应的 MergedBeanDefinition， MergedBeanDefinition合并了 子类和父类的信息
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// bd对应的Bean实例：不是抽象类 && 是单例 && 不是懒加载
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 判断beanName对应的bean是否为FactoryBean
if (isFactoryBean(beanName)) {
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
final FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
else {
// 如果beanName对应的bean不是FactoryBean，只是普通Bean，通过beanName获取bean实例
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
首先，拷贝一个容器中所有 BeanDefinition 的名称到beanNames的List集合中， list中的内容如图：
批注 2020-03-29 171730.png
对 beanNames 进行循环遍历并进行实例化，此时我们只关心 goodsService 实例化过程。
第二，获取 goodsService 的 RootBeanDefinition 此时的 RootBeanDefinition 是一个 MergedLocalBeanDefinition 即和并了父类 相关信息的 BeanDefinition ，检测bd对应的Bean实例：不是抽象类 && 是单例 && 不是懒加载，因为 goodsService 不是 FactoryBean 则直接执行 getBean(beanName) 获取bean 实例，详细过程请查看 2、获取bean ，getBean(beanName) 已经把bean 实例化并缓存到单例池中，本方法的第二个for 循环 并并没有对本次流程产生任何影响
2、获取 bean
方法 getBean(beanName) 调用了 doGetBean 方法
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
方法 doGetBean 的全路径是 org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
// 返回bean名称，去掉工厂取消引用前缀，并将别名解析为规范名称。
final String beanName = transformedBeanName(name);
Object bean;
// 首先检查单例缓存中手动注册的单例对象。（此处会涉及到注入的逻辑，本次没有注入不过多关注），因为goodsService还没有被创建所以此处sharedInstance为null
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 + "'");
}
}
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// 缓存中没有，创建这个bean实例:
// 如果该bean正在创建则抛出异常
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 检查这个父工厂中是否存在bean定义。本次执行过程中parentBeanFactory 为 null
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
if (!typeCheckOnly) {
// 标记bean要创建了: 从 mergedBeanDefinitions 中删除，在 alreadyCreated 中添加
// 让bean定义重新合并，现在我们实际上是在创建bean…以防在此期间它的一些元数据发生变化。
// 并把 goodsService 加入到 alreadyCreated 集合中
markBeanAsCreated(beanName);
}
try {
// 重新合并 goodsService 以防在此期间它的一些元数据发生变化。
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 检查 MergedBeanDefinition，其实就是检查 goodsService 是否为抽象类，如果是则抛出异常
checkMergedBeanDefinition(mbd, beanName, args);
// 保证当前bean所依赖的bean的初始化。 （goodsService 没有依赖注入，所以 dependsOn 为 null）
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 + "'");
}
// 为给定bean注册一个从属bean，在销毁给定bean之前销毁它。dep 和 beanName 分别在两个Map中 建立关联关系，表示他们之间的依赖关系
registerDependentBean(dep, beanName);
try {
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// 创建bean 实例 检测是否是单例模式
if (mbd.isSingleton()) {
// 此处调用 getSingleton 方法 传递了两个参数，一个是 beanName, 另一个是 ObjectFactory 的实现类，ObjectFactory 只有一个抽象方法 getObject() ，所以当执行到 ObjectFactory.getObject() 时，其实执行的是 createBean(beanName, mbd, args);
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
String scopeName = mbd.getScope();
final 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);
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; consider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// Check if required type matches the type of the actual bean instance.
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
首先，转换 bean 的名称，去掉工厂引用前缀，并将别名解析为规范名称。因为 goodsService 没有使用别名并且是一个普通的类，所以最终转换的结果还是 goodsService 。
第二，从缓存中获取共享实例，因为 goodsService 是首次创建所以 Object sharedInstance = null 进入到 else 分支
第三，检测如果 goodsService 正在实例化则抛出异常
第四，获取父工厂，这里边抛出一个问题：spring的父、子 工厂？ 当前 parentBeanFactory = null , 所以不走 if 分支，走 else 分支
第五，标记 bean 即 goodsService 要被创建， 从 mergedBeanDefinitions 集合中删除（让bean定义重新合并，现在是在创建bean…以防在此期间它的一些元数据发生变化。） ，加入到 alreadyCreated 集合中
protected void markBeanAsCreated(String beanName) {
if (!this.alreadyCreated.contains(beanName)) {
synchronized (this.mergedBeanDefinitions) {
if (!this.alreadyCreated.contains(beanName)) {
// 让bean定义重新合并，现在我们实际上是在创建bean…以防在此期间它的一些元数据发生变化。
clearMergedBeanDefinition(beanName);
this.alreadyCreated.add(beanName);
}
}
}
}
第六，重新合并 MergedBeanDefinition 并检测是不是抽象类
第七，获取 goodsService 初始化所需要的依赖，此时 String[] dependsOn = null
第八，判断 goodsService 是否为单例 mbd.isSingleton() = true , 所以调用 getSingleton(String beanName, ObjectFactory<?> singletonFactory) 方法， 下面的代码 是 ObjectFactory 接口的实现类，大括号 {...} 中便是 T getObject() 的实现方法，即调用 singletonFactory.getObject() 方法时 便是执行大括号里边的代码 。获取单例的具体流程请查看 **3、获取单例对象 **
() -> {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
}
此处可以获取单例对象
第八，调用 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); getObjectForBeanInstance 会先调用 org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#getObjectForBeanInstance 在该方法中 需要注意 registerDependentBean(beanName, currentlyCreatedBean); 这一行，当然，本次流程不会执行这行代码，然后调用 org.springframework.beans.factory.support.AbstractBeanFactory#getObjectForBeanInstance 这个方法，在本次流程中bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); 这行代码并没有对 sharedInstance 做任何修改。返回单例对象
3、获取单例对象
根据 beanName 名称返回注册的单例对象，如果没有则创建并注册一个新的单例对象。方法的全路径名是 org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String, org.springframework.beans.factory.ObjectFactory<?>)
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
// 判断当前是否正在销毁单例bean集合,如果是则抛出异常
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
// 检测创建的bean 是否在排除创建的集合中（如果在则抛出异常） 和 将beanName 加入 singletonsCurrentlyInCreation （正在创建的bean的集合）
beforeSingletonCreation(beanName);
boolean newSingleton = false;
// 被抑制的异常列表
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
// singletonFactory 生产bean
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
afterSingletonCreation(beanName);
}
if (newSingleton) {
// 把实例放入缓存中
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
首先，加同步锁，再次从单例缓存池 singletonObjects 中获取单例，如果不为null 则直接返回，此时为 null
第二，判断当前是否正在销毁 单例 ，如果是则抛出异常
第三，检测创建的bean 是否在排除创建的集合中（如果在则抛出异常）， 将beanName 加入 singletonsCurrentlyInCreation （正在创建的bean的集合）
第四，执行 singletonObject = singletonFactory.getObject(); 即 2、获取bean 中 第八 步 的 lambda 表达式， 即 执行 createBean(beanName, mbd, args) 该方法的具体执行流程请查看 4、创建bean，这个行代码将会获得单例对象 singletonObject = GoodsService@1654 并设置 newSingleton = true;
第五，执行 afterSingletonCreation(beanName) 将 beanName 从 singletonsCurrentlyInCreation 集合中移除
第六，执行 addSingleton(beanName, singletonObject) 该方法的代码如下：
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
this.singletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
返回单例对象
4、解析bean并首次调用后置处理器
该方法执行单例创建前的一次后置处理器，返回一个对象，如果该对象不为null，则直接返回， 如果为 null 则执行 doCreateBean 方法，完成真正的单例的创建
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// 解析beanName对应的Bean的类型
// resolvedClass = com.yunfan.bean.instantiation.simple.GoodsService
// mbd.hasBeanClass() = true
// mbd.getBeanClassName() = com.yunfan.bean.instantiation.simple.GoodsService
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
// 如果resolvedClass存在，并且mdb不存在beanClass即类型不是Class，并且mdb的beanClassName不为空（则代表beanClass存的是Class的name）,
// 则使用mdb深拷贝一个新的RootBeanDefinition副本，并且将解析的Class赋值给拷贝的RootBeanDefinition副本beanClass属性，
// 该拷贝副本取代mdb用于后续的操作
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
try {
// 对override属性进行标记及验证
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// 实例化前的处理，给beanpostprocessor(InstantiationAwareBeanPostProcessor)一个机会返回代理对象来替代真正的bean实例，达到“短路”效果
// 第一次调用后置处理器
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
// 如果bean不为空，则会跳过Spring默认的实例化过程，直接使用返回的bean
// 此时 bean = null
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
// 创建Bean实例（真正创建Bean的方法）
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
// 返回创建的Bean实例
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
首先，解析beanName（goodsService）对应的Bean的类型，resolvedClass = com.yunfan.bean.instantiation.simple.GoodsService
第二，对override属性进行标记及验证
第三，实例化前调用 beanpostprocessor ( InstantiationAwareBeanPostProcessor) 后置处理器返回代理对象来替代真正的bean实例，第一次实例化前调用 后置处理器，返回结果 Object bean = null 继续向下执行，如果bean 不为 null 则直接返回。
第四，调用 doCreateBean 方法创建单例，该方法是真正的创建单例，然后返回单例。想要了解 doCreateBean 的具体流程请查看 5、真正创建bean单例， 返回单例
5、创建 bean 单例
该方法实际创建指定的bean。在这一点上，预创建处理已经发生了，例如检查{@code postProcessBeforeInstantiation}回调。
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// 新建Bean包装类
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
// 如果是FactoryBean，则需要先移除未完成的FactoryBean实例的缓存
// 因为 goodsService 是一个普通的类，所以此处instanceWrapper = null
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 根据beanName、mbd、args，使用对应的策略创建Bean实例，并返回包装类BeanWrapper
/*
* 第二次调用后置处理器
* 创建bean实例，并将实例放在包装类BeanWrapper中返回
* 1、通过工厂方法创建bean实例
* 2、通过构造方法自动注入创建bean实例
* 3、通过无参构造器创建bean实例
* */
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 拿到创建好的Bean实例
final Object bean = instanceWrapper.getWrappedInstance();
// 拿到Bean实例的类型
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// 允许后处理程序修改合并的bean定义。
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
// 应用后置处理器MergedBeanDefinitionPostProcessor，允许修改MergedBeanDefinition，
// Autowired注解正是通过此方法实现注入类型的预解析
// 允许后置处理器修改合并的bean定义 MergedBeanDefinitionPostProcessor
// 第三次调用后置处理器
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// 急切地缓存单例，以便能够解析循环引用，甚至在由生命周期接口(如BeanFactoryAware)触发时也是如此。
// 判断是否需要提早曝光实例：单例 && 允许循环依赖 && 当前bean正在创建中
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
// 提前曝光beanName的ObjectFactory，用于解决循环引用
// 应用后置处理器SmartInstantiationAwareBeanPostProcessor，允许返回指定bean的早期引用，若没有则直接返回bean
// 解决循环依赖 SmartInstantiationAwareBeanPostProcessor.getEarlyBeanReference
// 第四次调用后置处理器
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// 初始化bean实例。
Object exposedObject = bean;
try {
// 对bean进行属性填充；其中，可能存在依赖于其他bean的属性，则会递归初始化依赖的bean实例
// 第五次、第六次调用后置处理器
populateBean(beanName, mbd, instanceWrapper);
// 对bean进行初始化
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
if (earlySingletonExposure) {
// 如果允许提前曝光实例，则进行循环依赖检查
Object earlySingletonReference = getSingleton(beanName, false);
// earlySingletonReference只有在当前解析的bean存在循环依赖的情况下才会不为空
if (earlySingletonReference != null) {
if (exposedObject == bean) {
// 如果exposedObject没有在initializeBean方法中被增强，则不影响之前的循环引用
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
// 如果exposedObject在initializeBean方法中被增强 && 不允许在循环引用的情况下使用注入原始bean实例
// && 当前bean有被其他bean依赖
// 拿到依赖当前bean的所有bean的beanName数组
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
// 尝试移除这些bean的实例，因为这些bean依赖的bean已经被增强了，他们依赖的bean相当于脏数据
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
// 移除失败的添加到 actualDependentBeans
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
// 如果存在移除失败的，则抛出异常，因为存在bean依赖了“脏数据”
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// 将bean注册为一次性的。
try {
// 注册用于销毁的bean，执行销毁操作的有三种：自定义destroy方法、DisposableBean接口、DestructionAwareBeanPostProcessor
// 将bean注册为可以销毁 DestructionAwareBeanPostProcessor bean的销毁后置处理器
// 第九次调用后置处理器
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
// 完成创建并返回
return exposedObject;
}
首先，先移除未完成的FactoryBean实例的缓存，因为 goodsService 是一个普通的bean ，所以 this.factoryBeanInstanceCache.remove(beanName) 执行的结果为 null。
第二，创建 bean 实例，调用 createBeanInstance 方法。代码如下：
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 确保此时bean类已经被解析。
// beanClass = class com.yunfan.bean.instantiation.simple.GoodsService
Class<?> beanClass = resolveBeanClass(mbd, beanName);
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
// beanClass不为空 && beanClass不是公开类（不是public修饰） && 该bean不允许访问非公共构造函数和方法，则抛异常
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
}
// 返回创建bean实例的回调(如果有的话)。
// instanceSupplier = null
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
// 如果存在工厂方法则使用工厂方法实例化bean对象
// mbd.getFactoryMethodName() = null
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// Shortcut when re-creating the same bean...
// 英文注释翻译：重新创建相同的bean时的快捷方式…
// resolved: 构造函数或工厂方法是否已经解析过
boolean resolved = false;
// autowireNecessary: 是否需要自动注入（即是否需要解析构造函数参数）
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
// mbd.resolvedConstructorOrFactoryMethod 用于缓存已解析构造函数或工厂方法的包可见字段。
// 此处 mbd.resolvedConstructorOrFactoryMethod = null
if (mbd.resolvedConstructorOrFactoryMethod != null) {
// 如果resolvedConstructorOrFactoryMethod缓存不为空，则将resolved标记为已解析
resolved = true;
// 根据constructorArgumentsResolved判断是否需要自动注入
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
// 因为 mbd.resolvedConstructorOrFactoryMethod = null 所以 resolved = false，程序不会进入 if 分支
if (resolved) {
// 如果已经解析过，则使用resolvedConstructorOrFactoryMethod缓存里解析好的构造函数方法
if (autowireNecessary) {
// 需要自动注入，则执行构造函数自动注入
return autowireConstructor(beanName, mbd, null, null);
}
else {
// 否则使用默认的构造函数进行bean的实例化
return instantiateBean(beanName, mbd);
}
}
// 应用后置处理器SmartInstantiationAwareBeanPostProcessor，可以得到bean的候选构造函数，如@Autowire 注解的构造方法， 然后使用该构造函数进行创建对象。
// 自动装配的候选者构造器 SmartInstantiationAwareBeanPostProcessor#determineCandidateConstructors
// 第二次调用后置处理器，这个方法用来推断构造函数，实际使用的实现SmartInstantiationAwareBeanPostProcessor接口的AutowiredAnnotationBeanPostProcess后置处理器去做的。
// 此处 ctors = null
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
// AutowireMode设置为3，采用构造器贪婪模式
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
// 如果ctors不为空 || mbd的注入方式为AUTOWIRE_CONSTRUCTOR || mdb定义了构造函数的参数值 || args不为空，则执行构造函数自动注入
return autowireConstructor(beanName, mbd, ctors, args);
}
// 默认构造的首选构造函数 ctors = null
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
return autowireConstructor(beanName, mbd, ctors, null);
}
// 没有特殊处理，则使用默认的构造函数进行bean的实例化
// 即无参构造器 通过反射调用无参构造函数进行创建
return instantiateBean(beanName, mbd);
}
在 createBeanInstance 方法中有一个第二次调用后置处理器，需要注意一下，即Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName); 这个方法用来推断构造函数，实际使用的实现SmartInstantiationAwareBeanPostProcessor 接口的AutowiredAnnotationBeanPostProcess 后置处理器去做的。
第三，第三次调用后置处理器 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); 该方法实际调用了 MergedBeanDefinitionPostProcessor的 方法：postProcessMergedBeanDefinition，用来缓存注解信息。
第四，即第四次调用后置处理器 addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); 调用了 SmartInstantiationAwareBeanPostProcessor 后置处理器的 getEarlyBeanReference(exposedObject, beanName) 方法 ，这个方法是来解决循环依赖问题的
第五，即第五次调用后置处理器, 在 populateBean(beanName, mbd, instanceWrapper); 方法里调用了后置处理器 InstantiationAwareBeanPostProcessor 的方法 postProcessAfterInstantiation(bw.getWrappedInstance(), beanName) 判断是否需要填充属性，goodsService 需要填充的属性个数为零，但并不是不允许修改bean的属性，所以不会忽略直接返回
第六，即第六次调用后置处理器，在 populateBean(beanName, mbd, instanceWrapper); 方法里调用了后置处理器 InstantiationAwareBeanPostProcessor 的方法 postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName); 进行属性填充前的处理
第七，即第七次调用后置处理器，在方法exposedObject = initializeBean(beanName, exposedObject, mbd) 中 wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); 调用了 BeanPostProcessor 的方法 postProcessBeforeInitialization(result, beanName) 对bean实例进行包装
第八，即第七次调用后置处理器，在方法exposedObject = initializeBean(beanName, exposedObject, mbd) 中 wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); 调用了 BeanPostProcessor 的方法 postProcessAfterInitialization(result, beanName)
第九，即第九次调用后置处理器，在方法 registerDisposableBeanIfNecessary(beanName, bean, mbd); 中 将bean注册为可以销毁 DestructionAwareBeanPostProcessor bean的销毁后置处理器
网友评论