1. SpringBoot的自动配置概念

SpringBoot相对于SSM来说，主要的优点就是简化了配置，不再需要像SSM哪有写一堆的XML配置，这些XML配置在大项目上会成为一种累赘，使得后期项目难以维护。

SpringBoot的出现，使得开发者不再关注于配置，能够更加专注于业务的开发，这得益于SpringBoot的自动配置。

2. SpringBoot自动配置的原理

SpringBoot的自动配置的核心就在于SpringBoot启动类中的@SpringBootApplication注解上

@SpringBootApplication
@Slf4j
public class MyApplication {public static void main(String[] args) {SpringApplication.run(MyApplication.class, args);log.info("Project running .....");}}

这是一个复合注解，标识该类为SpringBoot的应用入口，里面包含了SpringBootConfiguration、EnableAutoConfiguration、ComponentScan三个注解

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {@Filter(type = FilterType.CUSTOM,classes = {TypeExcludeFilter.class}
), @Filter(type = FilterType.CUSTOM,classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {....
}

三个注解的作用如下

SpringBootConfiguration：这是SpringBoot框架中的一个特殊注解，属于@Configuration派生注解，它的作用是在应用启动时会被自动加载和处理，简化应用程序的配置过程，提供快速的启动配置.
EnableAutoConfiguration：启用自动配置机制（自动配置的核心）
ComponentScan：扫描启动类路径下的类，自动注册带有@Component以及其他相关注解的类到Spring容器中

3. EnableAutoConfiguration

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注解的作用是将当前类所在的包以及子包作为自动配置的包路径，以便让SpringBoot能够自动加载和处理这些组件的配置。

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import({AutoConfigurationPackages.Registrar.class})
public @interface AutoConfigurationPackage {String[] basePackages() default {};Class<?>[] basePackageClasses() default {};
}

AutoConfigurationPackage中有@Import({AutoConfigurationPackages.Registrar.class})

@Import({AutoConfigurationPackages.Registrar.class})的作用是导入一个配置文件，在springboot中为给容器导入一个组件，而导入的组件由 AutoConfigurationPackages.class的内部类Registrar.class 执行逻辑来决定是如何导入的。

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {Registrar() {}public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {AutoConfigurationPackages.register(registry, (String[])(new PackageImports(metadata)).getPackageNames().toArray(new String[0]));}public Set<Object> determineImports(AnnotationMetadata metadata) {return Collections.singleton(new PackageImports(metadata));}
}

Registrar作为一个静态内部类，实现了ImportBeanDefinitionRegistrar接口，就可以被@Import注入到Spring容器中。

在这里类中，需要重点关注registerBeanDefinitions方法

通过DEBUG发现，(String[])(new PackageImports(metadata)).getPackageNames().toArray(new String[0])的值为当前启动类所在的包名。

因此，可以得出结论，这个方法的主要作用是启动类所在的包下的所有组件注入到Spring容器中。

接着，再看@Import({AutoConfigurationImportSelector.class})

通过@Import将AutoConfigurationImportSelector选择器导入。

在AutoConfigurationImportSelector需要重点关注getAutoConfigurationEntry方法

protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {if (!this.isEnabled(annotationMetadata)) {// 检查是否开始自动配置，如果返回false，则不开启，不需要导入任何配置类return EMPTY_ENTRY;} else {//从注解元数据中获取自动配置相关属性AnnotationAttributes attributes = this.getAttributes(annotationMetadata);//根据注解元数据和属性，获取潜在的候选自动配置类的列表List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);//去除重复的自动配置类configurations = this.removeDuplicates(configurations);//获取与自动配置相关的排除列表，即需要从候选自动配置中排除的类。Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);//检查排除列表中的类是否存在于候选自动配置列表中，并进行必要的处理。this.checkExcludedClasses(configurations, exclusions);//从候选自动配置列表中移除在排除列表中指定的类。configurations.removeAll(exclusions);//使用配置类过滤器（ConfigurationClassFilter）对候选自动配置列表进行进一步筛选和过滤。configurations = this.getConfigurationClassFilter().filter(configurations);//触发自动配置导入事件，可以通知其他监听器关于自动配置的导入信息。this.fireAutoConfigurationImportEvents(configurations, exclusions);return new AutoConfigurationEntry(configurations, exclusions);}
}

这个方法的返回值是候选的配置类，经过处理和筛选后的自动配置类列表以及排除列表。

重点是关注如何获取自动配置类列表，这个需要关注getCandidateConfigurations方法

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {//使用 SpringFactoriesLoader 从 META-INF/spring.factories 文件中加载所有的工厂名称，并将它们存储在一个新的 ArrayList 中。//getSpringFactoriesLoaderFactoryClass() 返回用于加载自动配置的工厂类。List<String> configurations = new ArrayList(SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader()));//使用 ImportCandidates 从指定的类路径加载 AutoConfiguration 类的子类或实现类，并将它们添加到候选配置列表中。//this.getBeanClassLoader() 返回当前线程的类加载器。ImportCandidates.load(AutoConfiguration.class, this.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;
}

这个方法的主要作用就是利用SpringFactoriesLoader加载META-INF/spring.factories文件

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

接着查看loadSpringFactories，这里面就是获取需要配置的类的主要核心过程了。

private static Map<String, List<String>> loadSpringFactories(ClassLoader 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 {//使用给定的类加载器获取所有位于 META-INF/spring.factories 路径下的资源文件的 URL 枚举Enumeration<URL> urls = classLoader.getResources("META-INF/spring.factories");//遍历每个资源文件的 URLwhile(urls.hasMoreElements()) {//获取下一个资源文件的 URLURL url = (URL)urls.nextElement();//将 URL 封装为 UrlResource 对象，以便进行读取。UrlResource resource = new UrlResource(url);//通过 PropertiesLoaderUtils 加载 UrlResource 对象所代表的资源文件，并将其作为属性对象 Properties 进行读取。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());}}}//对结果中的每个工厂类型及其对应的实现类列表，进行去重操作，并将列表转换为不可修改的集合，以确保唯一性result.replaceAll((factoryType, implementations) -> {return (List)implementations.stream().distinct().collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));});//将结果存储到缓存中，以便下次直接获取cache.put(classLoader, result);return result;} catch (IOException var14) {throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var14);}}
}

也就是说这个方法通过加载和解析 META-INF/spring.factories 文件中的内容，将工厂类型和其对应的实现类名关联起来，并返回一个包含工厂配置信息的 Map 对象。它使用了缓存机制来避免重复加载相同的配置文件，提高了性能。这些工厂配置信息在 Spring Boot 中用于自动装配和初始化各种组件、功能和设置。

这个META-INF/spring.factories文件指什么呢？

在我们导入的每一个XXX-spring-boot-starter中，除了本身的jar包以外，还会有一个 xxx-spring-boot-autoConfigure，这个就是第三方依赖自己编写的自动配置类。我们现在就以 spring-boot-autocongigure 这个依赖来说。

这些类就是自动配置的类了。就RedisAutoConfiguration而言
@AutoConfiguration
@ConditionalOnClass({RedisOperations.class})
@EnableConfigurationProperties({RedisProperties.class})
@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
public class RedisAutoConfiguration {public RedisAutoConfiguration() {}@Bean@ConditionalOnMissingBean(name = {"redisTemplate"})@ConditionalOnSingleCandidate(RedisConnectionFactory.class)public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {RedisTemplate<Object, Object> template = new RedisTemplate();template.setConnectionFactory(redisConnectionFactory);return template;}@Bean@ConditionalOnMissingBean@ConditionalOnSingleCandidate(RedisConnectionFactory.class)public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {return new StringRedisTemplate(redisConnectionFactory);}
}
里面已经配置好了，Redis参数指定了RedisProperties配置文件，还有数据源配置文件。

我们只需要在yml文件配置好，后面的全交给SpringBoot框架自己配置即可。