SpringBoot（二）依赖管理和自动配置

最新推荐文章于 2025-02-13 10:27:56 发布
最新推荐文章于 2025-02-13 10:27:56 发布
阅读量487 收藏
点赞数 1
文章标签： spring boot java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49741990/article/details/113531690
版权

SpringBoot（二）依赖管理和自动配置

传统的Spring框架实现一个Web服务，需要导入各种依赖JAR包，然后编写对应的XML配置文件等，相较而言，Spring Boot显得更加方便、快捷和高效。那么，Spring Boot究竟如何做到这些的呢？

接下来分别针对Spring Boot框架的依赖管理、自动配置通过源码进行深入分析

依赖管理

问题：（1）为什么导入dependency时不需要指定版本？

在Spring Boot入门程序中，项目pom.xml文件有两个核心依赖，分别是spring-boot-starter-parent和spring-boot-starter-web，关于这两个依赖的相关介绍具体如下：

spring-boot-starter-parent依赖

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

在这里插入图片描述

上述代码中，将spring-boot-starter-parent依赖作为Spring Boot项目的统一父项目依赖管理，并将项目版本号统一为2.2.2.RELEASE，该版本号根据实际开发需求是可以修改的

使用“Ctrl+鼠标左键”进入并查看spring-boot-starter-parent底层源文件，发现spring-boot-starter-parent的底层有一个父依赖spring-boot-dependencies，核心代码具体如下

<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-dependencies</artifactId>
  <version>2.4.2</version>
</parent>

继续查看spring-boot-dependencies底层源文件，核心代码具体如下：

<properties>
  <activemq.version>5.16.0</activemq.version>
  <antlr2.version>2.7.7</antlr2.version>
  <appengine-sdk.version>1.9.84</appengine-sdk.version>
  <artemis.version>2.15.0</artemis.version>
  <aspectj.version>1.9.6</aspectj.version>
  <assertj.version>3.18.1</assertj.version>
  <atomikos.version>4.0.6</atomikos.version>
  <awaitility.version>4.0.3</awaitility.version>
  <bitronix.version>2.1.4</bitronix.version>
  <build-helper-maven-plugin.version>3.2.0</build-helper-maven-plugin.version>
  <byte-buddy.version>1.10.19</byte-buddy.version>
  <caffeine.version>2.8.8</caffeine.version>
  <cassandra-driver.version>4.9.0</cassandra-driver.version>
  <classmate.version>1.5.1</classmate.version>
    ...
</properties>

在这里插入图片描述

从spring-boot-dependencies底层源文件可以看出，该文件通过标签对一些常用技术框架的依赖文件进行了统一版本号管理，例如activemq、spring、tomcat等，都有与Spring Boot 2.2.2版本相匹配的版本，这也是pom.xml引入依赖文件不需要标注依赖文件版本号的原因。

需要说明的是，如果pom.xml引入的依赖文件不是 spring-boot-starter-parent管理的，那么在pom.xml引入依赖文件时，需要使用标签指定依赖文件的版本号。

问题（2）： spring-boot-starter-parent父依赖启动器的主要作用是进行版本统一管理，那么项目运行依赖的JAR包是从何而来的？

spring-boot-starter-web依赖

查看spring-boot-starter-web依赖文件源码，核心代码具体如下

<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <version>2.4.2</version>
    <scope>compile</scope>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-json</artifactId>
    <version>2.4.2</version>
    <scope>compile</scope>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <version>2.4.2</version>
    <scope>compile</scope>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.3.3</version>
    <scope>compile</scope>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.3</version>
    <scope>compile</scope>
  </dependency>
</dependencies>

从上述代码可以发现，spring-boot-starter-web依赖启动器的主要作用是提供Web开发场景所需的底层所有依赖

正是如此，在pom.xml中引入spring-boot-starter-web依赖启动器时，就可以实现Web场景开发，而不需要额外导入Tomcat服务器以及其他Web依赖文件等。当然，这些引入的依赖文件的版本号还是由spring-boot-starter-parent父依赖进行的统一管理。

有哪些starter：

https://github.com/spring-projects/spring-boot/tree/v2.1.0.RELEASE/spring-boot-project/spring-boot-starters

https://mvnrepository.com/search?q=starter

Spring Boot除了提供有上述介绍的Web依赖启动器外，还提供了其他许多开发场景的相关依赖，我们可以打开Spring Boot官方文档，搜索“Starters”关键字查询场景依赖启动器

在这里插入图片描述

列出了Spring Boot官方提供的部分场景依赖启动器，这些依赖启动器适用于不同的场景开发，使用时只需要在pox.xml文件中导入对应的依赖启动器即可。

需要说明的是，Spring Boot官方并不是针对所有场景开发的技术框架都提供了场景启动器，例如数据库操作框架MyBatis、阿里巴巴的Druid数据源等，Spring Boot官方就没有提供对应的依赖启动器。为了充分利用Spring Boot框架的优势，在Spring Boot官方没有整合这些技术框架的情况下，MyBatis、Druid等技术框架所在的开发团队主动与Spring Boot框架进行了整合，实现了各自的依赖启动器，例如mybatis-spring-boot-starter、druid-spring-boot-starter等。我们在pom.xml文件中引入这些第三方的依赖启动器时，切记要配置对应的版本号

自动配置

概念：能够在我们添加jar包依赖的时候，自动为我们配置一些组件的相关配置，我们无需配置或者只需要少量配置就能运行编写的项目

问题：Spring Boot到底是如何进行自动配置的，都把哪些组件进行了自动配置？

Spring Boot应用的启动入口是@SpringBootApplication注解标注类中的main()方法，@SpringBootApplication ： SpringBoot 应用标注在某个类上说明这个类是 SpringBoot 的主配置类， SpringBoot 就应该运行这个类的 main() 方法启动 SpringBoot 应用。

下面，查看@SpringBootApplication内部源码进行分析 ，核心代码具体如下

@SpringBootApplication
public class Springbootdemo2Application {

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

}

进入到 @SpringBootApplication 内，观察其做了哪些工作：

@Target({ElementType.TYPE})		//当前注解的作用范围，TYPE表示可以描述类、接口、注解、枚举类型
@Retention(RetentionPolicy.RUNTIME)		//表示注解的生命周期，RUNTIME表示运行时
@Documented		//表示注解可以记录在Java doc中
@Inherited		//表示可以被子类继承该注解
//		以上四个注解描述的是元数据信息
@SpringBootConfiguration		//表示该类为配置类
@EnableAutoConfiguration		//表示启动自动配置
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)		//表示启动组件扫描
public @interface SpringBootApplication {
    
    // 根据class来排除特定的类，使其不能加入spring容器，传入参数value类型是class类型。
    @AliasFor(
        annotation = EnableAutoConfiguration.class
    )
    Class<?>[] exclude() default {};

    // 根据classname 来排除特定的类，使其不能加入spring容器，传入参数value类型是class的全类名字符串数组。
    @AliasFor(
        annotation = EnableAutoConfiguration.class
    )
    String[] excludeName() default {};

    // 指定扫描包，参数是包名的字符串数组。
    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "basePackages"
    )
    String[] scanBasePackages() default {};

    // 扫描特定的包，参数类似是Class类型数组。
    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "basePackageClasses"
    )
    Class<?>[] scanBasePackageClasses() default {};

}

从上述源码可以看出，@SpringBootApplication注解是一个组合注解，前面 4 个是注解的元数据信息， 我们主要看后面 3 个注解：@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan三个核心注解，关于这三个核心注解的相关说明具体如下：

@SpringBootConfiguration注解

@SpringBootConfiguration ： SpringBoot 的配置类，标注在某个类上，表示这是一个 SpringBoot的配置类。

查看@SpringBootConfiguration注解源码，核心代码具体如下。

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration		// 配置类的作用等同于配置文件，配置类也是容器中的一个对象
public @interface SpringBootConfiguration {
    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

从上述源码可以看出，@SpringBootConfiguration注解内部有一个核心注解@Configuration，该注解是Spring框架提供的，表示当前类为一个配置类（XML配置文件的注解表现形式），并可以被组件扫描器扫描。由此可见，@SpringBootConfiguration注解的作用与@Configuration注解相同，都是标识一个可以被组件扫描器扫描的配置类，只不过@SpringBootConfiguration是被Spring Boot进行了重新封装命名而已

@EnableAutoConfiguration注解

@EnableAutoConfiguration ：开启自动配置功能，以前由我们需要配置的东西，现在由 SpringBoot帮我们自动配置，这个注解就是 Springboot 能实现自动配置的关键。

同样，查看该注解内部查看源码信息，核心代码具体如下

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
// 自动配置包
@AutoConfigurationPackage		
// Spring的底层注解@Import，给容器中导入一个组件；
// 导入的组件是AutoConfigurationPackages.Registrar.class
@Import({AutoConfigurationImportSelector.class})
// 告诉SpringBoot开启自动配置功能，这样自动配置才能生效。
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    // 返回不会被导入到 Spring 容器中的类
    Class<?>[] exclude() default {};

    // 返回不会被导入到 Spring 容器中的类名
    String[] excludeName() default {};
}

可以发现它是一个组合注解， Spring 中有很多以 Enable 开头的注解，其作用就是借助 @Import来收集并注册特定场景相关的 Bean ，并加载到 IOC 容器。@EnableAutoConfiguration就是借助@Import来收集所有符合自动配置条件的bean定义，并加载到IoC容器。

下面，对这两个核心注解分别讲解 :

@AutoConfigurationPackage注解

查看@AutoConfigurationPackage注解内部源码信息，核心代码具体如下：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import({Registrar.class}) 		// 导入Registrar中注册的组件
public @interface AutoConfigurationPackage {
    String[] basePackages() default {};

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

从上述源码可以看出，@AutoConfigurationPackage注解的功能是由@Import注解实现的，它是spring框架的底层注解，它的作用就是给容器中导入某个组件类，例如@Import(AutoConfigurationPackages.Registrar.class)，它就是将Registrar这个组件类导入到容器中，可查看Registrar类中registerBeanDefinitions方法，这个方法就是导入组件类的具体实现 :

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
    Registrar() {
    }

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

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

从上述源码可以看出，在Registrar类中有一个registerBeanDefinitions()方法，使用Debug模式启动项目， 可以看到选中的部分就是com.szx。也就是说，@AutoConfigurationPackage注解的主要作用就是将主程序类所在包及所有子包下的组件到扫描到spring容器中。

因此 在定义项目包结构时，要求定义的包结构非常规范，项目主程序启动类要定义在最外层的根目录位置，然后在根目录位置内部建立子包和类进行业务开发，这样才能够保证定义的类能够被组件扫描器扫描

@Import({AutoConfigurationImportSelector.class})注解

将 AutoConfigurationImportSelector 这个类导入到 Spring 容器中，AutoConfigurationImportSelector 可以帮助 Springboot 应用将所有符合条件的 @Configuration配置都加载到当前 SpringBoot 创建并使用的 IOC 容器( ApplicationContext )中。

继续研究AutoConfigurationImportSelector这个类，通过源码分析这个类中是通过selectImports这个方法告诉springboot都需要导入那些组件：

public String[] selectImports(AnnotationMetadata annotationMetadata) {
    if (!this.isEnabled(annotationMetadata)) {
        return NO_IMPORTS;
    } else {
        //获得自动配置元信息，需要传入beanClassLoader这个类加载器
        AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(annotationMetadata);	
        return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
    }
}

深入研究loadMetadata方法

protected static final String PATH = "META-INF/spring-autoconfigure-metadata.properties";		//文件中为需要加载的配置类的类路径

private AutoConfigurationMetadataLoader() {
}

static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader) {
    return loadMetadata(classLoader, "META-INF/spring-autoconfigure-metadata.properties");
}

static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader, String path) {
    try {
        //读取spring-boot-autoconfigure-2.3.4.RELEASE.jar包中的spring-autoconfigure-metadata.properties的信息生成url
        Enumeration<URL> urls = classLoader != null ? classLoader.getResources(path) : ClassLoader.getSystemResources(path);
        Properties properties = new Properties();

        //解析url枚举对象中的信息封装成properties对象并加载
        while(urls.hasMoreElements()) {
            properties.putAll(PropertiesLoaderUtils.loadProperties(new UrlResource((URL)urls.nextElement())));
        }

        //根据封装好的properties对象生成AutoConfigurationMetadata对象返回
        return loadMetadata(properties);
    } catch (IOException var4) {
        throw new IllegalArgumentException("Unable to load @ConditionalOnClass location [" + path + "]", var4);
    }
}

AutoConfigurationImportSelector类 getAutoConfigurationEntry方法

protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
    //判断EnabledAutoConfiguration注解有没有开启,默认开启
    if (!this.isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    } else {
        //获得注解的属性信息
        AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
        //获取默认支持的自动配置类列表
        List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
        //去重
        configurations = this.removeDuplicates(configurations);
        //去除一些多余的配置类，根据EnabledAutoConfiguratio的exclusions属性进行排除
        Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
        this.checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);
        //根据pom文件中加入的依赖文件筛选中最终符合当前项目运行环境对应的自动配置类
        configurations = this.getConfigurationClassFilter().filter(configurations);
        //触发自动配置导入监听事件
        this.fireAutoConfigurationImportEvents(configurations, exclusions);
        return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
    }
}

深入getCandidateConfigurations方法

这个方法中有一个重要方法loadFactoryNames，这个方法是让SpringFactoryLoader去加载一些组件的名字。

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    /**
    *	这个方法传两个参数getSpringFactoriesLoaderFactoryClass()和getBeanClassLoader()
    *	getSpringFactoriesLoaderFactoryClass()这个方法返回的是EnableAutoConfiguration.class
    *	getBeanClassLoader()这个方法返回的是beanClassLoader（类加载器）
    */
    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;
}

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

protected ClassLoader getBeanClassLoader() {
	return this.beanClassLoader;
}

继续点开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());
}

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 {
            //如果类加载器不为null，则加载类路径下spring.factories文件，将其中设置的配置类的全路径信息封装 为Enumeration类对象
            Enumeration urls = classLoader.getResources("META-INF/spring.factories");

            //循环Enumeration类对象，根据相应的节点信息生成Properties对象，通过传入的键获取值，在将值切割为一个个小的字符串转化为Array，方法result集合中
            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);
        }
    }
}

会去读取一个 spring.factories 的文件，读取不到会表这个错误，我们继续根据会看到，最终路径的长这样，而这个是spring提供的一个工具类

public final class SpringFactoriesLoader {
    public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
}

它其实是去加载一个外部的文件，而这文件是在

在这里插入图片描述

@EnableAutoConfiguration就是从classpath中搜寻META-INF/spring.factories配置文件，并将其中org.springframework.boot.autoconfigure.EnableutoConfiguration对应的配置项通过反射（Java Refletion）实例化为对应的标注了@Configuration的JavaConfig形式的配置类，并加载到IOC容器中以刚刚的项目为例，在项目中加入了Web环境依赖启动器，对应的WebMvcAutoConfiguration自动配置类就会生效，打开该自动配置类会发现，在该配置类中通过全注解配置类的方式对Spring MVC运行所需环境进行了默认配置，包括默认前缀、默认后缀、视图解析器、MVC校验器等。而这些自动配置类的本质是传统Spring MVC框架中对应的XML配置文件，只不过在Spring Boot中以自动配置类的形式进行了预先配置。因此，在Spring Boot项目中加入相关依赖启动器后，基本上不需要任何配置就可以运行程序，当然，我们也可以对这些自动配置类中默认的配置进行更改

总结

因此springboot底层实现自动配置的步骤是：

  1. springboot应用启动；
  2. @SpringBootApplication起作用；
  3. @EnableAutoConfiguration；
  4. @AutoConfigurationPackage：这个组合注解主要是@Import(AutoConfigurationPackages.Registrar.class)，它通过将Registrar类导入到容器中，而Registrar类作用是扫描主配置类同级目录以及子包，并将相应的组件导入到springboot创建管理的容器中；
  5. @Import(AutoConfigurationImportSelector.class)：它通过将AutoConfigurationImportSelector类导入到容器中，AutoConfigurationImportSelector类作用是通过selectImports方法执行的过程中，会使用内部工具类SpringFactoriesLoader，查找classpath上所有jar包中的META-INF/spring.factories进行加载，实现将配置类信息交给SpringFactory加载器进行一系列的容器创
    建过程

@ComponentScan注解

@ComponentScan注解具体扫描的包的根路径由Spring Boot项目主程序启动类所在包位置决定，在扫描过程中由前面介绍的@AutoConfigurationPackage注解进行解析，从而得到Spring Boot项目主程序启动类所在包的具体位置

总结：

@SpringBootApplication 的注解的功能就分析差不多了， 简单来说就是 3 个注解的组合注解：

|- @SpringBootConfiguration
	|- @Configuration  //通过javaConfig的方式来添加组件到IOC容器中
|- @EnableAutoConfiguration
	|- @AutoConfigurationPackage //自动配置包，与@ComponentScan扫描到的添加到IOC
	|- @Import(AutoConfigurationImportSelector.class) //到META-INF/spring.factories中定义的bean添加到IOC容器中
|- @ComponentScan //包扫描
浅谈springboot自动配置原理
08-25
自动配置原理是SpringBoot框架的核心机制之一，它可以自动加载依赖项，减少手动配置的工作量，提高开发效率。但是，需要注意自动配置的使用场景，并且需要合理地使用自动配置原理，避免自动配置的类和手动配置的类...
Spring Boot架构篇 - @AutoConfigurationPackage
The Secret
10-15 8500
本文解析 @AutoConfigurationPackage注解的作用。
学到长痘之 - Spring Boot
闲狗的博客
10-19 403
努力学习，成为一个吃喝不愁的人。 1 Spring Boot 基础回顾 1.1 约定优于配置 约定优于配置简单来理解，就是遵循约定。大家都自觉遵守一些约定，牢记之后，就不用再写在小本本里了。 系统、类库或框架应该假定合理的默认值，不需提供不必要的配置。比如说模型中有一个名为 User的类，那么数据库中对应的表就会默认命名为user。只有在偏离这一个约定的时候，例如想要将该表命名为 person，才需要写有关这个名字的配置。 比如平时架构师搭建项目就是限制软件开发随便写代码，制定出一套规范...
org.springframework.boot.autoconfigure.AutoConfiguration.imports为什么使用？如何使用？
最新发布
weixin_41290863的博客
02-13 2029
如果你了解过spring boot自动装配的原理，那么你可以很容易知道，在项目根目录以外的Bean，也就是导入的spring-boot-starter-***的maven依赖 是根据 /META-INF/spring.factories下的文件去进行加载的。是一种手段，用于为 Spring Boot 的自动配置类提供额外的配置信息，或者使得某些类被自动引入，从而简化 Spring Boot 应用的配置过程。它使得开发者可以通过导入其他配置类来扩展自动配置的功能，避免代码冗余，提升代码的可维护性。
springBoot 依赖管理 自动配置，容器功能 ，以及配置常用注解详解
weixin_44990295的博客
01-02 585
springboot 特点 依赖管理 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.3.4.RELEASE</version> </parent> 他的父项目 <p
SpringBoot的依赖管理以及自动配置原理
Selene_wy的博客
05-09 1138
SpringBoot的依赖管理以及自动配置原理 本篇对springBoot的依赖管理以及自动配置等两个特性进行介绍，尤其对自动配置的原理进行了详细的解释和源码分析，通过redis的案例对配置加载过程进行说明。 依赖管理 父项目做依赖管理（自动版本仲裁）。即spring-boot-starter-parent提供相关的 Maven 默认依赖，使用它之后，常用包的依赖就可以省去 version 标签。 <parent> <groupId>org.springframework.b
SpringBoot源码之-关于注解`@AutoConfigurationPackage`作用
qq_40890412的博客
09-27 3759
关于注解@AutoConfigurationPackage作用 最近在看SpringBoot源码时发现了这个注解 看了一下 网上的教程和视频几乎都是说该注解作用是扫描我们启动类包和子包下组件并加入容器 然而断点跟踪一下发现 在这个注解导入的组件生效之前 我们启动类包下的内容已经被放入Bean定义信息工厂里了 那这个注解的作用到底是什么那 我们来跟踪一下代码 首先说一下 我们包和子包标注注解的组件 之所以被加载入容器 是因为 @ComponentScan(...}) 注解 它在不填写value的情况下 就会
springboot的依赖管理和自动配置
Serendipity的博客
09-12 1417
依赖管理 根据springboot官方文档建立一个springboot项目 我们导入父工程 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.5.4</version> </pare
springboot的依赖和自动配置
mrluoxj的专栏
07-23 1043
为了探讨SpringMVC在SpringBoot自动配置的问题，首先在本地下载的Maven仓库的目录spring-boot-autoconfigure中找到spring-boot-autoconfigure-2.0.0.RELEASE-sources.jar的包。代码中的中文注释是我加入的。打开spring-boot-start-web文件夹，就可以看到一个名为spring-boot-starter-web-2.0.0.RELEASE.pom的文件，打开它就可以看到如下代码清单所示的代码。...
【SpringBoot：详解依赖注入和使用配置文件】
qq_73918355的博客
04-19 1524
好了，如果我们还使用着YoungPerson类，那么麻烦来了，因为这个类只是定义了一个动物属性（Animal），而我们却有两个动物，一个狗， 一个猫， SpringIoC 如何注入呢。的默认值为false，也就是没有找到属性文件， 就会报错。再回到上面的例子，我们只是创建了一个动物一一狗，而实际上动物还可以有猫 （Cat），猫可以为我们抓老鼠， 于是我们又创建了一个猫的类。，它是一个修改优先权的注解，当我们有猫有狗的时候，假设这次需要使用猫， 那么只需要在猫类的定义上加入＠Primarγ就可以了，如下：。
【Springboot】| 从深入自动配置原理到实现 自定义Springboot starter
狮子也疯狂的博客
08-27 3755
是SpringBoot的一个重要概念，是“一站式服务 (one-stop)”的依赖 Jar 包包含 Spring 以及相关技术(比如 Redis)的所有依赖提供了自动配置的功能，开箱即用提供了良好的依赖管理，避免了包遗漏、版本冲突等问题。简单来说， Springboot starter 提供了一种自动配置的机制，我们只需要将需要的Starter引入项目中，它就会自动为我们配置相关的依赖和配置。这使得开发人员可以更加关注业务逻辑的实现；现在我们来学习一下它的原理，以便后面能更清晰地实现。这个技能对你有用么。
SpringBoot中,@EnableAutoConfiguration包含的@AutoConfigurationPackage有什么用,具体做了什么
JavaMyDream的博客
04-16 673
【代码】SpringBoot中,@EnableAutoConfiguration包含的@AutoConfigurationPackage有什么用,具体做了什么。
@AutoConfigurationPackage注解真正的作用
乖松鼠的博客
07-24 883
我们知道是实现自动配置的关键注解。其由构成。这里我们讨论下的作用，作者才疏学浅，望大家多多指正。
@AutoConfigurationPackage自动包规则原理
hanlin_zhao的博客
07-30 1521
@AutoConfigurationPackage自动配置包
@AutoConfigurationPackage注解详解
怪咖@的博客
10-23 8994
@AutoConfigurationPackage是在springboot启动类注解@SpringBootApplication下的@EnableAutoConfiguration下。@AutoConfigurationPackage作用是指定springboot扫描包，默认就是扫描启动类同包下的类。可以通过@AutoConfigurationPackage来附加其他路径，然后springboot同样会进行扫描。
@AutoConfigurationPackage注解
热门推荐
ttyy1112的专栏
09-25 2万+
[SBIA-28] - @AutoConfigurationPackage注解参考 AutoConfigurationPackage注解的作用是将添加该注解的类所在的package作为自动配置package进行管理。 可以通过AutoConfigurationPackage获取自动配置package列表。 原理： 注意事项：注意自动配置依赖关系 示例： 参考 Spring boot web 应用 ...
@AutoConfigurationPackage和@ComponentScan的作用是否冲突
MyCurlingStick的博客
05-04 740
@AutoConfigurationPackage和@ComponentScan的作用是否冲突
SpringBoot利用Maven管理多环境配置的方法
通过上述知识点的详细介绍，我们不仅了解到如何利用SpringBoot和Maven打包加载不同环境配置的方法，还掌握了如何管理不同环境下的配置文件以及如何验证环境配置的正确性。这些知识对于任何从事SpringBoot应用开发的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值