【二】Spring IoC 最全源码详解之 register

如果我有８小时的时间砍一棵树，我就会花费６小时磨利自己的斧子。”

——亚伯拉罕·林肯

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
	this();
        //本节分析的步骤
	register(annotatedClasses);
	refresh();
}

上一节结束了Spring容器创建过程的分析，本节就是容器的初始化工作register(annotatedClasses)。

@EnableAutoConfiguration
@ComponentScan("com.Hodey")
public class CaseApplication {
	public static void main(String[] args) {
		AnnotationConfigApplicationContext ctx =
				new AnnotationConfigApplicationContext(CaseApplication.class);
		GardenofEden garden = ctx.getBean(GardenofEden.class);
		garden.sayHello();
	}
}

容器的初始化需要用户提供一个配置类，容器会将配置类进行注册。这个类一般情况下，就是你的启动类。Spring是支持用户提供多个配置类进行注册的，这里我们仅注册了一个配置类CaseApplication.class。这样在做doRegisterBean的时候传参等同于doRegisterBean(AutoInject.class, null, null, null);进入doRegisterBean方法(BeanDefinitionCustomizer... definitionCustomizers是可选参数).

<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
		@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {

	//1.将CaseApplication.class解析后成为一个注解类型的bd。
	AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
	if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
		return;
	}

	abd.setInstanceSupplier(instanceSupplier);

	//2.得出abd的scope属性。
	ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
	abd.setScope(scopeMetadata.getScopeName());
	String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));

	//3.通用注解的解析
	AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
	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));
			}
		}
	}

	//4.自定义注解解析
	for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
		customizer.customize(abd);
	}

	//holder仅仅是对beanDefinition， beanName, aliases封装在一起便于传参而已。
	BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);

	//如果该类需要使用代理，则会在bd上打上一些特有的标记，以便在后续bean实例化过程中使用。不适用 
        //代理则直接返回原始的bd
	definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);

        //5.向容器注册bd(本节最关键步骤)
	BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}

第一步是将CaseApplication.class解析后成为一个注解类型的bd。过程是分别初始化父类AbstractBeanDefinition的成员。然后将CaseApplication.class全限定名com.Hodey.learn.CaseApplication设置到abd的beanClass属性上。再创建一个StandardAnnotationMetadata对象赋给metadata属性，这个并不重要。然后通过conditionEvaluator对象提供的shouldSkip判断当前bd是否可以跳过解析。跳过的依据是该类是否有@Conditional注解，如果含有则返回true。

第二步是得到abd的scope属性。比如将CaseApplication.class是单例的，并且不使用代理行为。

第三步是对通用注解的解析工作。通用注解包括@Lazy， @Primay, @DependsOn, @Role, @Description。

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

	if (metadata.isAnnotated(Primary.class.getName())) {
		abd.setPrimary(true);
	}
	AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class);
	if (dependsOn != null) {
		abd.setDependsOn(dependsOn.getStringArray("value"));
	}

	AnnotationAttributes role = attributesFor(metadata, Role.class);
	if (role != null) {
		abd.setRole(role.getNumber("value").intValue());
	}
	AnnotationAttributes description = attributesFor(metadata, Description.class);
	if (description != null) {
		abd.setDescription(description.getString("value"));
	}
}

深入进去看，解析注解的核心方法是searchWithGetSemantics方法簇。由于CaseApplication.class的注解仅有@ComponentScan，并且不存在嵌套类的注解，所以在解析上述注解时都会跳过。若存在嵌套类，则会进行递归解析。searchWithGetSemantics方法簇如下：

searchWithGetSemantics(AnnotatedElement, Class<? extends Annotation>, String, Processor<T>)
searchWithGetSemantics(AnnotatedElement, Set<Class<? extends Annotation>>, String, Class<? extends Annotation>, Processor<T>)
searchWithGetSemantics(AnnotatedElement, Set<Class<? extends Annotation>>, String, Class<? extends Annotation>, Processor<T>, Set<AnnotatedElement>, int)
searchWithGetSemanticsInAnnotations(AnnotatedElement, List<Annotation>, Set<Class<? extends Annotation>>, String, Class<? extends Annotation>, Processor<T>, Set<AnnotatedElement>, ...)

第四步是自定义注解解析。由于我没有定义自定义注解，所以该流程不会执行。

第五步，是最关键的一步。接下来我们进行详细分析。干货是在registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition())这一步。

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

	// 又从刚刚将bd, beanName和aliases一起封装的holder中解封出beanName，你说Spring是不是有病？！
	String beanName = definitionHolder.getBeanName();
        //重点
	registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

	// 别名注册。如果有别名，则会注册到bean工厂的aliasMap<beanName, aliase>上。
	String[] aliases = definitionHolder.getAliases();
	if (aliases != null) {
		for (String alias : aliases) {
			registry.registerAlias(beanName, alias);
		}
	}
}

首先对传入的bd进行合法性检查，如果检查失败则不会注册该bd。然后看看容器中是否已经存在该bd，若存在并且该bean允许被后来的同名bd覆盖，则直接覆盖。否则进入到else分支中。else分支中第一个过滤条件是处理并发注册bd的情况，如果存在则在锁内进行bd注册，否则直接向DefaultListableBeanFactory的beanDefinitionMap中注册bd即可。最后为了保险起见，如果该bd是声明为Singleton的bean，则需要重新注册一遍该类与其派生类的bd。在替换或删除现有bean定义之后调用，从而触发给定bean上的 clearMergedBeanDefinition、destroySingleton和resetBeanDefinition，以及所有将给定bean作为父bean的bd。完成后返回registerBeanDefinition中进行别名(aliases)的注册。

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {

	// bd的合法性检查，还未见过出错的情况
	if (beanDefinition instanceof AbstractBeanDefinition) {
		try {
			((AbstractBeanDefinition) beanDefinition).validate();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
					"Validation of bean definition failed", ex);
		}
	}

	//从bean工厂的bdmap中看看有没有我们需要注册的bd。因为这里是第一次进来，并且没有并发的情况发生，有就闯鬼了！所以进入else分支。
	BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
	if (existingDefinition != null) {
		if (!isAllowBeanDefinitionOverriding()) {
			throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
		}
		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 + "]");
			}
		}
		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 + "]");
			}
		}
		this.beanDefinitionMap.put(beanName, beanDefinition);
	}
	else {
		//在同一时间是否有另外的线程已经在创建这个bean了？一般不会。
		if (hasBeanCreationStarted()) {
			// Cannot modify startup-time collection elements anymore (for stable iteration)
			synchronized (this.beanDefinitionMap) {
				this.beanDefinitionMap.put(beanName, beanDefinition);
				List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
				updatedDefinitions.addAll(this.beanDefinitionNames);
				updatedDefinitions.add(beanName);
				this.beanDefinitionNames = updatedDefinitions;
				if (this.manualSingletonNames.contains(beanName)) {
					Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
					updatedSingletons.remove(beanName);
					this.manualSingletonNames = updatedSingletons;
				}
			}
		}
		else {
			//向bean工厂beanDefinitionMap中注册<beanName, beanDefinition>
			this.beanDefinitionMap.put(beanName, beanDefinition);
			//向bean工厂beanDefinitionNames(list)中添加beanName
			this.beanDefinitionNames.add(beanName);
			//如果beanName还出现在通过手动注册的链表中，则将其移除。
			this.manualSingletonNames.remove(beanName);
		}
		this.frozenBeanDefinitionNames = null;
	}

	//走到这里发现该beanName之前已经被注册，或者是单例的，则需要重置该bean，用新的覆盖旧的。
	if (existingDefinition != null || containsSingleton(beanName)) {
		resetBeanDefinition(beanName);
	}
}

到此，就完成了容器启动的配置类注册。

0 = "org.springframework.context.annotation.internalConfigurationAnnotationProcessor"
1 = "org.springframework.context.annotation.internalAutowiredAnnotationProcessor"
2 = "org.springframework.context.annotation.internalCommonAnnotationProcessor"
3 = "org.springframework.context.event.internalEventListenerProcessor"
4 = "org.springframework.context.event.internalEventListenerFactory"
5 = "caseApplication"

如果将00:00-7:00的时刻表映射到Sping的启动流程的话，目前的时间大致应该是在01:00左右。下一节，我们将开始分析refresh方法，讲述bean的实例化过程。

【二】Spring IoC 最全源码详解之 register

猜你喜欢