当前位置：首页 > news >正文

SpringBoot 源码分析初始化应用上下文(1)-createApplicationContext

news 2025/8/13 7:35:11

前言：springBoot的版本是 2.2.4.RELEASE

一、入口

/*** Run the Spring application, creating and refreshing a new* {@link ApplicationContext}.* @param args the application arguments (usually passed from a Java main method)* @return a running {@link ApplicationContext}*/public ConfigurableApplicationContext run(String... args) {StopWatch stopWatch = new StopWatch();stopWatch.start();ConfigurableApplicationContext context = null;Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();configureHeadlessProperty();SpringApplicationRunListeners listeners = getRunListeners(args);listeners.starting();try {ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);configureIgnoreBeanInfo(environment);Banner printedBanner = printBanner(environment);//主要看这个方法，初始化应用上下文context = createApplicationContext();exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,new Class[] { ConfigurableApplicationContext.class }, context);prepareContext(context, environment, listeners, applicationArguments, printedBanner);refreshContext(context);afterRefresh(context, applicationArguments);stopWatch.stop();if (this.logStartupInfo) {new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);}listeners.started(context);callRunners(context, applicationArguments);}catch (Throwable ex) {handleRunFailure(context, ex, exceptionReporters, listeners);throw new IllegalStateException(ex);}try {listeners.running(context);}catch (Throwable ex) {handleRunFailure(context, ex, exceptionReporters, null);throw new IllegalStateException(ex);}return context;}

问题切入：为什么叫做上下文对象呢？上下文对象，就是当前应用环境下的一个集合

初始化(创建)上下文对象主要看上面注释那行，即：

context = createApplicationContext();

接着看下 createApplicationContext() 这个方法的实现

截图：

代码：

/*** Strategy method used to create the {@link ApplicationContext}. By default this* method will respect any explicitly set application context or application context* class before falling back to a suitable default.* @return the application context (not yet refreshed)* @see #setApplicationContextClass(Class)*/protected ConfigurableApplicationContext createApplicationContext() {Class<?> contextClass = this.applicationContextClass;if (contextClass == null) {try {switch (this.webApplicationType) {case SERVLET:// 创建上下文对象 AnnotationConfigServletWebServerApplicationContext 进行实例化的过程中，此时 ioc 容器也会被创建contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);break;case REACTIVE:contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);break;default:contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);}}catch (ClassNotFoundException ex) {throw new IllegalStateException("Unable create a default ApplicationContext, please specify an ApplicationContextClass", ex);}}//创建 AnnotationConfigServletWebServerApplicationContext 对象的无参构造return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);}

接着看下AnnotationConfigServletWebServerApplicationContext 这个对象的继承关系

从继承关系上面看继承关系比较深，同时可以看到 GenericApplicationContext（通用上下文对象），上面实例化AnnotationConfigServletWebServerApplicationContext的时候就是从该对象的无参构造方法开始的，我们就从AnnotationConfigServletWebServerApplicationContext对象的无参构造方法从代码上面看一下代码逻辑，注意：子类实例化的时候先实例化父类的构造方法

截图如下：

1、AnnotationConfigServletWebServerApplicationContext 的无参构造【注解配置Servlet Web服务器应用程序上下文】

2、ServletWebServerApplicationContext 的无参构造【Servlet Web服务器应用程序上下文】

==> 这一步啥事没做

3、GenericWebApplicationContext 的无参构造【通用Web应用程序上下文】

==> 这个方法实例化的时候继承了父类

4、GenericApplicationContext 的无参构造【通用应用程序上下文】

==> 这里直接new一个 DefaultListableBeanFactory 对象，这个对象就是IOC容器最开始的样子，

这里其实是已经创建了 bean 工厂， DefaultListableBeanFactory 这个类里面有一个beanDefinitionMap，就是用来存放bean对象的。

二、AnnotationConfigServletWebServerApplicationContext 无参构造的两个重要方法

截图：

代码：

/*** Create a new {@link AnnotationConfigServletWebServerApplicationContext} that needs* to be populated through {@link #register} calls and then manually* {@linkplain #refresh refreshed}.*/public AnnotationConfigServletWebServerApplicationContext() {//创建一个读取注解的Bean定义读取器//什么是 Bean 定义？BeanDefinition 完成了 spring 内部 Bean 的 BeanDefinition 的注册(主要是后置处理器)this.reader = new AnnotatedBeanDefinitionReader(this);//创建 BeanDefinition 扫描器，可以用来扫描包或者类，继而转换为 bd，//spring 默认的扫描器其实不是这个 scanner 对象，而是在后面自己又重新 new 了一个 ClassPathBeanDefinitionScanner //spring 在执行工程后置器 ConfigurationClassPostProcessor 时，去扫描包时会 new//这里 scanner 仅仅是为了 程序员可以手动调用 AnnotationConfigApplicationContext 对象的 scanner方法this.scanner = new ClassPathBeanDefinitionScanner(this);}

2.1 AnnotatedBeanDefinitionReader 构造方法

在看这个方法之前，我们先打个断点，然后看下this里面的 beanDefinitionMap 里面是否有有值，即IOC容器中是否有bean对象，可以看到，到这一步还是没有值的，即还没有bean实例存在IOC容器中。接着我们继续跑下一步

到这一步的时候可以看到 beanDefinitionMap 已经有bean存进去了，接下来我们重点看下

AnnotatedBeanDefinitionReader 构造方法都做了哪些事情。

AnnotatedBeanDefinitionReader 构造方法

截图：

接着看其有参构造方法

截图：

代码：

/*** Create a new {@code AnnotatedBeanDefinitionReader} for the given registry,* using the given {@link Environment}.* @param registry the {@code BeanFactory} to load bean definitions into,* in the form of a {@code BeanDefinitionRegistry}* @param environment the {@code Environment} to use when evaluating bean definition* profiles.* @since 3.1*/public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {Assert.notNull(registry, "BeanDefinitionRegistry must not be null");Assert.notNull(environment, "Environment must not be null");this.registry = registry;this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);//根据名字顾名思义就是注册注解配置的处理器//也就是这个方法里面会注册一些用于处理注解的处理器AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);}

接着看 registerAnnotationConfigProcessors 这个方法

继续看 registerAnnotationConfigProcessors 方法

截图：

代码：

	/*** Register all relevant annotation post processors in the given registry.* @param registry the registry to operate on* @param source the configuration source element (already extracted)* that this registration was triggered from. May be {@code null}.* @return a Set of BeanDefinitionHolders, containing all bean definitions* that have actually been registered by this call*/public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(BeanDefinitionRegistry registry, @Nullable Object source) {//unwrap 打开...的包装，这里即获取默认bean工厂对象DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);if (beanFactory != null) {if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {//主要解析 @Order 和 @Priority	beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);}if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {//提供处理延迟加载的功能beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());}}Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);//spring 默认 BeanDefinition 的注册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));}//注册 AutowiredAnnotationBeanPostProcessorif (!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));}//注册 CommonAnnotationBeanPostProcessor// 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;}

==> 这里其实就是6个默认的spring内部bean的注册

(1) ConfigurationClassPostProcessor 配置类后置处理器

工厂后置处理器，这个后置处理器非常重要，基本上类上面的注解都在这里面判断并解析，spring的包扫描也在里面完成

(2) AutowiredAnnotationBeanPostProcessor 自动导入注解Bean后处置理器

主要是@Autowired，是一个bean的后置处理器，在bean的属性注入的时候会用到

(3) CommonAnnotationBeanPostProcessor 通用注释Bean后置处理器

处理一些公共注解的，它是一个bean的后置处理器，可以处理@PostConstruct和@PreDestroy还有@Resource等

(4) PersistenceAnnotationBeanPostProcessor 持久性注释Bean后置处理器

对jpa的处理，所以需要引入spring-orm的包，没有引入的话则spring不会注册这个类

(5) internalEventListenerProcessor 内部事件监听器处理器

对 @EventListener 注解的处理，spring实现事件监听的方式有很多种，其中一种就是在方法上添加 @EventListener 注解

(6) internalEventListenerFactory 内部事件监听器工厂

跟事件监听有关

接着我们看其中一个方法，挑第一个来跟一下逻辑代码

截图：

接着看 registerPostProcessor 这个方法

截图：

代码：

private static BeanDefinitionHolder registerPostProcessor(BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);//registry 就是 AnnotationApplicationContext//这里是调用父类 GenericApplicationContext 中的 registerBeanDefinition 方法//调用 beanFactory 将 spring 默认的 BeanDefinition 注册进去registry.registerBeanDefinition(beanName, definition);//一开始就初始化了 DefaultListableBeanFactoryreturn new BeanDefinitionHolder(definition, beanName);}

接着看 registerBeanDefinition 方法

截图：

代码：

/*** Register a new bean definition with this registry.//在此注册表中注册一个新的bean定义，* Must support RootBeanDefinition and ChildBeanDefinition.//必须支持 RootBeanDefinition 和 ChildBeanDefinition* @param beanName the name of the bean instance to register //beanName 要注册的bean实例的名称* @param beanDefinition definition of the bean instance to register //beanDefinition  要注册的 bean 实例的定义* @throws BeanDefinitionStoreException if the BeanDefinition is invalid* @throws BeanDefinitionOverrideException if there is already a BeanDefinition* for the specified bean name and we are not allowed to override it //指定bean的名称，我们不允许覆盖它* @see GenericBeanDefinition* @see RootBeanDefinition* @see ChildBeanDefinition*/void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)throws BeanDefinitionStoreException;

这是一个接口，继续看其具体实现类

这里看默认的工厂实现类 DefaultListableBeanFactory

截图：

代码：

//---------------------------------------------------------------------// Implementation of BeanDefinitionRegistry interface//---------------------------------------------------------------------@Overridepublic void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)throws BeanDefinitionStoreException {Assert.hasText(beanName, "Bean name must not be empty");Assert.notNull(beanDefinition, "BeanDefinition must not be null");if (beanDefinition instanceof AbstractBeanDefinition) {try {((AbstractBeanDefinition) beanDefinition).validate();}catch (BeanDefinitionValidationException ex) {throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,"Validation of bean definition failed", ex);}}//在注册 bd 的时候判断该名字有没有被注册BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);//该名字已经被注册//spring 默认支持覆盖 bd，但是 spring 会输入一些日志//1、两个 bd 相同的情况下//2、两个 bd 不同的情况 role 不同//3、两个 bd 不相同但是 role 相同if (existingDefinition != null) {if (!isAllowBeanDefinitionOverriding()) {throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);}//优先级else if (existingDefinition.getRole() < beanDefinition.getRole()) {// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTUREif (logger.isInfoEnabled()) {logger.info("Overriding user-defined bean definition for bean '" + beanName +"' with a framework-generated bean definition: replacing [" +existingDefinition + "] with [" + beanDefinition + "]");}}else if (!beanDefinition.equals(existingDefinition)) {if (logger.isDebugEnabled()) {logger.debug("Overriding bean definition for bean '" + beanName +"' with a different definition: replacing [" + existingDefinition +"] with [" + beanDefinition + "]");}}else {if (logger.isTraceEnabled()) {logger.trace("Overriding bean definition for bean '" + beanName +"' with an equivalent definition: replacing [" + existingDefinition +"] with [" + beanDefinition + "]");}}this.beanDefinitionMap.put(beanName, beanDefinition);}else {//判断我们的 spring 容器是否开启实例化 bean了//如果为null，set 为空，没有开始就创建 bean 不会进入 ifif (hasBeanCreationStarted()) {// Cannot modify startup-time collection elements anymore (for stable iteration)synchronized (this.beanDefinitionMap) {//一个 map 一个 list ，list里面方法的 map 的 key，也就是 beanNamethis.beanDefinitionMap.put(beanName, beanDefinition);List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);updatedDefinitions.addAll(this.beanDefinitionNames);updatedDefinitions.add(beanName);this.beanDefinitionNames = updatedDefinitions;//如果注册了 beanDefinition 的名字和手工注册的 bd 集合当中某个相同则删除手动注册的 beanNameremoveManualSingletonName(beanName);}}else {// Still in startup registration phasethis.beanDefinitionMap.put(beanName, beanDefinition);this.beanDefinitionNames.add(beanName);removeManualSingletonName(beanName);}this.frozenBeanDefinitionNames = null;}//判断注册的 bd 以及 beanName 是否存在if (existingDefinition != null || containsSingleton(beanName)) {//清除 allBeanNameByType//把单例池当中的 bean 也 removeresetBeanDefinition(beanName);}}

this.beanDefinitionMap.put(beanName, beanDefinition);

从这里可以看到bean已经存在到 IOC容器中，到此 AnnotatedBeanDefinitionReader 分析结束

接着看 ClassPathBeanDefinitionScanner 的构造方法

2.2 ClassPathBeanDefinitionScanner 构造方法

这个方法主要是创建BeanDefinition扫描器，可以用来扫描包或者类，继而转换为bd，spring默认的扫描器其实不是这个scanner对象，而是在后面自己又重新new了一个ClassPathBeanDefinitionScanner， spring在执行工程后置处理器ConfigurationClassPostProcessor时，去扫描包时会new一个ClassPathBeanDefinitionScanner
这里的scanner仅仅是为了程序员可以手动调用AnnotationConfigApplicationContext对象的scan方法

所以这里不展开看了。

3、最后回到我们最开始的地方，可以看到 spring 初始化上下文已经有了，打个断点可以看到IOC容器已经实例化了一些对象，就是上面的6中默认bean，

截图：