spring源码解析②-bean的实例化过程

入口类AbstractBeanFactory

调用getBean，再调用getBean方法

如下：

重点解析方法doGetBean()说明：

1.先从缓存对象singletonObjects中获取bean的实例；

2.如果缓存中没有，进行实例化。这个步骤比较多，详细如下：

先判断scope 是Prototype的实例化过程是否出现了循环依赖；

这里重点解析作用域scope 为singleton的步骤，以下步骤对bean的实例化过程非常重要！！！！

代码入口：

1.getSingleton方法的调用说明

从缓存singletonObjects对象中获取获取实例是否存在；说明下大部分beanDefinition的实例化后都会放在这个对象中，存在则直接还回

　　不存在，把当前实例对象对象的beanName加入缓存；这一步解决了缓存循环依赖的问题；具体下文会讲到

	protected void beforeSingletonCreation(String beanName) {
		//在这个集合里面的bean都是正在实例化的bean
		if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
			throw new BeanCurrentlyInCreationException(beanName);
		}
	}

　　singletonFactory.getObject()该方法会调用到一个函数式方法，即是步骤二的createBean（）方法

@FunctionalInterface
public interface ObjectFactory<T> {

	/**
	 * Return an instance (possibly shared or independent)
	 * of the object managed by this factory.
	 * @return the resulting instance
	 * @throws BeansException in case of creation errors
	 */
	T getObject() throws BeansException;

}

　创建对象完成后，会加入实例到singletonObjects中

    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);
        }
    }

2.createBean方法说明

下面会重点说明该方法

介绍步骤：下面每一项对于理解bean的实例化都非常重要！！！！！

创建实例（通过反射实例化对象）

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
   // Make sure bean class is actually resolved at this point.
   //反射拿到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());
   }

   Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
   if (instanceSupplier != null) {
      return obtainFromSupplier(instanceSupplier, beanName);
   }

   //如果有FactoryMethodName属性
   if (mbd.getFactoryMethodName() != null) {
      return instantiateUsingFactoryMethod(beanName, mbd, args);
   }

   // Shortcut when re-creating the same bean...
   boolean resolved = false;
   boolean autowireNecessary = false;
   if (args == null) {
      synchronized (mbd.constructorArgumentLock) {
         if (mbd.resolvedConstructorOrFactoryMethod != null) {
            resolved = true;
            autowireNecessary = mbd.constructorArgumentsResolved;
         }
      }
   }
   if (resolved) {
      if (autowireNecessary) {
         return autowireConstructor(beanName, mbd, null, null);
      }
      else {
         return instantiateBean(beanName, mbd);
      }
   }

   // Candidate constructors for autowiring?
   //寻找当前正在实例化的bean中有@Autowired注解的构造函数
   Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
   if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
         mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
      //如果ctors不为空，就说明构造函数上有@Autowired注解
      return autowireConstructor(beanName, mbd, ctors, args);
   }

   // Preferred constructors for default construction?
   ctors = mbd.getPreferredConstructors();
   if (ctors != null) {
      return autowireConstructor(beanName, mbd, ctors, null);
   }

   //无参构造函数的实例化,大部分的实例是采用的无参构造函数的方式实例化
   // No special handling: simply use no-arg constructor.
   return instantiateBean(beanName, mbd);
}