SpringBoot自动装配原理

最新推荐文章于 2024-10-04 22:46:18 发布

橘子吃不

最新推荐文章于 2024-10-04 22:46:18 发布

阅读量90

点赞数

本文链接：https://blog.csdn.net/xjnxvjd/article/details/128756160

版权

文章详细阐述了SpringBoot自动装配的原理，从pom.xml的父依赖和启动器设置开始，探讨了@SpringBootApplication注解的作用，特别是@EnableAutoConfiguration如何工作，通过加载META-INF/spring.factories文件找到自动配置类进行组件导入和配置。SpringBoot通过starter简化了依赖管理和功能引入，使得开发更加便捷。

摘要由CSDN通过智能技术生成

自动装配原理

SpringBoot的自动装配也是面试中一个老生常谈的话题,属于谈到SpringBoot就避不开的问题,今天就从源码的层面分析一下SpringBoot的自动装配

我们在创建一个SpringBoot项目的时候会有这样的配置信息在pom.xml中

父依赖

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.5.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

点进去里面还有一个依赖


<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.2.5.RELEASE</version>
    <relativePath>../../spring-boot-dependencies</relativePath>
</parent>

这里就是SpringBoot应用里面所有依赖版本信息的地方,是SpringBoot的版本控制中心;

有了这个配置我们就可以导入默认的版本,不需要单独写版本号,但是如果导入的包没有在依赖管理中,那就需要自己手动导入版本信息了.

spring-boot-starter 启动器

我们在pom.xml还可以看到这样的依赖


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

spring-boot-starter-xxx:这个就是spring-boot的长场景启动器

spring-boot-starter-web:帮我们导入了web模块正常运行所依赖的一些组件;

SpringBoot将所有的功能场景都抽取出来,做成一个一个的starter,只需要在项目中引用这些starter就可以,帮要用的依赖导进来,我们要用什么功能就导入什么功能场景启动器;我们在之后甚至可以自定义starter;

主启动类

默认的主启动类如下:

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

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

}

@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 {
    // ......
}

有着一些别的注解分别是

@ComponentScan

这个注解是Spring中的他的作用就是自动扫描并加载符合条件的组件或者bean,将这个bean定义加载到ioc容器中

@SpringBootConfiguration

这个注解是表示由它所标注的类就是SpringBoot的配置类

我们点进@SpringBootConfiguration注解中可以看到


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

@Component
public @interface Configuration {}

这里面的@Configuration注解说明他是一个配置类,对应的就是Spring的xml配置文件

@Component 说明启动类就是一个组件他的功能就是负责启动应用

我们再退回到@SpringBootConfiguration可以看到

@EnableAutoConfiguration

@EnableAutoConfiguration这个注解的意思是开启配置功能

之前的我们都是自己配置信息,现在是SpringBoot帮助我们配置

这个注解告诉SpringBoot开启自动配置

我们点进去可以看到

@AutoConfigurationPackage

他的意思是自动装配包


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

@Import:Spring底层注解@import,它是给容器导入一个组件

Registrar.class它的作用就是将著启动类下面所有组件扫描到Spring容器中

我们再看@EnableAutoConfiguration下的

@Import({AutoConfigurationImportSelector.class})

他的作用是给容器导入组件

AutoConfigurationImportSelector :自动装配导入选择器,那么他会导入到那一给选择器中呢


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


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

我们进入loadSpringFactories方法


private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
    //获得classLoader ， 我们返回可以看到这里得到的就是EnableAutoConfiguration标注的类本身
    MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
    if (result != null) {
        return result;
    } else {
        try {
            //去获取一个资源 "META-INF/spring.factories"
            Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
            LinkedMultiValueMap result = new LinkedMultiValueMap();

            //将读取到的资源遍历，封装成为一个Properties
            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 factoryClassName = ((String)entry.getKey()).trim();
                    String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                    int var10 = var9.length;

                    for(int var11 = 0; var11 < var10; ++var11) {
                        String factoryName = var9[var11];
                        result.add(factoryClassName, factoryName.trim());
                    }
                }
            }

            cache.put(classLoader, result);
            return result;
        } catch (IOException var13) {
            throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
        }
    }
}

发现所有的源头都在一个叫做spring.factories的文件中

结论：