Spring源码解析 – @Configuration配置类及注解Bean的解析

最新推荐文章于 2024-05-08 21:09:15 发布

纸上得来终深浅

最新推荐文章于 2024-05-08 21:09:15 发布

阅读量405

点赞数 1

分类专栏： Spring 文章标签： spring @Configuration

本文链接：https://blog.csdn.net/mingtiandexia/article/details/88806256

版权

Spring 专栏收录该内容

10 篇文章 1 订阅

订阅专栏

何时加载后置处理器

以AnnotationConfigApplicationContext为例，在构造函数中初始化reader时，加载默认后置处理器。其中 ConfigurationClassPostProcessor这个后置处理器专门处理带有@Configuration注解的类，ConfigurationClassPostProcessor后置处理实现了BeanDefinitionRegistryPostProcessor接口和PriorityOrdered接口，所以会在容器初始化refresh()方法中执行后置处理器时优先执行，主要负责解析所有@Configuration标签类，并将Bean定义注册到容器中。

初始化AnnotationConfigApplicationContext

    public AnnotationConfigApplicationContext() {
    		this.reader = new AnnotatedBeanDefinitionReader(this);
    		this.scanner = new ClassPathBeanDefinitionScanner(this);
    	}

在AnnotatedBeanDefinitionReader中注册注解配置的后置处理

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
			BeanDefinitionRegistry registry, Object source) {
．．．
		Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<BeanDefinitionHolder>(4);
		<font color=#0099ff size=7 face="黑体">/解析@Configuration注解</font>

		if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
			RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
			def.setSource(source);
			//添加beanDef到集合中
			beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
		}
...

		return beanDefs;
	}

何时回调后置处理器

refresh->invokeBeanFactoryPostProcessors

AbstractApplicationContext#refresh

// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

调用后置处理器来处理beanDefination

实现了BeanDefinitionRegistryPostProcessor接口和PriorityOrdered接口，所以会在容器初始化refresh()方法中执行后置处理器时优先执行

public static void invokeBeanFactoryPostProcessors(
 		ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

 	// Invoke BeanDefinitionRegistryPostProcessors first, if any.
 	Set<String> processedBeans = new HashSet<String>();

 	if (beanFactory instanceof BeanDefinitionRegistry) {
 		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
 		List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
 		List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList<BeanDefinitionRegistryPostProcessor>();

 		for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
 			if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
 				BeanDefinitionRegistryPostProcessor registryProcessor =
 						(BeanDefinitionRegistryPostProcessor) postProcessor;
 				registryProcessor.postProcessBeanDefinitionRegistry(registry);
 				registryProcessors.add(registryProcessor);
 			}
 			else {
 				regularPostProcessors.add(postProcessor);
 			}
 		}

 		// Do not initialize FactoryBeans here: We need to leave all regular beans
 		// uninitialized to let the bean factory post-processors apply to them!
 		// Separate between BeanDefinitionRegistryPostProcessors that implement
 		**// PriorityOrdered, Ordered, and the rest.**
 		
 		List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();

 		// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
 		String[] postProcessorNames =
 				beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
 		for (String ppName : postProcessorNames) {
 			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
 				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
 				processedBeans.add(ppName);
 			}
 		}
 		sortPostProcessors(currentRegistryProcessors, beanFactory);
 		registryProcessors.addAll(currentRegistryProcessors);
 		**//调用后置处理器的处理方法，@Configrauton的后置处理器类也属于下面这个来处理**
 		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
 		currentRegistryProcessors.clear();

 		// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
 		postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
 		for (String ppName : postProcessorNames) {
 			if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
 				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
 				processedBeans.add(ppName);
 			}
 		}
 		sortPostProcessors(currentRegistryProcessors, beanFactory);
 		registryProcessors.addAll(currentRegistryProcessors);
 		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
 		currentRegistryProcessors.clear();

 		// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
 		boolean reiterate = true;
 		while (reiterate) {
 			reiterate = false;
 			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
 			for (String ppName : postProcessorNames) {
 				if (!processedBeans.contains(ppName)) {
 					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
 					processedBeans.add(ppName);
 					reiterate = true;
 				}
 			}
 			sortPostProcessors(currentRegistryProcessors, beanFactory);
 			registryProcessors.addAll(currentRegistryProcessors);
 			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
 			currentRegistryProcessors.clear();
 		}

 		// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
 		invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
 		invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
 	}

 	else {
 		// Invoke factory processors registered with the context instance.
 		invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
 	}

 	// Do not initialize FactoryBeans here: We need to leave all regular beans
 	// uninitialized to let the bean factory post-processors apply to them!
 	String[] postProcessorNames =
 			beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

 	// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
 	// Ordered, and the rest.
 	List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
 	List<String> orderedPostProcessorNames = new ArrayList<String>();
 	List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
 	for (String ppName : postProcessorNames) {
 		if (processedBeans.contains(ppName)) {
 			// skip - already processed in first phase above
 		}
 		else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
 			priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
 		}
 		else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
 			orderedPostProcessorNames.add(ppName);
 		}
 		else {
 			nonOrderedPostProcessorNames.add(ppName);
 		}
 	}

 	// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
 	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
 	invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

 	// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
 	List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
 	for (String postProcessorName : orderedPostProcessorNames) {
 		orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
 	}
 	sortPostProcessors(orderedPostProcessors, beanFactory);
 	invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

 	// Finally, invoke all other BeanFactoryPostProcessors.
 	List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
 	for (String postProcessorName : nonOrderedPostProcessorNames) {
 		nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
 	}
 	invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

 	// Clear cached merged bean definitions since the post-processors might have
 	// modified the original metadata, e.g. replacing placeholders in values...
 	beanFactory.clearMetadataCache();
 }

上面调用后置处理器ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry

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

这里主要查看processConfigBeanDefinitions(registry);

{
		List<BeanDefinitionHolder> configCandidates = new ArrayList<BeanDefinitionHolder>();
		String[] candidateNames = registry.getBeanDefinitionNames();

		for (String beanName : candidateNames) {
			BeanDefinition beanDef = registry.getBeanDefinition(beanName);
			if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
					ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
				if (logger.isDebugEnabled()) {
					logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
				}
			}
			else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
				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
		Collections.sort(configCandidates, new Comparator<BeanDefinitionHolder>() {
			@Override
			public int compare(BeanDefinitionHolder bd1, BeanDefinitionHolder bd2) {
				int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
				int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
				return (i1 < i2) ? -1 : (i1 > i2) ? 1 : 0;
			}
		});

		// 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 && sbr.containsSingleton(CONFIGURATION_BEAN_NAME_GENERATOR)) {
				BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
				this.componentScanBeanNameGenerator = generator;
				this.importBeanNameGenerator = generator;
			}
		}

		// Parse each @Configuration class
		ConfigurationClassParser parser = new ConfigurationClassParser(
				this.metadataReaderFactory, this.problemReporter, this.environment,
				this.resourceLoader, this.componentScanBeanNameGenerator, registry);

		Set<BeanDefinitionHolder> candidates = new LinkedHashSet<BeanDefinitionHolder>(configCandidates);
		Set<ConfigurationClass> alreadyParsed = new HashSet<ConfigurationClass>(configCandidates.size());
		do {
			parser.parse(candidates);
			parser.validate();

			Set<ConfigurationClass> configClasses = new LinkedHashSet<ConfigurationClass>(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());
			}
			this.reader.loadBeanDefinitions(configClasses);
			alreadyParsed.addAll(configClasses);

			candidates.clear();
			if (registry.getBeanDefinitionCount() > candidateNames.length) {
				String[] newCandidateNames = registry.getBeanDefinitionNames();
				Set<String> oldCandidateNames = new HashSet<String>(Arrays.asList(candidateNames));
				Set<String> alreadyParsedClasses = new HashSet<String>();
				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) {
			if (!sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
				sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
			}
		}

		if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
			((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
		}
	}

上面最主要的步骤有两步

1. parser.parse(candidates);

ConfigurationClassParser#doProcessConfigurationClass

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
			throws IOException {

		// Recursively process any member (nested) classes first
		processMemberClasses(configClass, sourceClass);

		// Process any @PropertySource annotations
		for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
				sourceClass.getMetadata(), PropertySources.class,
				org.springframework.context.annotation.PropertySource.class)) {
			if (this.environment instanceof ConfigurableEnvironment) {
				processPropertySource(propertySource);
			}
			else {
				logger.warn("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
						"]. Reason: Environment must implement ConfigurableEnvironment");
			}
		}

		**// Process any @ComponentScan annotations**
		
		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
				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) {
					if (ConfigurationClassUtils.checkConfigurationClassCandidate(
							holder.getBeanDefinition(), this.metadataReaderFactory)) {
						parse(holder.getBeanDefinition().getBeanClassName(), holder.getBeanName());
					}
				}
			}
		}

		// Process any @Import annotations
		processImports(configClass, sourceClass, getImports(sourceClass), true);

		// Process any @ImportResource annotations
		if (sourceClass.getMetadata().isAnnotated(ImportResource.class.getName())) {
			AnnotationAttributes importResource =
					AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
			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**
		Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
		for (MethodMetadata methodMetadata : beanMethods) {
			configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
		}

		// Process default methods on interfaces
		processInterfaces(configClass, sourceClass);

		// Process superclass, if any
		if (sourceClass.getMetadata().hasSuperClass()) {
			String superclass = sourceClass.getMetadata().getSuperClassName();
			if (!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;
	}

1.1 解析@ComponentScan annotations

org.springframework.context.annotation.ComponentScanAnnotationParser#parse->scanner.doScan(StringUtils.toStringArray(basePackages))

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
		Assert.notEmpty(basePackages, "At least one base package must be specified");
		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
		for (String basePackage : basePackages) {
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
			for (BeanDefinition candidate : candidates) {
				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
				candidate.setScope(scopeMetadata.getScopeName());
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
				if (candidate instanceof AbstractBeanDefinition) {
					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
				}
				if (candidate instanceof AnnotatedBeanDefinition) {
					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
				}
				if (checkCandidate(beanName, candidate)) {
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					definitionHolder =
							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
					beanDefinitions.add(definitionHolder);
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}

1.2 解析@Bean

// Process individual @Bean methods
		Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
		for (MethodMetadata methodMetadata : beanMethods) {
			configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
		}

private Set<MethodMetadata> retrieveBeanMethodMetadata(SourceClass sourceClass) {
		AnnotationMetadata original = sourceClass.getMetadata();
		Set<MethodMetadata> beanMethods = original.getAnnotatedMethods(Bean.class.getName());
		if (beanMethods.size() > 1 && original instanceof StandardAnnotationMetadata) {
			// Try reading the class file via ASM for deterministic declaration order...
			// Unfortunately, the JVM's standard reflection returns methods in arbitrary
			// order, even between different runs of the same application on the same JVM.
			try {
				AnnotationMetadata asm =
						this.metadataReaderFactory.getMetadataReader(original.getClassName()).getAnnotationMetadata();
				Set<MethodMetadata> asmMethods = asm.getAnnotatedMethods(Bean.class.getName());
				if (asmMethods.size() >= beanMethods.size()) {
					Set<MethodMetadata> selectedMethods = new LinkedHashSet<MethodMetadata>(asmMethods.size());
					for (MethodMetadata asmMethod : asmMethods) {
						for (MethodMetadata beanMethod : beanMethods) {
							if (beanMethod.getMethodName().equals(asmMethod.getMethodName())) {
								selectedMethods.add(beanMethod);
								break;
							}
						}
					}
					if (selectedMethods.size() == beanMethods.size()) {
						// All reflection-detected methods found in ASM method set -> proceed
						beanMethods = selectedMethods;
					}
				}
			}
			catch (IOException ex) {
				logger.debug("Failed to read class file via ASM for determining @Bean method order", ex);
				// No worries, let's continue with the reflection metadata we started with...
			}
		}
		return beanMethods;
	}

2. this.reader.loadBeanDefinitions(configClasses);

3. loadBeanDefinitionsForConfigurationClass

//@configuraiton中的@bean
for (BeanMethod beanMethod : configClass.getBeanMethods()) {
			loadBeanDefinitionsForBeanMethod(beanMethod);
		}
		//Configuration中的@import
		loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
		loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());

总结

Spring容器初始化时注册默认后置处理器ConfigurationClassPostProcessor
Spring容器初始化执行refresh()方法中调用ConfigurationClassPostProcessor
ConfigurationClassPostProcessor处理器借助ConfigurationClassParser完成配置类解析
ConfigurationClassParser配置内解析过程中完成嵌套的MemberClass、@PropertySource注解、@ComponentScan注解（扫描package下的所有Class并进行迭代解析，主要是@Component组件解析及注册）、@ImportResource、@Bean等处理
完成@Bean注册， @ImportResource指定bean的注册以及@Import(实现ImportBeanDefinitionRegistrar接口方式)的bean注册

参考： https://www.cnblogs.com/ashleyboy/p/9667485.html

纸上得来终深浅

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spring源码解析 – @Configuration配置类及注解Bean的解析

何时加载后置处理器以AnnotationConfigApplicationContext为例，在构造函数中初始化reader时，加载默认后置处理器。其中 ConfigurationClassPostProcessor这个后置处理器专门处理带有@Configuration注解的类，ConfigurationClassPostProcessor后置处理实现了BeanDefinitionRegistr...
复制链接

扫一扫