Spring源码解析容器初始化构造方法

更新时间：2022年07月07日 09:11:26 作者：码农参上

这篇文章主要介绍了Spring源码解析容器初始化构造方法，文章围绕主题展开详细的内容介绍，具有一定的参考价值，需要的小伙伴可以参考一下

前言

Spring框架被广泛应用于我们的日常工作中，但是很长时间以来我都是只会使用，不懂它的作用原理。通过最近一段时间的阅读源码，个人发现通过阅读源码，能够帮助我们了解Spring的设计理念，并且对Java编程中的一些设计模式更加熟悉，所以记录一下自己对Spring源码的理解。

在开始进行源码学习前，首先再回顾一下三种Spring编程风格：

基于Schema，即通过xml标签的配置方式
基于Annotation的注解技术，使用@Component等注解配置bean
基于Java Config，简单来说就是使用@Configuration和@Bean进行配置

基于注解的方式需要通过xml或java config来开启。

在使用xml时，需要手动开启对注解的支持：

<context: annotation-config/>

当然，如果在xml中配置了扫描包，现在也可以光添加下面这一行，这行代码中已经包含了注解的开启功能。

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

如果你使用的是下面AnnotationConfigApplicationContext这种方式，那么就不需要添加任何操作了，其中已经包含了对注解的支持。

AnnotationConfigApplicationContext ctx
	=new AnnotationConfigApplicationContext(SpringConfig.class);

在实际使用过程中，三种方式是可以混合使用的，不存在冲突。按照下面这种方式作为AnnotationConfigApplicationContext传入的配置文件，即可实现三种风格的统一使用：

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

之前也有小伙伴对我说，在开始学习Spring的时候，差点因为配置繁杂的xml被劝退，我也翻阅了一下网上spring入门的技术文章，确实很多还是停留在使用xml的方式上。但是其实如果你翻阅一下spring5的官方文档，可以看出官方是推荐我们使用注解的方式的。

尤其是现在的Spring Boot更多的是基于注解，省略了很多配置的过程，对新手更加友好，降低了劝退率，所以本文将基于注解的方式进行源码解析，另外再说明一下本文基于spring-framework-5.0.x源码。

使用注解的方式初始化一个Spring环境，只需要下面一行代码：

AnnotationConfigApplicationContext context
    = new AnnotationConfigApplicationContext(SpringConfig.class);

如果看一下它的构造方法，那么可以将它做的工作拆分为三步，为了便于理解可以写成下面的形式，并分为三大模块分别进行说明。

构造方法

首先看一下AnnotationConfigApplicationContext的继承关系：

AnnotationConfigApplicationContext继承了GenericApplicationContext，那么我们先看GenericApplicationContext的构造方法：

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

在这里初始化了一个beanFactory的实现类DefaultListableBeanFactory，这就是我们常提到的spring中重要的bean工厂，这里面存放了很多非常重要的数据结构。这里先列出比较重要的beanDefinitionMap，会在后面频繁使用：

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

在上面的这个beanDefinitionMap中就维护了beanName及BeanDefinition的对应关系，beanDefinitionNames则是一个存放beanName的List。

从AnnotationConfigApplicationContext的构造方法开始分析：

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

首先实例化了一个AnnotatedBeanDefinitionReader对象，看一下AnnotatedBeanDefinitionReader的构造函数：

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

那么，为什么在这能够将AnnotationConfigApplicationContext对象作为BeanDefinitionRegistry传入呢？

回头看一下继承关系那张图，AnnotationConfigApplicationContext继承了BeanDefinitionRegistry，并且最终实现了接口BeanFactory，BeanFactory可以说是Spring中的顶层类，它是一个工厂，能够产生bean对象，提供了一个非常重要的方法getBean，会在后面讲到。

到这，我们可以得出一个结论：

BeanDefinitionRegistry可以等同于AnnotationConfigApplicationContext ，看做spring的上下文环境。

AnnotatedBeanDefinitionReader在实例化时，会调用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());
      }
}

在这里先获取在父类构造函数中实例好的beanFactory，并为它填充一些属性：

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

再看后半段代码，下面生成了6个重要类的BeanDefinitionHolder，并存放到一个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来将普通类转换为BeanDefinition，并进一步封装成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环境中，这个操作其实就是执行了上面的beanDefinitionMap的put操作：

this.beanDefinitionMap.put(beanName, beanDefinition);

在上面的操作全部完成后，在还没有实例化用户自定义的bean前，已经有了6个spring自己定义的beanDefinition，

用于实现spring自身的初始化：

这里有必要对BeanDefinition进行一下说明，它是对具有属性值的bean实例的一个说明，或者说是定义。就像是在java类加载的过程，普通java文件要先生成字节码文件，再加载到jvm中生成class对象，spring初始化过程中首先要将普通类转化为BeanDefinition，然后再实例化为bean。

在实例化AnnotatedBeanDefinitionReader完成后，实例化了一个ClassPathBeanDefinitionScanner，可以用来扫描包或者类，并将扫描到的类转化为BeanDefinition。但是翻阅源码，我们可以看到实际上扫描包的工作不是这个scanner对象来完成的，而是在后面spring自己实例化了一个ClassPathBeanDefinitionScanner来负责的。

这里的scanner仅仅是对外提供一个扩展，可以让我们能够在外部调用AnnotationConfigApplicationContext对象的scan方法，实现包的扫描，

例如：

context.scan("com.hydra");

到这里，AnnotationConfigApplicationContext的构造函数就执行完了，下一篇，我们来详细说说接下来被调用的register方法。

到此这篇关于Spring源码解析容器初始化构造方法的文章就介绍到这了,更多相关Spring构造方法内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

最大子数组和Java实现代码示例
这篇文章主要介绍了最大子数组和Java实现的相关资料,文中介绍了两种方法来解决寻找具有最大和的连续子数组的问题,第一种方法是动态规划,第二种方法是分治法,需要的朋友可以参考下
2024-11-11
Java maven三种仓库,本地仓库,私服,中央仓库的配置
今天给大家简单介绍Maven三种仓库的配置,文中有非常详细的解释,对Java初学者很有帮助哟,需要的朋友可以参考下，希望能够给你带来帮助
2021-09-09
java中volatile关键字的作用详解
这篇文章主要介绍了java中volatile关键字的作用详解,volatile可以保证,若一个线程改变了某块内存的值,其他线程是可见的,以至于其他线程能及时更新这块内存,需要的朋友可以参考下
2023-09-09
Java多线程 Callable、Future 和FutureTask
这篇文章主要介绍Java多线程中的 Callable、Future 以及FutureTask,下面文章围绕Java多线程的相关资料展开全文详细内容,需要的朋友可以参考一下
2021-10-10
SpringBoot读取自定义配置文件方式(properties,yaml)
这篇文章主要介绍了SpringBoot读取自定义配置文件方式(properties，yaml)，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2022-07-07
spring cloud中微服务之间的调用以及eureka的自我保护机制详解
这篇文章主要介绍了spring cloud中微服务之间的调用以及eureka的自我保护机制详解,小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2018-07-07
基于java文本复制的7种方式总结
下面小编就为大家分享一篇基于java文本复制的7种方式总结，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
2018-01-01
Spring boot配置文件加解密详解
这篇文章主要给大家介绍了关于Spring boot配置文件加解密的相关资料，文中通过示例代码以及图文介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
2019-03-03
基于SpringBoot实现文件秒传功能
在开发Web应用时,文件上传是一个常见需求,然而,当用户需要上传大文件或相同文件多次时,会造成带宽浪费和服务器存储冗余,此时可以使用文件秒传技术通过识别重复文件,本文就给大家介绍了如何基于SpringBoot实现文件秒传功能,需要的朋友可以参考下
2025-04-04
如何解决idea的Translation插件google翻译无法使用问题
这篇文章主要介绍了如何解决idea的Translation插件google翻译无法使用问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教
2024-05-05

Spring源码解析容器初始化构造方法

目录

前言

构造方法

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具