spring-源码-AnnotationConfigApplicationContext-创建分析-2

最新推荐文章于 2023-04-03 21:11:59 发布
最新推荐文章于 2023-04-03 21:11:59 发布
阅读量252 收藏
点赞数
分类专栏： spring spring启动源码 文章标签： spring spring源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vistaed/article/details/107764267
版权

文章目录

前言

  • 分析为两种springboot、单独调用
    • springboot调用AnnotationConfigServletWebServerApplicationContext
    • 单独调用AnnotationConfigApplicationContext

AnnotatedBeanDefinitionReader

如果单从类名分析，说的就是 注解 BeanDefinition 读取

注释：实用的适配器，用于编程的方式注册 Bean，这是的替代ClassPathBeanDefinitionScanner，仅对显式注册的类的注解解析，简单来说这个类是显示的注册一个类，并且会读取这个类上的注解进行解析~

源码分析

AnnotationConfigApplicationContext调用进行分析

public AnnotationConfigApplicationContext() {
    super();
    /**
     创建一个用于以编程方式注册Bean类。
     并且完成了spring内部一些（后置处理器）的注册
     */
    this.reader = new AnnotatedBeanDefinitionReader(this);
}

构造函数

传递了一个AnnotationConfigApplicationContext（BeanDefinitionRegistry）

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
    //创建了一个 StandardEnvironment()
    this(registry, getOrCreateEnvironment(registry));
}

调用 getOrCreateEnvironment

这个方法就是去创建 StandardEnvironment去了，区别不同的是做了一个判断，这里为什么需要这么一个判断？既然都是一样的直接返回不就好了嘛？带着疑问我们继续看下个方法

private static Environment getOrCreateEnvironment(BeanDefinitionRegistry registry) {
    // 判断当前的 是不是 BeanDefinitionRegistry
    // 这里为什么要有这么一个判断呢？
    // 那其实可以看看 BeanDefinitionRegistry 实际跟 EnvironmentCapable 并没有关系，
    // 这里需要注意的是 registry 的类型是什么？是 AnnotationConfigApplicationContext
    // 如果是 AnnotationConfigApplicationContext 类型的话会初始化一个 StandardEnvironment 对内部进行一个赋值，然后在返回
    if (registry instanceof EnvironmentCapable) {
        //强转调用 getEnvironment()--> 去创建 StandardEnvironment()
        return ((EnvironmentCapable) registry).getEnvironment();
    }
    // 不是 EnvironmentCapable 的话则直接创建，
    return new StandardEnvironment();
}

个人见解这里是必须要返回一个 StandardEnvironment() 由于StandardEnvironment() 是下面流程不可缺少的一环，只是取决于谁去维护这个 StandardEnvironment

这也就是如果是ApplicationContext的话就由ApplicationContext而如果不是的话那可能是你在单独调用那就不需要维护，只需要不影响流程即可…

调用 getEnvironment

这里是采用单例模式创建了一个 Environment，也就说当 registry参数是 EnvironmentCapable的实现类的时候会初始化一个 StandardEnvironment对象并且进行赋值做一个赋值动作

// 这里其实可以看到是一个单例模式~~~
public ConfigurableEnvironment getEnvironment() {
    // 如果为 null
    if (this.environment == null) {
        // 这里就会创建一个
        this.environment = createEnvironment();
    }
    //然后返回
    return this.environment;
}

说明

  1. 通过上面的方法分析，我们得出了结论：如果 registry参数是 EnvironmentCapable的实现类的时候会初始化一个 StandardEnvironment对象并且进行赋值做一个赋值动作，由于我们知道BeanDefinitionRegistry的实现类有很多，但是其实现类中可能并没有去实现EnvironmentCapable所以会进行一个判断强转处理，这里可以去看扩展知识

调用构造函数

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
    this.registry = registry;
    //ConditionEvaluator
    this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
    //把一些自动注解处理器加入到AnnotationConfigApplicationContext下的BeanFactory的BeanDefinitions中
    AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}

创建 ConditionEvaluator

  1. 创建了 StandardEnvironment
  2. 创建了 ConditionEvaluator(registry, environment,null) 赋值给 conditionEvaluator
    1. registry 是 AnnotationConfigApplicationContext
    2. environment 是 StandardEnvironment
      1. 创建 ConditionContextImpl 赋值给 context
        1. registry 是 AnnotationConfigApplicationContext
        2. beanFactory 是 DefaultListableBeanFactory
        3. environment 是 StandardEnvironment
        4. resourceLoader 是 AnnotationConfigApplicationContext
        5. classLoader 是 DefaultListableBeanFactory 中的 classLoader

调用registerAnnotationConfigProcessors

public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
    registerAnnotationConfigProcessors(registry, null);
}
 
public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(BeanDefinitionRegistry registry, @Nullable Object source) {
 
    //这里获取的就是 DefaultListableBeanFactory()
    DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
    if (beanFactory != null) {
        /**
         * AnnotationAwareOrderComparator主要能解析@Order和@Priority
         */
        if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
            //设置一个值
            beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
        }
        /**
         * ContextAnnotationAutowireCandidateResolver 提供处理延迟加载的功能
         */
        if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
            // 创建一个
            beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
        }
    }
 
    Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
 
    //去注册 ConfigurationClassPostProcessor
    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));
    }
    //这里是去注册 @Autowired  的 AutowiredAnnotationBeanPostProcessor 后置处理器
    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));
    }
 
    //注册 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));
    }
 
    // 注册PersistenceAnnotationProcessor
    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));
    }
 
    // 注册 EventListenerMethodProcessor
    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));
    }
    // 注册 DefaultEventListenerFactory
    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;
}
注册 ConfigurationClassPostProcessor
public static final String CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME =
    "org.springframework.context.annotation.internalConfigurationAnnotationProcessor";
 
//去注册 ConfigurationClassPostProcessor
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));
}
注册AutowiredAnnotationBeanPostProcessor
public static final String AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME =
    "org.springframework.context.annotation.internalAutowiredAnnotationProcessor";
 
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));
}
注册RequiredAnnotationBeanPostProcessor
public static final String REQUIRED_ANNOTATION_PROCESSOR_BEAN_NAME =
    "org.springframework.context.annotation.internalRequiredAnnotationProcessor";
 
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));
}
注册CommonAnnotationBeanPostProcessor
  1. 这里做了一个jsr250Present的判断
public static final String COMMON_ANNOTATION_PROCESSOR_BEAN_NAME =
    "org.springframework.context.annotation.internalCommonAnnotationProcessor";
 
private static final boolean jsr250Present = ClassUtils.isPresent("javax.annotation.Resource", AnnotationConfigUtils.class.getClassLoader());
 
//按理说 @Resource 不可能不存在的.. 因为本身就在JAVA当中
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));
}
注册PersistenceAnnotationProcessor
  1. 这样也是通过做了一个JAP的注解判断，如果有则加载，不然则不进行加载
public static final String PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME =
    "org.springframework.context.annotation.internalPersistenceAnnotationProcessor";
 
private static final String PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME =
    "org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor";
 
 
private static final boolean jpaPresent = ClassUtils.isPresent("javax.persistence.EntityManagerFactory", classLoader) &&
    ClassUtils.isPresent(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, classLoader);
 
// 如果JPA的包存在则进行加载.
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));
}
注册 EventListenerMethodProcessor
  1. 这里注册了监听器
public static final String EVENT_LISTENER_PROCESSOR_BEAN_NAME =
    "org.springframework.context.event.internalEventListenerProcessor";
// 注册 EventListenerMethodProcessor
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));
}
注册 DefaultEventListenerFactory
public static final String EVENT_LISTENER_FACTORY_BEAN_NAME ="org.springframework.context.event.internalEventListenerFactory";
// 注册 DefaultEventListenerFactory
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));
}

调用registerPostProcessor()

 
private static BeanDefinitionHolder registerPostProcessor(
    BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {
     // 设置为 spring 内部Bean
    definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    /**
     *  注册到 容器中
     */
    registry.registerBeanDefinition(beanName, definition);
    return new BeanDefinitionHolder(definition, beanName);
}

调用registerBeanDefinition()方法

  1. BeanDefinition（RootBeanDefinition）
  2. name
 
/**
* Map of bean definition objects, keyed by bean name.
* <br/ >Bean 映射BeanDefinition
*/
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
 
//要注册的Bean，按照顺序逐一注册
private volatile List<String> beanDefinitionNames = new ArrayList<>(256);
 
 
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
    throws BeanDefinitionStoreException {
 
 
     //先去Map去一次，如果存在，判断允许不允许覆盖，
    BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
    if (existingDefinition != null) {
        //是否允许覆盖
        if (!isAllowBeanDefinitionOverriding()) {
            throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
        }
        // cdoe....
        //进行覆盖
        this.beanDefinitionMap.put(beanName, beanDefinition);
    } else {
        //判断容器是否已经创建，如果已经创建创建则走这里
        if (hasBeanCreationStarted()) {
            // 对 beanDefinitionMap 加锁，保证线程安全
            synchronized (this.beanDefinitionMap) {
                // 将 name 和 beanDefinition 放到map中
                this.beanDefinitionMap.put(beanName, beanDefinition);
                List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
                updatedDefinitions.addAll(this.beanDefinitionNames);
                updatedDefinitions.add(beanName);
                this.beanDefinitionNames = updatedDefinitions;
                removeManualSingletonName(beanName);
            }
        } else {
            // 主要就是这里，将 name和 beanDefinition 存到一个地方去
            this.beanDefinitionMap.put(beanName, beanDefinition);
            // 将 name 放到 集合中
            this.beanDefinitionNames.add(beanName);
            //暂时不用关系..还没有用到.
            removeManualSingletonName(beanName);
        }
        this.frozenBeanDefinitionNames = null;
    }
 
    if (existingDefinition != null || containsSingleton(beanName)) {
        resetBeanDefinition(beanName);
    } else if (isConfigurationFrozen()) {
        clearByTypeCache();
    }
}

后言

  1. 创建 AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) 赋值给 reader
    1. registry 传递是 this，this 是 AnnotationConfigApplicationContext
  2. 调用AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment)
    1. registry 传递是 AnnotationConfigApplicationContext
    2. environment 是从 getOrCreateEnvironment() 获取或者创建StandardEnvironment
    3. 创建ConditionEvaluator赋值给conditionEvaluator —这里的代码上面分析过了
  3. 调用 registerAnnotationConfigProcessors(this.registry) 传递了 AnnotationConfigApplicationContext
    1. 初始化的时候会帮我们添加几个默认的后置处理器，注册到spring容器当中的后置处理器都会被包装一下包装成RootBeanDefinition
    2. 然后会存在 一个Map里面，name 和 BeanDefinition 做一个映射
    3. 还会将 name 存到一个List里面

流程图

在这里插入图片描述

扩展知识

单独使用 AnnotatedBeanDefinitionReader

让我们单独玩玩AnnotatedBeanDefinitionReader，可以看到当创建 AnnotatedBeanDefinitionReader 是需要传递一个参数，源码也是这样

public class AnnotatedBeanDefinitionReaderContext {
 
    public static void main(String[] args) {
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        AnnotatedBeanDefinitionReader definitionReader = new AnnotatedBeanDefinitionReader(beanFactory);
        definitionReader.registerBean(User.class);
        User bean = beanFactory.getBean(User.class);
        System.out.println(bean);
    }
}
class User{}

通过上面这个Demo 我们可以明确的知道 Bean的注册是委托给了 DefaultListableBeanFactory，所以 可以通过 DefaultListableBeanFactory 获取到User类 而AnnotatedBeanDefinitionReader 本身仅仅只有注册功能，并没有获取的功能

关于getEnvironment

需要说明的时候 当我们去创建 AnnotatedBeanDefinitionReader 的时候这个类时候当你传递的参数是 BeanDefinitionRegistry这个类型的时候就都可以去创建 AnnotatedBeanDefinitionReader

public class AnnotatedBeanDefinitionReaderContext {
 
    public static void main(String[] args) {
        // 比如 DefaultListableBeanFactory 就是实现了 BeanDefinitionRegistry
        // 但是 并没有实现 EnvironmentCapable 接口，也就会去直接创建，
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        AnnotatedBeanDefinitionReader definitionReader = new AnnotatedBeanDefinitionReader(beanFactory);
 
        //而我们的 AnnotationConfigApplicationContext 就是同时实现了 BeanDefinitionRegistry 和 EnvironmentCapable
        AnnotationConfigApplicationContext value = new AnnotationConfigApplicationContext();
        AnnotatedBeanDefinitionReader definitionReader = new AnnotatedBeanDefinitionReader(value);
    }
}

后续文章

森林猿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring-framework5.1.7:spring-framework5.1.7源码解析
03-24
学习Spring源码建议构建Spring-framemwork源码环境（这是一个比较麻烦的过程，可能遇到各种问题，需要有耐心..），新建一个模块打断点一步步调试。 举个例子，这是Spring的.class反编译的结果，不但没有注释，暗示性...
spring-boot源码解析之AnnotationConfigServletWebServerApplicationContext
weixin_45594127的博客
10-04 4917
org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext
SpringBoot（十二）启动流程分析之创建应用上下文AnnotationConfigServletWebServerApplicationContext
热门推荐
yhahaha_的博客
04-08 3万+
SpringBoot版本：2.1.1 ==》启动流程分析汇总 接上篇博客Spring Boot 2.1.1（十一）启动流程分析之设置系统属性spring.beaninfo.ignore、自定义banner图 目录 流程分析 1、AbstractApplicationContext 2、GenericApplicationContext 2.1、DefaultListable...
SpringBoot源码解析（1.3.1）-自动装配原理（创建应用上下文AnnotationConfigServletWebServerApplicationContext）
sql2008help的博客
03-07 1134
SpringBoot源码解析（1.3.1）-自动装配原理（创建应用上下文AnnotationConfigServletWebApplicationContext） 承接上文：https://blog.csdn.net/sql2008help/article/details/123311657 关键代码 ： ConfigurableApplicationContext context = null; context = this.createApplicationContext(); Application
Springboot启动流程(五):Context
wishl_gmy的博客
01-21 644
Springboot启动流程(五) 前面我们看了Spring的environment和banner.下面就到了同样重要的Context, Context是做什么的?我的理解就是存放上下文需要用到的对象的,Spring是单利模式所以我们获取的对象要放在一块儿地方供以后调用,这个地方就是Context 接下来我们看下创建context的具体流程: Application 类 public Config...
Spring原理学习（一）：BeanFactory和ApplicationContext的原理和实现
m0_49499183的博客
04-03 1338
BeanFactory是一个比较基础的类，他本身并没有特别多的功能，这些事情它不会不会主动调用BeanFactory后处理器不会主动添加Bean后处理器不会主动初始化单例不会解析#{}、${}等。
Spring 源码分析（Bean的初始化）
12-21
本篇文章是个人第一次看spring源码并总结，同时也参考了下面这篇博客。基本也是按照他的思路来理解的。这也算是第一版个人简易理解。也算是窥见spring的冰山一角，之后也会继续阅读下去。望各位多多支持。 本片博文...
深入解析Spring IoC：源码与实践指南
最新发布
12-13
本文深入探讨了Spring IoC容器的加载过程及其源码实现，揭示了Spring中最为根本的概念之一。这包括从AnnotationConfigApplicationContext的实例化开始，到DefaultListableBeanFactory工厂的建立，再到...
spring5源码 gradle编译好的，可以直接在idea运行，包含demo-test测试模块
09-20
发现csdn上其他的spring5 源码都不能直接运行，花了大量时间自己用gradle 编辑一下spring5.1的源码，可以直接在idea运行，包含demo-test测试模块。导入idea后 ，点项目右键build Module spring 。然后打开demo-test ...
深入解析Spring IoC源码：核心机制与实践应用
12-13
本文深入探讨了Spring框架中IoC容器的源码机制，涵盖了容器的初始化、Bean工厂的实例化、Bean定义的读取及Spring Bean的生命周期管理。通过精细的分析，本文揭示了AnnotationConfigApplicationContext的实例化过程，...
【spring源码解析】spring容器初始化过程
worn_xiao的博客
10-11 1731
SpringIOC容器加载原理 一 Spring容器框架 如上图所示，我们可以看到Spring初始化的架构原理，如上图所示通过不同的bean的定义方式，比如xml配置的方式，注解配置的方式，可能后面还有相信的扩展bean的定义方式，这个它是怎么工作呢，总的框架来说，无非是制作一层读取配置的抽象类BeanDefinationReader，以不同的方式读取配置,然后生成不同的beanDefination放到了beanDefinitionMap的bean容器池中。用到的时候再从beanDefinition
springboot源码-AnnotationConfigServletWebServerApplicationContext
qq_39482039的博客
10-05 1228
/* * Copyright 2012-2019 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * https.
【spring】源码-spring 容器启动过程之 AnnotationConfigWebApplicationContext （四)
东方鲤鱼 博客
03-19 1900
1
Spring源码分析-AnnotationConfigApplicationContext
PRINTFdfjc的博客
11-27 386
Spring源码
spring-源码-AnnotationConfigApplicationContext-创建分析-1
菜鸡在路上找食吃
07-13 510
文章目录前言springbootspring一、入口二、调用构造函数DefaultListableBeanFactoryAbstractAutowireCapableBeanFactory调用ignoreDependencyInterface()ignoredDependencyInterfaces-作用演示定义入口定义PortProcessor定义 Config定义A类定义B类定义C类复现学到了什么 前言 需要说明的是这里仅仅是分析 ApplicationContext 初始化的时候都做了一些什么 当然
Spring基于注解配置的AnnotationConfigApplicationContext源码分析
学无止境！
10-10 652
启动AnnotationConfigApplicationContext的main方法如下代码所示。AnnotationConfigApplicationContext的构造器参数如下图所示。这里我们用的是第二个构造器。点进去，如下代码所示。为了整个源码分析的过程有层次感，我将上面三行代码分三个标题去叙述。
spring源码分析 - AnnotationConfigApplicationContext启动之refresh
lin000_0的博客
11-18 648
spring源码分析 - AnnotationConfigApplicationContext启动之refresh
Spring源码-02
weixin_42576312的博客
09-22 97
Spring源码-02
spring源码解析之AnnotationConfigWebApplicationContext#loadBeanDefinitions()方法加载BeanDefinition过程
蛐蛐的博客
10-13 1861
1.简介 AnnotationConfigWebApplicationContext是常用的上下文容器类，在spring boot没有流行的时候，以前用tomcat在web.xml配置 spring容器时，如果使用Java注解的配置类，一般都会使用这个上下文类 顾名思义，AnnotationConfig代表注解配置，Web代表具有web功能，可以访问ServletContext。这是这个上下文的基本功能。 之前在spring源码解析之AbstractApplicationContext#..
play framework 整合 mybatis-plus 、spring
05-21
2. 创建一个 Spring Context 配置文件，例如 applicationContext.xml，并在文件中配置 MyBatis-Plus 和数据源。 ```xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值