6-Spring源码解析之register——register(annotatedClasses)注册配置类

上一篇：5-Spring源码解析之this()(2)——ClassPathBeanDefinitionScanner
上一篇我们讲到执行完this()方法

	public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
		// 1. 首先初始化Spring的7个内置Bean后置处理器，并放到 DefaultListableBeanFactory 类型的对象 beanFactory 中
		// 2. 创建Spring的注解解析器 Component
		this();
		// 传入的配置类annotatedClasses，生成BeanDefinition，然后将BeanDefinition注册到DefaultListableBeanFactory 类型的对象 beanFactory 中
		register(annotatedClasses);
		refresh();
	}

1. AnnotationConfigApplicationContext类的register()方法

	public void register(Class<?>... annotatedClasses) {
		Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified");
		this.reader.register(annotatedClasses);
	}

从上述代码的参数中可以看出该方法可以传入多个配置类。
该方法的功能：注册一个或者多个带有注解的配置类

	public void register(Class<?>... annotatedClasses) {
		for (Class<?> annotatedClass : annotatedClasses) {
			registerBean(annotatedClass);
		}
	}

	public void registerBean(Class<?> annotatedClass) {
		registerBean(annotatedClass, null, (Class<? extends Annotation>[]) null);
	}

下面进入了关键的代码段。

	// 根据给定的class来注册一个bean
	public void registerBean(Class<?> annotatedClass, String name, Class<? extends Annotation>... qualifiers) {
		// 根据传入的annotatedClass生成AnnotatedGenericBeanDefinition。AnnotatedGenericBeanDefinition是BeanDefinition的一个实现类。类图在4.补充图片中的图1中。
		AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
		// 根据 @cONditional注解来判断是否要跳过解析
		if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
			return;
		}

		// 获取类的作用域，默认为Singleton
		ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
		// 将类的作用域添加到AnnotatedGenericBeanDefinition的数据结构中
		abd.setScope(scopeMetadata.getScopeName());
		String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));

		// 【1】1.1中补充介绍
		// 处理配置类中的通用注解，即Lazy、DependsOn、Primary和Role等，将处理的结果放到AnnotatedGenericBeanDefinition的数据结构中
		AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
		//  依次判断了注解当中是否包含了Primary、Lazy、qualifier，如果包含就设置AnnotatedGenericBeanDefinition对应的属性
		if (qualifiers != null) {
			for (Class<? extends Annotation> qualifier : qualifiers) {
				if (Primary.class == qualifier) {
					abd.setPrimary(true);
				}
				else if (Lazy.class == qualifier) {
					abd.setLazyInit(true);
				}
				else {
					abd.addQualifier(new AutowireCandidateQualifier(qualifier));
				}
			}
		}
		// 将AnnotatedGenericBeanDefinition和他对应的beanName存储到BeanDefinitionHolder中的对应属性中
		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
		// 
		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
		
		// 将 BeanDefinitionHolder 注册给 this.registry 即 AnnotationConfigApplicationContext。
		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
	}

1.1 processCommonDefinitionAnnotations方法

	public static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd) {
		processCommonDefinitionAnnotations(abd, abd.getMetadata());
	}
	
	public final AnnotationMetadata getMetadata() {
		 return this.metadata;
	}


	// 检查通用的注解，将存在的注解添加到AnnotatedBeanDefinition中
	static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
		// 判断Lazy
		if (metadata.isAnnotated(Lazy.class.getName())) {
			abd.setLazyInit(attributesFor(metadata, Lazy.class).getBoolean("value"));
		}
		// 判断metadata 和 Lazy
		else if (abd.getMetadata() != metadata && abd.getMetadata().isAnnotated(Lazy.class.getName())) {
			abd.setLazyInit(attributesFor(abd.getMetadata(), Lazy.class).getBoolean("value"));
		}
		// 判断Primary
		if (metadata.isAnnotated(Primary.class.getName())) {
			abd.setPrimary(true);
		}
		// 判断DependsOn
		if (metadata.isAnnotated(DependsOn.class.getName())) {
			abd.setDependsOn(attributesFor(metadata, DependsOn.class).getStringArray("value"));
		}

		if (abd instanceof AbstractBeanDefinition) {
			AbstractBeanDefinition absBd = (AbstractBeanDefinition) abd;
			if (metadata.isAnnotated(Role.class.getName())) {
				absBd.setRole(attributesFor(metadata, Role.class).getNumber("value").intValue());
			}
			if (metadata.isAnnotated(Description.class.getName())) {
				absBd.setDescription(attributesFor(metadata, Description.class).getString("value"));
			}
		}
	}

2. registerBeanDefinition方法

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

		// Register bean definition under primary name.
		String beanName = definitionHolder.getBeanName();
		// 获取到的是配置类的BeanDefinition
		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

		// Register aliases for bean name, if any.
		String[] aliases = definitionHolder.getAliases();
		if (aliases != null) {
			for (String alias : aliases) {
				registry.registerAlias(beanName, alias);
			}
		}
	}

	public BeanDefinition getBeanDefinition() {
		return this.beanDefinition;
	}

3. register的执行结果

执行完以上的步骤后，register方法就执行完成了，执行完成后，Spring容器的beanFactory中除了有在this()构造方法中增加的7个（目前为6个，因为没有引入jpa依赖）还增加了配置类的Bean。

其中最后一个mainConfig就是我们传入的配置类。可以追溯到最初的代码：

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);

4. 补充图片

1. 图1
   

5. 总结

	public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
		// 1. 首先初始化Spring的7个内置Bean后置处理器，并放到 DefaultListableBeanFactory 类型的对象 beanFactory 中
		// 2. 创建Spring的注解解析器 Component
		this();
		// 传入的配置类annotatedClasses，生成BeanDefinition，然后将BeanDefinition注册到DefaultListableBeanFactory 类型的对象 beanFactory 中
		register(annotatedClasses);
		refresh();
	}

1. 在执行完register(annotatedClasses);方法后，我们传入的配置类信息就会保存到Spring容器的beanFactory中。至此，Spring容器中包含了7个类信息。（6个内置后置处理器类，一个配置类）。