Spring 5.x 源码之旅八ConfigurationClassParser验证配置类以及加载bean定义

ConfigurationClassParser的validate

为什么要讲这个，因为这里涉及到一个CGLIB动态代理的条件问题，GCLIB的代理原理是继承目标类，覆盖相应的方法，可能还有一些方法拦截器，所以对类和方法是有要求的。
所以他会进行配置类的遍历验证

	public void validate() {
		for (ConfigurationClass configClass : this.configurationClasses.keySet()) {
			configClass.validate(this.problemReporter);
		}
	}

ConfigurationClass的validate

具体验证是交给ConfigurationClass自身方法的。这里就是我们所说的Configuration注解的重要作用，可以进行类代理的增强。如果是Configuration注解的，默认proxyBeanMethods=true，后面就会进行GCLIB代理增强，所以这里要验证下元数据里有没有final修饰类，因为final修饰类是不可以被继承的，同时还要验证下所有的bean方法是可以被覆盖的。

	//进行验证，如果是proxyBeanMethods=true，默认用GCLIB做代理，是继承的，所以不可以是final类
	public void validate(ProblemReporter problemReporter) {
		// A configuration class may not be final (CGLIB limitation) unless it declares proxyBeanMethods=false
		Map<String, Object> attributes = this.metadata.getAnnotationAttributes(Configuration.class.getName());
		if (attributes != null && (Boolean) attributes.get("proxyBeanMethods")) {//要GCLIB代理
			if (this.metadata.isFinal()) {//配置类不可以是final的
				problemReporter.error(new FinalConfigurationProblem());
			}
			for (BeanMethod beanMethod : this.beanMethods) {
				beanMethod.validate(problemReporter);//验证方法可覆盖
			}
		}
	}

BeanMethod的validate

这里就是验证bean注解的方法，如果是静态的，就没关系，立即返回，否则的话要判断是否可以覆盖。

@Override
	public void validate(ProblemReporter problemReporter) {
		if (getMetadata().isStatic()) {//静态方法属于类的，不管
			// static @Bean methods have no constraints to validate -> return immediately
			return;
		}

		if (this.configurationClass.getMetadata().isAnnotated(Configuration.class.getName())) {
			if (!getMetadata().isOverridable()) {//不能覆盖的话，也报错，因为不能GCLIB覆盖啦
				// instance @Bean methods within @Configuration classes must be overridable to accommodate CGLIB
				problemReporter.error(new NonOverridableMethodError());
			}
		}
	}
	//可以覆盖的条件，非静态且非final且不是私有的
	@Override
	public boolean isOverridable() {
		return !isStatic() && !isFinal() && !isPrivate();
	}

ConfigurationClassBeanDefinitionReader加载bean定义

每一个ConfigurationClass基本的加载流程

前面我们把配置类解析好了，放进ConfigurationClass集合里，但是还没有进行bean定义，所以后面就是进行bean定义了，遍历所有的ConfigurationClass，加载bean定义。

	public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
		TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
		for (ConfigurationClass configClass : configurationModel) {
			loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
		}
	}

loadBeanDefinitionsForConfigurationClass

从ConfigurationClass中获取bean名字，如果发现是条件过滤的且注册器里有相关bean定义，就要删除。然后处理是否是被import进来的，处理bean注解方法的，处理ImportedResources和ImportBeanDefinitionRegistrar接口实现类的。

	private void loadBeanDefinitionsForConfigurationClass(
			ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {

		if (trackedConditionEvaluator.shouldSkip(configClass)) {
			String beanName = configClass.getBeanName();
			if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
				this.registry.removeBeanDefinition(beanName);
			}
			this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
			return;
		}

		if (configClass.isImported()) {//是被import进来的
			registerBeanDefinitionForImportedConfigurationClass(configClass);
		}
		for (BeanMethod beanMethod : configClass.getBeanMethods()) {//处理bean注解方法
			loadBeanDefinitionsForBeanMethod(beanMethod);
		}

		loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());//从ImportedResources加载bean定义
		loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());//从Registrars接口加载bean定义
	}

registerBeanDefinitionForImportedConfigurationClass被import进来的

如果是被import进来的，直接将自己就封装成AnnotatedGenericBeanDefinition ，注册到注册器registry中。

private void registerBeanDefinitionForImportedConfigurationClass(ConfigurationClass configClass) {
		AnnotationMetadata metadata = configClass.getMetadata();
		AnnotatedGenericBeanDefinition configBeanDef = new AnnotatedGenericBeanDefinition(metadata);

		ScopeMetadata scopeMetadata = scopeMetadataResolver.resolveScopeMetadata(configBeanDef);
		configBeanDef.setScope(scopeMetadata.getScopeName());
		String configBeanName = this.importBeanNameGenerator.generateBeanName(configBeanDef, this.registry);
		AnnotationConfigUtils.processCommonDefinitionAnnotations(configBeanDef, metadata);

		BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(configBeanDef, configBeanName);
		definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
		this.registry.registerBeanDefinition(definitionHolder.getBeanName(), definitionHolder.getBeanDefinition());
		configClass.setBeanName(configBeanName);

		if (logger.isTraceEnabled()) {
			logger.trace("Registered bean definition for imported class '" + configBeanName + "'");
		}
	}

loadBeanDefinitionsForBeanMethod

看起来这个方法好像很长，其实就是将bean注解的方法元数据取出来分析，分析bean注解，有没有别名啊，有没有跟xml配置冲突啊，封装成一个ConfigurationClassBeanDefinition，然后设置工厂方法名，获取bean注解的属性，设置初始化方法，销毁方法，是否自动装配，是否需要代理，是JDK动态代理，还是CGLIB动态代理，如果用了动态代理，除了目标bean定义会注册以外，代理bean也会被注册，具体源码暂时不深入。

private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
		ConfigurationClass configClass = beanMethod.getConfigurationClass();
		MethodMetadata metadata = beanMethod.getMetadata();//方法元数据
		String methodName = metadata.getMethodName();

		// Do we need to mark the bean as skipped by its condition?
		if (this.conditionEvaluator.shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN)) {
			configClass.skippedBeanMethods.add(methodName);
			return;
		}
		if (configClass.skippedBeanMethods.contains(methodName)) {
			return;
		}
		//获取bean注解的属性
		AnnotationAttributes bean = AnnotationConfigUtils.attributesFor(metadata, Bean.class);
		Assert.state(bean != null, "No @Bean annotation attributes");

		// Consider name and any aliases获取别名
		List<String> names = new ArrayList<>(Arrays.asList(bean.getStringArray("name")));
		String beanName = (!names.isEmpty() ? names.remove(0) : methodName);//获取第一个别名,没有别名就用方法名

		// Register aliases even when overridden
		for (String alias : names) {//注册剩下的别名
			this.registry.registerAlias(beanName, alias);
		}
		//是否存在同名bean定义就不处理了，比如处理器扩展的，XML定义的
		// Has this effectively been overridden before (e.g. via XML)?
		if (isOverriddenByExistingDefinition(beanMethod, beanName)) {
			if (beanName.equals(beanMethod.getConfigurationClass().getBeanName())) {
				throw new BeanDefinitionStoreException(beanMethod.getConfigurationClass().getResource().getDescription(),
						beanName, "Bean name derived from @Bean method '" + beanMethod.getMetadata().getMethodName() +
						"' clashes with bean name for containing configuration class; please make those names unique!");
			}
			return;
		}
		//封装为ConfigurationClassBeanDefinition，表示是来自配置类里的bean定义
		ConfigurationClassBeanDefinition beanDef = new ConfigurationClassBeanDefinition(configClass, metadata);
		beanDef.setResource(configClass.getResource());//设置来源的类
		beanDef.setSource(this.sourceExtractor.extractSource(metadata, configClass.getResource()));//设置元数据

		if (metadata.isStatic()) {//静态的，设置BeanClass
			// static @Bean method
			if (configClass.getMetadata() instanceof StandardAnnotationMetadata) {
				beanDef.setBeanClass(((StandardAnnotationMetadata) configClass.getMetadata()).getIntrospectedClass());
			}
			else {
				beanDef.setBeanClassName(configClass.getMetadata().getClassName());//设置配置类全限定名
			}
			beanDef.setUniqueFactoryMethodName(methodName);
		}
		else {
			// instance @Bean method 实例的，设置工厂名，也就是配置类名
			beanDef.setFactoryBeanName(configClass.getBeanName());
			beanDef.setUniqueFactoryMethodName(methodName);//设置工厂方法的名字，也就是方法名
		}
		//如果方法元数据是标准方法元数据的话，就设置解析的工厂方法
		if (metadata instanceof StandardMethodMetadata) {
			beanDef.setResolvedFactoryMethod(((StandardMethodMetadata) metadata).getIntrospectedMethod());
		}
		//设置自定装配模式默认是构造器
		beanDef.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
		beanDef.setAttribute(org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor.
				SKIP_REQUIRED_CHECK_ATTRIBUTE, Boolean.TRUE);//设置略过属性检查
		//处理通用注解，注解里可能还有自动装配注解等
		AnnotationConfigUtils.processCommonDefinitionAnnotations(beanDef, metadata);
		//获取自动装配枚举信息
		Autowire autowire = bean.getEnum("autowire");
		if (autowire.isAutowire()) {//如果是自动装配，也就是BY_NAME 或者 BY_TYPE，再设置了一次自动装配模式
			beanDef.setAutowireMode(autowire.value());
		}
		//自动装配候选，默认是true
		boolean autowireCandidate = bean.getBoolean("autowireCandidate");
		if (!autowireCandidate) {
			beanDef.setAutowireCandidate(false);
		}
		//初始化方法 @PostConstruct 和 @PreDestroy  或者XML 或者 InitializingBean和 DisposableBean接口
		String initMethodName = bean.getString("initMethod");
		if (StringUtils.hasText(initMethodName)) {
			beanDef.setInitMethodName(initMethodName);
		}
		//销毁方法
		String destroyMethodName = bean.getString("destroyMethod");
		beanDef.setDestroyMethodName(destroyMethodName);

		// Consider scoping 处理范围
		ScopedProxyMode proxyMode = ScopedProxyMode.NO;
		AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(metadata, Scope.class);
		if (attributes != null) {
			beanDef.setScope(attributes.getString("value"));
			proxyMode = attributes.getEnum("proxyMode");
			if (proxyMode == ScopedProxyMode.DEFAULT) {
				proxyMode = ScopedProxyMode.NO;
			}
		}

		// Replace the original bean definition with the target one, if necessary
		BeanDefinition beanDefToRegister = beanDef;
		if (proxyMode != ScopedProxyMode.NO) {//如果范围不是no的话就要使用代理
			BeanDefinitionHolder proxyDef = ScopedProxyCreator.createScopedProxy(
					new BeanDefinitionHolder(beanDef, beanName), this.registry,
					proxyMode == ScopedProxyMode.TARGET_CLASS);
			beanDefToRegister = new ConfigurationClassBeanDefinition(
					(RootBeanDefinition) proxyDef.getBeanDefinition(), configClass, metadata);
		}

		if (logger.isTraceEnabled()) {
			logger.trace(String.format("Registering bean definition for @Bean method %s.%s()",
					configClass.getMetadata().getClassName(), beanName));
		}
		this.registry.registerBeanDefinition(beanName, beanDefToRegister);
	}

loadBeanDefinitionsFromImportedResources

这个就是加载ImportedResources的xml的，有两种加载类GroovyBeanDefinitionReader和XmlBeanDefinitionReader，然后用他们去加载xml，这里面就是各种xml解析，就暂时不深入了。

private void loadBeanDefinitionsFromImportedResources(
			Map<String, Class<? extends BeanDefinitionReader>> importedResources) {

		Map<Class<?>, BeanDefinitionReader> readerInstanceCache = new HashMap<>();

		importedResources.forEach((resource, readerClass) -> {
			// Default reader selection necessary?
			if (BeanDefinitionReader.class == readerClass) {
				if (StringUtils.endsWithIgnoreCase(resource, ".groovy")) {
					// When clearly asking for Groovy, that's what they'll get...
					readerClass = GroovyBeanDefinitionReader.class;
				}
				else {
					// Primarily ".xml" files but for any other extension as well
					readerClass = XmlBeanDefinitionReader.class;
				}
			}

			BeanDefinitionReader reader = readerInstanceCache.get(readerClass);
			if (reader == null) {
				try {
					// Instantiate the specified BeanDefinitionReader
					reader = readerClass.getConstructor(BeanDefinitionRegistry.class).newInstance(this.registry);
					// Delegate the current ResourceLoader to it if possible
					if (reader instanceof AbstractBeanDefinitionReader) {
						AbstractBeanDefinitionReader abdr = ((AbstractBeanDefinitionReader) reader);
						abdr.setResourceLoader(this.resourceLoader);
						abdr.setEnvironment(this.environment);
					}
					readerInstanceCache.put(readerClass, reader);
				}
				catch (Throwable ex) {
					throw new IllegalStateException(
							"Could not instantiate BeanDefinitionReader class [" + readerClass.getName() + "]");
				}
			}

			// TODO SPR-6310: qualify relative path locations as done in AbstractContextLoader.modifyLocations
			reader.loadBeanDefinitions(resource);
		});
	}

loadBeanDefinitionsFromRegistrars扩展点

这个是处理ImportBeanDefinitionRegistrar类型的import注解。具体就是去遍历被import进来的ImportBeanDefinitionRegistrar的registerBeanDefinitions自定义方法啦，这里也是一个扩展点，可以自己注册bean定义。

private void loadBeanDefinitionsFromRegistrars(Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> registrars) {
		registrars.forEach((registrar, metadata) ->
				registrar.registerBeanDefinitions(metadata, this.registry, this.importBeanNameGenerator));
	}

扩展实战

我们举个例子：



运行后回调到这里：

扩展后注册进去了。

至此对配置类的bean定义加载完成。主要步骤就是如果是被import进来的，就把自己注册进去，如果有bean注解方法的，把bean注解的方法作为bean定义注册进去，然后处理xml里的bean定义和ImportBeanDefinitionRegistrar实现类的扩展bean定义。

好了，今天就到这里了，希望对学习理解有帮助，大神看见勿喷，仅为自己的学习理解，能力有限，请多包涵。