最新springboot中必須要了解的自動裝配原理

更新時間：2022年05月20日 11:30:20 作者：奔走的王木木Sir

本文給大家介紹springboot中必須要了解的自動裝配原理，spring-boot-dependencies：核心依賴都在父工程中，這個里面主要是管理項目的資源過濾及插件，本文對springboot自動裝配原理給大家介紹的非常詳細，需要的朋友參考下吧

1.pom.xml

父依賴 \textcolor{orange}{父依賴} 父依賴

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

這里ctrl+左鍵，點擊之后我們可以看到父依賴

這個里面主要是管理項目的資源過濾及插件，我們發(fā)現(xiàn)他還有一個父依賴

看看下面這個，熟悉嗎？

再點進去，我們發(fā)現(xiàn)有很多的依賴。這就是SpringBoot的版本控制中心。

這個地方才是真正管理SpringBoot應(yīng)用里面所有依賴的地方，也就是版本控制中心。

我們在寫或引入一些SpringBoot依賴的時候，不需要指定版本，就是因為有這些版本倉庫。

2.啟動器

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

啟動器就是springboot的啟動場景 \textcolor{red}{啟動器就是SpringBoot的啟動場景} 啟動器就是SpringBoot的啟動場景

springboot-boot-starter-xxx：就是spring-boot的場景啟動器

spring-boot-starter-web：幫我們導(dǎo)入了web模塊正常運行所依賴的組件；也就是自動導(dǎo)入web環(huán)境所有的依賴

SpringBoot將所有的功能場景都抽取出來，做成一個個的starter （啟動器）；

要用什么功能就導(dǎo)入什么樣的場景啟動器：只需要在項目中引入這些starter即可，所有相關(guān)的依賴都會導(dǎo)入進來；

我們未來也可以自己自定義 starter；

3.主程序

//程序的主入口
//@SpringBootApplication：標注這個類是一個springBoot的應(yīng)用
@SpringBootApplication
public class HelloSpringBootApplication {
   public static void main(String[] args) {
      //將springBoot應(yīng)用啟動
      SpringApplication.run(HelloSpringBootApplication.class, args);
   }
}

看著如此的簡單，它就是通過反射加載這個類的對象，這是表面意思，我們看不到它為啥啟動。

首先我們來看

3.1注解

@SpringBootApplication

我們點擊@SpringBootApplication后可以看到有這么幾個注解

結(jié)論：springBoot所有的自動配置都是在啟動的時候掃描并加載：spring.factories所有的自動配置類都在這里面，但是不一定生效，要判斷條件是否成立，只要導(dǎo)入了對應(yīng)的start，就有了對應(yīng)的啟動器，有了啟動器，自動裝配就是生效，之后配置成功

@ComponentScan

這個注解在Spring中非常重要，對應(yīng)的是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
@Indexed
public @interface SpringBootConfiguration {
    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

這里的@Configuration說明這是一個配置類，這個配置類就是對應(yīng)Spring的xml配置文件

@Component說明，啟動類本身也是Spring中的一個組件，負責(zé)啟動應(yīng)用。

@EnableAutoConfiguration

作用：開啟自動配置功能

點進去后會看到

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

然后我們發(fā)現(xiàn)了@AutoConfigurationPackage它的作用是自動配置包

@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {
}

@import ：Spring底層注解@import ，給容器中導(dǎo)入一個組件

AutoConfigurationPackages.Registrar.class 作用：將主啟動類的所在包及包下面所有子包里面的所有組件掃描到Spring容器；

我們退回上一步看一下這個注解

@Import({AutoConfigurationImportSelector.class}) ：給容器導(dǎo)入組件；

AutoConfigurationImportSelector ：自動配置導(dǎo)入選擇器，在這個類中有這么一個方法

/**
 * 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
 */
//獲得候選的配置
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    //這里的getSpringFactoriesLoaderFactoryClass()
    //返回的是我們最開是看到啟動自動導(dǎo)入配置文件的注解類；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;
}

在上面這個方法中調(diào)用了SpringFactoriesLoader這個類中的靜態(tài)方法，我們查看一下這個類中的loadFactoryNames這個方法。

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

發(fā)現(xiàn)他又調(diào)用了loadSpringFactories這個方法，我們繼續(xù)看

private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
    Map<String, List<String>> result = (Map)cache.get(classLoader);
    if (result != null) {
        return result;
    } else {
        HashMap result = new HashMap();
        try {
            Enumeration 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()) {
                    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) -> {
                            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);
        }
    }
}

這里我們發(fā)現(xiàn)多次出現(xiàn)了一個叫spring.factories\textcolor{red}{這里我們發(fā)現(xiàn)多次出現(xiàn)了一個叫spring.factories} 這里我們發(fā)現(xiàn)多次出現(xiàn)了一個叫spring.factories

3.2 spring.factories

隨便點一個看看JerseyAutoConfiguration

會發(fā)現(xiàn)這都是javaConfig配置類，而且都注入了一些Bean。

所以，自動配置真正實現(xiàn)是從classpath中搜尋所有的META-INF/spring.factories配置文件，并將其中對應(yīng)的 org.springframework.boot.autoconfigure. 包下的配置項，通過反射實例化為對應(yīng)標注了 @Configuration的JavaConfig形式的IOC容器配置類，然后將這些都匯總成為一個實例并加載到IOC容器中。

4. 結(jié)論

springboot在啟動的時候，從類路徑下/META-INF/spring.factories獲取指定的值；
將這些自動配置的類導(dǎo)入容器，自動配置就會生效，進行自動配置；
以前需要自動配置的東西，現(xiàn)在springboot幫忙做了；
整合JavaEE，解決方案和自動配置的東西都在spring-boot-autoconfigure-2.5.7.jar這個包下
他會把所有需要導(dǎo)入的組件，以類名的方式返回，這些組件就會被添加到容器中
容器中也會存在非常多的xxxAutoConfiguration的文件（@Bean），就是這些類給容器中的導(dǎo)入這個場景需要的所有組件，并自動配置。@Configuration，javaCOnfig
有了自動配置類，免去了我們手動編寫配置文件的工作。

到此這篇關(guān)于最新springboot中必須要了解的自動裝配原理的文章就介紹到這了,更多相關(guān)springboot自動裝配原理內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: