欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2022-04-10 15:45:33
上一篇看完了register方法的代码,继续跟后面代码 后面执行refresh方法,代码清单如下: 这里就只讨论两个比较重要的方法,分别是 invokeBeanFactoryPostProcessors 方法和 finishBeanFactoryInitialization 方法 这里的 invok ......

上一篇看完了register方法的代码,继续跟后面代码

后面执行refresh方法,代码清单如下:

public void refresh() throws beansexception, illegalstateexception {
	synchronized (this.startupshutdownmonitor) {
		// prepare this context for refreshing.
		/**
		 * 准备刷新上下文,设置其启动日期和活动标志以及执行属性源的任何初始化
		 */
		preparerefresh();

		// tell the subclass to refresh the internal bean factory.
		/**
		 * 通知子类刷新内部的 bean 工厂
		 * 得到创建的 defaultlistablebeanfactory 工厂
		 * defaultlistablebeanfactory 实现了 configurablelistablebeanfactory
		 * 接下来对工厂进行初始化
		 */
		configurablelistablebeanfactory beanfactory = obtainfreshbeanfactory();

		// prepare the bean factory for use in this context.
		/**
		 * 配置工厂的标准上下文特征
		 */
		preparebeanfactory(beanfactory);

		try {
			// allows post-processing of the bean factory in context subclasses.
			/**
			 * 允许在上下文子类中对 bean 工厂进行后置处理
			 *
			 * 当前版本的 spring 代码中没有任何作用,可能是 spring 为了在后面的版本中方便扩展
			 */
			postprocessbeanfactory(beanfactory);

			// invoke factory processors registered as beans in the context.
			/**
			 * 第一重要的方法
			 *
			 * 在上下文中调用工厂处理器方法,注册为 bean
			 * 在 spring 的环境中去执行已经被注册的 beanfactorypostprocessors
			 * 注册自定义的 beanfactorypostprocessors 和 spring 内部定义的 beanfactorypostprocessors
			 *
			 * 比较重要的一个是 configurationclasspostprocessor
			 * 实例化 annotationconfigapplicationcontext 时初始化了一个 annotatedbeandefinitionreader
			 * annotatedbeandefinitionreader 的构造方法中将 configurationclasspostprocessor 注册到 beandefinition 中
			 */
			invokebeanfactorypostprocessors(beanfactory);

			// register bean processors that intercept bean creation.
			// 注册 beanpostprocessor,spring aop 就是在这里进行注册的
			registerbeanpostprocessors(beanfactory);

			// initialize message source for this context.
			// 初始化此上下文的消息源
			initmessagesource();

			// initialize event multicaster for this context.
			// 初始化应用事件广播器【springboot 的启动源码中与该方法有很大关系】
			initapplicationeventmulticaster();

			// initialize other special beans in specific context subclasses.
			// 在特定的上下文子类中初始化其他特殊 bean
			// 当前版本中也是什么都没做
			onrefresh();

			// check for listener beans and register them.
			// 检查监听器 bean 并注册它们
			registerlisteners();

			// instantiate all remaining (non-lazy-init) singletons.
			/**
			 * 第二重要的方法
			 *
			 * 实例化所有剩余(非延迟初始化)单例。
			 */
			finishbeanfactoryinitialization(beanfactory);

			// last step: publish corresponding event.
			/**
			 * 最后一步:发布相应的事件
			 */
			finishrefresh();
		} catch (beansexception ex) {
			if (logger.iswarnenabled()) {
				logger.warn("exception encountered during context initialization - " +
						"cancelling refresh attempt: " + ex);

			}

			// destroy already created singletons to avoid dangling resources.
			/**
			 * 摧毁已经创建的单例 bean 以避免悬空资源
			 */
			destroybeans();

			// reset 'active' flag.
			/**
			 * 重置 active 属性值
			 */
			cancelrefresh(ex);

			// propagate exception to caller.
			throw ex;
		} finally {
			// reset common introspection caches in spring's core, since we
			// might not ever need metadata for singleton beans anymore...
			resetcommoncaches();
		}
	}
}  

这里就只讨论两个比较重要的方法,分别是 invokebeanfactorypostprocessors 方法和 finishbeanfactoryinitialization 方法

public static void invokebeanfactorypostprocessors(configurablelistablebeanfactory beanfactory,
	                          list<beanfactorypostprocessor> beanfactorypostprocessors) {

	/**
	 * 如果有的话,首先调用 beandefinitionregistrypostprocessors
	 */
	set<string> processedbeans = new hashset<>();

	/**
	 * 如果 beanfactory 是 beandefinitionregistry
	 *
	 * beanfactory 是 defaultlistablebeanfactory
	 * defaultlistablebeanfactory implements configurablelistablebeanfactory, beandefinitionregistry
	 */
	if (beanfactory instanceof beandefinitionregistry) {
		// 转换成 beandefinition 注册器
		beandefinitionregistry registry = (beandefinitionregistry) beanfactory;
		// bean 工厂后置处理器集合
		// 存放手动添加的 beanfactorypostprocessor
		list<beanfactorypostprocessor> regularpostprocessors = new arraylist<>();
		// beandefinition 注册器后置处理器集合
		/**
		 * beandefinitionregistrypostprocessor 继承了 beanfactorypostprocessor
		 * 存放所有需要注册的 beandefinitionregistrypostprocessor
		 */
		list<beandefinitionregistrypostprocessor> registryprocessors = new arraylist<>();

		// 循环遍历手动添加的 beanfactorypostprocessor
		for (beanfactorypostprocessor postprocessor : beanfactorypostprocessors) {
			// 外部扩展的
			if (postprocessor instanceof beandefinitionregistrypostprocessor) {

				beandefinitionregistrypostprocessor registryprocessor =
						(beandefinitionregistrypostprocessor) postprocessor;
				// 调用 postprocessbeandefinitionregistry 方法,不是回调
				registryprocessor.postprocessbeandefinitionregistry(registry);
				// 存入集合
				registryprocessors.add(registryprocessor);
			}
			// spring 内部的
			else {
				// 存入集合
				regularpostprocessors.add(postprocessor);
			}
		}

		/**
		 * 需要保留所有未初始化的常规 bean,以使 bean 工厂后置处理器适用于这些 bean
		 * 在实现 priorityordered,ordered 和其余的 beandefinitionregistrypostprocessors 之间分开
		 *
		 * 放 spring 内部的 beandefinitionregistrypostprocessor
		 */
		list<beandefinitionregistrypostprocessor> currentregistryprocessors = new arraylist<>();
		/**
		 * 获取 beandefinitionregistrypostprocessor bean 名称
		 * beandefinitionregistrypostprocessor 是 beanfactorypostprocessor 的子类
		 *
		 * 此时至少包含了一个 configurationclasspostprocessor
		 * class configurationclasspostprocessor implements beandefinitionregistrypostprocessor
		 * 名称为 internalconfigurationannotationprocessor
		 */
		string[] postprocessornames =
				beanfactory.getbeannamesfortype(beandefinitionregistrypostprocessor.class, true, false);
		/**
		 * configurationclasspostprocessor 最重要的类
		 */
		for (string ppname : postprocessornames) {
			/**
			 * 首先,调用实现 priorityordered 的 beandefinitionregistrypostprocessors
			 */
			if (beanfactory.istypematch(ppname, priorityordered.class)) {
				// 实例化该 bean,并添加到集合中
				currentregistryprocessors.add(beanfactory.getbean(ppname, beandefinitionregistrypostprocessor.class));
				// 添加到集合中
				processedbeans.add(ppname);
			}
		}
		// 排序
		sortpostprocessors(currentregistryprocessors, beanfactory);
		// 合并
		registryprocessors.addall(currentregistryprocessors);
		/**
		 * 调用 beandefinitionregistrypostprocessor#postprocessbeandefinitionregistry 方法
		 *
		 * 集合中的元素包含 configurationclasspostprocessor
		 */
		invokebeandefinitionregistrypostprocessors(currentregistryprocessors, registry);
		// 执行完成,清空集合数据
		// 至少清除包含的 configurationclasspostprocessor
		currentregistryprocessors.clear();

		// 获取 beandefinitionregistrypostprocessor bean 名称
		// 下面的代码理论上不会执行,只是 spring 确保初始化过程中没有新的类被添加进来
		postprocessornames = beanfactory.getbeannamesfortype(beandefinitionregistrypostprocessor.class, true, false);
		for (string ppname : postprocessornames) {
			/**
			 * 接下来,调用实现 ordered 的 beandefinitionregistrypostprocessors
			 *
			 * 不在 processedbeans 中且实现了 ordered 的 beandefinitionregistrypostprocessors
			 */
			if (!processedbeans.contains(ppname) && beanfactory.istypematch(ppname, ordered.class)) {
				// 实例化该 bean,并添加到集合中
				currentregistryprocessors.add(beanfactory.getbean(ppname, beandefinitionregistrypostprocessor.class));
				// 添加到集合中
				processedbeans.add(ppname);
			}
		}
		// 排序
		sortpostprocessors(currentregistryprocessors, beanfactory);
		// 合并
		registryprocessors.addall(currentregistryprocessors);
		/**
		 * 调用 beandefinitionregistrypostprocessor#postprocessbeandefinitionregistry 方法
		 */
		invokebeandefinitionregistrypostprocessors(currentregistryprocessors, registry);
		// 执行完成,清空集合数据
		currentregistryprocessors.clear();

		/**
		 * 最后,调用所有其他 beandefinitionregistrypostprocessors
		 * 直到不再出现其他 beandefinitionregistrypostprocessors
		 */
		boolean reiterate = true;
		while (reiterate) {
			reiterate = false;
			// 获取 beandefinitionregistrypostprocessor 名称
			postprocessornames = beanfactory.getbeannamesfortype(
					beandefinitionregistrypostprocessor.class,
					true,
					false
			);
			for (string ppname : postprocessornames) {
				// 执行剩下的 beandefinitionregistrypostprocessors
				if (!processedbeans.contains(ppname)) {
					// 实例化该 bean,并添加到集合中
					currentregistryprocessors.add(beanfactory.getbean(ppname, beandefinitionregistrypostprocessor.class));
					processedbeans.add(ppname);
					reiterate = true;
				}
			}
			// 排序
			sortpostprocessors(currentregistryprocessors, beanfactory);
			// 合并
			registryprocessors.addall(currentregistryprocessors);
			/**
			 * 调用 beandefinitionregistrypostprocessor#postprocessbeandefinitionregistry 方法
			 */
			invokebeandefinitionregistrypostprocessors(currentregistryprocessors, registry);
			// 执行完成,清空集合数据
			currentregistryprocessors.clear();
		}

		/**
		 * 刚才执行完 configurationclasspostprocessor 的回调
		 * configurationclasspostprocessor implements beandefinitionregistrypostprocessor
		 * 现在调用到目前为止处理的所有 beanfactorypostprocessor#postprocessbeanfactory 方法的回调
		 */
		invokebeanfactorypostprocessors(registryprocessors, beanfactory);
		invokebeanfactorypostprocessors(regularpostprocessors, beanfactory);
	} else {
		// invoke factory processors registered with the context instance.
		/**
		 * 调用在上下文实例中注册的工厂处理器
		 */
		invokebeanfactorypostprocessors(beanfactorypostprocessors, beanfactory);
	}

	/**
	 * 获取 beanfactorypostprocessor 名称
	 * 此时至少有两个元素:
	 * 		org.springframework.context.annotation.internalconfigurationannotationprocessor
	 * 		org.springframework.context.event.internaleventlistenerprocessor
	 *
	 * 需要保留所有未初始化的常规 bean,以使 bean 工厂后处理器适用于这些 bean
	 */
	string[] postprocessornames =
			beanfactory.getbeannamesfortype(beanfactorypostprocessor.class, true, false);
	/**
	 * 分隔实现了 priorityordered,ordered 和其余的 beanfactorypostprocessors
	 */
	list<beanfactorypostprocessor> priorityorderedpostprocessors = new arraylist<>();
	list<string> orderedpostprocessornames = new arraylist<>();
	list<string> nonorderedpostprocessornames = new arraylist<>();
	for (string ppname : postprocessornames) {
		// 处理过则跳过
		if (processedbeans.contains(ppname)) {
			// skip - already processed in first phase above
		}
		// 实现了 priorityordered
		else if (beanfactory.istypematch(ppname, priorityordered.class)) {
			priorityorderedpostprocessors.add(beanfactory.getbean(ppname, beanfactorypostprocessor.class));
		}
		// 实现了 ordered
		else if (beanfactory.istypematch(ppname, ordered.class)) {
			orderedpostprocessornames.add(ppname);
		}
		// 普通类
		else {
			// org.springframework.context.event.internaleventlistenerprocessor 是普通类
			nonorderedpostprocessornames.add(ppname);
		}
	}

	/**
	 * 首先,调用实现 priorityordered 的 beanfactorypostprocessors
	 */
	// 排序
	sortpostprocessors(priorityorderedpostprocessors, beanfactory);
	// 调用 beanfactorypostprocessor#postprocessbeanfactory 方法
	invokebeanfactorypostprocessors(priorityorderedpostprocessors, beanfactory);

	/**
	 * 接下来,调用实现 ordered 的 beanfactorypostprocessors
	 */
	list<beanfactorypostprocessor> orderedpostprocessors = new arraylist<>(orderedpostprocessornames.size());
	for (string postprocessorname : orderedpostprocessornames) {
		orderedpostprocessors.add(beanfactory.getbean(postprocessorname, beanfactorypostprocessor.class));
	}
	// 排序
	sortpostprocessors(orderedpostprocessors, beanfactory);
	// 调用 beanfactorypostprocessor#postprocessbeanfactory 方法
	invokebeanfactorypostprocessors(orderedpostprocessors, beanfactory);

	/**
	 * 最后,调用所有其他 beanfactorypostprocessors
	 */
	list<beanfactorypostprocessor> nonorderedpostprocessors = new arraylist<>(nonorderedpostprocessornames.size());
	for (string postprocessorname : nonorderedpostprocessornames) {
		nonorderedpostprocessors.add(beanfactory.getbean(postprocessorname, beanfactorypostprocessor.class));
	}
	// 调用 beanfactorypostprocessor#postprocessbeanfactory 方法
	invokebeanfactorypostprocessors(nonorderedpostprocessors, beanfactory);
/** * 清除缓存的合并 bean 定义,因为后处理器可能已经修改了原始元数据,例如,替换值中的占位符 */ beanfactory.clearmetadatacache(); }

这里的 invokebeandefinitionregistrypostprocessors 方法比较重要,跟进去后最后调用的是 processconfigbeandefinitions 方法。

spring将处理 beandefinition 的工作委托给了 configurationclasspostprocessor  这个辅助类来完成

public void processconfigbeandefinitions(beandefinitionregistry registry) {

	list<beandefinitionholder> configcandidates = new arraylist<>();
	// 获取容器中注册的所有 beandefinition 名称
	/**
	 * annotatedbeandefinitionreader 扫描的 6 个
	 * 和初始化 spring 上下文环境时传入的一个配置类
	 */
	string[] candidatenames = registry.getbeandefinitionnames();

	/**
	 * 遍历获取需要解析的类
	 */
	for (string beanname : candidatenames) {
		// 获取 beandefinition
		beandefinition beandef = registry.getbeandefinition(beanname);
		/**
		 * 如果 beandefinition 中的 configurationclass 属性为 full 或者 lite,则表示已经处理过了,直接跳过
		 */
		if (beandef.getattribute(configurationclassutils.configuration_class_attribute) != null) {
			if (logger.isdebugenabled()) {
				logger.debug("bean definition has already been processed as a configuration class: " + beandef);
			}
		}
		// 否则判断是否是 @configuration 注解配置类,加了则通过校验,没加再判断是否加了以下注解
		/**
		 * 如果加了 @configuration 注解,会在后面再解析其他注解;如果没加,只会单独解析相应的注解
		 *
		 * 此时只有传进来的配置类会执行
		 */
		/**
		 * candidateindicators.add(component.class.getname());
		 * candidateindicators.add(componentscan.class.getname());
		 * candidateindicators.add(import.class.getname());
		 * candidateindicators.add(importresource.class.getname());
		 */
		else if (configurationclassutils.checkconfigurationclasscandidate(beandef, this.metadatareaderfactory)) {
			// 有的话就添加到 beandefinitionholder 集合中【此时传入的配置类会添加进集合中】
			configcandidates.add(new beandefinitionholder(beandef, beanname));
		}
	}

	// 如果没有发现其他的 @configuration 类就立即返回
	if (configcandidates.isempty()) {
		return;
	}

	// 按先前确定的 @order 值排序
	configcandidates.sort((bd1, bd2) -> {
		int i1 = configurationclassutils.getorder(bd1.getbeandefinition());
		int i2 = configurationclassutils.getorder(bd2.getbeandefinition());
		return integer.compare(i1, i2);
	});

	// detect any custom bean name generation strategy supplied through the enclosing application context
	/**
	 * 检测通过封闭的应用程序上下文提供的任何自定义 bean 名称生成策略
	 */
	singletonbeanregistry sbr = null;
	/**
	 * 如果 beandefinitionregistry 是 singletonbeanregistry 的子类
	 * 传入的是 defaultlistablebeanfactory 是 singletonbeanregistry 的子类
	 */
	if (registry instanceof singletonbeanregistry) {
		// 强转
		sbr = (singletonbeanregistry) registry;
		// 没有自定义的 name
		if (!this.localbeannamegeneratorset) {
			// 获取 beanname 生成器
			// singletonbeanregistry 中是否包含 beanname 为 internalconfigurationbeannamegenerator 的对象
			beannamegenerator generator = (beannamegenerator) sbr.getsingleton(
						annotationconfigutils.configuration_bean_name_generator);
			// 有则使用,没有则使用 spring 默认的
			if (generator != null) {
				this.componentscanbeannamegenerator = generator;
				this.importbeannamegenerator = generator;
			}
		}
	}

	// environment 为空则初始化为 standardenvironment
	if (this.environment == null) {
		this.environment = new standardenvironment();
	}

	// parse each @configuration class
	// 实例化 configurationclassparser 对象,用于解析每个 @configuration 类
	configurationclassparser parser = new configurationclassparser(
			this.metadatareaderfactory, this.problemreporter, this.environment,
			this.resourceloader, this.componentscanbeannamegenerator, registry);

	/**
	 * 定义两个集合
	 * candidates 集合用于将之前加入的 configcandidates 进行去重,因为可能有重复的配置类
	 * alreadyparsed 用于判断是否解析过
	 */
	set<beandefinitionholder> candidates = new linkedhashset<>(configcandidates);
	set<configurationclass> alreadyparsed = new hashset<>(configcandidates.size());
	do {
		/**
		 * 解析
		 */
		parser.parse(candidates);
		/**
		 * 验证
		 *
		 * 主要验证 @configuration 的 @bean 方法是否是静态和可覆盖的
		 * 静态则跳过验证
		 * @configuration 类中的实例 @bean 方法必须可以覆盖才能容纳cglib
		 */
		parser.validate();

		// 去重
		/**
		 * 此时加了注解的普通类已经注册完成,包括 @configuration 配置类
		 */
		set<configurationclass> configclasses = new linkedhashset<>(parser.getconfigurationclasses());
		// 移除所有已解析的
		configclasses.removeall(alreadyparsed);

		// read the model and create bean definitions based on its content
		// 读取模型并根据其内容创建 beandefinition
		if (this.reader == null) {
			// 实例化 configurationclassbeandefinitionreader 阅读器,用于创建 beandefinitions
			this.reader = new configurationclassbeandefinitionreader(
						registry, this.sourceextractor, this.resourceloader, this.environment,
						this.importbeannamegenerator, parser.getimportregistry());
		}

		// 加载 beandefinitions 存入集合中
		this.reader.loadbeandefinitions(configclasses);
		// 全部标记为已处理
		alreadyparsed.addall(configclasses);
		// 清空候选者集合,后面保存经过校验存在是配置类的候选者 并且 没有处理过
		candidates.clear();

		// 处理后工厂内的 beandefinition 数量大于处理前的数量
		if (registry.getbeandefinitioncount() > candidatenames.length) {
			// 处理后 beanfactory 中 beandefinitionnames 数据
			string[] newcandidatenames = registry.getbeandefinitionnames();
			// 处理前 beanfactory 中 beandefinitionnames 数据
			set<string> oldcandidatenames = new hashset<>(arrays.aslist(candidatenames));
			/**
			 * alreadyparsed + oldcandidatenames = newcandidatenames
			 */
			set<string> alreadyparsedclasses = new hashset<>();
			// 已处理的普通类添加到 alreadyparsedclasses 集合中
			for (configurationclass configurationclass : alreadyparsed) {
					alreadyparsedclasses.add(configurationclass.getmetadata().getclassname());
			}
			/**
			 * 循环遍历处理后的 beandefinitionnames
			 */
			for (string candidatename : newcandidatenames) {
				// 过滤出处理后的候选者中存在于处理前的候选者,即 alreadyparsed 中候选者
				// 为什么不直接遍历 alreadyparsed 集合,而是通过这种方式?
				// 可能是 spring 怕正在处理的时候,又手动添加了新的需要解析的类
				if (!oldcandidatenames.contains(candidatename)) {
					beandefinition bd = registry.getbeandefinition(candidatename);
					// 再次检查 beandefinition 是否是配置类的候选者 并且 没有处理过
					if (configurationclassutils.checkconfigurationclasscandidate(bd, this.metadatareaderfactory) &&
								!alreadyparsedclasses.contains(bd.getbeanclassname())) {
							candidates.add(new beandefinitionholder(bd, candidatename));
					}
				}
			}
			// 标记所有候选者已处理完成
			candidatenames = newcandidatenames;
		}
	}
	while (!candidates.isempty());

	// register the importregistry as a bean in order to support importaware @configuration classes
	/**
	 * 将 importregistry 注册为 bean 以支持 importaware 的 @configuration类
	 */
	if (sbr != null && !sbr.containssingleton(import_registry_bean_name)) {
		sbr.registersingleton(import_registry_bean_name, parser.getimportregistry());
	}

	// 如果是 cachingmetadatareaderfactory 的子类,这里会进入判断
	if (this.metadatareaderfactory instanceof cachingmetadatareaderfactory) {
		// clear cache in externally provided metadatareaderfactory; this is a no-op
		// for a shared cache since it'll be cleared by the applicationcontext.
		// 清除外部提供的 metadatareaderfactory 缓存
		// 这是一个无操作的共享缓存,因为它会通过applicationcontext中被清除
		((cachingmetadatareaderfactory) this.metadatareaderfactory).clearcache();
	}
}  

 解析的流程委托给了 configurationclassparser 这个类的parser方法来完成

public void parse(set<beandefinitionholder> configcandidates) {
	// 此时只有我们传入的配置类这一个元素
	// 根据 beandefinition 的类型做不同的处理
	for (beandefinitionholder holder : configcandidates) {
		// 获取 beandefinition
		beandefinition bd = holder.getbeandefinition();
		try {
			// 是 annotatedbeandefinition 的子类
			if (bd instanceof annotatedbeandefinition) {
				/**
				 * 解析注解对象,并存入 map<configurationclass, configurationclass> 集合中
				 * 但是这里的 beandefinition 是普通的
				 * 什么是不普通的呢?比如加了 @bean 和各种 beanfactorypostprocessor 得到的 beandefinition 不在这里存放
				 * 但是在这里解析,只是不存放而已
				 */
				parse(((annotatedbeandefinition) bd).getmetadata(), holder.getbeanname());
			}
			// 是 abstractbeandefinition 的子类
			else if (bd instanceof abstractbeandefinition && ((abstractbeandefinition) bd).hasbeanclass()) {
				parse(((abstractbeandefinition) bd).getbeanclass(), holder.getbeanname());
			} else {
				parse(bd.getbeanclassname(), holder.getbeanname());
			}
		} catch (beandefinitionstoreexception ex) {
			throw ex;
		} catch (throwable ex) {
			throw new beandefinitionstoreexception(
					"failed to parse configuration class [" + bd.getbeanclassname() + "]", ex);
		}
	}
	// 延迟导入处理类,执行流程暂时没跟,但是到后面的代码就重复了
	this.deferredimportselectorhandler.process();
}  

继续跟 parse 方法,最后执行的是 processconfigurationclass 方法,代码如下:

protected void processconfigurationclass(configurationclass configclass) throws ioexception {
	// 判断是否需要跳过
	if (this.conditionevaluator.shouldskip(configclass.getmetadata(), configurationphase.parse_configuration)) {
		return;
	}

	/**
	 * 是否已存在
	 *
	 * map<configurationclass, configurationclass> configurationclasses
	 * 是存放类之间相互引入的关系集合
	 */
	configurationclass existingclass = this.configurationclasses.get(configclass);
	if (existingclass != null) {
		// 如果当前类被别的类 @import,则做如下处理
		if (configclass.isimported()) {
			if (existingclass.isimported()) {
				existingclass.mergeimportedby(configclass);
			}
			// otherwise ignore new imported config class; existing non-imported class overrides it.
			// 否则忽略新导入的配置类; 现有的非导入类会覆盖它
			return;
		} else {
			// explicit bean definition found, probably replacing an import.
			// let's remove the old one and go with the new one.
			// 找到显式 beandefinition,可能替换导入,则删除旧的并使用新的
			this.configurationclasses.remove(configclass);
				this.knownsuperclasses.values().removeif(configclass::equals);
		}
	}

	// recursively process the configuration class and its superclass hierarchy.
	/**
	 * 递归处理配置类及其超类层次结构
	 */
	sourceclass sourceclass = assourceclass(configclass);
	do {
		sourceclass = doprocessconfigurationclass(configclass, sourceclass);
	}
	while (sourceclass != null);

	this.configurationclasses.put(configclass, configclass);
}  

 这里循环处理配置类,doprocessconfigurationclass 代码如下:

protected final sourceclass doprocessconfigurationclass(configurationclass configclass, sourceclass sourceclass)
			throws ioexception {
	// 是否加了 @component 注解,@configuration 注解同样适用
	if (configclass.getmetadata().isannotated(component.class.getname())) {
		// recursively process any member (nested) classes first
		/**
		 * 首先递归处理任何成员(嵌套)类
		 * 处理内部类
		 */
		processmemberclasses(configclass, sourceclass);
	}

	// process any @propertysource annotations
	/**
	 * 处理 @propertysource 注解
	 */
	for (annotationattributes propertysource : annotationconfigutils.attributesforrepeatable(
			sourceclass.getmetadata(), propertysources.class,
				org.springframework.context.annotation.propertysource.class)) {
		if (this.environment instanceof configurableenvironment) {
			processpropertysource(propertysource);
		} else {
			logger.info("ignoring @propertysource annotation on [" + sourceclass.getmetadata().getclassname() +
					"]. reason: environment must implement configurableenvironment");
		}
	}

	// process any @componentscan annotations
	/**
	 * 获取 @componentscan 注解数据
	 *
	 * 处理 @componentscan 注解
	 * 扫描路径下加了 @component 注解的类,并存入 beandefinitionmap 中
	 */
	set<annotationattributes> componentscans = annotationconfigutils.attributesforrepeatable(
			sourceclass.getmetadata(), componentscans.class, componentscan.class);
	// 判断是否需要处理
	if (!componentscans.isempty() &&
				!this.conditionevaluator.shouldskip(sourceclass.getmetadata(), configurationphase.register_bean)) {
		// 是个集合,循环遍历
		for (annotationattributes componentscan : componentscans) {
			// the config class is annotated with @componentscan -> perform the scan immediately
			/**
			 * 扫描 @componentscan 路径下符合过滤器和候选者条件的类
			 * 转换为 beandefinitionholder,并注册到 beanfactory 中
			 *
			 * 可以理解为扫描 @componentscan 路径下加了 @configuration、@component、@service 等的类
			 */
			set<beandefinitionholder> scannedbeandefinitions =
						this.componentscanparser.parse(componentscan, sourceclass.getmetadata().getclassname());
			// check the set of scanned definitions for any further config classes and parse recursively if needed
			/**
			 * 检查扫描出来的类当中是否还有 configuration 类
			 */
			for (beandefinitionholder holder : scannedbeandefinitions) {
				// 获取原始 beandefinition
				beandefinition bdcand = holder.getbeandefinition().getoriginatingbeandefinition();
				if (bdcand == null) {
					bdcand = holder.getbeandefinition();
				}
				// 检查给定的 beandefinition 是否是配置类的候选者
				if (configurationclassutils.checkconfigurationclasscandidate(bdcand, this.metadatareaderfactory)) {
					parse(bdcand.getbeanclassname(), holder.getbeanname());
				}
			}
		}
	}

	// process any @import annotations
	// springboot 很多 enablexxx 都是基于 @import 注解来实现灵活配置的
	/**
	 * 处理 @import 注解
	 * 可以引入 @configuration 类,importselector 类,importbeandefinitionregistrar 类
	 *
	 * 解析 @import 注解引入的类,importselector 类、importbeandefinitionregistrar 类和 @configuration 类作相应的处理
	 * importselector 类需要递归处理
	 * importbeandefinitionregistrar 类存入 map<importbeandefinitionregistrar, annotationmetadata> importbeandefinitionregistrars 集合中
	 * @configuration 类存入 map<configurationclass, configurationclass> configurationclasses 集合中
	 *
	 * importselector 的实现类可以动态实例化一个 beandefinition 到 ioc 容器中
	 */
	processimports(configclass, sourceclass, getimports(sourceclass), true);

	// process any @importresource annotations
	// 处理 @importresource 注解
	annotationattributes importresource =
				annotationconfigutils.attributesfor(sourceclass.getmetadata(), importresource.class);
	if (importresource != null) {
		string[] resources = importresource.getstringarray("locations");
		class<? extends beandefinitionreader> readerclass = importresource.getclass("reader");
		for (string resource : resources) {
			string resolvedresource = this.environment.resolverequiredplaceholders(resource);
			configclass.addimportedresource(resolvedresource, readerclass);
		}
	}

	// process individual @bean methods
	// 处理每个 @bean 注解方法
	set<methodmetadata> beanmethods = retrievebeanmethodmetadata(sourceclass);
	for (methodmetadata methodmetadata : beanmethods) {
		configclass.addbeanmethod(new beanmethod(methodmetadata, configclass));
	}

	// process default methods on interfaces
	// 处理接口上的默认方法
	processinterfaces(configclass, sourceclass);

	// process superclass, if any
	// 如果有父类则处理
	if (sourceclass.getmetadata().hassuperclass()) {
		string superclass = sourceclass.getmetadata().getsuperclassname();
		// 排除 java.lang.object 的父类且不存在于 knownsuperclasses 集合中
		if (superclass != null && !superclass.startswith("java") &&
				!this.knownsuperclasses.containskey(superclass)) {
				this.knownsuperclasses.put(superclass, configclass);
			// superclass found, return its annotation metadata and recurse
			// 找到超类,返回其注释元数据并递归
			return sourceclass.getsuperclass();
		}
	}

	// no superclass -> processing is complete
	return null;
}  

这里 this.componentscanparser.parse 方法和 processimports 方法都是比较重要的方法,尤其是  processimports 方法。springboot很多enablexxx注解都是使用了spring的importbeandefinitionregistrar 这个类来实现动态注册的,这是spring提供的扩展点,以后会写一篇详细的博文和示例来说明,这里就先跳过,跟一下 this.componentscanparser.parse 方法:

public set<beandefinitionholder> parse(annotationattributes componentscan, final string declaringclass) {
	/**
	 * 此时又实例化了一个 classpathbeandefinitionscanner
	 * 并没有使用 annotationconfigapplicationcontext 构造方法中实例化的 classpathbeandefinitionscanner
	 */
	classpathbeandefinitionscanner scanner = new classpathbeandefinitionscanner(this.registry,
			componentscan.getboolean("usedefaultfilters"), this.environment, this.resourceloader);

	// 获取 beanname 生成器
	class<? extends beannamegenerator> generatorclass = componentscan.getclass("namegenerator");
	boolean useinheritedgenerator = (beannamegenerator.class == generatorclass);

	scanner.setbeannamegenerator(useinheritedgenerator ? this.beannamegenerator :
				beanutils.instantiateclass(generatorclass));

	// 处理代理模型
	scopedproxymode scopedproxymode = componentscan.getenum("scopedproxy");
	if (scopedproxymode != scopedproxymode.default) {
		scanner.setscopedproxymode(scopedproxymode);
	} else {
		class<? extends scopemetadataresolver> resolverclass = componentscan.getclass("scoperesolver");
			scanner.setscopemetadataresolver(beanutils.instantiateclass(resolverclass));
	}

	scanner.setresourcepattern(componentscan.getstring("resourcepattern"));

	/**
	 * 遍历 @componentscan 中的 includefilters
	 * 获取符合组件扫描的条件的类型
	 * filter[] includefilters() default {};
	 */
	for (annotationattributes filter : componentscan.getannotationarray("includefilters")) {
		for (typefilter typefilter : typefiltersfor(filter)) {
			scanner.addincludefilter(typefilter);
		}
	}

	/**
	 * 遍历 @componentscan 中的 excludefilters
	 * 获取不符合组件扫描的条件的类型
	 * filter[] excludefilters() default {};
	 */
	for (annotationattributes filter : componentscan.getannotationarray("excludefilters")) {
		for (typefilter typefilter : typefiltersfor(filter)) {
			scanner.addexcludefilter(typefilter);
		}
	}

	/**
	 * 获取 @componentscan 中的 lazyinit
	 * 默认不是懒加载
	 * 如果是懒加载,则修改 beandefinitiondefaults 的懒加载属性值为 true,而不是修改 beandefinition 的懒加载属性值为 true
	 * 为后面应用默认值提供便利
	 * boolean lazyinit() default false;
	 */
	boolean lazyinit = componentscan.getboolean("lazyinit");
	if (lazyinit) {
		scanner.getbeandefinitiondefaults().setlazyinit(true);
	}

	// 去重存储扫描的包路径
	set<string> basepackages = new linkedhashset<>();
	/**
	 * 获取 @componentscan 中的 basepackages()
	 * string[] basepackages() default {};
	 */
	string[] basepackagesarray = componentscan.getstringarray("basepackages");
	// 循环遍历
	for (string pkg : basepackagesarray) {
		// 处理逗号、分号、回车和换行符
		string[] tokenized = stringutils.tokenizetostringarray(this.environment.resolveplaceholders(pkg),
					configurableapplicationcontext.config_location_delimiters);
		collections.addall(basepackages, tokenized);
	}
	/**
	 * 获取 @componentscan 中的 basepackageclasses
	 * class<?>[] basepackageclasses() default {};
	 */
	for (class<?> clazz : componentscan.getclassarray("basepackageclasses")) {
		basepackages.add(classutils.getpackagename(clazz));
	}

	// 如果没有注明扫描路径,则默认扫描 @configuration 类所在包及其子包
	if (basepackages.isempty()) {
			basepackages.add(classutils.getpackagename(declaringclass));
	}

	scanner.addexcludefilter(new abstracttypehierarchytraversingfilter(false, false) {
		@override
		protected boolean matchclassname(string classname) {
			return declaringclass.equals(classname);
		}
	});

	return scanner.doscan(stringutils.tostringarray(basepackages));
}  

话不多说,scanner.doscan 方法跟进去就完事了

protected set<beandefinitionholder> doscan(string... basepackages) {
		
	set<beandefinitionholder> beandefinitions = new linkedhashset<>();
	// 循环扫描 basepackage 路径下的文件,即 @componentscan 注解的 value 或 basepackages 值
	for (string basepackage : basepackages) {
		/**
		 * 加了注解且符合条件则转换为 beandefinition
		 *
		 * annotatedgenericbeandefinition 或 scannedgenericbeandefinition
		 * annotatedgenericbeandefinition 和 scannedgenericbeandefinition 都是 abstractbeandefinition 的子类
		 * 这里都转换成了 scannedgenericbeandefinition
		 */
		set<beandefinition> candidates = findcandidatecomponents(basepackage);

		for (beandefinition candidate : candidates) {
			// 解析 scope 属性
			scopemetadata scopemetadata = this.scopemetadataresolver.resolvescopemetadata(candidate);
			candidate.setscope(scopemetadata.getscopename());
			// 使用 beanname 生成器获取候选者的 beanname
			string beanname = this.beannamegenerator.generatebeanname(candidate, this.registry);
			/**
			 * 如果这个类是 abstractbeandefinition 的子类
			 *
			 * 此时会进入这个判断
			 *
			 * public class scannedgenericbeandefinition extends genericbeandefinition implements annotatedbeandefinition
			 * public class annotatedgenericbeandefinition extends genericbeandefinition implements annotatedbeandefinition
			 * public class genericbeandefinition extends abstractbeandefinition
			 *
			 * 而被 @componentscan 注解扫描后的类都变成了 scannedgenericbeandefinition 或 annotatedgenericbeandefinition
			 *
			 * 基本上都是 abstractbeandefinition 的子类
			 * 即先将 beandefinitiondefaults 的值赋给候选 beandefinition
			 */
			if (candidate instanceof abstractbeandefinition) {
				/**
				 * 应用如下默认值:
				 * 		setlazyinit(lazyinit);
				 * 		setautowiremode(defaults.getautowiremode());
				 * 		setdependencycheck(defaults.getdependencycheck());
				 * 		setinitmethodname(defaults.getinitmethodname());
				 * 		setenforceinitmethod(false);
				 * 		setdestroymethodname(defaults.getdestroymethodname());
				 * 		setenforcedestroymethod(false);
				 */
				postprocessbeandefinition((abstractbeandefinition) candidate, beanname);
			}
			/**
			 * 如果这个类是 annotatedbeandefinition 的子类
			 *
			 * scannedgenericbeandefinition 或 annotatedgenericbeandefinition 也是 annotatedbeandefinition 的子类
			 *
			 * 这个判断也会进,即跑完上一步时已经具有了默认值,但是用户可能单独为这个类配置了注解值
			 * 再将扫描到的注解值赋给候选 beandefinition
			 */
			if (candidate instanceof annotatedbeandefinition) {
				/**
				 * 处理自定义注解的值
				 * 包含的注解有 @lazy,@primary,@dependson,@role,@description
				 */
				annotationconfigutils.processcommondefinitionannotations((annotatedbeandefinition) candidate);
			}
			/**
			 * 检查给定候选者的 beanname
			 *
			 * 1、是否存在于 beanfactory 中,如果不存在则直接返回为 true
			 * 2、校验存在的和现有的 beandefinition 是否兼容,兼容则返回 false
			 * 3、抛异常
			 *
			 * 此时刚进行扫描,并没有注册到 beanfactory 中,所以一般会进
			 */
			if (checkcandidate(beanname, candidate)) {
				// 转换为 beandefinitionholder
				beandefinitionholder definitionholder = new beandefinitionholder(candidate, beanname);
				// 应用代理模式
				definitionholder = annotationconfigutils.applyscopedproxymode(scopemetadata, definitionholder, this.registry);
				beandefinitions.add(definitionholder);
				/**
				 * 由 bean 的主要名称和别名注册 beandefinition
				 *
				 * 将 beandefinition 加入 map<string, beandefinition>【主名】 和 map<string, string>【别名】 集合中
				 */
				registerbeandefinition(definitionholder, this.registry);
			}
		}
	}

	return beandefinitions;
}  

而 registerbeandefinition 方法跟进去与我们上一篇探究的代码一样,这里就不再赘述了。

到这里 invokebeanfactorypostprocessors 方法就执行完成了,没执行之前 defaultlistablebeanfactory 中的 beandefinitionmap 中的数据如下

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

 执行完后,我们的@service,@component,@bean,@import等注解类都已经注册到 bean 工厂中

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

 

下一篇解析 refresh 中另一个重要的方法 finishbeanfactoryinitialization

在spring的方法名中包含了很多 initialization 和 instantiation 这两个单词,一个是初始化,一个是实例化

beanpostprocessor 的直接实现类能够干预 bean 的初始化过程,比如 applicationcontextawareprocessor

beanpostprocessor 的继承类能够干预 bean 的实例化过程,比如 smartinstantiationawarebeanpostprocessor

这个先提一下,以后再详细说,希望坚持写下去。