Spring源码之reader、scanner

news2024/11/15 21:33:36

1.Spring的整体启动流程

2.reader

3.Scanner

ApplicationContext的三种加载应用上下文的方式（创建Spring容器）：

AnnotationConfigApplicationContext
ClassPathXmlApplicationContext
FileSystemXmlApplicationContext

1.Spring的整体启动流程

1.创建BeanFactory

在AnnotationConfigApplicationContext中调用父类GenericApplicationContext的初始化方法，生成DefaultListableBeanFactory。

2.解析配置类

3.扫描，生成BeanDefinition，存到BeanDefinitionMap

4.根据BeanDefinition生成Bean，存到单例池

5.使用Bean

本文首先讲解spring源码中的reader（读取器）和scanner（扫描器）

reader 和 scanner 通常用于处理组件扫描和元数据读取的功能

public AnnotationConfigApplicationContext() {
		StartupStep createAnnotatedBeanDefReader = this.getApplicationStartup().start("spring.context.annotated-bean-reader.create");
		// 额外会创建StandardEnvironment
		this.reader = new AnnotatedBeanDefinitionReader(this);
		createAnnotatedBeanDefReader.end();
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}

在初始化BeanFactory之后，创建reader和scanner。

2.reader

reader：将我们注册的东西生成beanDefinition，以及初始化一些关键的BeanPostProcessor。

主要BeanPostProcessor有：

ConfigurationClassPostProcessor：处理带有 @Configuration注解的类

AutowiredAnnotationBeanPostProcessor：负责处理带有 @Autowired注解的字段和方法，实现自动装配

CommonAnnotationBeanPostProcessor、

EventListenerMethodProcessor:负责在 Spring 容器启动时扫描带有@EventListener注解的方法，并将这些方法注册为事件监听器。

DefaultEventListenerFactory：负责创建事件监听器的实例

1.生成conditionEvaluator，condition解析器，用来解析@Conditional注解

2.之后进行相关注册。（内容很多，以下步骤都包含在2.中）

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, @Nullable Object source) {

		DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
		if (beanFactory != null) {

			// 设置beanFactory的OrderComparator为AnnotationAwareOrderComparator
			// 它是一个Comparator，是一个比较器，用来进行排序，分析类或方法上的注解（如 @Order、 @Priority）来决定对象的排序顺序
			if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
			}
			// 用来判断某个Bean能不能用来进行依赖注入
			if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
				beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
			}
		}

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

		// 注册ConfigurationClassPostProcessor类型的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));
		}

		// 注册AutowiredAnnotationBeanPostProcessor类型的BeanDefinition(重点)
		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类型的BeanDefinition(重点)）
		// 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));
		}

		// 注册PersistenceAnnotationBeanPostProcessor类型的BeanDefinition
		// 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));
		}

		// 注册EventListenerMethodProcessor类型的BeanDefinition，用来处理@EventListener注解的
		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类型的BeanDefinition，用来处理@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;
	}

3.设置比较器AnnotationAwareOrderComparator，用来排序。主要用于支持根据注解进行排序的功能，比如@Order、@Priority等。

在 Spring 中，多个 bean 可能会实现同一接口或继承自同一类，AnnotationAwareOrderComparator 可以确保这些 bean 按照指定的顺序进行处理。

4.设置解析器ContextAnnotationAutowireCandidateResolver，用来判断一个类能不能进行依赖注入。这个类的父类是QualifierAnnotationAutowireCandidateResolver，解析@Qualifier注解。而它的父类是GenericTypeAwareAutowireCandidateResolver，用来解析泛型。

说明：ContextAnnotationAutowireCandidateResolver是 Spring 框架中的一个类，负责解析和确定哪些候选 bean 可以被自动装配。它主要用于处理带有特定注解的 bean，例如 @Autowired 和 @Value，以便在依赖注入时选择合适的候选者。

5.注册ConfigurationClassPostProcessor类型的BeanDefinition，解析配置类，涉及到扫描，在扫描的时候，会用到这个PostProcessor。

6.注册AutowiredAnnotationBeanPostProcessor类型的BeanDefinition，解析@Autowired注解

7.注册CommonAnnotationBeanPostProcessor类型的BeanDefinition，解析@Resource注解

5，6，7中的PostProcessor此时还未成为Bean，是在后面生成Bean的！

8.注册EventListenerMethodProcessor类型的BeanDefinition，用来处理@EventListener注解的，它会去解析一个bean中的某个方法是不是监听器，也就是这个方法是不是加了@EventListener注解。

它的调用时机：所有bean初始化后会才会调用这个方法，在doCreateBean方法中。

在EventListenerMethodProcessor中调用afterSingletonsInstantiated（所有bean初始化后会调用这个方法），这个方法中会调用processBeans，里面进行@EventListener的解析。