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

public class genericapplicationcontext extends abstractapplicationcontext implements beandefinitionregistry {

	private final defaultlistablebeanfactory beanfactory;

	/**
	 * 注意这个无参构造函数
         *
         * 这个初始化的defaultlistablebeanfactory就是spring的bean工厂
	 */
	public genericapplicationcontext() {
　　　　　　　　this.beanfactory = new defaultlistablebeanfactory();
	}
}        

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

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

/**
 * 将给定的 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);
	}
}