spring5.2.x源码阅读笔记-AnnotationConfigApplicationContext构建

已于 2022-03-14 22:33:21 修改
阅读量1.7k 收藏 10
点赞数 22
文章标签： java 开发语言
于 2022-03-14 22:32:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43836063/article/details/123358692
版权

目录

一、测试用例

二、源码解析

（一）构造上下文

代码块1：根据配置类构造AnnotationConfigApplicationContext

代码块2：this()

代码块3：初始化父类GenericApplicationContext

代码块4：创建DefaultListableBeanFactory

代码块5：设置reader

代码块6：getOrCreateEnvironment

代码块7：构造AnnotatedBeanDefinitionReader

代码块8：构造ConditionEvaluator

代码块9：AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);注册registry中的注解后置处理器

代码块10：unwrapDefaultListableBeanFactory(registry)

代码块11：registerPostProcessor

代码块12： registry.registerBeanDefinition(beanName, definition);

代码块13：ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry)

一、测试用例

public class User {
	private String id;
	private String userName;

	public User() {
	}

	public User(String id, String userName) {
		this.id = id;
		this.userName = userName;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}

	@Override
	public String toString() {
		return "User{" +
				"id='" + id + '\'' +
				", userName='" + userName + '\'' +
				'}';
	}
}
@Configuration
@ComponentScan
public class JavaConfig {

	@Bean
	public User user() {
		return new User("001","test");
	}
}
public class Test {

	public static void main(String[] args) {
		System.out.println("hah");
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(JavaConfig.class);
		User user = (User) context.getBean("user");
		System.out.println(user.toString());
	}
}

此测试用例参考spring5.3.x源码阅读环境搭建_smart_an的专栏-优快云博客_spring源码搭建

二、源码解析

（一）构造上下文

代码块1：根据配置类构造AnnotationConfigApplicationContext

// 1. 使用从组件类中获取BeanDefinitions,并且自动刷新到上下文中
	// conponentClassess 一般是被@Configuration注解标准的配置类
	public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
		// 1. 构造器会先调用父类构造器，为beanFactory赋值
		// 2. 调用this()方法，即默认构造器，设置默认的reader和默认的scanner
		this();
		register(componentClasses);
		refresh();
	}

代码块2：this()

public AnnotationConfigApplicationContext() {
		// 首先调用父类的无参构造器，初始化beanFactory
		// 其次创建reader和scanner
		// 获取/创建StandardEnvironment，创建评估其，注册1. 解析工厂，为工厂设置注解依赖比较器，和注解自动装配候选人解析器；
		// 2. 注册@Configuration、autowired、jsr-250、jpa、event等后置处理器
		this.reader = new AnnotatedBeanDefinitionReader(this);
		// register:AnnotationConfigApplicationContext
		// filter: AnnotationTypeFilter(Component)
		// environment: StandardEnvironment
		// resourceLoader: ApplicationConfigApplicationContext
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}

// 从此类定义可以看出，继承自GenericApplicationContext
/**
 * 独立的应用上下文，接收组件类，尤其是@Configuration、@Component、和符合JSR-330规范的javax.inject注解的组件类
 * 继承GenericAllpicationContext,并实现AnnotationConfigRegistry接口
 *
 * GenericApplicationContext
 */
public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {...

代码块3：初始化父类GenericApplicationContext

GenericApplicationContext的主要作用是，初始化beanFactory,初始化resourceLoader，设置父ApplicationContext，设置BeanDefinition是否可以被重写，设置bean是否允许循环引用；实现ResourceLoader/ResourcePatternResolver接口，重写里边的getResource、getClassLoader、setClassLoader方法；实现AbstractApplicationContext的模板方法，包括refreshBeanFactroy，getBeanFactroy等；实现BeanDefinitionRegistry的方法，如registerBeanDefinition，removeBeanDefinition，getBeanDefinition，isBeanNameInUse，registerAlias，removeAlias，isAlias；实现注册单个Bean的方法，如registerBean。

// 默认构造器创建DefaultListableBeanFactory bean工厂
	public GenericApplicationContext() {
		this.beanFactory = new DefaultListableBeanFactory();
	}

代码块4：创建DefaultListableBeanFactory

public DefaultListableBeanFactory() {
		super();// 创建AbstractAutowireCapableBeanFactory
	}

public AbstractAutowireCapableBeanFactory() {
		// 调用父类构造器，AbstractBeanFactory
		super();
		// 在依赖检查和自动装配时忽略BeaanNameAware、BeanFactoryAware、BeanClassLoaderAware接口
		ignoreDependencyInterface(BeanNameAware.class);
		ignoreDependencyInterface(BeanFactoryAware.class);
		ignoreDependencyInterface(BeanClassLoaderAware.class);
	}

public AbstractBeanFactory() {
	}

代码块5：设置reader

public AnnotationConfigApplicationContext() {
		// 首先调用父类的无参构造器，初始化beanFactory
		// 其次创建reader和scanner
		this.reader = new AnnotatedBeanDefinitionReader(this);
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
        // 此处registry为AnnotationConfigApplicationContext
		this(registry, getOrCreateEnvironment(registry));
	}

代码块6：getOrCreateEnvironment

private static Environment getOrCreateEnvironment(BeanDefinitionRegistry registry) {
		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		if (registry instanceof EnvironmentCapable) {
			return ((EnvironmentCapable) registry).getEnvironment();
		}
		return new StandardEnvironment();
	}

// AbstractApplicationContext
public ConfigurableEnvironment getEnvironment() {
		if (this.environment == null) {
			this.environment = createEnvironment();
		}
		return this.environment;
	}

protected ConfigurableEnvironment createEnvironment() {
		return new StandardEnvironment();
	}

public AbstractEnvironment() {
		customizePropertySources(this.propertySources);
	}

protected void customizePropertySources(MutablePropertySources propertySources) {
		propertySources.addLast(
				new PropertiesPropertySource(SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, getSystemProperties()));
		propertySources.addLast(
				new SystemEnvironmentPropertySource(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, getSystemEnvironment()));
	}

代码块7：构造AnnotatedBeanDefinitionReader

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);
	}

代码块8：构造ConditionEvaluator

public ConditionEvaluator(@Nullable BeanDefinitionRegistry registry,
			@Nullable Environment environment, @Nullable ResourceLoader resourceLoader) {

		this.context = new ConditionContextImpl(registry, environment, resourceLoader);
	}

代码块9：AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);注册registry中的注解后置处理器

// 注册registry中所有相关的注解后置处理器
	public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
		registerAnnotationConfigProcessors(registry, null);
	}

// 注册registry中相关的 注解后置处理器
	public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, @Nullable Object source) {
		// 1. 解析工厂，为工厂设置注解依赖比较器，和注解自动装配候选人解析器
		// 从registry中获取DefaultListableBeanFactroy
		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
		// 如果bean工厂不为空
		if (beanFactory != null) {
			// 如果bean工厂中的依赖比较器不是AnnotationAwareOrderComparator(注解适配排序比较器)
			if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
				// 则将bean工厂中的依赖比较器设置为AnnotationAwareOrderComparator
				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
			}
			// 如果bean工厂中的自动装配候选人解析器不是ContextAnnotationAutowireCandidateResolver(注解自动装配候选人解析器)
			if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
				// 则将bean工厂中的自动装配候选人解析器设置为ContextAnnotationAutowireCandidateResolver
				beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
			}
		}
		// 2. 注册@Configuration、autowired、jsr-250、jpa、event等后置处理器
		// beanDefinitonHolder集合
		Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
		// internalConfigurationAnnotationProcessor 内部配置注解后置处理器，用于处理@Configuration，
		if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
			def.setSource(source);
			// registerPostProcessor(...)为：
			// this.beanDefinitionMap.put(beanName, beanDefinition);
			// this.beanDefinitionNames.add(beanName);
			// 将def和beanName封装成RootBeanDefinition
			beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
		}
		// 注册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));
		}
		// 注册jsr-250的internalCommonAnnotationProcessor
		// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
		// 在本类的静态块中
		// jsr250Present = ClassUtils.isPresent("javax.annotation.Resource", classLoader);
		//		jpaPresent = ClassUtils.isPresent("javax.persistence.EntityManagerFactory", classLoader) &&
		//				ClassUtils.isPresent(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, classLoader);
		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));
		}
		// 注册internalPersistenceAnnotationProcessor
		// 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));
		}
		// 注册internalEventListenerProcessor
		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));
		}
		// 注册internalEventListenreFactory
		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;
	}

代码块10：unwrapDefaultListableBeanFactory(registry)

// 从registry中获取DefaultListableBeanFactory
	@Nullable
	private static DefaultListableBeanFactory unwrapDefaultListableBeanFactory(BeanDefinitionRegistry registry) {
		// 如果registry是DefaultListableBeanFactroy，则知己返回
		if (registry instanceof DefaultListableBeanFactory) {
			return (DefaultListableBeanFactory) registry;
		}
		// 如果registry是GenericAppllicationContext，则从中获取DefaultListableBeanFactory
		else if (registry instanceof GenericApplicationContext) {
			return ((GenericApplicationContext) registry).getDefaultListableBeanFactory();
		}
		// 否则返回null
		else {
			return null;
		}
	}

代码块11：registerPostProcessor

/**
	 * 注册后置处理器，registry，beanDefinition，beanname
	 * @param registry
	 * @param definition
	 * @param beanName
	 * @return
	 */
	private static BeanDefinitionHolder registerPostProcessor(
			BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {
		//@Role，bean角色定义ROLE_APPLICATION(默认值)、ROLE_SUPPORT(辅助角色)、ROLE_INFRASTRUCTURE(后台角色，用户无感)
		definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
		registry.registerBeanDefinition(beanName, definition);
		return new BeanDefinitionHolder(definition, beanName);
	}

代码块12： registry.registerBeanDefinition(beanName, definition);

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {
		// 调用beanFactory注册BeanDefinition
		this.beanFactory.registerBeanDefinition(beanName, beanDefinition);
	}

代码块13：ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry)

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
		this(registry, true);
	}

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) {
		this(registry, useDefaultFilters, getOrCreateEnvironment(registry));
	}

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
			Environment environment) {
		// AnnotationConfigApplicationContext、true、StandardEnvironment、AnnotationConfigApplicationContext
		this(registry, useDefaultFilters, environment,
				(registry instanceof ResourceLoader ? (ResourceLoader) registry : null));
	}


public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
			Environment environment, @Nullable ResourceLoader resourceLoader) {

		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		this.registry = registry;// AnnotationConfigApplicationContext

		if (useDefaultFilters) {
			registerDefaultFilters();// AnnotationTypeFilter(Component.class)
		}
		setEnvironment(environment);// StandardEnvironment
		setResourceLoader(resourceLoader);// AnnotationConfigApplicationContext
	}

至此，new AnnotationConfigApplicationContext的this()方法完成，下一篇继续介绍register(componentClasses);

源码小白
关注
Spring系列(二) AnnotationConfigApplicationContext
Shine的博客
05-09 1190
AnnotationConfigApplicationContext 创建一个AnnotationConfigApplicationContext的方式及区别 构造传入注解配置类，一步式解析 扫描 创建spring 容器 AnnotationConfigApplicationContext context =new AnnotationConfigApplicationContext(AopConfig.class); 如果有自定义的BeanDefinitionRegistryPost
现在搞Java还不会SpringBoot?看完这篇两万字笔记精髓就够了
Java_supermanNO1的博客
03-20 868
本文转载自：现在搞Java还不会SpringBoot?看完这篇两万字笔记精髓就够了 一、大纲 了解Spring的发展 掌握Spring的java配置方式 学习Spring Boot 使用Spring Boot来改造购物车系统 二、Spring的发展 2.1 Spring1.x 时代 在Spring1.x时代，都是通过xml文件配置bean，随着项目的不断扩大，需要将xml配置分放到不同的配置...
AnnotationConfigApplicationContext
weixin_49849351的博客
12-02 7008
public class Main { public static void main(String[] args) { /* ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");*/ AnnotationConfigApplicationContext applicationContext = new A...
Spring源码分析之AnnotationConfigApplicationContext
zhanghuyi2022的博客
04-23 6828
AnnotationConfigApplicationContext spring版本：5.2.8.RELEASE 全类名：org.springframework.context.annotation.AnnotationConfigApplicationContext 从类依赖图，我们可以看出AnnotationConfigApplicationContext实现了Bean定义的注册、Bean的实例化、事件、生命周期、国际化等功能。 今天我们不去分析这些功能的实现方式，我们从new Annotation
spring5源码阅读（一）new AnnotationConfigApplicationContext(Appconfig.class)入口
雨剑的博客
08-26 2631
文章目录1.spring入口1.1 demo1.2 入口说明2.new AnnotationConfigApplicationContext2.1 this()2.1.1 方法作用2.1.2 如何作用的2.2 register(annotatedClasses)2.2.1 方法作用2.2.1 如何作用的2.3 refresh() Spring，让我们java开发变得越来越简单，越来越高效，一系列组...
spring application 之 AnnotationConfigApplicationContext
weixin_34232617的博客
06-09 385
2019独角兽企业重金招聘Python工程师标准>>> ...
B站 - 狂神 - Spring5课堂笔记
bell_love的博客
08-02 8431
文章目录1、Spring-8.11.1、简介1.2、优点1.3、组成1.4、扩展2、IOC理论推导IOC本质3、HolleSpring4、IOC创建对象的方式5、Spring配置5.1、别名5.2、Bean的配置5.3、import6、依赖注入（DI）6.1、构造器注入6.2、set方式注入【重点】6.3、拓展注入6.4、Bean作用域7、Bean的自动装配7.1测试：自动装配7.2、使用注解实现自动装配7.2.1、@Autowired7.2.2、@Autowired+@Qualifier7.2.3、@Re
Spring组件注册 - springboot实战电商项目mall4j
mall4j的博客
12-13 763
springboot实战电商项目mall4j （https://gitee.com/gz-yami/mall4j) java开源商城系统 1. bean注册 我们有个Person类 public class Person { private Integer age; private String name; public Integer getAge() { return age; } public void setAge(Integer age) { this.age = ag
狂神说Spring课堂笔记
weixin_44202871的博客
02-09 582
文章目录1、Spring1.1、简介1.2、优点1.3、组成1.4、拓展2、IOC理论推导IOC本质3、HelloSpring思考修改案例一4、IOC创建对象的方式5、Spring配置5.1、别名5.2、bean的配置5.3、import6、依赖注入6.1、构造器注入6.2、Set方式注入【重点】6.3、拓展方式注入6.4、bean的作用域7、bean的自动装配7.1、自动装配7.2、ByName自动装配7.3、ByType自动装配7.4、使用注解实现自动装配8、使用注解开发9、使用Java的方式配置Spr
【Java进阶营】现在搞Java还不会SpringBoot?看完这篇两万字笔记精髓就够了
java700001的博客
05-04 470
一、大纲 了解Spring的发展 掌握Spring的java配置方式 学习Spring Boot 使用Spring Boot来改造购物车系统 二、Spring的发展 2.1 Spring1.x 时代 在Spring1.x时代，都是通过xml文件配置bean，随着项目的不断扩大，需要将xml配置分放到不同的配置文件中，需要频繁的在java类和xml配置文件中切换。 2.2 Spring2.x时代 随着JDK 1.5带来的注解支持，Spring2.x可以使用注解对Bean进行申明和注入，大大的减少了xml配
spring源码分析笔记（1）AnnotationConfigApplicationContext
weixin_43541132的博客
06-18 156
spring源码分析笔记（1） 这是我第一篇博客，写博客是因为之前本地的笔记老是容易丢失，所以现在抽空把能找到的搬运到博客上，也是为了日后便于查看。 new AnnotationConfigApplicationContext的时候，第一步构造方法中有三步 this(),register(),refresh() this() 调用的是当前类的构造方法，内部创建了reader和scanner，分别是： this.reader = new AnnotatedBeanDefinitionReader(this);
spring-源码-AnnotationConfigApplicationContext-创建分析-1
菜鸡在路上找食吃
07-13 615
文章目录前言springbootspring一、入口二、调用构造函数DefaultListableBeanFactoryAbstractAutowireCapableBeanFactory调用ignoreDependencyInterface()ignoredDependencyInterfaces-作用演示定义入口定义PortProcessor定义 Config定义A类定义B类定义C类复现学到了什么 前言 需要说明的是这里仅仅是分析 ApplicationContext 初始化的时候都做了一些什么 当然
spring 源码系列（四）- AnnotationConfigApplicationContext
bintoYu的博客
02-16 1199
在spring中，使用的入口就是在main函数中创建Spring容器，基于XML形式的是ClassPathXmlApplicationContext；而基于注解形式的是AnnotationConfigApplicationContext。本文将对AnnotationConfigApplicationContext进行详细讲解。 使用篇 在这里简单介绍一下AnnotationConfigApplic...
【spring】AnnotationConfigApplicationContext 类学习
一个写了10年bug的程序员日常笔记。
03-15 3307
是 Spring 框架中的一个类，用于创建基于注解的 Spring 应用上下文。它继承自类，并实现了接口。使用创建 Spring 应用上下文时，需要指定一个或多个配置类。，开发者可以直接在 Java 类中使用注解如@Bean等来声明和配置 Bean。属于 Spring 的 Java 配置支持模块，用于以纯 Java 注解的方式来替代 XML 配置文件来创建和管理 Spring 容器上下文。属于其中的一种。
Spring源码深入阅读AnnotationConfigApplicationContext
热门推荐
旭旭1998的博客
09-20 7万+
一直很好奇代码 AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SimpleBeanConfig.class);运行的时候，spring容器做了什么事情，为了搞清楚，我要看一看Spring源码剖析一下。 AnnotationConfigApplicationContext的Class构造方法有三行代码如下，当然是进去看一看了 public AnnotationConfigApplicati
22. spring-容器:详解AnnotationConfigApplicationContext
elegent Developer's 的博客
08-12 354
先看类结构图 可以看出跟XmlWebApplicationContext很像，都是基于AbstractApplicationContext, 而容器加载和实例化bean的核心方法都是在AbstractApplicationContext中组织，不同之处各个子类再重写。 AnnotationConfigApplicationContext public class AnnotationConfigApplicationContext extends GenericApplicationContext imp
Spring本地启动Main函数-AnnotationConfigApplicationContext
z69183787的专栏
04-05 1227
spring
Spring源码阅读3 -- Spring5.1.6源码AnnotationConfigApplicationContext方式测试bean
CleverCode的博客
03-15 322
文章目录1 安装环境2 修改build.gradle3 添加类文件4 AppConfig5 测试6 测试7 AnnotationConfigApplicationContext 类图技术交流 1 安装环境 《Spring源码阅读1 – Mac使用Idea工具编译Spring5源码(v5.1.6)+测试spring源码》：https://clevercode.blog.csdn.net/article/details/114232589 2 修改build.gradle dependencies {
【Spring cooking】厨师就位（一）AnnotationConfigApplicationContext
qq_44737446的博客
03-29 676
ApplicationContext 接口的抽象实现类，使用的是模板方法设计模式，下面两个抽象方法子类必须实现与 BeanFactory 不同，ApplicationContext 应该检测其内部 BeanFactory 中定义的特殊bean。这些特殊Bean包括同时继承了 DefaultResourceLoader，加载类路径资源也实现了 ConfigurableEnvironment接口，创建环境} }} }
SSM系类代码：org.springframework.context.annotation.AnnotationConfigApplicationContext
最新发布
12-17
`org.springframework.context.annotation.AnnotationConfigApplicationContext` 是Spring框架中的一个重要类，它允许开发者通过注解配置（Annotation-based Configuration）来初始化Spring应用上下文（ApplicationContext）。相比于传统的XML配置方式，注解配置更加简洁灵活。 创建并使用`AnnotationConfigApplicationContext`的基本步骤如下： 1. 定义Spring Bean的注解配置类（@Configuration注解的类）： ```java @Configuration public class AppConfig { // 使用@Bean注解声明Bean实例 @Bean public MyService myService() { return new MyServiceImpl(); } } ``` 2. 创建`AnnotationConfigApplicationContext`实例，并加载配置类： ```java import org.springframework.context.annotation.AnnotationConfigApplicationContext; public class Main { public static void main(String[] args) { AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class); // 现在可以使用@Autowired自动装配bean，如 MyService service = context.getBean(MyService.class); // ... context.close(); // 关闭上下文 } } ``` 在这个示例中，`AppConfig`类的`myService()`方法会被自动注册为Spring的一个Bean，当我们在`Main`类中通过`context.getBean()`获取时，Spring会调用这个方法创建相应的实例。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值