spring（三）-----register方法注册一个bean

此文章只介绍使用register方法注册一个bean对象

		AnnotationConfigApplicationContext ac=new AnnotationConfigApplicationContext();
		ac.register(Appconfig.class);
		ac.refresh();

大家都知道使用ac.register的方法去注册一个bean。那么这个bean是如何注册的呢？下面就通过源码分析。
首先我们将我们自己写的类的class（Appconfig.class）使用register的方式注册进去。跟前面的scan方法相似，register使用实例化好的reader去注册一个bean，若是前面遗忘了可以看下面的代码。

	public AnnotationConfigApplicationContext() {
		//读取已注解的定义，实例化一个AnnotatedBeanDefinitionReader，主要作用就是初始化环境
		this.reader = new AnnotatedBeanDefinitionReader(this);
		//这里仅仅是获得扫描器
		//能够扫描BeanDefinition,能够扫描一个类，并且转换成BeanDefinition
		//但是实际上我们扫描包工作不是scanner这个对象来完成的
		//是spring自己new的一个ClassPathBeanDefinitionScanner
		//这里的scanner仅仅是为了程序员能够在外部调用AnnotationConfigApplicationContext对象的scan方法
		//测试可以使用scan方法跟进
		this.scanner = new ClassPathBeanDefinitionScanner(this);
	}

前面提到过在初始化环境的时候会存在reader和scanner对象。而register方法如下：

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

这个方法调用了reader的register方法，经过层层调用，最终起作用的方法在org.springframework.context.annotation.AnnotatedBeanDefinitionReader#doRegisterBean中体现。

	/**
	 * Register a bean from the given bean class, deriving its metadata from
	 * class-declared annotations.
	 * @param beanClass the class of the bean
	 * @param name an explicit name for the bean
	 * @param qualifiers specific qualifier annotations to consider, if any,
	 * in addition to qualifiers at the bean class level
	 * @param supplier a callback for creating an instance of the bean
	 * (may be {@code null})
	 * @param customizers one or more callbacks for customizing the factory's
	 * {@link BeanDefinition}, e.g. setting a lazy-init or primary flag
	 * @since 5.0
	 */
	private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
			@Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
			@Nullable BeanDefinitionCustomizer[] customizers) {
		//创建AnnotatedGenericBeanDefinition，包含了类的其它信息，比如元数据，scope，lazy，autowired。
		AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
		//里面有个重载函数，判断metadata == null || !metadata.isAnnotated(Conditional.class.getName())是否成立。是则返回false
		if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
			return;
		}
		//设置实例提供者？？目前没看懂，不重要
		abd.setInstanceSupplier(supplier);
		//ScopeMetadata是对@Scope的描述转换，以此得到作用域
		ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
		abd.setScope(scopeMetadata.getScopeName());
		//beanNameGenerator--->bean名字生成器
		String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
		//处理注解Bean定义类中通用的注解，主要处理Lazy DependsOn Primary Role等等注解
		AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
		//按照目前传参一直为空。程序员无法直接给其传参，可能是spring内部调用。
		//由上面的英文注释可知若使用了额外的限定符注解则解析。
		//由下面可知在循环数组。此处判断了是否存在@Primary和@Lazy注解。
		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 {
					//除@Primary和@Lazy以外的其他注解，则为该Bean添加一个根据名字自动装配的限定符
					//这里需要后面介绍
					abd.addQualifier(new AutowireCandidateQualifier(qualifier));
				}
			}
		}
		if (customizers != null) {
			for (BeanDefinitionCustomizer customizer : customizers) {
				customizer.customize(abd);
			}
		}
		//definitionHolder存beanDefinition，beanName，aliases。基本使用前两个。
		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
		//根据注解Bean定义类中配置的作用域，创建相应的代理对象。scopeMetadata就对应了@Scope，判断是否使用代理，CGLIB代理还是JDK动态代理还是不适用代理
		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
		//将definitionHolder注册到注册器中
		BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
	}

从最后一行可以看出我们得普通类经过转换已经put到了map中，此时还没开始实例化，仅仅只是保存了这个bean。且什么时候开始扫描包也还没有开始。这些需要到refresh中学习。

再说说这个方法：AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);

	//判断注解类型
	static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) {
		AnnotationAttributes lazy = attributesFor(metadata, Lazy.class);
		//确认是否是懒加载
		if (lazy != null) {
			abd.setLazyInit(lazy.getBoolean("value"));
		}
		else if (abd.getMetadata() != metadata) {//一般都不成立
			lazy = attributesFor(abd.getMetadata(), Lazy.class);
			if (lazy != null) {
				abd.setLazyInit(lazy.getBoolean("value"));
			}
		}
		//@Primary注解
		if (metadata.isAnnotated(Primary.class.getName())) {
			abd.setPrimary(true);
		}
		//@DependsOn注解
		AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);
		if (dependsOn != null) {
			abd.setDependsOn(dependsOn.getStringArray("value"));
		}
		//@Role
		AnnotationAttributes role = attributesFor(metadata, Role.class);
		if (role != null) {
			abd.setRole(role.getNumber("value").intValue());
		}
		//@Description
		AnnotationAttributes description = attributesFor(metadata, Description.class);
		if (description != null) {
			abd.setDescription(description.getString("value"));
		}
	}

就是把注解拿出来并将其设置到AnnotatedBeanDefinition的属性中。