系列文章目录

文章目录

系列文章目录
前言
new AnnotationConfigApplicationContext(HelloWorld.class)

前言

暂无

new AnnotationConfigApplicationContext(HelloWorld.class)

@Configuration
public class HelloWorld {
    
    

	@Bean
	public Object bean() {
    
    
		return "Hello World, 你好 世界";
	}

	public static void main(String[] args) {
    
    
		AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(HelloWorld.class);
		System.out.println(ac.getBean("bean"));
		ac.close();
	}

}

new AnnotationConfigApplicationContext(HelloWorld.class);

做好初始化准备并调用 refresh()

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
    
    
	
	// 子类在初始化时会调用父类的无参构造器, 即隐式调用 super(); 然后才是 this(); 从最顶层开始(包括抽象类)
	// AnnotationConfigApplicationContext extends GenericApplicationContext
	// GenericApplicationContext extends AbstractApplicationContext
	// AbstractApplicationContext extends DefaultResourceLoader
	// 调用父类 GenericApplicationContext 的无参构造器, 初始化了一个 DefaultListableBeanFactory
	
	// 调用 AnnotationConfigApplicationContext 的无参构造器, 初始化了 reader 和 scanner
	this();
	
	// 把 配置类(可多个) 注册成为 BeanDefinition, 为了在 refresh 中统一解析
	// 加 @Configuration 的配置类被 Spring 称为 Full, 反之称为 Lite, Full 的在解析时会有额外的代理
	register(componentClasses);
	
	// 到这里, 注册了内部使用的类和配置类的 BeanDefinition
	// Spring 中最重要的方法, 是一个模板方法, 该流程定义在 AbstractApplicationContext 中, 贯穿 Spring 应用的整个生命周期, 加载 bean 到销毁 bean
	refresh();
}

配置类是否需要加 @Configuration

加 @Configuration 的配置类被 Spring 称为 Full, 反之称为 Lite, Full 的在解析时会做 CGLib 动态代理

配置类中的 @Bean 配置会受 @Configuration 有无的影响
没有 @Configuration 时, 在创建 Bean b 时, 会调用 b(), 在创建 Bean a 的时候还会再调用一次 b(), B 被实例化两次
配置 @Configuration 时, 调用 b() 会被 CGLib 动态代理加强, 会先从容器中获取, 有的话, 就不会再次调用了, 没有的话, 会创建并加入到容器中

@Bean
public B b() {
    
    
	return new B();
}
@Bean
public A a() {
    
    
	b();
	return new A();
}

super(); - GenericApplicationContext 的无参构造器

创建了一个 DefaultListableBeanFactory

public GenericApplicationContext() {
    
    
	// 创建了一个 DefaultListableBeanFactory, 是 BeanFactory 及其子接口的默认实现
	// 注册 BeanDefinition, 创建和管理 Bean 都是该类完成的, 该类非常重要
	this.beanFactory = new DefaultListableBeanFactory();
}

this(); - AnnotationConfigApplicationContext 的无参构造器

public AnnotationConfigApplicationContext() {
    
    
	
	// AnnotatedBeanDefinitionReader 聚合了一个 BeanDefinitionRegistry, 代理其注册, 管理 BeanDefinition 的能力
	// 根据继承实现关系可知, AnnotationConfigApplicationContext 也是一个 BeanDefinitionRegistry, 所以 this 可以直接作为入参传入
	
	// AnnotatedBeanDefinitionReader 的主要作用是在容器启动早期, 把一些创世纪工具类(角色是基础设施)封装并注册为 BeanDefinition
	
	// 1. ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor, PriorityOrdered, ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware
	// 解析配置类(传入 AnnotationConfigApplicationContext 的参数), 解析 @ComponentScan, @ComponentScan 扫描的包, @Import 等
	// 2. AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter implements MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware
	// 解析 @Autowired
	// 3. CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable
	// 顾名思义就是处理一些公共注解的, 是一个 BeanPostProcessor，可以处理 @PostConstruct 和 @PreDestroy 还有 @Resource (还有 @WebServiceRef, @EJB?) 等
	// 这些注解都是定义在 javax.* 包下的注解, 属于 java 中的注解, 是 JSR-250 标准定义的
	// 4. EventListenerMethodProcessor implements SmartInitializingSingleton, ApplicationContextAware, BeanFactoryPostProcessor
	// 解析 @EventListener
	// 5. DefaultEventListenerFactory implements EventListenerFactory, Ordered
	// 解析 @EventListener
	this.reader = new AnnotatedBeanDefinitionReader(this);
	
	// 提供 applicationContext.scan(basePackage) 主动调用能力
	// 在解析配置类时使用的是该类的另一个实例对象
	this.scanner = new ClassPathBeanDefinitionScanner(this);
}

this.reader = new AnnotatedBeanDefinitionReader(this);

AnnotatedBeanDefinitionReader 的主要作用是在容器启动早期, 把一些创世纪工具类(角色是基础设施)封装并注册为 BeanDefinition, 主要包括如下工具类

ConfigurationClassPostProcessor 该类非常重要, 用于解析配置类, 把相关类都注册成为 BeanDefinition, 只有该类是 BeanFactoryPostProcessor, 其他的都是 BeanPostProcessor

AutowiredAnnotationBeanPostProcessor 解析 @Autowired
CommonAnnotationBeanPostProcessor
EventListenerMethodProcessor
DefaultEventListenerFactory

扫描二维码关注公众号，回复： 12008755 查看本文章

RequiredAnnotationBeanPostProcessor Spring 5.1 已经不再使用该工具类了
PersistenceAnnotationBeanPostProcessor

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

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

public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
    
    
	registerAnnotationConfigProcessors(registry, null);
}

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

	Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

	// 1. ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor, PriorityOrdered, ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware
	// 解析配置类, 解析 @ComponentScan, @ComponentScan 扫描的包, @Import 等, 是一个 BeanFactoryPostProcessor
	// 把配置类里面相关的一些 Bean 的类型(如 Car, Tank 等)解析成 BeanDefinition
	// ---- interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor
	// ---- interface PriorityOrdered extends Ordered
	// ---- interface ResourceLoaderAware,BeanClassLoaderAware,EnvironmentAware extends Aware
	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));
	}

	// 2. AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter implements MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware
	// 解析 @Autowired, 是一个 BeanPostProcessor, 在 Bean 的属性注入的时候会用到
	// ---- interface MergedBeanDefinitionPostProcessor extends BeanPostProcessor
	// ---- class InstantiationAwareBeanPostProcessorAdapter implements SmartInstantiationAwareBeanPostProcessor
	// ---- ---- interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor
	// ---- interface BeanFactoryAware extends Aware
	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));
	}

	// 5.1 开始不注册 RequiredAnnotationBeanPostProcessor
	// 解析 @Required, 是一个 BeanPostProcessor, 在 Bean 的属性注入的时候会用到

	// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
	// 3. CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessor implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable
	// 顾名思义就是处理一些公共注解的, 是一个 BeanPostProcessor，可以处理 @PostConstruct 和 @PreDestroy 还有 @Resource (还有 @WebServiceRef, @EJB?) 等
	// 这些注解都是定义在 javax.* 包下的注解, 属于 java 中的注解, 是 JSR-250 标准定义的
	// ---- class InitDestroyAnnotationBeanPostProcessor implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor, PriorityOrdered, Serializable
	// ---- ---- interface DestructionAwareBeanPostProcessor extends BeanPostProcessor
	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));
	}

	// 4. EventListenerMethodProcessor implements SmartInitializingSingleton, ApplicationContextAware, BeanFactoryPostProcessor
	// 解析 @EventListener, spring 实现事件监听的方式有很多种, 其中一种就是在方法上添加 @EventListener 注解
	// ---- interface ApplicationContextAware extends Aware
	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));
	}

	// 5. DefaultEventListenerFactory implements EventListenerFactory, Ordered
	// 解析 @EventListener
	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;
}

AnnotationConfigUtils.registerPostProcessor(registry, beanDefinition, beanName)

	private static BeanDefinitionHolder registerPostProcessor(
			BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {
    
    

		// ROLE_INFRASTRUCTURE, 表明当前 BeanDefinition 是基础架构组件, 是 Spring 内部使用的, 和用户无关的
		definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
		
		// 调用 registry(即 AnnotationConfigApplicationContext) 注册 BeanDefinition
		// 其实是 AnnotationConfigApplicationContext 代理了 DefaultListableBeanFactory 的所有 BeanDefinitionRegistry 能力
		registry.registerBeanDefinition(beanName, definition);
		
		return new BeanDefinitionHolder(definition, beanName);
	}

DefaultListableBeanFactory.registerBeanDefinition(beanName, beanDefinition)

注册 BeanDefinition 其实是使用 AnnotationConfigApplicationContext 的父类 GenericApplicationContext 聚合的 DefaultListableBeanFactory 来实现的, 其内部维护了 BeanDefinitionMap 和 BeanDefinitionNames 两个容器, 用于存放 BeanDefinition 的信息, 注册就是把 BeanDefinition 添加到这两个容器中

// 在 启动注册 BeanDefinition 阶段
// 把 beanName 作为 key, BeanDefinition 作为 value, put 到 beanDefinitionMap 中
this.beanDefinitionMap.put(beanName, beanDefinition);
// 把 beanName add 到 beanDefinitionNames 中
this.beanDefinitionNames.add(beanName);

this.scanner = new ClassPathBeanDefinitionScanner(this);

实例化一个BeanDefinitionScanner, 只用于手动调用 applicationContext.scan(basePackage)

Spring Ioc 加载过程会用到该类的另一个实例来扫描

AnnotationConfigApplicationContext 初始化