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

上一篇看完了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 中的数据如下

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

 

 

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

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

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

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

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