前言

本節將正式介紹Spring原始碼細節，將講解Bean生命週期。請注意，雖然我們不希望過於繁瑣地理解Spring原始碼，但也不要認為Spring原始碼很簡單。在本節中，我們將主要講解Spring 5.3.10版本的原始碼。如果您看到的程式碼與我講解的不同，也沒有關係，因為其中的原理和業務邏輯基本相同。為了更好地理解，我們將先講解Bean的生命週期，再講解Spring的啟動原理和流程，因為啟動是準備工作的一部分。

題外話

目前在該版本中，引入了一個名為jfr的JDK技術，類似於Java飛行紀錄檔（JFL），也稱為飛行資料記錄器（Black Box）技術。具體作用不再詳細闡述，讀者可以參考此文：JFR介紹
如果您看到以下程式碼，請直接跳過，因為它並沒有太大的作用：

    public AnnotationConfigApplicationContext() {
        StartupStep createAnnotatedBeanDefReader = this.getApplicationStartup().start("spring.context.annotated-bean-reader.create");
        // 額外會建立StandardEnvironment
        this.reader = new AnnotatedBeanDefinitionReader(this);
        createAnnotatedBeanDefReader.end();
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }

需要注意的是，其中的 StartupStep 關於預設實現並沒有什麼實際作用。但是，還有一種實現方式是 FlightRecorderStartupStep，它是JDK的JFR技術。

Bean的生成過程

生成BeanDefinition

BeanDefinition的作用大家基本通過前面的文章也知道了大概，就是用來描述bean的。
那麼它是如何載入的呢？首先我們看一下 ClassPathBeanDefinitionScanner 類，它是用於掃描的。其中有一個屬性是 BeanDefinitionRegistry，即Bean定義的註冊類。預設實現是 DefaultListableBeanFactory，但是在 ClassPathBeanDefinitionScanner 類中並沒有直接使用該類作為屬性，而是使用了它的父介面 BeanDefinitionRegistry。這是因為 ClassPathBeanDefinitionScanner 類實際上並沒有使用 BeanDefinitionRegistry 介面中的許多方法來註冊Bean定義。

接下來，我們來分析 ClassPathBeanDefinitionScanner 類的 scan 方法：

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
        Assert.notEmpty(basePackages, "At least one base package must be specified");
        Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
        for (String basePackage : basePackages) {

            Set<BeanDefinition> candidates = findCandidateComponents(basePackage);

            for (BeanDefinition candidate : candidates) {
                ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
                candidate.setScope(scopeMetadata.getScopeName());

                String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);

                if (candidate instanceof AbstractBeanDefinition) {
                    postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
                }
                if (candidate instanceof AnnotatedBeanDefinition) {
                    // 解析@Lazy、@Primary、@DependsOn、@Role、@Description
                    AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
                }

                // 檢查Spring容器中是否已經存在該beanName
                if (checkCandidate(beanName, candidate)) {
                    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
                    definitionHolder =
                            AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                    beanDefinitions.add(definitionHolder);

                    // 註冊
                    registerBeanDefinition(definitionHolder, this.registry);
                }
            }
        }
        return beanDefinitions;
    }

大致邏輯如下：

獲取掃描包路徑
findCandidateComponents:獲取符合條件的bean
遍歷candidate（候選bean），由於第二部使用了ASM技術，所以並沒有真正獲取beanclass而是使用了beanname替代所以，遍歷的做法就是將符合條件的bean定義進行註冊。
scopeMetadata解析scope註解。
beanNameGenerator構建當前bean的唯一名字。
postProcessBeanDefinition這裡其實就是進行預設值賦值。
processCommonDefinitionAnnotations進行解析@Lazy、@Primary、@DependsOn、@Role、@Description
checkCandidate(beanName, candidate)再次檢查是否該beanName已經註冊過。
registerBeanDefinition，註冊到我們的DefaultListableBeanFactory的BeanDefinitionMap中。

其實這裡基本就已經大概瞭解的差不多了，然後再繼續講解下每一個流程裡面都走了那些邏輯：

findCandidateComponents

其主要邏輯會進入如下原始碼：

private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
        Set<BeanDefinition> candidates = new LinkedHashSet<>();
        try {
            // 獲取basePackage下所有的檔案資源
            String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
                    resolveBasePackage(basePackage) + '/' + this.resourcePattern;

            Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);

            boolean traceEnabled = logger.isTraceEnabled();
            boolean debugEnabled = logger.isDebugEnabled();
            for (Resource resource : resources) {
                if (traceEnabled) {
                    logger.trace("Scanning " + resource);
                }
                if (resource.isReadable()) {
                    try {
                        MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
                        // excludeFilters、includeFilters判斷
                        if (isCandidateComponent(metadataReader)) { // @Component-->includeFilters判斷
                            ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
                            sbd.setSource(resource);

                            if (isCandidateComponent(sbd)) {
                                if (debugEnabled) {
                                    logger.debug("Identified candidate component class: " + resource);
                                }
                                candidates.add(sbd);
                            }
                            //此處省略部分程式碼
                            ......
        }
        return candidates;
    }

讓我們來深入瞭解一下Bean掃描的具體細節。以下是主要流程：

獲取basePackage下所有的檔案資源。以下分析註解資訊等都是用到了ASM技術，並沒有真正的去載入這個類。
isCandidateComponent(metadataReader)，進行判斷是否當前類具有@component註解。
isCandidateComponent(sbd)，進行判斷是否當前類屬於內部類、介面、抽象類
符合上述條件則會加入到bean定義候選集合中。

ASM技術這裡不做多解釋，主要看下Spring是如何進行判斷校驗當前bean是否符合條件的，第一個 isCandidateComponent(metadataReader)方法：

	protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
		for (TypeFilter tf : this.excludeFilters) {
			if (tf.match(metadataReader, getMetadataReaderFactory())) {
				return false;
			}
		}
		// 符合includeFilters的會進行條件匹配，通過了才是Bean，也就是先看有沒有@Component，再看是否符合@Conditional
		for (TypeFilter tf : this.includeFilters) {
			if (tf.match(metadataReader, getMetadataReaderFactory())) {
				return isConditionMatch(metadataReader);
			}
		}
		return false;
	}

那麼includeFilters預設會在啟動AnnotationConfigApplicationContext時就會預設註冊一個解析Component註解的filter，程式碼如下:

protected void registerDefaultFilters() {  
  
   // 註冊@Component對應的AnnotationTypeFilter  
  this.includeFilters.add(new AnnotationTypeFilter(Component.class));  
  
   ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();  
  
   try {  
      this.includeFilters.add(new AnnotationTypeFilter(  
            ((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));  
      logger.trace("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");  
   }  
   catch (ClassNotFoundException ex) {  
      // JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.  
  }  
  
   try {  
      this.includeFilters.add(new AnnotationTypeFilter(  
            ((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));  
      logger.trace("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");  
   }  
   catch (ClassNotFoundException ex) {  
      // JSR-330 API not available - simply skip.  
  }  
}

如果符合過濾條件，那麼他就會開始生成最初的bean定義：

public ScannedGenericBeanDefinition(MetadataReader metadataReader) {  
   Assert.notNull(metadataReader, "MetadataReader must not be null");  
   this.metadata = metadataReader.getAnnotationMetadata();  
   // 這裡只是把className設定到BeanDefinition中  
  setBeanClassName(this.metadata.getClassName());  
   setResource(metadataReader.getResource());  
}

那麼就剩下最後的校驗了：isCandidateComponent(sbd)；再來看看他的作用子什麼：

protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {  
   AnnotationMetadata metadata = beanDefinition.getMetadata();  
   return (metadata.isIndependent() && (metadata.isConcrete() ||  
         (metadata.isAbstract() && metadata.hasAnnotatedMethods(Lookup.class.getName()))));  
}

看完一臉懵，那我們就好好解釋一下每個判斷都是什麼意思吧：

metadata.isIndependent()：是否當前類為內部類，眾說周知java語言編譯內部類的時候會產生兩個class檔案，比如下面這樣：

那麼這個Member內部類是不會被Spring作為單獨的類去掃描的。除非也加上@component註解，並且為static內部類
metadata.isConcrete()：這個類就是判斷下是否是介面還是抽象類
metadata.hasAnnotatedMethods(Lookup.class.getName())：判斷是否有方法是帶有Lookup註解的，Lookup註解工作中用到的確實有些少，我在這裡簡要說明下：比如我們註冊給Spring的bean都是單例，但是如果我們有多例的bean被一個單例的bean所依賴的話，一次屬性只能注入一次，也打不到多例的效果，這時候就可以用Lookup註解實現了，比如這樣：

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);  
 //UserService 為單例
UserService bean = applicationContext.getBean(UserService.class);  
bean.test();  
bean.test();

@Component  
public class UserService {  

   @Autowired  
  private User user;  
  
   public void test(){  
      System.out.println(user);  
   }  
}

 @Component  
@Scope("prototype")  
public class User {  
  
}

如果這樣執行的話，你永遠拿不到多例的User類，因為UserService 在屬性依賴注入的時候已經做完了賦值，每次呼叫拿到的都是同一個物件，那如果不這麼做可不可以，當然可以：比如這樣改下UserService 類：

@Component  
public class UserService {  
  
   @Autowired  
  private User user;  
  
   public void test(){  
      System.out.println(get());  
   }  
  
   @Lookup  
  public User get(){  
      return null;  
   }  
}

至於為什麼這裡返回null，後續在進行講解，只要知道他的註解的作用即可。到此我們終於解決完了findCandidateComponents方法找出了符合條件的bean定義。

generateBeanName

獲取當前bean的beanname，原始碼如下：

public String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry) {  
   if (definition instanceof AnnotatedBeanDefinition) {  
      // 獲取註解所指定的beanName  
  String beanName = determineBeanNameFromAnnotation((AnnotatedBeanDefinition) definition);  
      if (StringUtils.hasText(beanName)) {  
         // Explicit bean name found.  
  return beanName;  
      }  
   }  
   // Fallback: generate a unique default bean name.  
  return buildDefaultBeanName(definition, registry);  
}

buildDefaultBeanName構建註解我們寫 beanname這個不難理解，如果沒有那麼就會走預設的構建，那麼這裡是jdk提供的，有個點需要注意下如果首字母和第二個字母都是大寫那麼名字直接return，如果你寫的是ABtest，那麼beanname就是ABtest：

public static String decapitalize(String name) {  
    if (name == null || name.length() == 0) {  
        return name;  
    }  
    if (name.length() > 1 && Character.isUpperCase(name.charAt(1)) &&  
                    Character.isUpperCase(name.charAt(0))){  
        return name;  
    }  
    char chars[] = name.toCharArray();  
    chars[0] = Character.toLowerCase(chars[0]);  
    return new String(chars);  
}

postProcessBeanDefinition

這裡主要是進行設定BeanDefinition的預設值,直接看原始碼就能看懂：

public void applyDefaults(BeanDefinitionDefaults defaults) {  
   Boolean lazyInit = defaults.getLazyInit();  
   if (lazyInit != null) {  
      setLazyInit(lazyInit);  
   }  
   setAutowireMode(defaults.getAutowireMode());  
   setDependencyCheck(defaults.getDependencyCheck());  
   setInitMethodName(defaults.getInitMethodName());  
   setEnforceInitMethod(false);  
   setDestroyMethodName(defaults.getDestroyMethodName());  
   setEnforceDestroyMethod(false);  
}

processCommonDefinitionAnnotations

這一步主要時進行解析類上的註解,看原始碼也可以基本看懂，沒有太多繞的邏輯，如下展示：

static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {  
   AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);  
   if (lazy != null) {  
      abd.setLazyInit(lazy.getBoolean("value"));  
   }  
   else if (abd.getMetadata() != metadata) {  
      lazy = attributesFor(abd.getMetadata(), Lazy.class);  
      if (lazy != null) {  
         abd.setLazyInit(lazy.getBoolean("value"));  
      }  
   }  
  
   if (metadata.isAnnotated(Primary.class.getName())) {  
      abd.setPrimary(true);  
   }  
   AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);  
   if (dependsOn != null) {  
      abd.setDependsOn(dependsOn.getStringArray("value"));  
   }  
  
   AnnotationAttributes role = attributesFor(metadata, Role.class);  
   if (role != null) {  
      abd.setRole(role.getNumber("value").intValue());  
   }  
   AnnotationAttributes description = attributesFor(metadata, Description.class);  
   if (description != null) {  
      abd.setDescription(description.getString("value"));  
   }  
}

checkCandidate

這一步主要是檢查是否我們的bean定義map註冊中已經存在了，不過我們工作中基本上都會通過，如果存在多個那會拋異常：

protected boolean checkCandidate(String beanName, BeanDefinition beanDefinition) throws IllegalStateException {  
   if (!this.registry.containsBeanDefinition(beanName)) {  
      return true;  
   }  
   BeanDefinition existingDef = this.registry.getBeanDefinition(beanName);  
   BeanDefinition originatingDef = existingDef.getOriginatingBeanDefinition();  
   if (originatingDef != null) {  
      existingDef = originatingDef;  
   }  
   // 是否相容，如果相容返回false表示不會重新註冊到Spring容器中，如果不衝突則會拋異常。  
  if (isCompatible(beanDefinition, existingDef)) {  
      return false;  
   }  
   throw new ConflictingBeanDefinitionException("Annotation-specified bean name '" + beanName +  
         "' for bean class [" + beanDefinition.getBeanClassName() + "] conflicts with existing, " +  
         "non-compatible bean definition of same name and class [" + existingDef.getBeanClassName() + "]");  
}

可是你像我這樣下面寫的話就不會出現異常，但是工作中肯定也不會這麼用，這裡只做展示,AppConfig和AppConfig1都是對同樣的設定，會對同一個包路徑掃描兩次:

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();  
applicationContext.register(AppConfig.class);  
applicationContext.register(AppConfig1.class);  
applicationContext.refresh();  
UserService bean = applicationContext.getBean(UserService.class);  
bean.test();

registerBeanDefinition

那麼最後當前的bean定義正式生成，並註冊到我們之前經常說的DefaultListableBeanFactory的Map<String, BeanDefinition> beanDefinitionMap屬性。

public static void registerBeanDefinition(  
      BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)  
      throws BeanDefinitionStoreException {  
  
   // Register bean definition under primary name.  
  String beanName = definitionHolder.getBeanName();  
   registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());  
  
   // Register aliases for bean name, if any.  
  String[] aliases = definitionHolder.getAliases();  
   if (aliases != null) {  
      for (String alias : aliases) {  
         registry.registerAlias(beanName, alias);  
      }  
   }  
}

合併bean定義

這個是非常重要的一個步驟，所以單獨拿出來說下，這個步驟也是獲取bean之前的最後一個對bean定義做修改的地方，getMergedLocalBeanDefinition(beanName);通過beanname來獲取合併後的bean定義，這是什麼意思呢？看下原始碼：

protected RootBeanDefinition getMergedBeanDefinition(  
      String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)  
      throws BeanDefinitionStoreException {  
  
   synchronized (this.mergedBeanDefinitions) {  
      RootBeanDefinition mbd = null;  
      RootBeanDefinition previous = null;  
  
      // Check with full lock now in order to enforce the same merged instance.  
  if (containingBd == null) {  
         mbd = this.mergedBeanDefinitions.get(beanName);  
      }  
  
      if (mbd == null || mbd.stale) {  
         previous = mbd;  
         if (bd.getParentName() == null) {  
            // Use copy of given root bean definition.  
  if (bd instanceof RootBeanDefinition) {  
               mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();  
            }  
            else {  
               mbd = new RootBeanDefinition(bd);  
            }  
         }  
         else {  
            // Child bean definition: needs to be merged with parent.  
 // pbd表示parentBeanDefinition  
  BeanDefinition pbd;  
            try {  
               String parentBeanName = transformedBeanName(bd.getParentName());  
               if (!beanName.equals(parentBeanName)) {  
                  pbd = getMergedBeanDefinition(parentBeanName);  
               }  
               else {  
                  BeanFactory parent = getParentBeanFactory();  
                  if (parent instanceof ConfigurableBeanFactory) {  
                     pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);  
                  }  
                  else {  
                     ......
                    }  
               }  
            }  
            catch (NoSuchBeanDefinitionException ex) {  
               ......
            }  
  
            // Deep copy with overridden values.  
 // 子BeanDefinition的屬性覆蓋父BeanDefinition的屬性，這就是合併  
  mbd = new RootBeanDefinition(pbd);  
            mbd.overrideFrom(bd);  
         }  
  
         // Set default singleton scope, if not configured before.  
  if (!StringUtils.hasLength(mbd.getScope())) {  
            mbd.setScope(SCOPE_SINGLETON);  
         }  
  
  if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {  
            mbd.setScope(containingBd.getScope());  
         }  
  
		 if (containingBd == null && isCacheBeanMetadata()) {  
            this.mergedBeanDefinitions.put(beanName, mbd);  
         }  
      }  
      if (previous != null) {  
         copyRelevantMergedBeanDefinitionCaches(previous, mbd);  
      }  
      return mbd;  
   }  
}

為什麼需要進行合併bean定義，因為每個bean都會可能被其他宣告bean所參照，因為我們在工作中用到的都是註解形式，所以很少注意，我們看下Spring是xml時代時寫的宣告bean：

<bean id="user1" class="com.xiaoyu.service.User" scope="prototype"/>  
  
<bean id="user2" class="com.xiaoyu.service.User" parent="user1"/>

然後我們在看下合併bean定義的原始碼邏輯：

判斷是否有parent，沒有的話就正常包裝原始bean定義為RootBeanDefinition。
如果有parent，那麼在判斷其父類別是否還有父類別，如果有則遞迴合併bean定義方法。
最關鍵的其實是這個程式碼：先以父類別的bean定義生成RootBeanDefinition，然後如果子類定義了某個屬性的話那就覆蓋父類別的bean定義。
mbd = new RootBeanDefinition(pbd); mbd.overrideFrom(bd);

public void overrideFrom(BeanDefinition other) {  
   if (StringUtils.hasLength(other.getBeanClassName())) {  
      setBeanClassName(other.getBeanClassName());  
   }  
   if (StringUtils.hasLength(other.getScope())) {  
      setScope(other.getScope());  
   }  
   setAbstract(other.isAbstract());  
   if (StringUtils.hasLength(other.getFactoryBeanName())) {  
      setFactoryBeanName(other.getFactoryBeanName());  
   }  
   if (StringUtils.hasLength(other.getFactoryMethodName())) {  
      setFactoryMethodName(other.getFactoryMethodName());  
   }  
   setRole(other.getRole());  
   setSource(other.getSource());  
   copyAttributesFrom(other);  
  //此處省略部分程式碼
   ......
}

最後將包裝的bean定義放入mergedBeanDefinitions合併定義的map中。

現在我們的的Spring中了兩個bean定義Map，那麼在啟動時進行建立bean時用到的都是合併後的bean定義map。

結語

那麼現在Spring的Bean定義環節就基本講解完畢了。其實最主要的是Spring是如何判斷是否將Bean定義加入，並生成Bean定義，以及最後如何使用合併的Bean定義來包裝原始的Bean定義。下一節我們將開始講解Spring的Bean範例化。
公眾號

Spring原始碼：bean的生命週期（一）

前言

題外話