Spring Boot 自动装配

最新推荐文章于 2024-08-05 19:59:36 发布
最新推荐文章于 2024-08-05 19:59:36 发布
阅读量744 收藏 20
点赞数 27
文章标签： spring boot 后端 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79016406/article/details/136963540
版权

 

@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 = Configuration.class)
    boolean proxyBeanMethods() default true;
​
}
​

EnableAutoConfiguration

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
​
}

AutoConfigurationImportSelector

  • 类图

getAutoConfigurationMetadata()

        @Override
        public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
            Assert.state(deferredImportSelector instanceof AutoConfigurationImportSelector,
                    () -> String.format("Only %s implementations are supported, got %s",
                            AutoConfigurationImportSelector.class.getSimpleName(),
                            deferredImportSelector.getClass().getName()));
            AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
                    .getAutoConfigurationEntry(
                            // 加载配置元数据
                            getAutoConfigurationMetadata(), annotationMetadata);
            this.autoConfigurationEntries.add(autoConfigurationEntry);
            for (String importClassName : autoConfigurationEntry.getConfigurations()) {
                this.entries.putIfAbsent(importClassName, annotationMetadata);
            }
        }
​
​
        private AutoConfigurationMetadata getAutoConfigurationMetadata() {
            if (this.autoConfigurationMetadata == null) {
                // 加载配置信息
                this.autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
            }
            return this.autoConfigurationMetadata;
        }
​

  • org.springframework.boot.autoconfigure.AutoConfigurationMetadataLoader#loadMetadata(java.lang.ClassLoader)

        static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader, String path) {
        try {
​
            // 获取资源路径
            Enumeration<URL> urls = (classLoader != null) ? classLoader.getResources(path)
                    : ClassLoader.getSystemResources(path);
            Properties properties = new Properties();
            while (urls.hasMoreElements()) {
                properties.putAll(PropertiesLoaderUtils.loadProperties(new UrlResource(urls.nextElement())));
            }
            return loadMetadata(properties);
        }
        catch (IOException ex) {
            throw new IllegalArgumentException("Unable to load @ConditionalOnClass location [" + path + "]", ex);
        }
    }
​

  • protected static final String PATH = "META-INF/spring-autoconfigure-metadata.properties";

    注意： 这个文件在target编译后的文件夹中

    相关 Issues : spring-boot-autoconfigure-processor incorrectly process @ConditionalOnClass with an inner class value · Issue #11282 · spring-projects/spring-boot · GitHub

  • 自动装配

    spring-boot-project/spring-boot-autoconfigure/src/main/resources/META-INF/spring.factories

    该文件内存有:

    # Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\

同样找一下 redis

  • 仔细看org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration类

先说注解

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })

EnableConfigurationProperties

自动映射一个POJO到Spring Boot配置文件（默认是application.properties文件）的属性集。

  • org.springframework.boot.autoconfigure.data.redis.RedisProperties

  • 部分 redis 配置属性

@ConfigurationProperties(prefix = "spring.redis")
public class RedisProperties {
​
    /**
     * Database index used by the connection factory.
     */
    private int database = 0;
​
    /**
     * Connection URL. Overrides host, port, and password. User is ignored. Example:
     * redis://user:password@example.com:6379
     */
    private String url;
​
    /**
     * Redis server host.
     */
    private String host = "localhost";
​
    /**
     * Login password of the redis server.
     */
    private String password;
​
    /**
     * Redis server port.
     */
    private int port = 6379;
​
    /**
     * Whether to enable SSL support.
     */
    private boolean ssl;
​
    /**
     * Connection timeout.
     */
    private Duration timeout;
​
    /**
     * Client name to be set on connections with CLIENT SETNAME.
     */
    private String clientName;
​
​
​
}

  • 找到一个我们用相同方式去寻找到别的一些属性处理如org.springframework.boot.autoconfigure.jdbc.JdbcProperties 具体展开请各位读者自行了解了

AnnotationMetadata

回过头继续我们的主要流程

  • org.springframework.boot.autoconfigure.AutoConfigurationImportSelector.AutoConfigurationGroup#process

再此之前我们看过了getAutoConfigurationMetadata()的相关操作

关注 AnnotationMetadata annotationMetadata 存储了一些什么

这里简单理解

  1. mergedAnnotations 类相关的注解信息

  2. annotationTypes 在启动类上的注解列表

getAutoConfigurationEntry

    protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
            AnnotationMetadata annotationMetadata) {
        if (!isEnabled(annotationMetadata)) {
            return EMPTY_ENTRY;
        }
        // 获取注解属性值
        AnnotationAttributes attributes = getAttributes(annotationMetadata);
        // 获取候选配置信息
        List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
        // 删除重复配置
        configurations = removeDuplicates(configurations);
        // 获取 exclude 属性
        Set<String> exclusions = getExclusions(annotationMetadata, attributes);
        // 校验 exclude 类
        checkExcludedClasses(configurations, exclusions);
        // 配置中删除 exclude 的6属性值
        configurations.removeAll(exclusions);
        // 过滤
        configurations = filter(configurations, autoConfigurationMetadata);
        // 触发自动配置事件
        fireAutoConfigurationImportEvents(configurations, exclusions);
        // 返回
        return new AutoConfigurationEntry(configurations, exclusions);
    }
​

getAttributes

    protected AnnotationAttributes getAttributes(AnnotationMetadata metadata) {
        // name = org.springframework.boot.autoconfigure.EnableAutoConfiguration , 这是一个固定的值
        String name = getAnnotationClass().getName();
        // 获取注解的属性
        AnnotationAttributes attributes = AnnotationAttributes.fromMap(metadata.getAnnotationAttributes(name, true));
        Assert.notNull(attributes, () -> "No auto-configuration attributes found. Is " + metadata.getClassName()
                + " annotated with " + ClassUtils.getShortName(name) + "?");
        return attributes;
    }
​

getCandidateConfigurations

  • 读取spring.factories数据

    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        // 读取 org.springframework.boot.autoconfigure.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;
    }
​

  • 第一个是我自己写的一个测试用

    org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  org.sourcehot.service.HelloServiceAutoConfiguration

removeDuplicates

  • new 两个对象直接做数据转换，去重

    protected final <T> List<T> removeDuplicates(List<T> list) {
        return new ArrayList<>(new LinkedHashSet<>(list));
    }
​

getExclusions

    protected Set<String> getExclusions(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        Set<String> excluded = new LinkedHashSet<>();
        // 获取属性 exclude 值转换成list
        excluded.addAll(asList(attributes, "exclude"));
      // 获取属性 excludeName 值转换成list
        excluded.addAll(Arrays.asList(attributes.getStringArray("excludeName")));
        // 获取 SpringBoot 本身的忽略配置属性
        excluded.addAll(getExcludeAutoConfigurationsProperty());
        return excluded;
    }
​

getExcludeAutoConfigurationsProperty

    private List<String> getExcludeAutoConfigurationsProperty() {
        if (getEnvironment() instanceof ConfigurableEnvironment) {
            Binder binder = Binder.get(getEnvironment());
            // 取出 "spring.autoconfigure.exclude" 转换成list
            return binder.bind(PROPERTY_NAME_AUTOCONFIGURE_EXCLUDE, String[].class).map(Arrays::asList)
                    .orElse(Collections.emptyList());
        }
        String[] excludes = getEnvironment().getProperty(PROPERTY_NAME_AUTOCONFIGURE_EXCLUDE, String[].class);
        return (excludes != null) ? Arrays.asList(excludes) : Collections.emptyList();
    }
​

  • 修改启动类

    @SpringBootApplication(excludeName =  { "org.sourcehot.service.HelloServiceAutoConfiguration" })
​

checkExcludedClasses

    private void checkExcludedClasses(List<String> configurations, Set<String> exclusions) {
        List<String> invalidExcludes = new ArrayList<>(exclusions.size());
        for (String exclusion : exclusions) {
            //
            if (ClassUtils.isPresent(exclusion, getClass().getClassLoader()) && !configurations.contains(exclusion)) {
                invalidExcludes.add(exclusion);
            }
        }
        if (!invalidExcludes.isEmpty()) {
            // 处理忽略的类
            handleInvalidExcludes(invalidExcludes);
        }
    }
​

  • configurations.removeAll(exclusions)

    移除忽略的类

filter

    private List<String> filter(List<String> configurations, AutoConfigurationMetadata autoConfigurationMetadata) {
        long startTime = System.nanoTime();
        String[] candidates = StringUtils.toStringArray(configurations);
        boolean[] skip = new boolean[candidates.length];
        boolean skipped = false;
        // 获取 AutoConfigurationImportFilter 相关配置
        for (AutoConfigurationImportFilter filter : getAutoConfigurationImportFilters()) {
            // 执行 aware 相关接口
            invokeAwareMethods(filter);
            // 比较
            boolean[] match = filter.match(candidates, autoConfigurationMetadata);
            for (int i = 0; i < match.length; i++) {
                if (!match[i]) {
                    skip[i] = true;
                    candidates[i] = null;
                    skipped = true;
                }
            }
        }
        if (!skipped) {
            return configurations;
        }
        List<String> result = new ArrayList<>(candidates.length);
        for (int i = 0; i < candidates.length; i++) {
            if (!skip[i]) {
                result.add(candidates[i]);
            }
        }
        if (logger.isTraceEnabled()) {
            int numberFiltered = configurations.size() - result.size();
            logger.trace("Filtered " + numberFiltered + " auto configuration class in "
                    + TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime) + " ms");
        }
        return new ArrayList<>(result);
    }
​

  • getAutoConfigurationImportFilters() 从spring.factories 获取 AutoConfigurationImportFilter的接口

  • 循环内执行Aware系列接口

match方法: org.springframework.boot.autoconfigure.AutoConfigurationImportFilter#match

  • filter.match(candidates, autoConfigurationMetadata) 比较判断哪些是需要自动注入的类

fireAutoConfigurationImportEvents

    rivate void fireAutoConfigurationImportEvents(List<String> configurations, Set<String> exclusions) {
        // 获取自动配置的监听器列表
        List<AutoConfigurationImportListener> listeners = getAutoConfigurationImportListeners();
        if (!listeners.isEmpty()) {
            // 创建 自动配置事件
            AutoConfigurationImportEvent event = new AutoConfigurationImportEvent(this, configurations, exclusions);
            for (AutoConfigurationImportListener listener : listeners) {
                // 执行 Aware 相关接口
                invokeAwareMethods(listener);
                // 监听器执行自动配置事件
                listener.onAutoConfigurationImportEvent(event);
            }
        }
    }
​

  • AutoConfigurationImportEvent event = new AutoConfigurationImportEvent(this, configurations, exclusions);

  • org.springframework.boot.autoconfigure.AutoConfigurationImportListener#onAutoConfigurationImportEvent 在执行自动配置时触发 , 实现类只有 ConditionEvaluationReportAutoConfigurationImportListener

        @Override
    public void onAutoConfigurationImportEvent(AutoConfigurationImportEvent event) {
        if (this.beanFactory != null) {
            ConditionEvaluationReport report = ConditionEvaluationReport.get(this.beanFactory);
            // 记录需要加载的配置
            report.recordEvaluationCandidates(event.getCandidateConfigurations());
            // 记录不需要加载的配置
            report.recordExclusions(event.getExclusions());
        }
    }
​

  • 初始化完

process

  • org.springframework.boot.autoconfigure.AutoConfigurationImportSelector.AutoConfigurationGroup#process

  • 后续的一些行为相对简单，直接放个源码了.

@Override
        public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
            Assert.state(deferredImportSelector instanceof AutoConfigurationImportSelector,
                    () -> String.format("Only %s implementations are supported, got %s",
                            AutoConfigurationImportSelector.class.getSimpleName(),
                            deferredImportSelector.getClass().getName()));
            // 自动装配信息
            AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
                    .getAutoConfigurationEntry(
                            // 加载配置元数据
                            getAutoConfigurationMetadata(), annotationMetadata);
            this.autoConfigurationEntries.add(autoConfigurationEntry);
            // 循环需要自动注入的类
            for (String importClassName : autoConfigurationEntry.getConfigurations()) {
                // 继续放入k,v
                this.entries.putIfAbsent(importClassName, annotationMetadata);
            }
        }

selectImports

        @Override
        public Iterable<Entry> selectImports() {
            if (this.autoConfigurationEntries.isEmpty()) {
                return Collections.emptyList();
            }
            // 获取忽略的类
            Set<String> allExclusions = this.autoConfigurationEntries.stream()
                    .map(AutoConfigurationEntry::getExclusions).flatMap(Collection::stream).collect(Collectors.toSet());
​
            // 获取需要注入的类
            Set<String> processedConfigurations = this.autoConfigurationEntries.stream()
                    .map(AutoConfigurationEntry::getConfigurations).flatMap(Collection::stream)
                    .collect(Collectors.toCollection(LinkedHashSet::new));
​
            // 把不需要自动注入的类从需要注入的类中移除
            processedConfigurations.removeAll(allExclusions);
​
            // 排序
            return sortAutoConfigurations(processedConfigurations, getAutoConfigurationMetadata()).stream()
                    .map((importClassName) -> new Entry(this.entries.get(importClassName), importClassName))
                    .collect(Collectors.toList());
        }
​

后续由 spring 进行不再继续跟踪

以后都是星期天
关注
  • 27
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Springboot自动装配
纯洁的小魔鬼
05-31 4453
自动装配是springboot的核心，一般提到自动装配就会和springboot联系在一起。实际上 Spring Framework 早就实现了这个功能。Spring Boot 只是在其基础上，通过 SPI 的方式，做了进一步优化。
springboot自动装配
好好玩的博客
04-03 4万+
文章目录1、自动装配是什么及作用2、spring自动装配的原理2.1、启动类上注解的作用@SpringBootApplication@SpringBootConfiguration@EnableAutoConfiguration@AutoConfigurationPackage@Import(AutoConfigurationImportSelector.class)@ComponentScan2.2、springboot自动装配的流程3、相关注解的作用@Conditional 1、自动装配是什么及作用 s
springBoot自动装配
qq_62898618的博客
11-16 1万+
为了简化配置，使spring的使用更加方便，例如：可以回忆一下springboot中是如何继承redis的。使用springboot后集成常用的第三方框架变得非常简单了。springboot starter带来的问题starter使SpringBoot集成第三方框架变得简单，但对刚刚上手SpringBoot的人来说，可能只知道配置属性是在application.xml或application.yml中添加，但他们各自的属性都有哪些，具体怎么配置，却无从下手。
SpringBoot自动装配原理
chenhui1721的专栏
10-12 1367
SpringBoot自动装配原理
Spring Boot 自动装配原理
林心涯的博客
01-20 3602
Spring Boot 自动装配原理 每次问到 Spring Boot， 面试官非常喜欢问这个问题：“讲述一下 SpringBoot 自动装配原理？”。 我觉得我们可以从以下几个方面回答： 什么是 SpringBoot 自动装配？ SpringBoot 是如何实现自动装配的？如何实现按需加载？ 如何实现一个 Starter？ 前言 使用过 Spring 的小伙伴，一定有被 XML 配置统治的恐惧。即使 Spring 后面引入了基于注解的配置，我们在开启某些 Spring
spring boot 之自动装配
iAmSoLucky_的博客
12-23 487
前言 在最初接触spring 的时候，还是使用xml进行装配，我记得很清楚，当时分别配置了spring-dao.xml , spring-service.xml , spring-controller.xml。然后把所有需要用到的扫包，注入bean，以及配置，全都一股脑的塞进xml中，虽然出发点很好，不用在java代码中硬编码了，但是xml的可读性并不是很好，那阵子，真是痛苦的要命。 正文 后来逐...
Spring Boot自动装配（一）
regrethh的博客
04-13 477
Spring Boot自动装配（一） 注：基于SpringBoot2.x版本以上 @EnableAutoConfiguration @Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @AutoConfigurationPackage @Import({AutoConfigur...
详解Spring Boot自动装配的方法步骤
08-25
详解Spring Boot自动装配的方法步骤 Spring Boot自动装配是基于Spring Framework提供的特性实现的，它极大的简化了程序开发中的工作。在本文中，我们将详细介绍Spring Boot自动装配的方法步骤，并通过示例代码进行...
深度剖析Spring Boot自动装配机制实现原理（csdn）————程序.pdf
12-05
总的来说，Spring Boot的自动装配机制基于一系列注解和接口，如`@EnableAutoConfiguration`、`AutoConfigurationImportSelector`、`@Conditional`等，实现了根据项目依赖和配置动态地加载和配置bean，极大地提升了...
Spring Boot 面试必备手册
03-31
Spring Boot 的自动配置原理是通过 `@EnableAutoConfiguration` 注解启动，然后从 `META-INF/spring.factories` 文件中导入自动配置类。这些配置类会根据类路径中是否存在某些类、环境变量、命令行参数等条件，来...
spring-boot自动装配原理.md
07-27
spring-boot自动装配原理.md
autowiring-bug-boot:带有有限泛型的服务的Spring Boot自动装配问题
03-13
在Spring Boot应用中，自动装配（Autowiring）是一种便捷的依赖注入机制，它允许Spring框架自动为bean提供所需的依赖。然而，当涉及到有限泛型的服务时，可能会遇到一些问题，这正是“autowiring-bug-boot”所指出的...
Spring Boot自动装配原理详解
dreamship
09-05 78
1 传统ssm整合redis的时候 需要在xml的配置文件中 进行大量的配置Bean 我们在这里使用springboot来代替ssm的整合，只是通过xml的形式来整合redis 第一步:加入配置 <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redis</artifactId> <version>2
关于 Spring Boot 自动装配你知道多少？
流楚丶格念的博客
08-25 3579
自动装配是springboot的核心，一般提到自动装配就会和springboot联系在一起。实际上 Spring Framework 早就实现了这个功能。Spring Boot 只是在其基础上，通过 SPI 的方式，做了进一步优化。SpringBoot 在启动时会扫描外部引用 jar 包中的META-INF/spring.factories文件，将文件中配置的类型信息加载到 Spring 容器，并执行类中定义的各种操作。
Spring boot 自动装配机制
罗伯特是疯子丶
07-06 2364
前述 在解析spring boot starter自动装配机制之前，我们先来回顾一下web工程是如何搭建的： gradle/pom文件中引入项目依赖jar包； 配置web.xml，Servlet配置，拦截器设置，Listener配置…; 数据库连接，配置spring事务； 配置视图解析器； 开启注解，自动扫描功能 配置完成后部署tomcat，调试等… … 在搭建这些环境的时候是非常耗时间耗精力的，而且有时还会缺斤少两，连蹦bug… 而有了springboot之后，所有的环境配置就
springboot入门之自动装配
指尖上的革新
02-16 2797
什么是Spring Spring是一个开源框架，2003年兴起的一个轻量级的Java开发框架，作者Rod Johnson. Spring是为了解决企业级应用开发的复杂性而创建的，简化开发。 Spring是如果简化Java开发的 为了降低Java开发的复杂性，spring采用了以下4种关键策略 1基于pojo的轻量级和最小侵入性编程； 2通过控制反转（IOC）,依赖注入（DI）和面向接口实现松耦合； 3基于切面（AOP）和惯例进行声明式编程； 4通过切面和模板减少样式代码 什么是springboot？ Spr
SpringBoot自动装配原理分析
热门推荐
【欢迎关注公众号：冬瓜白】
06-30 5万+
先看看SpringBoot的主配置类： 里面有一个main方法运行了一个run()方法，在run方法中必须要传入一个被@SpringBootApplication注解的类。 @SpringBootApplication SpringBoot应用标注在某个类上说明这个类是SpringBoot的主配置类，SpringBoot就会运行这个类的main方法来启动SpringBoot项目。 那@...
SpringBoot自动装配
qq_45562973的博客
02-20 419
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 一. Spring注解发展过程 SpringBoot的自动装配依赖于注解，所以我们先来看一下注解的发展过程。 以下主要对核心注解进行说明 Spring1.0：刚刚出现注解。 @Transaction：简化了事务的操作 Spring2.0：一些配置开始被xml代替，
Spring Boot集成liquibase快速入门Demo
最新发布
HBLOG
08-05 423
Liquibase是一个用于跟踪、管理和应用数据库变化的开源的数据库重构工具。它将所有数据库的变化（包括结构和数据）都保存在 changelog 文件中，便于版本控制，它的目标是提供一种数据库类型无关的解决方案，通过执行 schema 类型的文件来达到迁移。Liquibase 特性支持几乎所有主流的数据库，如 MySQL, PostgreSQL, Oracle, Sql Server, DB2 等；支持多开发者的协作维护；日志文件支持多种格式，如 XML, YAML, JSON, SQL等；
spring boot自动装配
05-10
Spring Boot自动装配是Spring框架的一种特性，它能够自动配置应用程序中的各个部分，包括数据源、Web容器、JPA、Spring Security等。通过自动装配，我们可以避免手动配置繁琐的XML文件和Java代码，从而提高开发效率。 Spring Boot自动装配的原理是通过条件注解和Spring的SPI机制实现的。Spring Boot在启动时会扫描classpath下的META-INF/spring.factories文件，读取其中的配置信息，并根据条件进行自动装配。 例如，我们可以在项目的pom.xml文件中引入spring-boot-starter-web依赖，它会自动配置Spring MVC、Tomcat等相关组件。如果我们需要使用其他Web容器，只需要排除spring-boot-starter-tomcat依赖，并引入其他容器的依赖即可。 Spring Boot还提供了一些注解来控制自动装配，例如@ConditionalOnClass、@ConditionalOnMissingBean、@ConditionalOnProperty等。这些注解可以根据条件来判断是否需要进行自动装配，从而实现更加精细的控制。 总的来说，Spring Boot自动装配是一个非常强大的特性，它可以让我们专注于业务逻辑的开发，而不用过多关注底层的配置和细节。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值