@SpringBootApplication注解及自动装配

参考:ConfigurationClassPostProcessor —— Spring中最!最!最!重要的后置处理器!没有之一!!!
@SpringBootApplication结构图如下:
@SpringBootApplication注解及自动装配_第1张图片
首先看看这个比较底层的@Import注解

@Import

首先来看看该注解的注释说明:

Indicates one or more component classes to import — typically @Configuration classes.
Allows for importing @Configuration classes, ImportSelector and ImportBeanDefinitionRegistrar implementations, as well as regular component classes

基本作用就是导入bean,由上可知通常有四个方式:

  1. @Configuration 注解类
  2. ImportSelector接口实现类
  3. ImportBeanDefinitionRegistrar接口实现类
  4. 普通java类

验证一下,现在有一个Student类需要注入IoC容器:

方式1:
@SpringBootApplication注解及自动装配_第2张图片
方式2:
@SpringBootApplication注解及自动装配_第3张图片

方式3:
@SpringBootApplication注解及自动装配_第4张图片
方式4:

@SpringBootApplication注解及自动装配_第5张图片

@AutoConfigurationPackage

看看它的注释:

Registers packages with AutoConfigurationPackages. When no base packages or base package classes are specified, the package of the annotated class is registered.
可以看到,这个注解这里就是将org.springframework.boot.autoconfigure.AutoConfigurationPackages注入IoC容器,原理是@Import一个ImportBeanDefinitionRegistrar接口的实现类,@import前后BeanDefinition变化如下两图所示:
@SpringBootApplication注解及自动装配_第6张图片@SpringBootApplication注解及自动装配_第7张图片

@EnableAutoConfiguration

基于Spring应用程序上下文进行自动配置,根据依赖尝试猜测并配置Bean;另外,被@EnableAutoConfiguration注解的类所在的 p a c k a g e package package 通常作为扫描注解@Entity的根路径,这也是为什么@SpringBootApplication放在顶级 p a c k a g e package package 下面。
注意,注解了@EnableAutoConfiguration的类的其他注解可以生效,如@Configuration、@Bean、@Controller等,但是这个类之外的其他类(包括同一个包中的其他类)的注解都不会生效,扫描包中其他类注解起作用的是@ComponentScan及其他特殊的途径。
综上,@EnableAutoConfiguration扫描的是注解它的类和classpath下依赖包中META-INF文件夹下spring.factories中以org.springframework.boot.autoconfigure.EnableAutoConfiguration为key的value类

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {

	String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
	Class<?>[] exclude() default {};
	String[] excludeName() default {};
	}

需要注意的是,虽然@EnableAutoConfiguration上有个@Import一个实现了ImportSelector接口的类,但它却不是通过ImportSelector接口的selectImports方法来工作的 而是通过DeferredImportSelector接口的内部接口Groupvoid process(AnnotationMetadata metadata, DeferredImportSelector selector);
为什么?答案就在ConfigurationClassParser.java(专门用于处理配置注解的类,由BeanDefinitionRegistryPostProcessor接口方法调用)中的processImports 方法,因为@EnableAutoConfiguration上的AutoConfigurationImportSelector.class实现了DeferredImportSelector接口,字面意思就是延迟import,这个接口import的东西会在扫描处理完所有的@Configuration注解之后(包括依赖包中的和手动写的)再处理。
小结一下:SpringBoot先加载扫描所有注解了@Configuration的类(同步解析@Component,@ComponentScan,@Import,@ImportResource,@Bean,@PropertySource注解),然后对于@Import(类名.class)中类如果没有继承自DeferredImportSelector接口则再扫描后立即进行解析处理,而如果该类继承自
DeferredImportSelector接口则不执行,等扫描完了所有的注解后再统一通过DeferredImportSelector接口的内部接口Groupvoid process(AnnotationMetadata metadata, DeferredImportSelector selector); 来执行。
看他的注释:

A variation of ImportSelector that runs after all @Configuration beans have been processed. This type of selector can be particularly useful when the selected imports are @Conditional.

注释意思也是,处理完所有@Configuration beans后再进行处理。从package org.springframework.context.annotation.ConfigurationClassParser类中的parser方法也可以看出:



class ConfigurationClassParser {
		
public void parse(Set<BeanDefinitionHolder> configCandidates) {
		for (BeanDefinitionHolder holder : configCandidates) {
			BeanDefinition bd = holder.getBeanDefinition();
			try {
				if (bd instanceof AnnotatedBeanDefinition) {
					// parse没有注解`DeferredImportSelector`接口的@Import注解和其他那几个注解
					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);
			}
		}
		// 统一处理继承自`DeferredImportSelector`接口的@Import注解
		this.deferredImportSelectorHandler.process();
	}

			protected final SourceClass doProcessConfigurationClass(
			ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
			throws IOException {
		// Process any @PropertySource annotations
		...
		// Process any @ComponentScan annotations
		...
		// Process any @ImportResource annotations
		...
		// Process individual @Bean methods
		...
		// 处理@Import
		processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
		...
		}

		// Process any @Import annotations
		private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
			Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter,
			boolean checkForCircularImports) {
			// 如果import的类继承了ImportSelector接口
			if (candidate.isAssignable(ImportSelector.class)){
				// 如果是DeferredImportSelector类型,defer延迟的意思
				if (selector instanceof DeferredImportSelector){
					// 这里只把selector转为DeferredImportSelectorHolder存入this.deferredImportSelectors,执行不在这块,在parse方法的最后一行执行。
					this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
				} else {					
					// 不是DeferredImportSelector类型就执行selectImports方法
					String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
					Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
					processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
				}
}
}

通过调用org.springframework.context.annotation;包下的ConfigurationClassPostProcessor类解析加了@Configuration@Component@ComponentScan@Import@ImportResource等注解。

凡是注解了@Configuration的类,beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL);;没有注解@Configuration但是注解了@Component@ComponentScan@Import@ImportResource的类,beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_LITE);

来看代码:

// 
public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor,
		PriorityOrdered, ResourceLoaderAware, ApplicationStartupAware, BeanClassLoaderAware, EnvironmentAware {
		...
		@Override
		public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
		// 本类中的方法
		processConfigBeanDefinitions(registry);
		}
		}

		public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
			List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
			String[] candidateNames = registry.getBeanDefinitionNames();
			for (String beanName : candidateNames) {
				BeanDefinition beanDef = registry.getBeanDefinition(beanName);
				// beandefinition里CONFIGURATION_CLASS_ATTRIBUTE设置过了,跳过
				if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
				if (logger.isDebugEnabled()) {
					logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
				}
			}
			// 这里这个最重要!!!
			// 跳到ConfigurationClassUtils类中的checkConfigurationClassCandidate方法
				else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
				configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
			}
			...
			// 解析配置类,在此处会解析配置类上的注解(ComponentScan扫描出的类,@Import注册的类,以及@Bean方法定义的类)
        	// 注意:这一步只会将加了@Configuration注解以及通过@ComponentScan注解扫描的类才会加入到BeanDefinitionMap中
        	// 通过其他注解(例如@Import、@Bean)的方式,在parse()方法这一步并不会将其解析为BeanDefinition放入到BeanDefinitionMap中,而是先解析成ConfigurationClass类
        	// 真正放入到map中是在下面的this.reader.loadBeanDefinitions()方法中实现的
        	// parse方法最后this.deferredImportSelectorHandler.process();这个就是处理延迟importSelector也就是这里加载依赖jar包下所有META-INF文件夹spring.factories类中AutoConfiguration
			parser.parse(candidates);
			...
			// 将上一步parser解析出的ConfigurationClass类加载成BeanDefinition
			// 实际上经过上一步的parse()后,解析出来的bean已经放入到BeanDefinition中了,但是由于这些bean可能会引入新的bean,例如实现了ImportBeanDefinitionRegistrar或者ImportSelector接口的bean,或者bean中存在被@Bean注解的方法
			// 因此需要执行一次loadBeanDefinition(),这样就会执行ImportBeanDefinitionRegistrar或者ImportSelector接口的方法或者@Bean注释的方法
			this.reader.loadBeanDefinitions(configClasses);
		}
}



abstract class ConfigurationClassUtils {
	...
	private static final Set<String> candidateIndicators = new HashSet<>(8);

	static {
		candidateIndicators.add(Component.class.getName());
		candidateIndicators.add(ComponentScan.class.getName());
		candidateIndicators.add(Import.class.getName());
		candidateIndicators.add(ImportResource.class.getName());
	}
	...

	public static boolean checkConfigurationClassCandidate(
			BeanDefinition beanDef, MetadataReaderFactory metadataReaderFactory) {
			...
		Map<String, Object> config = metadata.getAnnotationAttributes(Configuration.class.getName());
		// 如果有@Configuration注解,beanDefinition里面某个属性设为full
		if (config != null && !Boolean.FALSE.equals(config.get("proxyBeanMethods"))) {
			beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL);
		}
		// 这个isConfigurationCandidate就会从上面的candidateIndicators里面遍历比较
		// 如果有candidateIndicators任意一个注解,beanDefinition里面某个属性设为lite
		else if (config != null || isConfigurationCandidate(metadata)) {
			beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_LITE);
		}
		else {
			return false;
		}
		...
}
}

具体可参考ConfigurationClassPostProcessor —— Spring中最!最!最!重要的后置处理器!没有之一!!!

继而通过解析@EnableAutoConfiguration上的@Import(AutoConfigurationImportSelector.class)来调用getAutoConfigurationEntry(AnnotationMetadata annotationMetadata)方法,里面也有个getCandidateConfigurations(annotationMetadata, attributes)来扫描。
具体调用流程可参考:AutoConfigurationImportSelector到底怎么初始化

总而言之,该注解作用就是在依赖的包的META-INF文件夹下的spring.factories文件种找org.springframework.boot.autoconfigure.EnableAutoConfiguration的值,并扫描。

你可能感兴趣的:(java,java,spring,intellij-idea)