AnnotationConfigApplicationContext的实例化过程

最新推荐文章于 2024-06-01 09:29:25 发布
最新推荐文章于 2024-06-01 09:29:25 发布
阅读量2.4w 收藏 49
点赞数 9
分类专栏： Spring & SpringBoot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chr1sgong/article/details/79083770
版权

1，类继承结构

理解AnnotationConfigApplicationContext的实例化过程之前先看一下它的类继承结构：
这里写图片描述
主要涉及到的类或接口有以下几个：

  1. GenericApplicationContext——通用应用上下文，内部持有一个DefaultListableBeanFactory实例，这个类实现了BeanDefinitionRegistry接口，可以在它身上使用任意的bean definition读取器。典型的使用案例是：通过BeanFactoryRegistry接口注册bean definitions，然后调用refresh()方法来初始化那些带有应用上下文语义（org.springframework.context.ApplicationContextAware）的bean，自动探测org.springframework.beans.factory.config.BeanFactoryPostProcessor等。关于这两个接口，在介绍bean的生命周期时进行详细讲解。
  2. BeanDefinitionRegistry——用于持有像RootBeanDefinition和 ChildBeanDefinition实例的bean definitions的注册表接口。DefaultListableBeanFactory实现了这个接口，因此可以通过相应的方法向beanFactory里面注册bean。GenericApplicationContext内置一个DefaultListableBeanFactory实例，它对这个接口的实现实际上是通过调用这个实例的相应方法实现的。
  3. AbstractApplicationContext——ApplicationContext接口的抽象实现，没有强制规定配置的存储类型，仅仅实现了通用的上下文功能。这个实现用到了模板方法设计模式，需要具体的子类来实现其抽象方法。自动通过registerBeanPostProcessors()方法注册BeanFactoryPostProcessor, BeanPostProcessor和ApplicationListener的实例用来探测bean factory里的特殊bean——对比1分析
  4. AnnotationConfigRegistry——注解配置注册表。用于注解配置应用上下文的通用接口，拥有一个注册配置类和扫描配置类的方法。

2，构造方法

/**
 * Create a new AnnotationConfigApplicationContext that needs to be populated
 * through {@link #register} calls and then manually {@linkplain #refresh refreshed}.
 */
public AnnotationConfigApplicationContext() {
   this.reader = new AnnotatedBeanDefinitionReader(this);
   this.scanner = new ClassPathBeanDefinitionScanner(this);
}

/**
 * Create a new AnnotationConfigApplicationContext with the given   
 * DefaultListableBeanFactory.
 * @param beanFactory the DefaultListableBeanFactory instance to use for this context
 */
public AnnotationConfigApplicationContext(DefaultListableBeanFactory beanFactory) {
   super(beanFactory);
   this.reader = new AnnotatedBeanDefinitionReader(this);
   this.scanner = new ClassPathBeanDefinitionScanner(this);
}

/**
 * Create a new AnnotationConfigApplicationContext, deriving bean definitions
 * from the given annotated classes and automatically refreshing the context.
 * @param annotatedClasses one or more annotated classes,
 * e.g. {@link Configuration @Configuration} classes
 */
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
   this();
   register(annotatedClasses);
   refresh();
}

/**
 * Create a new AnnotationConfigApplicationContext, scanning for bean definitions
 * in the given packages and automatically refreshing the context.
 * @param basePackages the packages to check for annotated classes
 */
public AnnotationConfigApplicationContext(String... basePackages) {
   this();
   scan(basePackages);
   refresh();
}

第一个构造器是最基本的无参数构造器，需要通过调用register()方法填充注解类，并进行手动刷新。在这个构造器里初始化了一个读取器和扫描器。

第二个构造器能手动指定beanFactory。

第三个构造器能手动指定注解类。

第四个通过指定包名进行自动扫描并刷新。

由于AnnotationConfigApplicationContext是GenericApplicationContext的子类，在调用它的构造器之前会先调用父类的构造器，父类构造器会实例化一个DefaultListableBeanFactory实例，这个就是基于注解配置的应用上下文的IoC容器。SpringBoot默认调用第一个无参数构造器。

3，SpringApplication类

首先，用户的Application类是被@SpringBootApplication注解的。有必要对@SpringBootApplication进行了解。

@SpringBootApplication可以认为是@SpringBootConfiguration，@EnableAutoConfiguration和@ComponentScan三个注解的组合。下面进行详细分析。

3.1，@SpringBootConfiguration

@SpringBootConfiguration只是对@Configuration做了一下包装，说明编写的类是一个配置类。

3.2，@EnableAutoConfiguration

@EnableAutoConfiguration注解使能了自动配置功能。这个注解由@Import(EnableAutoConfigurationImportSelector.class)注解。在目前的版本中EnableAutoConfigurationImportSelector被废弃了，反而用了它的基类AutoConfigurationImportSelector。

AutoConfigurationImportSelector用于处理@EnableAutoConfiguration注解—未完待续！！！

3.3，@ComponentScan

开启组件扫描，和xml配置的<context:component-scan>效果一样

3.4，SpringApplication的执行过程

SpringApplication的静态run()方法通过主类构造一个新的SpringApplication实例，然后运行真正的run()方法。

SpringApplication类的初始化

在SpringApplication的构造器中调用了一个initialize()方法，这个方法的代码如下：

private void initialize(Object[] sources) {
  if (sources != null && sources.length > 0) {
    this.sources.addAll(Arrays.asList(sources));
  }
  //推断是否是web环境，如果是会专门针对web上下文进行设置
  this.webEnvironment = deduceWebEnvironment();
  //设置初始化器
  setInitializers((Collection) getSpringFactoriesInstances(
    ApplicationContextInitializer.class));
  //设置监听器
  setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
  this.mainApplicationClass = deduceMainApplicationClass();
}

初始化方法主要做了三件事情：

  1. 判断上下文环境，web还是非web？后面会根据上下文环境进行针对性的设置

  2. 设置初始化器，这里只获取ApplicationContextInitializer（应用上下文初始化器）。这里主要执行的代码是获取初始化器对应的工厂实例，代码如下：

    private <T> Collection<? extends T> getSpringFactoriesInstances(Class<T> type,
        Class<?>[] parameterTypes, Object... args) {
 ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
 // Use names and ensure unique to protect against duplicates
 Set<String> names = new LinkedHashSet<String>(
   SpringFactoriesLoader.loadFactoryNames(type, classLoader));
 List<T> instances = createSpringFactoriesInstances(type, parameterTypes,
                                                    classLoader, args, names);
 AnnotationAwareOrderComparator.sort(instances);
 return instances;
}

    这里用到了SpringFactoriesLoader类。这个类主要用于装载工厂，工厂资源位于META-INF/spring.factories文件中，这个文件可能在类路径的多个jar文件中。然后调用createSpringFactoriesInstances()方法对工厂进行实例化并根据注解进行排序。

  3. 设置监听器，具体过程同2.

run()方法的执行

run()的代码如下：

public ConfigurableApplicationContext run(String... args) {
  StopWatch stopWatch = new StopWatch();
  stopWatch.start();
  ConfigurableApplicationContext context = null;
  FailureAnalyzers analyzers = null;
  configureHeadlessProperty();
  // 获取启动监听器
  SpringApplicationRunListeners listeners = getRunListeners(args);
  listeners.starting();
  try {
    // 构建应用参数 
    ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                    args);
    // 准备应用环境
    ConfigurableEnvironment environment = prepareEnvironment(listeners,
                                                        applicationArguments);
    Banner printedBanner = printBanner(environment);
    // 创建ApplicationContext
    context = createApplicationContext();
    analyzers = new FailureAnalyzers(context);
    // 准备context
    prepareContext(context, environment, listeners, applicationArguments, 
                   printedBanner);
    // 刷新context-----！！！很重要
    refreshContext(context);
    // 后置工作
    afterRefresh(context, applicationArguments);
    listeners.finished(context, null);
    stopWatch.stop();
    if (this.logStartupInfo) {
      new StartupInfoLogger(this.mainApplicationClass)
                    .logStarted(getApplicationLog(), stopWatch);
    }
    return context;
  }
  catch (Throwable ex) {
    handleRunFailure(context, listeners, analyzers, ex);
    throw new IllegalStateException(ex);
  }
}

  1. 获取启动监听器。具体实现与获取初始化器的方式一样。实际上获取的是一个EventPublishingRunListener对象，这个类能通过一个SimpleApplicationEventMulticaster对象广播事件，用到了Executor多线程异步执行框架，复习！！！！

  2. 构建应用参数。保存命令行参数。

  3. 准备应用环境。prepareEnvironment()的代码如下：

    private ConfigurableEnvironment prepareEnvironment(
 SpringApplicationRunListeners listeners,
        ApplicationArguments applicationArguments) {
 // Create and configure the environment
 ConfigurableEnvironment environment = getOrCreateEnvironment();
 // 配置环境
 configureEnvironment(environment, applicationArguments.getSourceArgs());
 listeners.environmentPrepared(environment);
 if (!this.webEnvironment) {
   environment = new EnvironmentConverter(getClassLoader())
     .convertToStandardEnvironmentIfNecessary(environment);
 }
 return environment;
}

    在构造environment的时候，会根据前面推断的web环境创建相应的Environment对象，如果是web环境，则创建StandardServletEnvironment对象，否则创建StandardEnvironment对象，StandardEnvironment的构造器会先对属性源进行定制（将系统属性和系统环境添加到一个MutablePropertySources维护的list中）。这个对象的主要工作包括property分析、profile相关操作、获取系统属性和系统环境等。参考相关类结构。

    接着是配置环境，configureEnvironment()的实现如下：

    protected void configureEnvironment(ConfigurableEnvironment environment,
        String[] args) {
 // 配置属性源
 configurePropertySources(environment, args);
 // 配置profile
 configureProfiles(environment, args);
}

    SpringApplication#configurePropertySources()的实现如下：

    protected void configurePropertySources(ConfigurableEnvironment environment,
        String[] args) {
 MutablePropertySources sources = environment.getPropertySources();
 // 添加默认属性
 if (this.defaultProperties != null && !this.defaultProperties.isEmpty()) {
   sources.addLast(new MapPropertySource("defaultProperties",this.defaultProperties));
 }
 // 添加命令行属性
 if (this.addCommandLineProperties && args.length > 0) {
   String name = CommandLinePropertySource.COMMAND_LINE_PROPERTY_SOURCE_NAME;
   if (sources.contains(name)) {
     PropertySource<?> source = sources.get(name);
     CompositePropertySource composite = new CompositePropertySource(name);
     composite.addPropertySource(new SimpleCommandLinePropertySource(
       name + "-" + args.hashCode(), args));
     composite.addPropertySource(source);
     sources.replace(name, composite);
   }
   else {
     sources.addFirst(new SimpleCommandLinePropertySource(args));
   }
 }
}

    在现在这个阶段的配置主要是添加默认属性（defaultProperties）和命令行属性。

    SpringApplication#configureProfiles()的实现如下：

    protected void configureProfiles(ConfigurableEnvironment environment, String[] args) {
 // 获取激活的profiles
 environment.getActiveProfiles(); // ensure they are initialized
 // But these ones should go first (last wins in a property key clash)
 Set<String> profiles = new LinkedHashSet<String>(this.additionalProfiles);
 profiles.addAll(Arrays.asList(environment.getActiveProfiles()));
 environment.setActiveProfiles(profiles.toArray(new String[profiles.size()]));
}

    AbstractEnvironment#getActiveProfiles()解析spring.profile.active属性，添加到activeProfiles这个集合中。后面的代码是为了实现“last win”策略。

    此时应用环境也准备完毕，它包括系统属性、系统环境和激活的profile。之后，通过发布环境准备完毕事件，这里，启动监听器会继续对environment进行配置，参考启动监听器！！。

  4. 创建应用上下文。SpringApplication#createApplicationContext()方法通过反射构造应用上下文。AnnotationConfigApplicationContext的默认构造器会构造一个AnnotationBeanDefinitionReader对象和ClassPathBeanDefinitionScanner对象，在构造AnnotationBeanDefinitionReader对象的过程中会向bean factory添加注解处理器和事件监听处理器BeanDefinition，为后续的配置解析作准备。这样，就能通过JavaConfig构建BeanDefinition并实现自动扫描。AnnotationConfigApplicationContext的父类GenericApplicationContext的默认构造器会构造一个DefaultListableBeanFactory对象，这样应用上下文持有一个bean factory的引用，大部分应用只需与应用上下文提供的接口打交道就是因为它对bean factory进行了一层封装。至此，一个Spring容器已经构造出来了，但是目前这个容器还什么都没有，需要根据用户的配置文件进行配置才能按照用户逻辑进行工作。

  5. 准备应用上下文。SpringApplication#prepareContext()的实现如下：

    private void prepareContext(ConfigurableApplicationContext context,
        ConfigurableEnvironment environment, SpringApplicationRunListeners
            listeners,
        ApplicationArguments applicationArguments, Banner printedBanner) {
 // 使context持有应用环境的引用，同时将应用环境的引用赋给reader和scanner
 context.setEnvironment(environment);
 // 实现应用上下文的后置处理
 postProcessApplicationContext(context);
 // 应用初始化器--添加监听器、logger、warnning等组件
 applyInitializers(context);
 listeners.contextPrepared(context);
 if (this.logStartupInfo) {
   logStartupInfo(context.getParent() == null);
   logStartupProfileInfo(context);
 }

 // 添加启动相关的bean
 context.getBeanFactory().registerSingleton("springApplicationArguments",
                                            applicationArguments);
 if (printedBanner != null) {
   context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
 }

 // Load the sources
 Set<Object> sources = getSources();
 Assert.notEmpty(sources, "Sources must not be empty");
 // 将source bean装载到应用上下文
 load(context, sources.toArray(new Object[sources.size()]));
 // 日志配置---参考具体实现
 listeners.contextLoaded(context);
}

    上下文后置处理SpringApplication#postProcessApplicationContext()代码如下：

    protected void postProcessApplicationContext(ConfigurableApplicationContext context) {
 if (this.beanNameGenerator != null) {
   context.getBeanFactory().registerSingleton(
     AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR,
                this.beanNameGenerator);
 }
 if (this.resourceLoader != null) {
   if (context instanceof GenericApplicationContext) {
     ((GenericApplicationContext) context)
                    .setResourceLoader(this.resourceLoader);
   }
   if (context instanceof DefaultResourceLoader) {
     ((DefaultResourceLoader) context)
                    .setClassLoader(this.resourceLoader.getClassLoader());
   }
 }
}

    这段后置处理代码主要是注册BeanNameGenerator类型的bean并设置应用上下文的资源加载器和类加载器。

    SpringApplication#load()方法会实例化一个BeanDefinitionLoader对象loader, 然后调用它的load()方法装载bean，这里完成的工作就是将用户编写的主类作为bean进行注册。

  6. 刷新应用上下文。刷新上下文实际上是调用AbstractApplicationContext#refresh()方法，这个方法很复杂，执行完毕后整个应用上下文也就完成了配置。下一节对这个方法进行详细讲解。

  7. 后置工作。后置工作等分析完了步骤6之后再写。

    ​

chr1sgong
关注
  • 9
    点赞
  • 踩
  • 49
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Spring计划任务用法实例详解
08-25
主类`Main`中，通过`AnnotationConfigApplicationContext`创建Spring上下文，初始化`TaskSchedulerConfig`，这样计划任务就会自动执行： ```java public class Main { public static void main(String[] args) { ...
spring注解开发AnnotationConfigApplicationContext的使用
weixin_34279061的博客
11-21 590
阅读目录 说明 示例 回到顶部 说明 使用AnnotationConfigApplicationContext可以实现基于Java的配置类加载Spring的应用上下文。避免使用application.xml进行配置。相比XML配置，更加便捷。 回到顶部 示例 AppConfig.java package com.myapp.co...
[Spring Boot] 5. Spring Boot中的ApplicationContext - 执行ApplicationContextInitializer初始化器
热门推荐
不忘初心，好好沉淀
08-27 1万+
前面已经对Spring Boot启动过程进行过源码分析，对于代表容器上下文的关键字段ApplicationContext只是一笔带过。实际上，它的生命周期才应该是重点关注的。Spring Boot使用的ApplicationContext分两种场景，常规应用和Web应用使用的上下文类型不一样： 常规应用：org.springframework.context.annotation.Annotatio
SpringBoot启动流程分析之创建应用上下文AnnotationConfigServletWebServerApplicationContext（六）
最新发布
lvyuanj的专栏
06-01 707
会创建Log对象；调用堆信息：初始化BeanFactoryPostProcessors 的List集合调用栈信息在构造方法中实例化一个ServletContextResourcePatternResolver，参数就是AnnotationConfigServletWebServerApplicationContext在构造方法中调用的方法是子类GenericWebApplicationContext重写后的方法。
SpringBoot2.7核心组件介绍
MCN的博客
07-22 1366
SpringBoot2.7核心组件介绍
Spring常用注解
爱吃饭的博客
06-09 763
spring常用注解
AnnotationConfigApplicationContext的实例化分析
qq_28849581的博客
10-05 187
spring源码分析
spring 源码系列（四）- AnnotationConfigApplicationContext
bintoYu的博客
02-16 1098
在spring中，使用的入口就是在main函数中创建Spring容器，基于XML形式的是ClassPathXmlApplicationContext；而基于注解形式的是AnnotationConfigApplicationContext。本文将对AnnotationConfigApplicationContext进行详细讲解。 使用篇 在这里简单介绍一下AnnotationConfigApplic...
深入讲解spring boot中servlet的启动过程与原理
08-27
然后，会实例化一个 SpringApplicationRunListeners 对象，用于监听应用程序的启动过程。 接下来，Spring Boot 会创建一个 ConfigurableEnvironment 对象，用于存储应用程序的环境变量。同时，会实例化一个 ...
深入解析Spring IoC源码：核心机制与实践应用
12-13
通过精细的分析，本文揭示了AnnotationConfigApplicationContext的实例化过程，详细解读了DefaultListableBeanFactory的作用及其在Bean生产和获取中的关键性作用。同时，本文对Spring Bean的生命周期进行了深入剖析...
Spring框架JavaConfig注解配置方式实例
03-20
3. `@Bean`：在方法上使用此注解，表示该方法的返回值将被Spring容器作为bean实例化并管理。这样，我们可以通过Java代码来创建bean实例，而不是XML配置文件。 4. `@Autowired`：自动装配bean，Spring会自动寻找合适...
springboot的java配置方式(实例讲解)
08-28
`Test`类的`main`方法是启动点，使用`AnnotationConfigApplicationContext`来初始化Spring容器，并传入`SpringConfig`类的Class对象作为参数。这使得Spring能够读取Java配置类并构建Bean。然后，从容器中获取`...
Spring 注解版 学习笔记（一）AnnotationConfigApplicationContext
FATCATS博客
05-18 879
AnnotationConfigApplicationContext1.传统XML配置类2.注解版Spring 1.传统XML配置类 Spring配置文件版–》传送门 2.注解版Spring 和XML不同的是，所有的注册方式全部使用注解的方式开发，下面小编演示基本操作。 创建一个测试实体类以及测试类。 测试实体类（TestAnnotaionBean） @AllArgsConstructor @NoArgsConstructor @Data public class TestAnnotaionBe
spring——教程——Spring的新注解——AnnotationConfigApplicationContext的使用
小白龙白龙马的博客
12-11 429
Spring源码分析之AnnotationConfigApplicationContext
zhanghuyi2022的博客
04-23 6634
AnnotationConfigApplicationContext spring版本：5.2.8.RELEASE 全类名：org.springframework.context.annotation.AnnotationConfigApplicationContext 从类依赖图，我们可以看出AnnotationConfigApplicationContext实现了Bean定义的注册、Bean的实例化、事件、生命周期、国际化等功能。 今天我们不去分析这些功能的实现方式，我们从new Annotation
SpringBoot源码阅读之AnnotationConfigApplicationContext类分析
tanglihai的博客
06-07 1125
1.通过SpringApplication.run方法进入查看源码，会发现代码中下面的这段代码创建了IOC容器。 context = createApplicationContext(); 跟进去找到下面这段代码，spring boot找到了AnnotationConfigApplicationContext类的Class信息，并且实例化然后返回。 contextClass = Class.forName(this.webEnvironment ? DEFAULT_WEB_CONTEXT_CLAS
spring启动流程 (1) 流程概览
xuguofeng2016的博客
06-26 554
阅读AnnotationConfigApplicationContext源码，分析Spring启动流程。
Spring注解开发AnnotationConfigApplicationContext
qq_44737446的博客
03-02 1060
Spring注解开发 AnnotationConfigApplicationContext
Spring5深度源码分析(三)之AnnotationConfigApplicationContext启动原理分析
weixin_30632899的博客
07-04 257
代码地址：https://github.com/showkawa/spring-annotation/tree/master/src/main/java/com/brian AnnotationConfigApplicationContext启动原理分析主要分析下面三点 1.@Qualifier与@Primary注解的使用2.BeanFactory与ApplicationContext区别3...
maven怎么实例化bean
04-16
对于您的问题，我可以提供以下回答： 在 Maven 中，您可以通过在 pom.xml 文件中配置依赖项和插件，然后实例化一个 bean。具体的步骤如下： 1. 首先在 pom.xml 文件中添加 Spring 被动性依赖项： ``` <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>{version}</version> </dependency> ``` 2. 接下来，在您的 Java 代码中，您可以通过将该类作为参数传递给 AnnotationConfigApplicationContext 实例来实例化 bean： ``` AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfiguration.class); MyBean myBean = context.getBean(MyBean.class); ``` 其中，MyConfiguration 是配置类，提供了有关 bean 的信息，而 MyBean 是将要实例化的 bean。然后您可以直接使用 myBean 对象。 希望这个回答可以帮助您解决问题。如果您有任何其他问题，请随时问我。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值