文章目录

• 1. 前言
• 2. SpringBoot的核心注解
• 3. SpringBoot的自动配置
• • 3.1 @AutoConfigurationPackage注解
  • 3.2 @Import注解
• 4. 按需开启自动配置
• • 4.1 以AopAutoConfiguration为例
  • 4.2 以BatchAutoConfiguration为例
• 5. 总结

---

1. 前言

        SpringBoot的自动配置原理是一个令人头疼的问题，经过一下午的学习写下这篇文章供大家参考，如果有雷同纯属巧合。文章中如果出现错误，欢迎大家指出，本人会随时修改。
        SpringBoot版本：2.7.5（注意版本号，不然跟文章中调试结果可能不一致）。

2. SpringBoot的核心注解

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

        我们在创建的springboot项目时都会写一个主启动类，每次启动项目时只要运行主启动类中的main方法即可。标注在主启动类上的 @SpringBootApplication注解就是springboot的核心注解，但该注解是一个合成注解，主要由下面三个注解组成：

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)

@SpringBootConfiguration
        @SpringBootConfiguration注解的作用是标注该类是一个配置类。它与@Configuration注解的功能一致，区别是@SpringBootConfiguration是springboot中的注解，而@Configuration注解是spring中的注解。由下面的代码可以看出@SpringBootConfiguration是@Configuration的一个派生注解。

@Documented
@Configuration
@Indexed
public @interface SpringBootConfiguration {
    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

@ComponentScan
        @ComponentScan注解的作用是扫描指定包及其子包中所有的类，将满村过滤器条件的类作为bean注册到spring容器中。默认情况下会扫描主启动类所在的包及其子包中所有的类。
@EnableAutoConfiguration
        @EnableAutoConfiguration注解的作用是开启自动配置功能。加上该注解，程序会加载META-INF/spring.factories文件中注册的各种AutoConfiguration类，当某个AutoConfiguration类满足指定的生效条件时，实例化AutoConfiguration类中定义的bean，最后注入到Spring容器中，这样就完成了依赖框架的自动配置。接下来的自动配置的讲解都是通过该注解进行展开。

3. SpringBoot的自动配置

@EnableAutoConfiguration:

@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注解主要由@AutoConfigurationPackage、@Import这两个注解组成。

3.1 @AutoConfigurationPackage注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {
}

Registrar类：

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
		@Override
		public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
			register(registry, new PackageImports(metadata).getPackageNames().toArray(new String[0]));
		}

		@Override
		public Set<Object> determineImports(AnnotationMetadata metadata) {
			return Collections.singleton(new PackageImports(metadata));
		}
	}

        @AutoConfigurationPackage注解在底层使用@Import注解将Registrar导入到容器中。而Registrar类的作用是以编程的形式注册自动配置包名称，以记录包扫描的入口。那获取的是哪个包名呢？


        我们看registerBeanDefinitions方法中的metadata参数（该参数表示注解元信息），其中包括注解的位置等信息，而注解的位置正是在启动类上面，所以获取的包名正是启动类所在的包。看上面的图，该代码计算出来的结果就是主启动类所在的包。
        很多人在这里就有疑问了，启动类上面的注解是@SpringbootApplication，为什么能够获取该包名？其实metadata元信息中的注解位置指的是@AutoConfigurationPackage位置，而@SpringbootApplication是合成注解，里面包括了@EnableAutoConfiguration注解，而@EnableAutoConfiguration注解又包括了@AutoConfigurationPackage注解，所以metadata中的包名就是主启动类的包名。

3.2 @Import注解

        我们查看@EnableAutoConfiguration注解中第二个重要的注解@Import。其作用是将AutoConfigurationImportSelector类作为一个组件导入容器中。接下来我们对AutoConfigurationImportSelector类进行分析一下。

@Override
	public String[] selectImports(AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return NO_IMPORTS;
		}
		AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
		return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
	}

        selectImports方法返回的数组中有哪些组件，那么程序就会导入哪些组件。组件的信息获取是通过getAutoConfigurationEntry方法进行获取的。

protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return EMPTY_ENTRY;
		}
		AnnotationAttributes attributes = getAttributes(annotationMetadata);
		List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
		configurations = removeDuplicates(configurations);
		Set<String> exclusions = getExclusions(annotationMetadata, attributes);
		checkExcludedClasses(configurations, exclusions);
		configurations.removeAll(exclusions);
		configurations = getConfigurationClassFilter().filter(configurations);
		fireAutoConfigurationImportEvents(configurations, exclusions);
		return new AutoConfigurationEntry(configurations, exclusions);
	}

        通过对getAutoConfigurationEntry方法进行分析，我们可以看出该方法还是要调用getCandidateConfigurations方法来获取数据，然后移除重复的组件等一系列操作后在返回给selectImports方法，接下来我们继续分析getCandidateConfigurations方法。

	protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
		List<String> configurations = new ArrayList<>(
				SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader()));
		ImportCandidates.load(AutoConfiguration.class, getBeanClassLoader()).forEach(configurations::add);
		Assert.notEmpty(configurations,
				"No auto configuration classes found in META-INF/spring.factories nor in META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports. If you "
						+ "are using a custom packaging, make sure that file is correct.");
		return configurations;
	}

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        ClassLoader classLoaderToUse = classLoader;
        if (classLoader == null) {
            classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
        }

        String factoryTypeName = factoryType.getName();
        return (List)loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
    }

  private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
        Map<String, List<String>> result = (Map)cache.get(classLoader);
        if (result != null) {
            return result;
        } else {
            Map<String, List<String>> result = new HashMap();
            try {
                Enumeration<URL> urls = classLoader.getResources("META-INF/spring.factories");

                while(urls.hasMoreElements()) {
                    URL url = (URL)urls.nextElement();
                    UrlResource resource = new UrlResource(url);
                    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                    Iterator var6 = properties.entrySet().iterator();

                    while(var6.hasNext()) {
                        Map.Entry<?, ?> entry = (Map.Entry)var6.next();
                        String factoryTypeName = ((String)entry.getKey()).trim();
                        String[] factoryImplementationNames = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        String[] var10 = factoryImplementationNames;
                        int var11 = factoryImplementationNames.length;

                        for(int var12 = 0; var12 < var11; ++var12) {
                            String factoryImplementationName = var10[var12];
                            ((List)result.computeIfAbsent(factoryTypeName, (key) -> {
                                return new ArrayList();
                            })).add(factoryImplementationName.trim());
                        }
                    }
                }

        为了不讲废话了，直接将所有代码粘出来一起分析。整体逻辑就是getCandidateConfigurations方法调用loadFactoryNames方法，然后loadFactoryNames方法调用loadSpringFactories方法得到的，我们直接分析loadSpringFactories即可。
        我们从loadSpringFactories方法的第8行可以知道，组件的获取是扫描META-INF文件夹下的spring.factories得到的。
结果：
spring.factories文件：

configuration数量：

        哈哈哈，是不是发现一个新的问题。。。没错，spring.factories文件中远远没有144个。经过我的努力，终于找到了问题所在。在springboot2.7.5的版本中，需要加载的自动配类已经放到META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports中，而不是写在spring.factories文件中。
官网原文：


        在这个文件中刚好有144条需要加载的配置类。

4. 按需开启自动配置

        上面讲解了springboot如何加载所有的自动配置类，但在实际上，并不会加载所有的自动配置类，而是按需加载。如何按需加载呢，我们举两个例子。

4.1 以AopAutoConfiguration为例

@AutoConfiguration
@ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)
public class AopAutoConfiguration {
	@Configuration(proxyBeanMethods = false)
	@ConditionalOnClass(Advice.class)
	static class AspectJAutoProxyingConfiguration {
		@Configuration(proxyBeanMethods = false)
		@EnableAspectJAutoProxy(proxyTargetClass = false)
		@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false")
		static class JdkDynamicAutoProxyConfiguration {
		}
		@Configuration(proxyBeanMethods = false)
		@EnableAspectJAutoProxy(proxyTargetClass = true)
		@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",
				matchIfMissing = true)
		static class CglibAutoProxyConfiguration {
		}
	}
	@Configuration(proxyBeanMethods = false)
	@ConditionalOnMissingClass("org.aspectj.weaver.Advice")
	@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",
			matchIfMissing = true)
	static class ClassProxyingConfiguration {

		@Bean
		static BeanFactoryPostProcessor forceAutoProxyCreatorToUseClassProxying() {
			return (beanFactory) -> {
				if (beanFactory instanceof BeanDefinitionRegistry) {
					BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
					AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
					AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
				}
			};
		}

	}
}

        在AopAutoConfiguration类上面加上了@ConditionalOnProperty注解，表明配置文件中如果存在spring.aop.auto=true,那么则加载该配置类，matchIfMissing = true表示就算配置文件没有配置，该配置类也生效。
        上面的第5行代码（@ConditionalOnClass(Advice.class)）表示如果Advice类存在，那么AspectJAutoProxyingConfiguration配置类则生效；上面第20行代码（@ConditionalOnMissingClass(“org.aspectj.weaver.Advice”)）表示Advice类不存在则ClassProxyingConfiguration配置类生效。
        由此可知，当没有导入aspectj相关的jar包时，springboot中AOP默认使用JDK动态代理来实现。

4.2 以BatchAutoConfiguration为例

@AutoConfiguration(after = HibernateJpaAutoConfiguration.class)
@ConditionalOnClass({ JobLauncher.class, DataSource.class })
@ConditionalOnBean(JobLauncher.class)
@EnableConfigurationProperties(BatchProperties.class)
@Import({ BatchConfigurerConfiguration.class, DatabaseInitializationDependencyConfigurer.class })
public class BatchAutoConfiguration {
}

        如上面的代码（第二第三行代码），当JobLauncher类存在且JobLauncher对应的bean存在于容器时，该配置类才会生效，否则不会开启该配置。
        总结：在springboot中默认会加载所有的配置类且开启按需自动配置类，自动配置功能是通过@ConditionalOnClass、@ConditionalOnProperty和@ConditionalOnMissingClass等一系列注解实现的。

5. 总结

• SpringBoot中的核心注解是@SpringBootApplication，不过该注解是一个合成注解，主要是由@SpringBootConfiguration、@EnableAutoConfiguration和@ComponentScan等三个注解组成。
• SpringBoot的自动配置是通过扫描spring-boot-configuration中META-INF文件夹下的spring.factories文件，然后加载对应的配置类来实现的。
• SpringBoot的自动配置不会加载所有的配置类，而是按需配置，主要是通过@ConditionalOnClass、@ConditionalOnProperty和@ConditionalOnMissingClass等一系列注解实现的。

注意：在以前的版本中，SpringBoot会扫描META-INF文件夹下的spring.factories文件，在SpringBoot2.7.5（从哪个版本开始不知道）中改成了spring文件夹下的org.springframework.boot.autoconfigure.AutoConfiguration.imports文件。

参考：【尚硅谷】SpringBoot2零基础入门教程