Java研学-SpringBoot(三)

五 Spring Boot 自动配置原理

1 概念

springboot的自动装配就是从spring.factories文件中获取到对应的需要进行自动装配的类，并生成相应的Bean对象，然后将它们交给spring容器来帮我们进行管理。核心注解：@SpringBootApplication
调用main函数之前会扫描该类上是否有注解，有注解就执行对应的某些功能SpringApplication.run(DemoApplication.class, args);表示把这个类加载进来作为主启动类，同时让springboot启动Tomcat，再将外界传递的参数通过args获取到(例如启动springboot项目时的命令 java -jar xxx.jar --server.port=80 就是通过args传递到项目中的)

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

2 @SpringBootApplication 核心注解（复合注解）

// 元注解
// 贴在哪里
@Target(ElementType.TYPE)
// 什么时期生效
@Retention(RetentionPolicy.RUNTIME)
// 文档标记
@Documented
// 继承
@Inherited

// 同为复合注解 含元注解中的123 与 @Configuration(装配类注解)
@SpringBootConfiguration

// 核心注解中的核心注解 自动装配
@EnableAutoConfiguration

// 扫描时 排除某些文件 从当前位置开始往下扫描
@ComponentScan(excludeFilters = {
	 @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
	 @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })

3 @EnableAutoConfiguration 核心注解（复合注解）

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
// 自动导入配置包
@AutoConfigurationPackage
// 导入AutoConfigurationImportSelector类 所有自动装配的活都是这个类做（自动配置类）
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
	String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

	Class<?>[] exclude() default {};

	String[] excludeName() default {};

}

4 AutoConfigurationImportSelector.class

于该类中的此方法中进行自动装配，基于注解元数据获取并筛选自动配置类，同时考虑用户可能希望排除的配置类。最后，它返回一个包含筛选后的配置和排除的配置的AutoConfigurationEntry对象

// 这是一个受保护的方法，返回AutoConfigurationEntry对象。它接收一个AnnotationMetadata对象作为参数，这个对象通常用于描述注解的元数据。
protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
		// 首先检查给定的注解元数据是否启用了自动配置。如果没有启用，则返回一个空的AutoConfigurationEntry
		if (!isEnabled(annotationMetadata)) {
			return EMPTY_ENTRY;
		}
		// 从注解元数据中获取注解属性，并将其存储在AnnotationAttributes对象中。
		AnnotationAttributes attributes = getAttributes(annotationMetadata);
		// 根据注解元数据和其属性，获取候选的自动配置类列表(127个结尾为AutoConfiguration的候选可装配类，版本不同数量不同)
		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);
		// 最后，返回一个新的AutoConfigurationEntry对象，该对象包含筛选后的配置列表和排除的配置列表
		return new AutoConfigurationEntry(configurations, exclusions);
	}

5 getCandidateConfigurations 方法

通过SpringFactoriesLoader的loadFactoryNames方法获取这127个候选可装配类，这是一个受保护的方法，它接收两个参数：AnnotationMetadata（注解元数据）和AnnotationAttributes（注解属性）。该方法返回一个List，其中包含自动配置类的名称

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
// 这行代码调用了SpringFactoriesLoader的loadFactoryNames方法，该方法用于从META-INF/spring.factories文件中加载指定类型的工厂类名
		List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
				getBeanClassLoader());
		Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you "
				+ "are using a custom packaging, make sure that file is correct.");
		return configurations;
	}

6 SpringFactoriesLoader.loadFactoryNames 方法

用于从META-INF/spring.factories文件中加载特定类型的工厂名称列表，并返回这个列表。如果文件中没有指定类型的条目，则返回一个空列表

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
// 这行代码获取factoryType的完全限定名（包括包名）
        String factoryTypeName = factoryType.getName();
// 拿到127个候选可装配类
        return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
    }

7 loadSpringFactories 方法

这个方法的目的是从META-INF/spring.factories文件中读取并解析工厂条目，并将结果存储在缓存中以便后续快速访问。这是Spring Boot自动配置机制的一部分，它允许第三方库通过spring.factories文件来声明它们提供的自动配置类或其他工厂类。

// 定义了一个私有静态方法loadSpringFactories，它接收一个可能为null的类加载器classLoader作为参数，并返回一个映射，其中键是工厂类型的名称，值是相应类型的工厂实现类名的列表。
private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
// 尝试从缓存cache中获取已加载的spring.factories映射。这里假设cache是一个ConcurrentMap，其键是类加载器，值是MultiValueMap。
        MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
        // 如果缓存中已经存在结果，则直接返回这个缓存的结果，避免重复加载。
        if (result != null) {
            return result;
        } else {
            try {
            // 尝试使用提供的类加载器（如果存在）或系统类加载器来获取所有META-INF/spring.factories资源的URL。
                Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
                // 初始化一个新的LinkedMultiValueMap来存储加载的工厂条目。这个映射允许同一个键关联多个值。
                LinkedMultiValueMap result = new LinkedMultiValueMap();

				// 遍历所有找到的spring.factories文件URL，为每个URL创建一个UrlResource，
				// 并使用PropertiesLoaderUtils加载文件内容为一个Properties对象。
                while(urls.hasMoreElements()) {
               		// 检索出的本地仓路径拼接上META-INF/spring.factories
                    URL url = (URL)urls.nextElement();
                    // urls实质上就是External Libraries中导入的所有jar包(jar包都在本地仓中)，于程序中拿到所有的jar包，看每个jar包中是否有META-INF/spring.factories文件（不是每个jar包都有这个文件，带有start的依赖对应的jar包才会有），若存在将其中的内容(自动装配类的全名)读取出来，将这些自动装配类的全名(格式为xxxAutoConfiguration)存到一个List集合中作为候选配置（不一定会生效）
                    UrlResource resource = new UrlResource(url);
                    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                    // 遍历Properties对象的每个条目。每个条目的键是工厂类型名称，值是逗号分隔的工厂实现类名列表
                    Iterator var6 = properties.entrySet().iterator();
                    while(var6.hasNext()) {
                        Entry<?, ?> entry = (Entry)var6.next();
                        String factoryTypeName = ((String)entry.getKey()).trim();
                        String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        // 对于每个工厂类型名称，遍历其关联的工厂实现类名数组，并将实现类名添加到result映射中，与工厂类型名称相关联。
                        int var10 = var9.length;
                        for(int var11 = 0; var11 < var10; ++var11) {
                            String factoryImplementationName = var9[var11];
                            result.add(factoryTypeName, factoryImplementationName.trim());
                        }
                    }
                }
                // 将加载的结果放入缓存中，并返回结果。
                cache.put(classLoader, result);
                return result;
            } catch (IOException var13) {
            // 如果在加载过程中出现IOException，则捕获该异常并抛出一个带有更具体消息的IllegalArgumentException
                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
            }
        }
    }

8 WebMvcAutoConfiguration – 例子

// 注解
@Configuration(proxyBeanMethods = false)
// 必须满足某些条件 才能进行自动装配(Conditional 有条件的) 不满足则不装配
// 检查当前应用是否是一个基于 Servlet 的 Web 应用，是则进行装配
@ConditionalOnWebApplication(type = Type.SERVLET)
// 必须有以下3个类(需要spring-boot-starter-web依赖)
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
// 当没有WebMvcConfigurationSupport这个Bean的时候进行自动装配，有则不进行装配
// WebMvcConfigurationSupport该类中会做所有的默认配置 若更改了默认配置 则不对更改的配置做默认配置了
// 即该类中都是可以自行传递的配置，若自己没配则全部使用默认配置(不满足于默认装配可自行配置(重写方法))
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
// 想使用SpringMvc需在配置DispatcherServlet之后
@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class,
		ValidationAutoConfiguration.class })

9 小结

Spring Boot的自动装配原理是基于其内部的一套约定和机制，使得开发者能够更便捷地构建Spring应用程序，而无需进行大量的手动配置。

主方法中通过SpringApplication.run(DemoApplication.class, args)方法将这个类加载进来作为主启动类，同时让springboot启动Tomcat，再将外界传递的参数通过args获取到，而调用main函数之前就会进行扫描，该类上是否有注解，有注解就会执行对应的某些功能，在主方法之上的就是@SpringBootApplication注解

该注解为复合注解包含了4个基本元注解，以及3个非元注解@SpringBootConfiguration(同为复合注解含元注解中的123 与 @Configuration)，@EnableAutoConfiguration(核心注解中的核心注解自动装配)，@ComponentScan(扫描时排除某些文件从当前位置开始往下扫描)

其中@EnableAutoConfiguration注解中导入了一个 AutoConfigurationImportSelector 配置类，该类中有个 getCandidateConfigurations 方法，方法的作用是委托 SpringFactoriesLoader 的方法loadSpringFactories去读取 jar 包中的 META-INF/spring.factories 文件，并加载里面配置的自动配置对象，包括：AOP，Jackson，DataSourceDataSourceTransactionManager，DispatcherServlet 等等。

选取其中一个对象，例如 Spring MVC，查看其自动配置类，类上含有4个注解@Configuration：声明这个类是一个配置类
@ConditionalOnWebApplication(type = Type.SERVLET)，ConditionalOn，翻译就是在某个条件下，此处就是满足项目的类是是 Type.SERVLET 类型
@ConditionalOnClass({Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
这里的条件是 OnClass，也就是满足以下类存在：Servlet、DispatcherServlet、WebMvcConfigurer。这里就是判断是否引入了 Spring MVC相关依赖，引入依赖后该条件成立，当前类的配置才会生效！

@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)这个条件与上面不同，OnMissingBean，是说环境中没有指定的 bean 这个才生效。其实这就是自定义配置的入口，也就是说，如果我们自己配置了一个 WebMVCConfigurationSupport 的 bean，代表容器里已经存在该 bean 了，那么这个默认配置就会失效！@AutoConfigureAfter 注解，意为指定的类加载完了后，再加载本类。

项目中添加了很多jar，在这些jar包中，我们依次去寻找spring.factories文件，该文件中存在了自动装配类的全名，这些类的名字有一个特点都是以XxxAutoConfiguration，将这些名字存到一个List集合中作为候选配置（所谓的候选就是不一定会生效）

至于这些自动装配类是否生效取决于，XxxAutoConfiguration类上面对注解，＠ConditionalOnXxx我们称之为条件注解，当有某些依赖的时候，自动装配生效，当相遇中有需求需要根据自己配置的时候，会让其自动装配不生效（大改）

自动从xxx.properties获取配置，获取的具体内容可以，通过application.properties或者application.yml，配置文件中修改（小改）

若自动装配生效，本质上其实就是在帮我们创建一些，Bean 存到容器中。

PS：对于依赖启动器，找到其对应的Maven：xxx-autoconfigure文件中的 META-INF/spring.factories 文件，其中就是其对应的自动装配候选类，选中定位后下面一般会对应有一个properties文件，其中有对应的前缀，获得前缀后就可以到application.properties文件中通过前缀进行配置，完成装配