Spring 源碼學習 - 單例bean的實例化過程

本文做者：geek，一個聰明好學的同事

1. 簡介

開發中咱們經常使用@Commpont，@Service，@Resource等註解或者配置xml去聲明一個類，使其成爲spring容器中的bean，如下我將用從源碼角度看以AnnotationConfigApplicationContext爲例看spring如何把帶有註解的類生成spring中bean。

2. 示例代碼

public class TestContext {
 public static void main(String[] args) {  AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);  SingleBean singleBean = context.getBean(SingleBean.class);  System.out.println("<=====>"+singleBean.getTestStr());  } } 複製代碼

@ComponentScan("com.geek")
public class AppConfig { } 複製代碼

@Component
public class SingleBean {  private String testStr = "testStr";   public String getTestStr() {  return testStr;  } } 複製代碼

注意：以上代碼僅須要引入spring-context依賴便可。

3. 源碼分析

​ 上面的demo在調用AnnotationConfigApplicationContext構造函數的時候，AppConfig類會被註冊到AnnotatedBeanDefinitionReader，由這個reader把AppConfig解釋爲beanDefination，從而被spring獲取到要實例化的類信息，如下爲bean生產的源碼及其註釋。（源碼基於springFramework 5.1.X）

3.1 建立入口

​ 單例bean的建立的入口爲DefaultListableBeanFactory.java#preInstantiateSingletons，下面源碼可見建立的bean條件爲非抽象，非@LazyInit註解，Scope爲singleTon（默認爲singleTon）。

@Override
 public void preInstantiateSingletons() throws BeansException {  if (logger.isTraceEnabled()) {  logger.trace("Pre-instantiating singletons in " + this);  }  // Iterate over a copy to allow for init methods which in turn register new bean definitions.  // While this may not be part of the regular factory bootstrap, it does otherwise work fine.  //全部可能須要去實例化的class（lazy，scope）  List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);   // Trigger initialization of all non-lazy singleton beans...  for (String beanName : beanNames) {  RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);  /**  * 非抽象，非懶初始化，單例bean  */  if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {  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);  }  }  }  //非工廠bean實例化  else {  getBean(beanName);  }  }  }  /**  * 實例化完成後觸發實現了SmartInitializingSingleton方法的bean  * 的afterSingletonsInstantiated方法  */  // 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();  }  }  }  }  複製代碼

3.2 建立前doGetBean代碼邏輯

getBean方法進來後即是直接調用doGetBean，doGetBean執行的源碼解釋以下：
複製代碼

protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,  @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {  /**  * 獲取beanName  * 1，去掉factortoryBean前綴&  * 2，帶有別名的bean轉換爲原來名字  */  final String beanName = transformedBeanName(name);  Object bean;  // Eagerly check singleton cache for manually registered singletons.  /**  * 從DefaultSingletonBeanRegistry的singletonObjects  * （spring內部用來緩存單例bean的currentHashMap）檢查是否存在該bean，不存在則建立  * 涉及單例模式下的循環依賴解決  */  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實例的對象，若是是Factory Bean，  * 則能夠是bean實例自己或其建立的對象。  */  bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);  }  else {  // Fail if we're already creating this bean instance:  // We're assembly within a circular reference.  /**  * 原型模式下的bean存在循環依賴則會拋異常  */  if (isPrototypeCurrentlyInCreation(beanName)) {  throw new BeanCurrentlyInCreationException(beanName);  }  // Check if bean definition exists in this factory.  /**  * 找不到則從父容器中查找  */  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) {  markBeanAsCreated(beanName);  }  try {  /**  * 父容器中也找不到該bean，則須要從新實例化  * 1，獲取要實例化bean的beanDefinition,  * 2，檢查bean的實例化須要依賴的其餘bean  */  final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);  checkMergedBeanDefinition(mbd, beanName, args);   // Guarantee initialization of beans that the current bean depends on.  String[] dependsOn = mbd.getDependsOn();  if (dependsOn != null) {  for (String dep : dependsOn) {  /**  * 若給定的依賴 bean 已經註冊爲依賴給定的bean  */  if (isDependent(beanName, dep)) {  throw new BeanCreationException(mbd.getResourceDescription(), beanName,  "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");  }  registerDependentBean(dep, beanName);  try {  /**  * 遞歸調用getBean，優先建立依賴的bean  */  getBean(dep);  }  catch (NoSuchBeanDefinitionException ex) {  throw new BeanCreationException(mbd.getResourceDescription(), beanName,  "'" + beanName + "' depends on missing bean '" + dep + "'", ex);  }  }  }  // Create bean instance.  if (mbd.isSingleton()) {  /**  * 經過調用DefaultSingletonBeanRegistry的getSingleton，從而調用核心方法createBean建立  */  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;  }  }  /**  * 檢查須要的bean類型是否符合  */  // 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;  } 複製代碼

doGetBean的操做流程以下：

1，執行transformedBeanName方法轉換beanName

​ 傳遞的參數多是bean的alias或者爲FactoryBean，transformedBeanName執行的操做:(1)若傳進來的FactoryBean（FactoryBean以&做爲前綴標記），去掉&修飾符。（2）通過（1）的處理後，有alias的bean則從aliasMap中獲取bean的原始beanName。

2，從容器的緩存中獲取bean

​ getSingleton先從spring三級緩存中的第一級singletonObjects（Map結構）中獲取，若不存在，則檢查該bean是否正在建立isSingletonCurrentlyInCreation(beanName)) ，正在建立的bean會從二級緩存earlySingletonObjects（Map結構）獲取。獲取到緩存的bean後會調用AbstractBeanFactory#getObjectForBeanInstance轉換bean的實例自己返回。由於從緩存中拿到的多是factoryBean，因此getObjectForBeanInstance須要把是經過從緩存factoryBeanObjectCache獲取或經過factory.getObject()得到相應的bean返回。

3，bean實例化前檢查

​ （1）先檢查是否原型模式下的bean是否存在循環依賴，是則會拋異常。

​ （2）檢查父類工廠（parentBeanFactory）是否存在，存在則從parentBeanFactory中遞歸調用doGetBean。

​ （3）獲取改bean的beanDefinition，檢查該bean實例化過程當中是否涉及依賴了其餘的bean，如果則遞歸調用getBean，優先建立依賴的bean。（涉及單例下的循環以來解決，下篇文章詳細介紹）。

​ （4）對建立bean代碼加synchronized和執行beforeSingletonCreation(beanName)前置處理。

3.3 建立前createBean邏輯

​ 通過前面的doGetBean的一輪檢查與準備後，便在AbstractAutowireCapableBeanFactory#createBean中開始bean的建立。

/**  * Central method of this class: creates a bean instance,  * populates the bean instance, applies post-processors, etc.  * 解析指定 BeanDefinition 的 class  * 處理 override 屬性  * 實例化的前置處理  * 建立 bean  * @see #doCreateBean  */  @Override  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;   // Make sure bean class is actually resolved at this point, and  // clone the bean definition in case of a dynamically resolved Class  // which cannot be stored in the shared merged bean definition.  /**  * 解釋bean的class，看beanDefinition是否有class，不然load class  */  Class<?> resolvedClass = resolveBeanClass(mbd, beanName);  if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {  mbdToUse = new RootBeanDefinition(mbd);  mbdToUse.setBeanClass(resolvedClass);  }  /**  * 對bean不存在lookup-method 和 replace-method  * 標記其方法的overloaded爲false  */  // Prepare method overrides.  try {  mbdToUse.prepareMethodOverrides();  }  catch (BeanDefinitionValidationException ex) {  throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),  beanName, "Validation of method overrides failed", ex);  }   try {  /**  * 調用實現實現BeanPostProcessor的bean後置處理生成代理對象，  * 有代理對象則直接返回代理對象  */  // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.  Object bean = resolveBeforeInstantiation(beanName, mbdToUse);  if (bean != null) {  return bean;  }  }  catch (Throwable ex) {  throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,  "BeanPostProcessor before instantiation of bean failed", ex);  }   try {  /**  * 無需代理的bean實例化  */  Object beanInstance = doCreateBean(beanName, mbdToUse, args);  if (logger.isTraceEnabled()) {  logger.trace("Finished creating instance of bean '" + beanName + "'");  }  return beanInstance;  }  catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {  // A previously detected exception with proper bean creation context already,  // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.  throw ex;  }  catch (Throwable ex) {  throw new BeanCreationException(  mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);  }  }  複製代碼

createBean的操做流程以下：

1，resolveBeanClass

​ 解釋beanDefinition的class，而且保存在beanDefinition中。

2，prepareMethodOverrides

​ 處理bean中的lookup-method （在單例bean用 @Lookup註解標記的方法，註解的方法返回的對象是原型）和 replace-method（ 標記的方法，標記bean中A的方法被實現被另一個實現MethodReplacer接口的B方法替代）。

3，resolveBeforeInstantiation

​ 調用實現實現BeanPostProcessor的bean後置處理生成代理對象，有代理對象則直接返回代理對象。（spring AOP則是基於此處實現）

3.4 bean的真正實例化createBeanInstance

​ 在AbstractAutowireCapableBeanFactory#createBeanInstance中，真正建立bean，源碼及註釋以下：

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
 // Make sure bean class is actually resolved at this point.  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回調方法建立  */  Supplier<?> instanceSupplier = mbd.getInstanceSupplier();  if (instanceSupplier != null) {  return obtainFromSupplier(instanceSupplier, beanName);  }  /**  * 經過工廠方法建立 bean 實例，能夠是靜態工廠方法或者實例工廠  */  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) {  /**  * 查找已經bean已經緩存解析的構造函數或者工廠方法  */  if (mbd.resolvedConstructorOrFactoryMethod != null) {  resolved = true;  autowireNecessary = mbd.constructorArgumentsResolved;  }  }  }  /**  * 已經有緩存的構造函數或者工廠方法，直接實例化  */  if (resolved) {  if (autowireNecessary) {  return autowireConstructor(beanName, mbd, null, null);  }  else {  return instantiateBean(beanName, mbd);  }  }  /**  * 經過實現BeanPostProcessor的代理類autowired的構造函數實例化  */  // Candidate constructors for autowiring?  Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);  if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||  mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {  return autowireConstructor(beanName, mbd, ctors, args);  }  /**  * 經過自己帶有autowired的構造函數實例化，經過調用反射newInstance實現  */  // Preferred constructors for default construction?  ctors = mbd.getPreferredConstructors();  if (ctors != null) {  return autowireConstructor(beanName, mbd, ctors, null);  }  /**  * 無參構造函數實例化，經過調用反射newInstance實現  */  // No special handling: simply use no-arg constructor.  return instantiateBean(beanName, mbd);  }  複製代碼

由上述源碼能夠看出，實例化bean操做流程以下：

1，若是存在 Supplier 回調，則經過提供supplier回調方法建立，如如下方式定義的bean：

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Spring5Application.class) public class BeanRegistrationTest {  @Autowired  private GenericWebApplicationContext context;   context.registerBean(A.class, () -> new A()); } 複製代碼

2，若是存在工廠方法，則經過工廠方法建立 bean 實例，能夠是靜態工廠方法或者實例工廠，如如下方式定義的bean：

public class AFactory implements FactoryBean<A> {
 @Override  public A getObject() throws Exception {  return new A();  }  @Override  public Class<?> getObjectType() {  return A.class;  } } //或： @Configuration public class BeanConfigration {  @Bean  public A a(){  return new A();  }  } 複製代碼

3，已經有緩存的構造函數或者工廠方法，直接實例化。

4，以上三點都不存在，則使用帶參構造函數與無參構造函數實例化。如如下方式定義的bean：

@Commponet
public class A{} 複製代碼

4.總結

spring單例bean的實例化流程大概就是這樣，不少細節地方，包括循環依賴處理，bean屬性填充等細節點下一章介紹。

參考：

• 《Spring 源碼深度解析》- 郝佳
• 《死磕spring源碼》-chenssy

歡迎關注個人公衆號：好奇心森林