Spring源碼解析容器初始化構(gòu)造方法

更新時(shí)間：2022年07月07日 09:11:26 作者：??碼農(nóng)參上??

這篇文章主要介紹了Spring源碼解析容器初始化構(gòu)造方法，文章圍繞主題展開詳細(xì)的內(nèi)容介紹，具有一定的參考價(jià)值，需要的小伙伴可以參考一下

前言

Spring框架被廣泛應(yīng)用于我們的日常工作中，但是很長時(shí)間以來我都是只會(huì)使用，不懂它的作用原理。通過最近一段時(shí)間的閱讀源碼，個(gè)人發(fā)現(xiàn)通過閱讀源碼，能夠幫助我們了解Spring的設(shè)計(jì)理念，并且對Java編程中的一些設(shè)計(jì)模式更加熟悉，所以記錄一下自己對Spring源碼的理解。

在開始進(jìn)行源碼學(xué)習(xí)前，首先再回顧一下三種Spring編程風(fēng)格：

基于Schema，即通過xml標(biāo)簽的配置方式
基于Annotation的注解技術(shù)，使用@Component等注解配置bean
基于Java Config，簡單來說就是使用@Configuration和@Bean進(jìn)行配置

基于注解的方式需要通過xml或java config來開啟。

在使用xml時(shí)，需要手動(dòng)開啟對注解的支持：

<context: annotation-config/>

當(dāng)然，如果在xml中配置了掃描包，現(xiàn)在也可以光添加下面這一行，這行代碼中已經(jīng)包含了注解的開啟功能。

<context: component-sacn base-package="com"/>

如果你使用的是下面AnnotationConfigApplicationContext這種方式，那么就不需要添加任何操作了，其中已經(jīng)包含了對注解的支持。

AnnotationConfigApplicationContext ctx
	=new AnnotationConfigApplicationContext(SpringConfig.class);

在實(shí)際使用過程中，三種方式是可以混合使用的，不存在沖突。按照下面這種方式作為AnnotationConfigApplicationContext傳入的配置文件，即可實(shí)現(xiàn)三種風(fēng)格的統(tǒng)一使用：

@Configuration
@ComponentScan("com")
@ImportResource("classpath:spring.xml") 
public class SpringConfig{
}

之前也有小伙伴對我說，在開始學(xué)習(xí)Spring的時(shí)候，差點(diǎn)因?yàn)榕渲梅彪s的xml被勸退，我也翻閱了一下網(wǎng)上spring入門的技術(shù)文章，確實(shí)很多還是停留在使用xml的方式上。但是其實(shí)如果你翻閱一下spring5的官方文檔，可以看出官方是推薦我們使用注解的方式的。

尤其是現(xiàn)在的Spring Boot更多的是基于注解，省略了很多配置的過程，對新手更加友好，降低了勸退率，所以本文將基于注解的方式進(jìn)行源碼解析，另外再說明一下本文基于spring-framework-5.0.x源碼。

使用注解的方式初始化一個(gè)Spring環(huán)境，只需要下面一行代碼：

AnnotationConfigApplicationContext context
    = new AnnotationConfigApplicationContext(SpringConfig.class);

如果看一下它的構(gòu)造方法，那么可以將它做的工作拆分為三步，為了便于理解可以寫成下面的形式，并分為三大模塊分別進(jìn)行說明。

構(gòu)造方法

首先看一下AnnotationConfigApplicationContext的繼承關(guān)系：

AnnotationConfigApplicationContext繼承了GenericApplicationContext，那么我們先看GenericApplicationContext的構(gòu)造方法：

public GenericApplicationContext() {
  this.beanFactory = new DefaultListableBeanFactory();
}

在這里初始化了一個(gè)beanFactory的實(shí)現(xiàn)類DefaultListableBeanFactory，這就是我們常提到的spring中重要的bean工廠，這里面存放了很多非常重要的數(shù)據(jù)結(jié)構(gòu)。這里先列出比較重要的beanDefinitionMap，會(huì)在后面頻繁使用：

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

在上面的這個(gè)beanDefinitionMap中就維護(hù)了beanName及BeanDefinition的對應(yīng)關(guān)系，beanDefinitionNames則是一個(gè)存放beanName的List。

從AnnotationConfigApplicationContext的構(gòu)造方法開始分析：

public AnnotationConfigApplicationContext() {
  this.reader = new AnnotatedBeanDefinitionReader(this);
  this.scanner = new ClassPathBeanDefinitionScanner(this);
}

首先實(shí)例化了一個(gè)AnnotatedBeanDefinitionReader對象，看一下AnnotatedBeanDefinitionReader的構(gòu)造函數(shù)：

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
  this(registry, getOrCreateEnvironment(registry));
}

那么，為什么在這能夠?qū)?code>AnnotationConfigApplicationContext對象作為BeanDefinitionRegistry傳入呢？

回頭看一下繼承關(guān)系那張圖，AnnotationConfigApplicationContext繼承了BeanDefinitionRegistry，并且最終實(shí)現(xiàn)了接口BeanFactory，BeanFactory可以說是Spring中的頂層類，它是一個(gè)工廠，能夠產(chǎn)生bean對象，提供了一個(gè)非常重要的方法getBean，會(huì)在后面講到。

到這，我們可以得出一個(gè)結(jié)論：

BeanDefinitionRegistry可以等同于AnnotationConfigApplicationContext ，看做spring的上下文環(huán)境。

AnnotatedBeanDefinitionReader在實(shí)例化時(shí)，會(huì)調(diào)用registerAnnotationConfigProcessors方法。先看前半段代碼：

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
    BeanDefinitionRegistry registry, @Nullable Object source) {
    DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
    if (beanFactory != null) {
      if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
        beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
      }
      if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
        beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
      }
}

在這里先獲取在父類構(gòu)造函數(shù)中實(shí)例好的beanFactory，并為它填充一些屬性：

AnnotationAwareOrderComparator：主要用于排序，解析@order和@Priority注解
ContextAnnotationAutowireCandidateResolver：提供處理延遲加載的功能

再看后半段代碼，下面生成了6個(gè)重要類的BeanDefinitionHolder，并存放到一個(gè)Set中：

 Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
    if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    if (!registry.containsBeanDefinition(REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(RequiredAnnotationBeanPostProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
    if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
    if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition();
      try {
        def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
            AnnotationConfigUtils.class.getClassLoader()));
      }
      catch (ClassNotFoundException ex) {
        throw new IllegalStateException(
            "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
      }
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
    }

    if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
    }

    return beanDefs;
  }

這里是使用RootBeanDefinition來將普通類轉(zhuǎn)換為BeanDefinition，并進(jìn)一步封裝成BeanDefinitionHolder。封裝成BeanDefinitionHolder的操作在registerPostProcessor方法中：

 private static BeanDefinitionHolder registerPostProcessor(
      BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {
    definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    registry.registerBeanDefinition(beanName, definition);
    return new BeanDefinitionHolder(definition, beanName);
  }

通過registerBeanDefinition方法將BeanDefinition注冊到spring環(huán)境中，這個(gè)操作其實(shí)就是執(zhí)行了上面的beanDefinitionMap的put操作：

this.beanDefinitionMap.put(beanName, beanDefinition);

在上面的操作全部完成后，在還沒有實(shí)例化用戶自定義的bean前，已經(jīng)有了6個(gè)spring自己定義的beanDefinition，

用于實(shí)現(xiàn)spring自身的初始化：

這里有必要對BeanDefinition進(jìn)行一下說明，它是對具有屬性值的bean實(shí)例的一個(gè)說明，或者說是定義。就像是在java類加載的過程，普通java文件要先生成字節(jié)碼文件，再加載到j(luò)vm中生成class對象，spring初始化過程中首先要將普通類轉(zhuǎn)化為BeanDefinition，然后再實(shí)例化為bean。

在實(shí)例化AnnotatedBeanDefinitionReader完成后，實(shí)例化了一個(gè)ClassPathBeanDefinitionScanner，可以用來掃描包或者類，并將掃描到的類轉(zhuǎn)化為BeanDefinition。但是翻閱源碼，我們可以看到實(shí)際上掃描包的工作不是這個(gè)scanner對象來完成的，而是在后面spring自己實(shí)例化了一個(gè)ClassPathBeanDefinitionScanner來負(fù)責(zé)的。

這里的scanner僅僅是對外提供一個(gè)擴(kuò)展，可以讓我們能夠在外部調(diào)用AnnotationConfigApplicationContext對象的scan方法，實(shí)現(xiàn)包的掃描，

例如：