spring 源码解读五 ConfigurationClassPostProcessor-java黑洞网

本站消息

站长简介/公众号

出租广告位,需要合作请联系站长

快起来搬砖啦

569

文章

271307

访问

+关注

分类

暂无分类

日期归档

2023-06(3)

spring 源码解读五 ConfigurationClassPostProcessor

发布于2021-05-30 01:05 阅读(901) 评论(0) 点赞(9) 收藏(5)

ConfigurationClassPostProcessor 是spring注解注入bean的核心类，ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor

因此 ConfigurationClassPostProcessor是 BeanDefinitionRegistryPostProcessor 的子类，在执行 BeanFactoryPostProcessor的时候回首先执行到 postProcessBeanDefinitionRegistry这个方法

ConfigurationClassPostProcessor -> postProcessBeanDefinitionRegistry


/**
	 * Derive further bean definitions from the configuration classes in the registry.
	 */
	@Override
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
		int registryId = System.identityHashCode(registry);
		if (this.registriesPostProcessed.contains(registryId)) {
			throw new IllegalStateException(
					"postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
		}
		if (this.factoriesPostProcessed.contains(registryId)) {
			throw new IllegalStateException(
					"postProcessBeanFactory already called on this post-processor against " + registry);
		}
		this.registriesPostProcessed.add(registryId);
 
		processConfigBeanDefinitions(registry);
	}

ConfigurationClassPostProcessor -> processConfigBeanDefinitions(registry);


/**
	 * Build and validate a configuration model based on the registry of
	 * {@link Configuration} classes.
	 */
	public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
 
		//遍历之后所有需要处理的BeanDefinition放在这里
		List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
 
		// 这里 registry.getBeanDefinitionNames() 这个方法需要重点讲解
		// 这里获取到的实际上是 DefaultListableBeanFactory 里面的 BeanDefinitionNames
		// 那么问题来了 DefaultListableBeanFactory 里面的 BeanDefinitionNames是哪里来的呢
		// 答案是 <context:component-scan base-package="com.spring.debug.beanPostProcess"></context:component-scan> 这个注解扫描到的
		// 那么问题又来了既然 context:component-scan 这个注解可以扫描到那么还要 ConfigurationClassPostProcessor干啥
		// 答案是 <context:component-scan 这个注解只会扫描到  base-package 这个包下面的类中定义了有 @Component 这个注解的类
		// 包括 @Component @Configuration @Controller @Service 等包括有 @Component 这个注解的的注解类
		// 并且如果包含了 @Component 这个注解的类里面定义了其他的注解类 <context:component-scan 这个标签也不会扫描到
		// 因此 ConfigurationClassPostProcessor 处理的是 <context:component-scan处理不到的类,即注解类里面嵌套的注解类
		String[] candidateNames = registry.getBeanDefinitionNames();
		for (String beanName : candidateNames) {
			BeanDefinition beanDef = registry.getBeanDefinition(beanName);
			//这里根据 beanDef 里面是否有  configurationClass 这个标记来判断 此beanDef 是否已经被处理过了
			if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
				if (logger.isDebugEnabled()) {
					logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
				}
			}
			//这个方法有意思的
			//首先判断了下 beanDef 的类型
			//其次判断了下 beanDef 上有没有 @Configuration注解，如果有设置 configurationClass为 full,否则设置为lite
			//如果为 full 这在创建对象时则创建代理对象, 否则则走spring正常创建对象的逻辑，具体逻辑可以看 postProcessBeanFactory
			else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
				//这里将 beanDef 包装成 BeanDefinitionHolder并加入到
				configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
			}
		}
 
		// Return immediately if no @Configuration classes were found
		if (configCandidates.isEmpty()) {
			return;
		}
 
		// Sort by previously determined @Order value, if applicable
		configCandidates.sort((bd1, bd2) -> {
			int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
			int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
			return Integer.compare(i1, i2);
		});
 
		// Detect any custom bean name generation strategy supplied through the enclosing application context
		SingletonBeanRegistry sbr = null;
		if (registry instanceof SingletonBeanRegistry) {
			sbr = (SingletonBeanRegistry) registry;
			if (!this.localBeanNameGeneratorSet) {
				BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
						AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
				if (generator != null) {
					this.componentScanBeanNameGenerator = generator;
					this.importBeanNameGenerator = generator;
				}
			}
		}
 
		if (this.environment == null) {
			this.environment = new StandardEnvironment();
		}
 
		// Parse each @Configuration class
		//这里创建了一个解析具体bean标签的处理类
		ConfigurationClassParser parser = new ConfigurationClassParser(
				this.metadataReaderFactory, this.problemReporter, this.environment,
				this.resourceLoader, this.componentScanBeanNameGenerator, registry);
		
		//所有解析到的 BeanDefinition定义信息放到 candidates 中
		Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
		
		//所有已经放到BeanFactory的BeanDefinition定义信息放到  alreadyParsed 中 
		Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
		do {
			//具体解析标签的类
			parser.parse(candidates);
			parser.validate();
			
			// 解析完成的 BeanDefinition定义信息 先放到 parser.getConfigurationClasses()
			// 然后再放到 configClasses
			Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
			configClasses.removeAll(alreadyParsed);
 
			// Read the model and create bean definitions based on its content
			if (this.reader == null) {
				this.reader = new ConfigurationClassBeanDefinitionReader(
						registry, this.sourceExtractor, this.resourceLoader, this.environment,
						this.importBeanNameGenerator, parser.getImportRegistry());
			}
			//将解析到的 BeanDefinition定义信息放到 BeanFactory中
			this.reader.loadBeanDefinitions(configClasses);
			alreadyParsed.addAll(configClasses);
 
			candidates.clear();
			if (registry.getBeanDefinitionCount() > candidateNames.length) {
				String[] newCandidateNames = registry.getBeanDefinitionNames();
				Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
				Set<String> alreadyParsedClasses = new HashSet<>();
				for (ConfigurationClass configurationClass : alreadyParsed) {
					alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
				}
				for (String candidateName : newCandidateNames) {
					if (!oldCandidateNames.contains(candidateName)) {
						BeanDefinition bd = registry.getBeanDefinition(candidateName);
						if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
								!alreadyParsedClasses.contains(bd.getBeanClassName())) {
							candidates.add(new BeanDefinitionHolder(bd, candidateName));
						}
					}
				}
				candidateNames = newCandidateNames;
			}
		}
		while (!candidates.isEmpty());
 
		// Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
		if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
			sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
		}
 
		if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
			// Clear cache in externally provided MetadataReaderFactory; this is a no-op
			// for a shared cache since it'll be cleared by the ApplicationContext.
			((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
		}
	}

下面我们重点关注下 ConfigurationClassParser的 parse(candidates); 方法

ConfigurationClassParser -> parse(Set<BeanDefinitionHolder> configCandidates)


public void parse(Set<BeanDefinitionHolder> configCandidates) {
		for (BeanDefinitionHolder holder : configCandidates) {
			BeanDefinition bd = holder.getBeanDefinition();
			try {
				if (bd instanceof AnnotatedBeanDefinition) {
					parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
				}
				else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
					parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
				}
				else {
					parse(bd.getBeanClassName(), holder.getBeanName());
				}
			}
			catch (BeanDefinitionStoreException ex) {
				throw ex;
			}
			catch (Throwable ex) {
				throw new BeanDefinitionStoreException(
						"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
			}
		}
 
		this.deferredImportSelectorHandler.process();
	}

ConfigurationClassParser -> parse(AnnotationMetadata metadata, String beanName)

ConfigurationClassParser ->processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter)


protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
		if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
			return;
		}
 
		ConfigurationClass existingClass = this.configurationClasses.get(configClass);
		if (existingClass != null) {
			if (configClass.isImported()) {
				if (existingClass.isImported()) {
					existingClass.mergeImportedBy(configClass);
				}
				// Otherwise ignore new imported config class; existing non-imported class overrides it.
				return;
			}
			else {
				// Explicit bean definition found, probably replacing an import.
				// Let's remove the old one and go with the new one.
				this.configurationClasses.remove(configClass);
				this.knownSuperclasses.values().removeIf(configClass::equals);
			}
		}
 
		// Recursively process the configuration class and its superclass hierarchy.
		SourceClass sourceClass = asSourceClass(configClass, filter);
		do {
			sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
		}
		while (sourceClass != null);
 
		this.configurationClasses.put(configClass, configClass);
	}

我们还是直奔主题 ConfigurationClassParser -> doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)


/**
	 * Apply processing and build a complete {@link ConfigurationClass} by reading the
	 * annotations, members and methods from the source class. This method can be called
	 * multiple times as relevant sources are discovered.
	 * @param configClass the configuration class being build
	 * @param sourceClass a source class
	 * @return the superclass, or {@code null} if none found or previously processed
	 */
	@Nullable
	protected final SourceClass doProcessConfigurationClass(
			ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
			throws IOException {
		// 解析 @Component 注解的类，这里面会递归执行到 @Component注解的类里面是否还有注解类
		if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
			// Recursively process any member (nested) classes first
			processMemberClasses(configClass, sourceClass, filter);
		}
 
		// Process any @PropertySource annotations
		// 解析 @PropertySources 注解的类
		for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getMetadata(), PropertySources.class,
				org.springframework.context.annotation.PropertySource.class)) {
			if (this.environment instanceof ConfigurableEnvironment) {
				processPropertySource(propertySource);
			}
			else {
				logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
						"]. Reason: Environment must implement ConfigurableEnvironment");
			}
		}
 
		// Process any @ComponentScan annotations
		// 解析 @ComponentScans @ComponentScan 注解的类
		Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
		if (!componentScans.isEmpty() &&
				!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
			for (AnnotationAttributes componentScan : componentScans) {
				// The config class is annotated with @ComponentScan -> perform the scan immediately
				//这里会扫描 ComponentScans basePackages 定义的包下面的所有类是否有被 @Component 修饰
				// 将ComponentScans basePackages 定义的包下面的所有被 @Component 修饰的类都解析过来
				Set<BeanDefinitionHolder> scannedBeanDefinitions =
						this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
				// Check the set of scanned definitions for any further config classes and parse recursively if needed
				for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
					BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
					if (bdCand == null) {
						bdCand = holder.getBeanDefinition();
					}
					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
						parse(bdCand.getBeanClassName(), holder.getBeanName());
					}
				}
			}
		}
 
		// Process any @Import annotations
		// 解析 @Import注解，spring boot 自动注入大量的用到了这玩意儿
		processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
 
		// Process any @ImportResource annotations
		AnnotationAttributes importResource =
				AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
		if (importResource != null) {
			String[] resources = importResource.getStringArray("locations");
			Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
			for (String resource : resources) {
				String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
				configClass.addImportedResource(resolvedResource, readerClass);
			}
		}
 
		// Process individual @Bean methods
		//解析@Bean注解
		// 这里有个问题
		/**
			 //1、@Configuration
			 //2、@Component
			 public class PersonConfiguration1 {
				@Bean
				private PersonConfiguration2 personConfiguration2(){
					return new PersonConfiguration2();
				}
			}
		 	这里这段代码不论是用 1、@Configuration 还是用 2、@Component 最后得到的 PersonConfiguration2 都是单例的
		    但是使用 1、@Configuration 注解的 PersonConfiguration1 会被注入成一个代理类
		 	所以网上说的使用 @Configuration 配置的类必须要被代理是为了解决 bean 的单例问题肯定是错的
		    不论是用 @Configuration 还是用 2、@Component 里面定义的 @Bean 注解最终都是走的 FactoryMethod 方法被实例化的
		 * **/
		Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
		for (MethodMetadata methodMetadata : beanMethods) {
			configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
		}
 
		// Process default methods on interfaces
		/**
			 public interface MyInterfaces {
				@Bean
				PersonConfiguration1 personConfiguration1();
			}
		 * **/
		// 如果接口中也定义有@Bean 则走这里解析
		processInterfaces(configClass, sourceClass);
 
		// Process superclass, if any
		if (sourceClass.getMetadata().hasSuperClass()) {
			String superclass = sourceClass.getMetadata().getSuperClassName();
			if (superclass != null && !superclass.startsWith("java") &&
					!this.knownSuperclasses.containsKey(superclass)) {
				this.knownSuperclasses.put(superclass, configClass);
				// Superclass found, return its annotation metadata and recurse
				return sourceClass.getSuperClass();
			}
		}
 
		// No superclass -> processing is complete
		return null;
	}