springboot中必须要了解的自动装配原理

🏇

       学
      
      
       习
      
      
       S
      
      
       p
      
      
       r
      
      
       i
      
      
       n
      
      
       g
      
      
       B
      
      
       o
      
      
       o
      
      
       t
      
     
    
    
     \textcolor{Orange}{学习SpringBoot}
    
   
  学习SpringBoot

🙏

      学
     
     
      习
     
     
      过
     
     
      程
     
     
      中
     
     
      的
     
     
      笔
     
     
      记
     
     
      ，
     
     
      方
     
     
      便
     
     
      查
     
     
      阅
     
     
      学
     
     
      习
     
    
   
   
    \textcolor{green}{学习过程中的笔记，方便查阅学习}
   
  
 学习过程中的笔记，方便查阅学习💗

🍣

      如
     
     
      果
     
     
      在
     
     
      其
     
     
      中
     
     
      需
     
     
      要
     
     
      我
     
     
      的
     
     
      源
     
     
      码
     
     
      ，
     
     
      可
     
     
      以
     
     
      私
     
     
      聊
     
     
      我
     
    
   
   
    \textcolor{green}{如果在其中需要我的源码，可以私聊我}
   
  
 如果在其中需要我的源码，可以私聊我🍣

欢迎各位小伙伴😄关注👍点赞⭐️收藏📝留言

自动装配原理

1.pom.xml

      父
     
     
      依
     
     
      赖
     
    
   
   
    \textcolor{orange}{父依赖}
   
  
 父依赖

• spring-boot-dependencies：核心依赖都在父工程中

这里ctrl+左键，点击之后我们可以看到父依赖
这个里面主要是管理项目的资源过滤及插件，我们发现他还有一个父依赖

看看下面这个，熟悉吗？😜

再点进去，我们发现有很多的依赖。这就是SpringBoot的版本控制中心。

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

• 我们在写或引入一些SpringBoot依赖的时候，不需要指定版本，就是因为有这些版本仓库。

2.启动器

<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency>

     启
    
    
     动
    
    
     器
    
    
     就
    
    
     是
    
    
     S
    
    
     p
    
    
     r
    
    
     i
    
    
     n
    
    
     g
    
    
     B
    
    
     o
    
    
     o
    
    
     t
    
    
     的
    
    
     启
    
    
     动
    
    
     场
    
    
     景
    
   
  
  
   \textcolor{red}{启动器就是SpringBoot的启动场景}
  
 
启动器就是SpringBoot的启动场景

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

spring-boot-starter-web：帮我们导入了web模块正常运行所依赖的组件；也就是自动导入web环境所有的依赖

SpringBoot将所有的功能场景都抽取出来，做成一个个的starter （启动器）；

要用什么功能就导入什么样的场景启动器：只需要在项目中引入这些

starter

即可，所有相关的依赖都会导入进来 ；

我们未来也可以自己自定义 starter；

3.主程序

//程序的主入口//@SpringBootApplication：标注这个类是一个springBoot的应用@SpringBootApplicationpublicclassHelloSpringBootApplication{publicstaticvoidmain(String[] args){//将springBoot应用启动SpringApplication.run(HelloSpringBootApplication.class, args);}}

看着如此的简单，它就是通过反射加载这个类的对象，这是表面意思，我们看不到它为啥启动。

首先我们来看

3.1注解

@SpringBootApplication

我们点击

@SpringBootApplication

后可以看到有这么几个注解

结论：springBoot所有的自动配置都是在启动的时候扫描并加载：

spring.factories

所有的自动配置类都在这里面，但是不一定生效，要判断条件是否成立，只要导入了对应的start，就有了对应的启动器，有了启动器，自动装配就是生效，之后配置成功

@ComponentScan

这个注解在Spring中非常重要，对应的是XML配置中的元素。

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

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

@SpringBootConfiguration

作用：SpringBoot的配置类 ，标注在某个类上 ， 表示这是一个SpringBoot的配置类；

@Target({ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Documented@Configuration@Indexedpublic@interfaceSpringBootConfiguration{@AliasFor(
        annotation =Configuration.class)booleanproxyBeanMethods()defaulttrue;}

这里的

@Configuration

说明这是一个配置类，这个配置类就是对应Spring的xml配置文件

@Component

说明，启动类本身也是Spring中的一个组件，负责启动应用。

@EnableAutoConfiguration

作用：开启自动配置功能

点进去后会看到

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

然后我们发现了

@AutoConfigurationPackage

它的作用是自动配置包

@Import(AutoConfigurationPackages.Registrar.class)public@interfaceAutoConfigurationPackage{}

@import 

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

AutoConfigurationPackages.Registrar.class

作用：将主启动类的所在包及包下面所有子包里面的所有组件扫描到Spring容器 ；

我们退回上一步看一下这个注解

@Import({AutoConfigurationImportSelector.class}) 

：给容器导入组件 ；

AutoConfigurationImportSelector ：自动配置导入选择器，在这个类中有这么一个方法

/**
 * Return the auto-configuration class names that should be considered. By default
 * this method will load candidates using {@link SpringFactoriesLoader} with
 * {@link #getSpringFactoriesLoaderFactoryClass()}.
 * @param metadata the source metadata
 * @param attributes the {@link #getAttributes(AnnotationMetadata) annotation
 * attributes}
 * @return a list of candidate configurations
 *///获得候选的配置protectedList<String>getCandidateConfigurations(AnnotationMetadata metadata,AnnotationAttributes attributes){//这里的getSpringFactoriesLoaderFactoryClass()//返回的是我们最开是看到启动自动导入配置文件的注解类；EnableAutoConfigurationList<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;}

在上面这个方法中调用了

SpringFactoriesLoader

这个类中的静态方法，我们查看一下这个类中的

loadFactoryNames

这个方法。

publicstaticList<String>loadFactoryNames(Class<?> factoryType,@NullableClassLoader classLoader){ClassLoader classLoaderToUse = classLoader;if(classLoader ==null){
        classLoaderToUse =SpringFactoriesLoader.class.getClassLoader();}String factoryTypeName = factoryType.getName();return(List)loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName,Collections.emptyList());}

发现他又调用了

loadSpringFactories

这个方法，我们继续看

privatestaticMap<String,List<String>>loadSpringFactories(ClassLoader classLoader){Map<String,List<String>> result =(Map)cache.get(classLoader);if(result !=null){return result;}else{HashMap result =newHashMap();try{Enumeration urls = classLoader.getResources("META-INF/spring.factories");while(urls.hasMoreElements()){URL url =(URL)urls.nextElement();UrlResource resource =newUrlResource(url);Properties properties =PropertiesLoaderUtils.loadProperties(resource);Iterator var6 = properties.entrySet().iterator();while(var6.hasNext()){Entry<?,?> entry =(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)->{returnnewArrayList();})).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){thrownewIllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var14);}}}

     这
    
    
     里
    
    
     我
    
    
     们
    
    
     发
    
    
     现
    
    
     多
    
    
     次
    
    
     出
    
    
     现
    
    
     了
    
    
     一
    
    
     个
    
    
     叫
    
    
     s
    
    
     p
    
    
     r
    
    
     i
    
    
     n
    
    
     g
    
    
     .
    
    
     f
    
    
     a
    
    
     c
    
    
     t
    
    
     o
    
    
     r
    
    
     i
    
    
     e
    
    
     s
    
   
  
  
   \textcolor{red}{这里我们发现多次出现了一个叫spring.factories}
  
 
这里我们发现多次出现了一个叫spring.factories

3.2 spring.factories

随便点一个看看

JerseyAutoConfiguration

会发现这都是javaConfig配置类，而且都注入了一些Bean。

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

4. 结论

• springboot在启动的时候，从类路径下/META-INF/spring.factories获取指定的值；
• 将这些自动配置的类导入容器，自动配置就会生效，进行自动配置；
• 以前需要自动配置的东西，现在springboot帮忙做了；
• 整合JavaEE，解决方案和自动配置的东西都在spring-boot-autoconfigure-2.5.7.jar这个包下
• 他会把所有需要导入的组件，以类名的方式返回，这些组件就会被添加到容器中
• 容器中也会存在非常多的xxxAutoConfiguration的文件（@Bean），就是这些类给容器中的导入这个场景需要的所有组件，并自动配置。@Configuration，javaCOnfig
• 有了自动配置类，免去了我们手动编写配置文件的工作。