Springboot自动装配原理

于 2024-08-09 10:54:08 发布
阅读量429 收藏 17
点赞数 20
分类专栏： Spring Boot 文章标签： spring boot 自动装配原理 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45606067/article/details/141055163
版权

文章目录

其他文章：Springboot实现自定义starter功能

从启动类分析装配原理

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

点 @SpringBootApplication 进去查看源码如下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
	@AliasFor(annotation = EnableAutoConfiguration.class)
	Class<?>[] exclude() default {};

	@AliasFor(annotation = EnableAutoConfiguration.class)
	String[] excludeName() default {};

	@AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
	String[] scanBasePackages() default {};

	@AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
	Class<?>[] scanBasePackageClasses() default {};

	@AliasFor(annotation = ComponentScan.class, attribute = "nameGenerator")
	Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;

	@AliasFor(annotation = Configuration.class)
	boolean proxyBeanMethods() default true;

}

@SpringBootApplication 这是一个组合注解，包含了

  • @SpringBootConfiguration：里面就是 @Configuration注解，表明这是一个配置类，可以向容器中注入组件
  • @EnableAutoConfiguration：开启自动配置（重点）
  • @ComponentScan：可以basePackeageClasses 或basePackages来定义要扫描的特定包。如果没有定义特定的包，将从声明该注解的类的包开始扫描（包含子包）

@EnableAutoConfiguration

点 @EnableAutoConfiguration 进去查看源码如下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
	String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

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

	String[] excludeName() default {};
}

@AutoConfigurationPackage

作用：自动导入配置包。

点 @AutoConfigurationPackage 进去查看源码如下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {

	String[] basePackages() default {};

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

}

@Import 是Spring 的注解，导入一个配置文件，在Springboot中为容器导入一个组件，而导入的组件由 AutoConfigurationPackages.class的内部类 Registrar.class执行逻辑来决定是如何导入的。

@Import(AutoConfigurationPackages.Registrar.class)

点 Registrar.class 进去查看源码如下：

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        register(registry, new PackageImports(metadata).getPackageNames().toArray(new String[0]));
    }

    @Override
    public Set<Object> determineImports(AnnotationMetadata metadata) {
        return Collections.singleton(new PackageImports(metadata));
    }

}

ImportBeanDefinitionRegistrar是Spring框架提供的一个接口，用于动态注册BeanDefinition到Spring容器中，具体来说，ImportBeanDefinitionRegistrar接口有一个registerBeanDefinitions方法，该方法会在Spring容器启动时被调用。在该方法中，我们可以通过BeanDefinitionRegistry接口向Spring容器注册BeanDefinition，从而实现动态注册Bean。
通常情况下，ImportBeanDefinitionRegistrar会与@Import注解一起使用。通过@Import注解引入ImportBeanDefinitionRegistrar的实现类，从而实现BeanDefinition的动态注册。

@Import(AutoConfigurationImportSelector.class)

作用：开启自动配置类的导包选择器。

点 AutoConfigurationImportSelector.class 进去查看源码如下：

selectImports方法

作用：选择需要导入的组件

@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
        return NO_IMPORTS;
    }
    //这里断点
    AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
    return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}

getAutoConfigurationEntry方法

根据导入的@Configuration类的AnnotationMetadata返回AutoConfigurationImportSelector .AutoConfigurationEntry

点 getAutoConfigurationEntry 方法查看源码如下：

protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    }
    AnnotationAttributes attributes = getAttributes(annotationMetadata);
    // 这打个断点，看看 返回的数据
    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);
    return new AutoConfigurationEntry(configurations, exclusions);
}

getCandidateConfigurations(annotationMetadata, attributes); 这里我们打断点查看

image.png
我们发现 configurations 集合的长度是144，并且文件后缀都为xxxAutoConfiguration。
总结：这些都是候选的配置类，经过去重，去除需要的排除的依赖，最终的组件才是这个环境需要的所有组件。有了自动配置，就不需要我们自己手写配置的值了，配置类有默认值的。

getCandidateConfigurations方法

点 getCandidateConfigurations 方法查看源码如下：

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    List<String> configurations = new ArrayList<>(
            SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader()));
    ImportCandidates.load(AutoConfiguration.class, getBeanClassLoader()).forEach(configurations::add);
    Assert.notEmpty(configurations,
            "No auto configuration classes found in META-INF/spring.factories nor in META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports. If you "
                    + "are using a custom packaging, make sure that file is correct.");
    return configurations;
}

这里有句断言： 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.”);
意思是：“在 META-INF/spring.factories 中没有找到自动配置类。如果您使用自定义包装，请确保该文件是正确的。“
结论： 即是要 loadFactoryNames()方法要找到自动的配置类返回才不会报错。

getSpringFactoriesLoaderFactoryClass方法

点 getSpringFactoriesLoaderFactoryClass 方法返回的是 EnableAutoConfiguration.class这个注解。

protected Class<?> getSpringFactoriesLoaderFactoryClass() {
    return EnableAutoConfiguration.class;
}

这个注解和@SpringBootApplication下标识注解是同一个注解。
结论: 获取一个能加载自动配置类的类，即SpringBoot默认自动配置类为EnableAutoConfiguration

loadFactoryNames方法

点 SpringFactoriesLoader.loadFactoryNames 方法查看源码如下：

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
    ClassLoader classLoaderToUse = classLoader;
    if (classLoader == null) {
        classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
    }
    // 这里返回的是org.springframework.boot.autoconfigure.EnableAutoConfiguration类名
    String factoryTypeName = factoryType.getName();
    // getOrDefault 当 Map 集合中有这个 key 时，就使用这个 key值，如果没有就使用默认值空数组
    return (List)loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
}

说明：SpringFactoriesLoader工厂加载机制是Spring内部提供的一个约定俗成的加载方式，只需要在模块的META-INF/spring.factories文件，这个Properties格式的文件中的key是接口、注解、或抽象类的全名，value是以逗号 “ , “ 分隔的实现类，使用SpringFactoriesLoader来实现相应的实现类注入Spirng容器中。

打断点查看 factoryTypeName 名 EnableAutoConfiguration类名。

image.png

接下来我们点 loadSpringFactories 方法查看源码如下：

private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
    //断点查看
    Map<String, List<String>> result = (Map)cache.get(classLoader);
    if (result != null) {
        return result;
    } else {
        Map<String, List<String>> result = new HashMap();

        try {
            //注意这里
            Enumeration<URL> 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()) {
                    Map.Entry<?, ?> entry = (Map.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值
            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);
        }
    }
}

在所有引入的java包的当前类路径下的META-INF/spring.factories文件都会被读取，如：
image.png
该方法作用是加载所有依赖的路径META-INF/spring.factories文件，通过map结构保存，key为文件中定义的一些标识工厂类，value就是能自动配置的一些工厂实现的类，value用list保存并去重。

在回看 loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
因为 loadFactoryNames 方法携带过来的第一个参数为 EnableAutoConfiguration.class，所以 factoryType 值也为 EnableAutoConfiguration.class，那么 factoryTypeName 值为 EnableAutoConfiguration。拿到的值就是META-INF/spring.factories文件下的key为
org.springframework.boot.autoconfigure.EnableAutoConfiguration的值

流程图汇总

https://www.yuque.com/july-sea/hqizd4/ib8fh7hxmul6grpg

如果有收获！ 希望老铁们来个三连，点赞、收藏、转发。
创作不易，别忘点个赞，可以让更多的人看到这篇文章，顺便鼓励我写出更好的博客
七月J
关注
  • 20
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值