SpringBoot-自动装配原理初探

SpringBoot-自动装配原理初探

三、自动装配原理初探

springboot项目是怎么运行的呢？我们一起来探究探究：

1、pom.xml

父依赖

主要是依赖一个父项目，管理项目的资源过滤和插件

<parent>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-parentartifactId>
    <version>2.4.3version>
    <relativePath/> 
parent>

点进源码发现还有一个父依赖：

<parent>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-dependenciesartifactId>
    <version>2.4.3version>
    <relativePath>../../spring-boot-dependenciesrelativePath>
parent>

这里才是真正管理SpringBoot应用里面所有依赖版本的地方，SpringBoot的版本控制中心；

以后我们导入依赖默认是不需要写版本；但是如果导入的包没有在依赖中管理着就需要手动配置版本了；

启动器spring-boot-starter

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-webartifactId>
dependency>

springboot-boot-starter-xxx：就是spring-boot的场景启动器

spring-boot-starter-web：帮我们导入了web模块正常运行所依赖的组件；

SpringBoot将所有的功能场景都抽取出来，做成一个个的starter （启动器），只需要在项目中引入这些starter即可，所有相关的依赖都会导入进来 ， 我们要用什么功能就导入什么样的场景启动器即可 ；我们未来也可以自己自定义 starter；

2、主启动类

默认的主启动类

/@SpringBootApplication 来标注一个主程序类
//说明这是一个Spring Boot应用
@SpringBootApplication
public class SpringbootApplication {

   public static void main(String[] args) {
     //以为是启动了一个方法，没想到启动了一个服务
      SpringApplication.run(SpringbootApplication.class, args);
   }
}

SpringApplication启动类

• SpringApplication.run方法分为两个部分：一部分是SpringApplication的实例化，一部分是run方法的执行

• SpringApplication类主要做了以下四件事：

  • 推断应用的类型是普通类型还是web类型；
  • 查找并加载所有可用初始化器，设置到initializers属性中；
  • 找出所有应用程序监听器，设置到listeners属性中；
  • 推断并设置main方法的定义类，找到运行的主类；

• 查看其构造器

public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
    // ......
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
    this.setInitializers(this.getSpringFactoriesInstances();
    this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
    this.mainApplicationClass = this.deduceMainApplicationClass();
}

@SpringBootApplication

作用：标注这个类为Springboot的主配置类，springboot运行这个类的main方法来启动springboot应用；

进入这个注解，可以看到很多其他注解：

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

@ComonentScan

作用：自动扫描并加载符合条件的组件或者bean，将整个bean定义加载到IOC容器中；

@SpringBootConfiguration

作用：SpringBoot的配置类;

点进这个注解继续查看：

// 点进去得到下面的 @Component
@Configuration
public @interface SpringBootConfiguration {}

@Component
public @interface Configuration {}

• 这里的 @Configuration，说明这是一个配置类 ，配置类就是对应Spring的xml 配置文件；
• @Component （组件）这就说明，启动类本身也是Spring中的一个组件而已，负责启动应用！

@EnableAutoConfiguration

开启自动配置功能，让自动配置生效；

进入注解查看：

@AutoConfigurationPackage：自动配置包

@Import(AutoConfigurationPackages.Registrar.class)

• @import: Spring底层注解@import，给容器中导入一个组件

• Registrar.class：将主启动类的所在包及包下面所有子包里面的所有组件扫描到Spring容器;

@Import(AutoConfigurationImportSelector.class):给容器导入组件

AutoConfigurationImportSelector：自动导入选择器

1、这个类中有一个这样的方法：

// 获得候选的配置
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    //这里的getSpringFactoriesLoaderFactoryClass（）方法
    //返回的就是我们最开始看的启动自动导入配置文件的注解类；EnableAutoConfiguration
    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;
}

2、这个方法调用了SpringFactoriesLoader类的静态方法，我们进入这个方法，可以看到loadFactoryNames()方法：

	public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
		String factoryTypeName = factoryType.getName();
        //这里它又调用了 loadSpringFactories 方法
		return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
	}

3、查看loadFactoryNames（）方法：

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
		MultiValueMap<String, String> result = cache.get(classLoader);
		if (result != null) {
			return result;
		}

		try {
            //去获取一个资源 FACTORIES_RESOURCE_LOCATION=>"META-INF/spring.factories"
			Enumeration<URL> urls = (classLoader != null ?
					classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
					ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
			result = new LinkedMultiValueMap<>();
            //将读取到的资源封装成一个Properties
			while (urls.hasMoreElements()) {
				URL url = urls.nextElement();
				UrlResource resource = new UrlResource(url);
				Properties properties = PropertiesLoaderUtils.loadProperties(resource);
				for (Map.Entry<?, ?> entry : properties.entrySet()) {
					String factoryTypeName = ((String) entry.getKey()).trim();
					for (String factoryImplementationName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
						result.add(factoryTypeName, factoryImplementationName.trim());
					}
				}
			}
			cache.put(classLoader, result);
			return result;
		}
		catch (IOException ex) {
			throw new IllegalArgumentException("Unable to load factories from location [" +
					FACTORIES_RESOURCE_LOCATION + "]", ex);
		}
	}

在jar包spring-boot-autoconfigure下的META-INF目录下找到spring.factories

发现里面有很多配置文件，这就是自动配置根源所在！！

所以，自动配置真正实现是从classpath中搜寻所有的META-INF/spring.factories配置文件 ，并将其中对应的 org.springframework.boot.autoconfigure. 包下的配置项，通过反射实例化为对应标注了 @Configuration的JavaConfig形式的IOC容器配置类 ， 然后将这些都汇总成为一个实例并加载到IOC容器中。

结论：

1. SpringBoot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值
2. 将这些值作为自动配置类导入容器 ， 自动配置类就生效 ， 帮我们进行自动配置工作；
3. 整个J2EE的整体解决方案和自动配置都在springboot-autoconfigure的jar包中；
4. 它会给容器中导入非常多的自动配置类 （xxxAutoConfiguration）, 就是给容器中导入这个场景需要的所有组件 ， 并配置好这些组件 ；
5. 有了自动配置类 ， 免去了我们手动编写配置注入功能组件等的工作；