基于Spring注解的上下文初始化过程源码解析(一…

2019-08-16 11:57:44来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

基于Spring注解的上下文初始化过程源码解析(一)

最近工作之余有时间和精力,加上平时对源码比较感兴趣,就开始啃起了Spring源码。为加深印象写了这篇博客,如有错误,望各位大佬不吝指正。

我看的是Spring5的源码,从同性社区download下来后编译,然后看源码、写注释、一步一步debug,理论指导实践,实践再反作用于理论。

因为基于注解的开发是现在比较主流的开发模式,所以就从 AnnotationConfigApplicationContext 开始啃了。

因为代码过多,执行流程过于复杂,就拆成了三篇来解析。

下面就从这个类开始探究Spring上下文的初始化。

 

这里需要留意 AnnotationConfigApplicationContext 继承了 GenericApplicationContext

public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {

	private final DefaultListableBeanFactory beanFactory;
/** * 注意这个无参构造函数
*
* 这个初始化的DefaultListableBeanFactory就是Spring的Bean工厂 */ public GenericApplicationContext() {
        this.beanFactory = new DefaultListableBeanFactory(); } }

再来看看 AnnotationConfigApplicationContext 这个类

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {

	/**
	 * 定义一个读取注解的 BeanDefinition 读取器
	 * 这个类在构造方法中被实例化
	 */
	private final AnnotatedBeanDefinitionReader reader;

	/**
	 * 定义一个扫描类路径下加了注解的 BeanDefinition 扫描器
	 * 这个类在构造方法中被实例化
	 */
	private final ClassPathBeanDefinitionScanner scanner;

	public AnnotationConfigApplicationContext() {
		// 实例化 BeanDefinition 读取器
		/**
		 * 注册所有注解相关的后置处理器
		 * 最重要的一个后置处理器 ConfigurationClassPostProcessor
		 * BeanName 是 internalConfigurationAnnotationProcessor
		 */
		this.reader = new AnnotatedBeanDefinitionReader(this);
		// 实例化 BeanDefinition 扫描器
		// 但是实际上扫描包的工作并不是 scanner 这个对象来完成的,是 Spring 自己创建的一个新的 ClassPathBeanDefinitionScanner
		// 这里的 scanner 仅仅是为了程序员能够在外部调用 AnnotationConfigApplicationContext 对象的 scanner 方法
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}

	public AnnotationConfigApplicationContext(DefaultListableBeanFactory beanFactory) {
		// 调用父类的构造方法,初始化 DefaultListableBeanFactory 的 Bean 工厂
		super(beanFactory);
		// 实例化该读取器
		this.reader = new AnnotatedBeanDefinitionReader(this);
		// 实例化该扫描器
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}

	/**
	 * 这个构造方法需要传入一个 @Configuration 注解配置类
	 * 通过注解读取器读取并解析
	 */
	public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
		/**
		 * 由于继承了父类,这里会先去调用父类的构造方法,然后调用自身的构造方法
		 *
		 * this.beanFactory = new DefaultListableBeanFactory();
		 *
		 * 其实就是初始化一个 DefaultListableBeanFactory
		 */
		this();
		/**
		 * 将传入的 @Configuration 配置类转换为 BeanDefinition
		 * 并添加到 DefaultListableBeanFactory 工厂的 BeanDefinitionMap 中
		 */
		register(annotatedClasses);
		/**
		 * 1、准备刷新山下文
		 * 2、通知子类刷新内部的 bean 工厂,得到创建的 DefaultListableBeanFactory 工厂
		 * 3、配置工厂的标准上下文特征
		 * 4、允许在上下文子类中对 bean 工厂进行后置处理
		 * 5、在上下文中调用工厂处理器方法,注册为 bean
		 * 6、注册 BeanPostProcessor
		 * 7、初始化此上下文的消息源
		 * 8、初始化应用事件广播器【SpringBoot 的启动源码中与该方法有很大关系】
		 * 9、在特定的上下文子类中初始化其他特殊 bean
		 * 10、检查监听器 bean 并注册它们
		 * 11、实例化所有剩余(非延迟初始化)单例
		 * 12、发布相应的事件
		 */
		refresh();
	}

	public AnnotationConfigApplicationContext(String... basePackages) {
		/**
		 * 由于继承了父类,这里会先去调用父类的构造方法,然后调用自身的构造方法
		 *
		 * this.beanFactory = new DefaultListableBeanFactory();
		 *
		 * 其实就是初始化一个 DefaultListableBeanFactory
		 */
		this();
		scan(basePackages);
		refresh();
	}
}  

这里还要注意一下AnnotatedBeanDefinitionReader的实例化,代码跟进去发现调用了 AnnotationConfigUtils 的 registerAnnotationConfigProcessors 方法,Spring在初始化上下文时,在Bean工厂中添加了很多辅助其初始化的类

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, @Nullable Object source) {
	// 获取 Bean 工厂
	DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
	if (beanFactory != null) {
		if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
			// AnnotationAwareOrderComparator 主要能解析 @Order 注解和 @Priority 注解
				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
		}
		if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
			// ContextAnnotationAutowireCandidateResolver 提供处理延迟加载的功能
			beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
		}
	}

	/**
	 * 存放所有辅助类的信息
	 */
	Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
	/**
	 * BeanDefinition 的注册,很重要,需要理解注册的每个 Bean 的类型和作用
	 *
	 * Spring 在初始化 ApplicationContext 和 Bean 工厂时,在 Bean 工厂中添加了很多辅助初始化 Bean 工厂的类
	 *
	 * 1.ConfigurationClassPostProcessor             类型是 BeanFactoryPostProcessor
	 * 2.AutowiredAnnotationBeanPostProcessor        类型是 BeanPostProcessor
	 * 3.CommonAnnotationBeanPostProcessor           类型是 BeanPostProcessor
	 * 4.PersistenceAnnotationBeanPostProcessor      类型是 BeanPostProcessor
	 * 5.EventListenerMethodProcessor                类型是 BeanFactoryPostProcessor
	 * 6.DefaultEventListenerFactory                 类型是 EventListenerFactory
	 */

	/**
	 * BeanName 是否包含 org.springframework.context.annotation.internalConfigurationAnnotationProcessor
	 * BeanClass 是 ConfigurationClassPostProcessor,类型是 BeanFactoryPostProcessor
	 */
	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));
	}

	/**
	 * BeanName 是否包含 org.springframework.context.annotation.internalAutowiredAnnotationProcessor
	 * BeanClass 是 AutowiredAnnotationBeanPostProcessor,类型是 BeanPostProcessor
	 */
	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));
	}

	// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
	/**
	 * BeanName 是否包含 org.springframework.context.annotation.internalCommonAnnotationProcessor
	 * BeanClass 是 CommonAnnotationBeanPostProcessor,类型是 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.
	/**
	 * 检查 JPA 支持,如果存在,则添加 PersistenceAnnotationBeanPostProcessor
	 *
	 * BeanName 是否包含 org.springframework.context.annotation.internalPersistenceAnnotationProcessor
	 * BeanClass 是 PersistenceAnnotationBeanPostProcessor,类型是 BeanPostProcessor
	 */
	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));
	}

	/**
	 * BeanName 是否包含 org.springframework.context.event.internalEventListenerProcessor
	 * BeanClass 是 EventListenerMethodProcessor,类型是 BeanFactoryPostProcessor
	 */
	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));
	}

	/**
	 * BeanName 是否包含 org.springframework.context.event.internalEventListenerFactory
	 * BeanClass 是 DefaultEventListenerFactory,类型是 EventListenerFactory
	 */
	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;
}

这个方法执行完后,可以看到 DefaultListableBeanFactory 中的 beanDefinitionMap 中已经有数据了,如果支持 JPA 则有6个元素,没有则有5个。分别是 ConfigurationClassPostProcessor、AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、EventListenerMethodProcessor、DefaultEventListenerFactory,支持 JPA 的是 PersistenceAnnotationBeanPostProcessor。

 这里实例化的 ClassPathBeanDefinitionScanner  仅仅是为了让程序员能够在外部调用 AnnotationConfigApplicationContext 对象的 scanner 方法。Spring 在后面又重新初始化了一个 ClassPathBeanDefinitionScanner,用新的 ClassPathBeanDefinitionScanner 进行扫描。  

回到一开始,我这里是传了一个@Configuration的配置类,所以从register方法往下跟,最后调用的是 AnnotatedBeanDefinitionReader 的 doRegisterBean 方法

/**
 * 将给定的 bean 类注册为 bean,从类声明的注释中派生其元数据
 */
private <T> void doRegisterBean(Class<T> annotatedClass, @Nullable String name, 
                   @Nullable Class<? extends Annotation>[] qualifiers,
                   @Nullable Supplier<T> supplier, @Nullable BeanDefinitionCustomizer[] customizers) { // 根据指定的 bean 创建一个 AnnotatedGenericBeanDefinition AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass); // 若这个类是需要跳过解析的类,则返回 if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) { return; } // 指定创建 bean 实例的回调方法,此时为 null abd.setInstanceSupplier(supplier); // 解析类的作用域元数据 ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd); // 添加类的作用域元数据 abd.setScope(scopeMetadata.getScopeName()); /** * 生成 BeanName * 调用 AnnotationBeanNameGenerator.generateBeanName() */ String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry)); /** * 处理类当中的通用注解 * 主要处理 @Lazy @DependsOn @Primary @Role @Description 等注解 * 处理完成之后将值赋给到 AnnotatedGenericBeanDefinition 对应的属性中 */ AnnotationConfigUtils.processCommonDefinitionAnnotations(abd); /** * 如果在向容器注册注解 BeanDefinition 时,使用了额外的限定符注解则解析 * byName 和 qualifiers 变量是 Annotation 类型的数组,里面不仅存了 @Qualifier 注解 * 所以 Spring 遍历这个数组判断是否加了指定注解 * * 此时 qualifiers 为 null,if 语句不执行 */ if (qualifiers != null) { for (Class<? extends Annotation> qualifier : qualifiers) { if (Primary.class == qualifier) { // 设置 primary 属性值 abd.setPrimary(true); } else if (Lazy.class == qualifier) { // 设置 lazyInit 属性值 abd.setLazyInit(true); } else { /** * 如果使用了除 @Primary 和 @Lazy 以外的其他注解 * 则为该 Bean 添加一个根据名字自动装配的限定符 */ // 向 Map<String, AutowireCandidateQualifier> qualifiers 集合中添加值 abd.addQualifier(new AutowireCandidateQualifier(qualifier)); } } } /** * 如果存在一个或多个用于自定义工厂的回调 * * 此时 customizers 为 null,if 语句不执行 */ if (customizers != null) { for (BeanDefinitionCustomizer customizer : customizers) { customizer.customize(abd); } } /** * 获取 BeanDefinitionHolder 持有者容器 * 里面包含的属性值有 String beanName,BeanDefinition beanDefinition 和 String[] aliases 别名集合 */ BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName); /** * 解析代理模型 */ definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry); /** * 将最终获取到的 BeanDefinitionHolder 持有者容器中包含的信息注册给 BeanDefinitionRegistry * * AnnotationConfigApplicationContext 在初始化的时候通过调用父类的构造方法,实例化了一个 DefaultListableBeanFactory * 这一步就是把 BeanDefinitionHolder 这个数据结构中包含的信息注册到 DefaultListableBeanFactory 中 * * DefaultListableBeanFactory 实现了 BeanDefinitionRegistry * * 此时传入的 @Configuration 配置类已经注册到 DefaultListableBeanFactory 工厂中 */ BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry); }

 这里比较重要的是最后一行代码,进行注册操作,代码如下:

public static void registerBeanDefinition(
			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
			throws BeanDefinitionStoreException {

	// Register bean definition under primary name.
	// 用类的主要名称注册 BeanDefinition
	String beanName = definitionHolder.getBeanName();
	/**
	 * 将 beanName 注册到 DefaultListableBeanFactory 工厂中
	 */
	registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

	// Register aliases for bean name, if any.
	// 如果有别名则为 BeanName 注册别名
	String[] aliases = definitionHolder.getAliases();
	if (aliases != null) {
		for (String alias : aliases) {
			/**
			 * 注册别名
			 */
			registry.registerAlias(beanName, alias);
		}
	}
}
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
		throws BeanDefinitionStoreException {

	if (beanDefinition instanceof AbstractBeanDefinition) {
		try {
			((AbstractBeanDefinition) beanDefinition).validate();
		} catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
					"Validation of bean definition failed", ex);
		}
	}

	// 先从 Map<String, BeanDefinition> beanDefinitionMap 中获取一次
	BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
	// 已注册过则进行逻辑校验
	if (existingDefinition != null) {
		// 是否允许 BeanDefinition 覆盖
		if (!isAllowBeanDefinitionOverriding()) {
			// 不允许则抛异常
			throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
		}
		// 已存在的角色是否小于传入的 beanDefinition 角色
		else if (existingDefinition.getRole() < beanDefinition.getRole()) {
			// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
			if (logger.isInfoEnabled()) {
				logger.info("Overriding user-defined bean definition for bean '" + beanName +
						"' with a framework-generated bean definition: replacing [" +
						existingDefinition + "] with [" + beanDefinition + "]");
			}
		}
		// 如果传入的 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 + "]");
			}
		}
		// 重新存入 Map<String, BeanDefinition> beanDefinitionMap 中
		this.beanDefinitionMap.put(beanName, beanDefinition);
	}
	// 不存在
	else {
		// 是否已经启动 bean 创建
		if (hasBeanCreationStarted()) {
			// Cannot modify startup-time collection elements anymore (for stable iteration)
			synchronized (this.beanDefinitionMap) {
				// 注册到 Map<String, BeanDefinition> beanDefinitionMap 集合中
				this.beanDefinitionMap.put(beanName, beanDefinition);
				// 用新的 beanDefinitionNames 替换旧的
				List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
					updatedDefinitions.addAll(this.beanDefinitionNames);
				updatedDefinitions.add(beanName);
				this.beanDefinitionNames = updatedDefinitions;
				// 从集合中移除该 bean 名称
				removeManualSingletonName(beanName);
			}
		}
		// 还未启动 bean 创建,即仍在启动注册阶段
		else {
			// 注册到 Map<String, BeanDefinition> beanDefinitionMap 集合中
			this.beanDefinitionMap.put(beanName, beanDefinition);
			// 添加 bean 名称到 beanDefinitionNames 数据集合中
			this.beanDefinitionNames.add(beanName);
			// 从集合中移除该 bean 名称
			removeManualSingletonName(beanName);
		}
		this.frozenBeanDefinitionNames = null;
	}

	if (existingDefinition != null || containsSingleton(beanName)) {
			resetBeanDefinition(beanName);
	}
}

register 方法执行完成,此时传入的 @Configuration 配置类已经注册到 DefaultListableBeanFactory 工厂中

那这一篇就先到这里,有问题或者错误欢迎大家沟通交流

下一篇从 refresh 方法开始往下跟代码


原文链接:https://www.cnblogs.com/elewin/p/11299635.html
如有疑问请与原作者联系

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:[JVM 相关] Java 新型垃圾回收器(Garbage First,G1)

下一篇:Spring再次学习(3)