Spring Boot起步依赖和自动配置

最新推荐文章于 2024-06-11 15:18:12 发布
最新推荐文章于 2024-06-11 15:18:12 发布
阅读量8.8k 收藏 16
点赞数 4
分类专栏： Spring Boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sscout/article/details/98234659
版权

起步依赖

在Spring Boot项目中，必须继承依赖spring-boot-starter-parent，所以从这个继承依赖开始。

在点击进入spring-boot-starter-parent后，其pom文件又继承了一个依赖spring-boot-dependencies，在看这个依赖前，先来看下这个文件的内容。

  • spring-boot-starter-parent

其中有对配置文件的引入配置

 <resource>
        <filtering>true</filtering>
        <directory>${basedir}/src/main/resources</directory>
        <includes>
          <include>**/application*.yml</include>
          <include>**/application*.yaml</include>
          <include>**/application*.properties</include>
        </includes>
      </resource>

可以看到，默认maven会去项目src/main/resources下寻找配置文件，可以.yml，.yaml，.properties文件，且加载顺序是先加载yml文件，然后yaml，最后properties，所以如果存在覆盖（即有相同属性的配置），properties文件的配置会覆盖前两者。

  • spring-boot-dependencies

在spring-boot-dependencies pom文件中，可以看到该文件管理了所有依赖的版本号;

<properties>
    <activemq.version>5.15.9</activemq.version>
    <antlr2.version>2.7.7</antlr2.version>
    <appengine-sdk.version>1.9.75</appengine-sdk.version>
    <artemis.version>2.6.4</artemis.version>
    <aspectj.version>1.9.4</aspectj.version>
    <assertj.version>3.11.1</assertj.version>
    <atomikos.version>4.0.6</atomikos.version>
    <bitronix.version>2.1.4</bitronix.version>
    <build-helper-maven-plugin.version>3.0.0</build-helper-maven-plugin.version>
    <byte-buddy.version>1.9.13</byte-buddy.version>
    <caffeine.version>2.6.2</caffeine.version>
    ...
</properties>

即解决了我们原有项目中可能存在依赖版本冲突的问题，它来真正管理spring boot应用里面的所有依赖版本。

在继承spring-boot-starter-parent的同时，还需要导入相应的spring-boot-starter-web依赖，所以来看看里面的内容。

  • spring-boot-starter-web

在spring-boot-starter-web pom文件中

  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter</artifactId>
      <version>2.1.6.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-json</artifactId>
      <version>2.1.6.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-tomcat</artifactId>
      <version>2.1.6.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.hibernate.validator</groupId>
      <artifactId>hibernate-validator</artifactId>
      <version>6.0.17.Final</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>5.1.8.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.1.8.RELEASE</version>
      <scope>compile</scope>
    </dependency>
  </dependencies>

它帮我们导入了web模块正常运行所依赖的组件，这些依赖的版本则有父项目进行管理。

  • 总结

在起步依赖上，spring boot帮我们管理了各个依赖的版本，使各个依赖不会出现版本冲突；另外，帮我们打包了各个依赖让我们不用再像之前那样自己导入一大堆的依赖，只要引入起步依赖的坐标就可以进行web开发了，同样体现了依赖传递的用。

 

自动配置

spring boot要求每一个启动类上都需要加上解@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 {

可以看到它是一个复合annotation，其中最重要的三个annotation是@SpringBootConfiguration，@EnableAutoConfiguration和@ComponentScan。 

  • @SpringBootConfiguration
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {

}

等同与@Configuration，启动类标注了@SpringBootConfiguration之后，本身其实也是一个ioc容器的配置类。

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

SpringBoot自动配置功能开启，是自动装配的核心注解。

首先来看下@AutoConfigurationPackage注解

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

}

@AutoConfigurationPackage在这里导入了一个AutoConfigurationPackages.Registrar.class的组件，下面是AutoConfigurationPackages.Registrar的源码

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
		@Override
		public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
			register(registry, new PackageImport(metadata).getPackageName());
		}
		@Override
		public Set<Object> determineImports(AnnotationMetadata metadata) {
			return Collections.singleton(new PackageImport(metadata));
		}
	}

在这个类中，我们关注的是registerBeanDefinitions方法，metadata是注解的源信息，包括@SpringBootConfiguration配置的类名等信息；

register方法会扫描主配置类所在包及其子包下的组件，并注册到IOC容器中。

至此，我们找到了@AutoConfigurationPackage的作用。

说完了@AutoConfigurationPackage的作用，再来探索下@Import(AutoConfigurationImportSelector.class)

首先来看下AutoConfigurationImportSelector源码，主要关注的方法即

@Override
	public String[] selectImports(AnnotationMetadata annotationMetadata) {
		if (!isEnabled(annotationMetadata)) {
			return NO_IMPORTS;
		}
		AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
				.loadMetadata(this.beanClassLoader);
		AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata,
				annotationMetadata);
		return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
	}

	/**
	 * Return the {@link AutoConfigurationEntry} based on the {@link AnnotationMetadata}
	 * of the importing {@link Configuration @Configuration} class.
	 * @param autoConfigurationMetadata the auto-configuration metadata
	 * @param annotationMetadata the annotation metadata of the configuration class
	 * @return the auto-configurations that should be imported
	 */
	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);
		Set<String> exclusions = getExclusions(annotationMetadata, attributes);
		checkExcludedClasses(configurations, exclusions);
		configurations.removeAll(exclusions);
		configurations = filter(configurations, autoConfigurationMetadata);
		fireAutoConfigurationImportEvents(configurations, exclusions);
		return new AutoConfigurationEntry(configurations, exclusions);
	}

在这里selectImports根据注解源信息获取需要导入容器组件的全类名，并返回，而获取就在getAutoConfigurationEntry中。

根据Debug发现，这里的configurations就是获取的全类名集合

所以我们重点来看下getCandidateConfigurations是如何获取这些类名的。下面是getCandidateConfigurations方法的源码。

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
		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;
	}

继续跟进loadFactoryNames方法

public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
		String factoryClassName = factoryClass.getName();
		return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
	}

在loadSpringFactories方法中到了答案

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
		MultiValueMap<String, String> result = cache.get(classLoader);
		if (result != null) {
			return result;
		}

		try {
			Enumeration<URL> urls = (classLoader != null ?
					classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
					ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
			result = new LinkedMultiValueMap<>();
			while (urls.hasMoreElements()) {
				URL url = urls.nextElement();
				UrlResource resource = new UrlResource(url);
				Properties properties = PropertiesLoaderUtils.loadProperties(resource);
				for (Map.Entry<?, ?> entry : properties.entrySet()) {
					String factoryClassName = ((String) entry.getKey()).trim();
					for (String factoryName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
						result.add(factoryClassName, factoryName.trim());
					}
				}
			}
			cache.put(classLoader, result);
			return result;
		}

看到这个方法后，就比较清晰了，首先读取类路径下的配置文件，然后循环遍历URL集合，并将URL加载为resource后读取成propertis对象，最后将键和值存入LinkedMultiValueMap中并返回。

这里的FACTORIES_RESOURCE_LOCATION即是所有组件的配置文件，它在类路径下的

# 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,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.cloud.CloudServiceConnectorsAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveRepositoriesAutoConfiguration,\
...

上面配置文件存在大量的以Configuration为结尾的类名称，这些类就是存有自动配置信息的类，而 SpringApplication在获取这些类名后再加载。

以HttpEncodingAutoConfiguration为例来分析加载的过程。

@Configuration    
@EnableConfigurationProperties(HttpProperties.class) 
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)
@ConditionalOnClass(CharacterEncodingFilter.class)
@ConditionalOnProperty(prefix = "spring.http.encoding", value = "enabled", matchIfMissing = true)
public class HttpEncodingAutoConfiguration {

	private final HttpProperties.Encoding properties;

	public HttpEncodingAutoConfiguration(HttpProperties properties) {
		this.properties = properties.getEncoding();
	}

	@Bean
	@ConditionalOnMissingBean
	public CharacterEncodingFilter characterEncodingFilter() {
		CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
		filter.setEncoding(this.properties.getCharset().name());
		filter.setForceRequestEncoding(this.properties.shouldForce(Type.REQUEST));
		filter.setForceResponseEncoding(this.properties.shouldForce(Type.RESPONSE));
		return filter;
	}
  1. @Configuration：表示该类为注解类；
  2. @EnableConfigurationProperties(HttpProperties.class) ：使使用 @ConfigurationProperties 注解的类生效。任何被@EnableConfigurationProperties应用到@ConfigurationProperties类都会被Environment属性配置，并注入到IOC容器中。具体可以看@EnableConfigurationProperties 注解；
  3. @ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)：Spring底层@Conditional注解，根据不同的条件，如果满足指定的条件，整个配置类里面的配置就会生效；判断当前应用是否是web应用，如果是，当前配置类生效 ；
  4. @ConditionalOnClass(CharacterEncodingFilter.class)：//判断当前项目有没有这个类 CharacterEncodingFilter；SpringMVC中进行乱码解决的过滤器； 
  5. ConditionalOnProperty(prefix = "spring.http.encoding", value = "enabled", matchIfMissing = true)：判断配置文件中是否存在某个配置 spring.http.encoding.enabled；matchlfMissing表示我们配置文件中没有pring.http.encoding.enabled=true，也是默认生效的； 

因为在类上标注了@Configuration，所以在扫描到后就会被创建放入IOC容器中，@Configuration类被创建的原理见@Configuration注解的类的加载实现原理，又因为@EnableConfigurationProperties(HttpProperties.class)注解，配置属性类HttpProperties被创建并由配置文件初始化后放入IOC容器中，之后由HttpEncodingAutoConfiguration的构造函数传入，这就是被扫描类被生成的过程,在该类中还有两个@Bean的方法，这些组件在创建后也被放入IOC容器中，在上面CharacterEncodingFilter解决乱码的过滤器类就被创建了。

最后，来看下HttpProperties这个配置类是如何获取属性注入的。

@ConfigurationProperties(prefix = "spring.http")
public class HttpProperties {

	private boolean logRequestDetails;

	public static class Encoding {
		public static final Charset DEFAULT_CHARSET = StandardCharsets.UTF_8;
		private Charset charset = DEFAULT_CHARSET;
		private Boolean force;
		private Boolean forceRequest;
		private Boolean forceResponse;
		private Map<Locale, Charset> mapping;
        
        ...
    }
}

配置类通过@ConfigurationProperties(prefix = "spring.http")注解，从配置文件中获取值并注入到配置类中，所以如果由需要自定义的值，也可以在类路径下application.properties或application.yml填写。

所以，SpringBoot中xxxxAutoConfigurartion：自动配置类，给容器中添加组件；xxxxProperties:封装配置文件中相关属性； 

  • 总结

自动配置，第一得益于能扫描主配置类所在包及其子包的组件，将这些组件注册到IOC容器中，第二它能借助spring框架原有的SpringFactoriesLoader的支持，加载META-INF/spring.factories获取组件的全类名并通过反射实例化为对应的标注了@Configuration的JavaConfig形式，并且符合要求@Conditional要求的IOC容器配置类，同时还有需要的Properties类和方法返回的@Bean类。

 

其他

  • @Conditional派生注解（Spring注解版原生的@Conditional作用）

作用：必须是@Conditional指定的条件成立，才给容器中添加组件，配置配里面的所有内容才生效；

  • 怎么知道哪些自动配置类生效；

通过在application.properties配置文件中添加debug=true属性，来让控制台打印自动配置报告。

这样，就可以清楚的知道哪些配置类生效，哪些没有生效，以便自定义设置。

 

sscout
关注
  • 4
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
万字干货！手把手带你自定义 Spring Boot Starter 并自动发布 Maven 中央仓库
wdj_yyds的博客
08-04 693
最近有一个需求，需要对接腾讯位置服务 WebService API，但找来找去发现官方并没有提供 Java SDK，考虑到后续其他项目也会有这个需求后，干脆索性自己封装一个 starter，并希望上传 Maven 中央仓库，实现像集成 MyBatis Plus 一样方便，直接引入依赖即可，让 Spring Boot 完成自动装配，并不需要关心具体配置以及代码，实现松耦合。
SpringBoot起步依赖和自动配置原理解析
六甲的博客
10-28 630
SpringBoot起步依赖和自动配置 起步依赖 我们知道一个SpringBoot项目都要以 spring-boot-starter-parent 作为父工程，也就是要在工程的 pom 文件中引入如下依赖（以 2.2.6版本为例）： <!-- in pom.xml of our project --> <parent> <groupId>org.springframework.boot</groupId> <artifactId>s
修改springboot默认的依赖，以spring-boot-dependencies作为版本控制
weixin_45269329的博客
12-27 2456
最近导入mysql依赖，发现默认的是8.0.25，里面方法有修改，要改为8.0.11； 网上很多文章都是说修改项目父工程的标签，如下 <properties> <mysql.version>8.0.11</mysql.version> <log4j.version>2.17.0</log4j.version> <logback.version>1.2.9</logback.versi
【SpringBoot】仿 spring-boot-project 自定义 starters
迪曼奥特迦-博客
10-09 505
自定义的框架基础，这里封装了统一响应结果、基础异常、基础错误码枚举、校验工具类等共用类，同时也引入了一些共用依赖，原则上每个新建的工程都需要引用此 module。- 空文件包，此包是对 pointer-boot-build 进行了依赖管理。在构建大型微服务框架时常常会引入此包，统一对依赖包进行版本管理。
springboot-起步依赖
最新发布
qq_44895567的博客
06-11 451
起步依赖是一组预定义的、可传递的依赖集，涵盖了各种常见的开发场景，如 Web 开发、数据访问、消息传递、安全等。每个起步依赖都封装了一组相关的库，并配置了合理的默认设置，使得开发者只需添加一个依赖即可使用相关功能。：结合 Spring Boot 的自动配置功能，起步依赖能够根据类路径中的库自动配置相关的 Bean 和设置。：Spring Boot 负责管理这些库的版本，确保它们之间的兼容性，开发者无需手动处理版本冲突。起步依赖的核心理念是通过组合常用的库和配置，提供一个开箱即用的开发体验。
自己如何写一个 SpringBoot 第三方依赖包？
Calm 的博客
12-09 1731
揭秘 SpringBoot 是如何实现 “轻配置” 的
IDEA IU 新建 SpringBoot 项目 dependency 类型 及列表
wuyujin1997的博客
12-14 1827
本来想试用三十天的，但是 2021.3 这个版本需要登录后才能试用Start trial。 用 github 账号登陆一下： 登录成功： Start trial 试用一个月。 New Project，然后左侧项目类型选Spring Initializer。修改右侧参数。 新的SpringBoot项目需要集成哪些依赖？勾选就好了。 专门装一次IDEA IU，就是为了看看默认提供的Template Enginees都有哪几种依赖： 以上界面，左侧按照功能类型将依赖列出，点击某个具体依赖项，右侧会有描述信息。 这
多模块开发SpringBoot项目自定义第三方依赖版本
Ep流苏的博客
03-11 1313
参考：官方文档 - Build System of Maven https://blog.didispace.com/books/spring-boot-reference/IX.%20%E2%80%98How-to%E2%80%99%20guides/80.3%20Customize%20dependency%20versions.html 对于 SpringBoot 使用 Maven 构建项目做依赖管理大致分下面两种情况，一种是以 spring-boot-starter-parent 作为父模块，属.
深入浅出Spring Boot 起步依赖和自动配置
Java_No2的博客
06-04 561
我们知道 Spring Boot 能快速的搭建起一个应用，简化了大量的配置过程，那到底有多”简”呢？ 我们通过一个例子来说明，平时我们通过 Spring 和 Spring MVC 搭建一个 helloword 的 Web 应用，需要做以下工作： 配置 pom.xml 添加 Spring 、 Spring MVC 框架的依赖，同时还需要考虑这* 些不同的框架的不同版本是否存在不兼容的问题。 配置 ...
通过Spring Boot整合Mybatis分析自动配置详解
08-25
对于Mybatis的集成，Spring Boot提供了`mybatis-spring-boot-starter`起步依赖，该依赖包含了Mybatis和Spring的整合模块，使得Mybatis能够无缝地融入到Spring Boot的环境中。 在整合Mybatis时，我们需要添加以下...
LEARNING SPRING BOOT 3.0 - THIRD EDITION
04-21
Spring Boot是Spring生态系统中的一个核心组件，它通过自动化配置、起步依赖和内嵌式Web服务器等功能，极大地简化了Java应用的开发。 在Spring Boot 3.0版本中，我们可以期待一系列更新和改进，包括性能提升、新...
Spring Boot 面试必备手册
03-31
1. **易上手**：Spring Boot 提供了起步依赖（Starters），这些依赖可以帮助开发者快速集成常用功能，比如数据访问、Web服务等。 2. **开箱即用**：它内置了 Tomcat 或 Jetty 等服务器，无需额外安装，大大减少了...
JDK 8 + Spring Boot 2.7.18
01-08
1. **自动配置**：通过`@SpringBootApplication`注解，Spring Boot会自动配置许多常见的依赖，如数据源、缓存等。 2. **起步依赖**：通过`spring-boot-starter`模块，开发者可以轻松引入所需的依赖，如Web、Data JPA...
Spring Boot实战派（源码）
05-31
- 自动配置：Spring Boot会根据项目依赖自动配置相应的bean，如数据源、Web服务器等。 2. **起步依赖（Starter POMs）** - Spring Boot通过一系列的起步依赖来简化Maven或Gradle配置，比如`spring-boot-starter-...
springboot知识点
--lky的博客
07-14 169
一：SpringBoot 随着 Spring Boot 使用越来越广泛，Spring Boot 已经成为 Java 程序员面试的知识点，很多同学对 Spring Boot 理解不是那么深刻，经常就会被几个连环跑给干趴下了！ 比如下面这一段的 Spring Boot 问答： 问：你觉得 Spring Boot 最大的优势是什么呢？ 答：Spring Boot 的最大的优势是“约定优于配置“。“约定优于配置“是一种软件设计范式，开发人员按照约定的方式来进行编程，可以减少软件开发人员需做决定的数量，获得简单的好处
深入理解 spring-boot-starter-parent
怪咖@的博客
05-06 6677
在idea当中创建springboot项目的时候都会继承一个`spring-boot-starter-parent`作为父类，假如不继承我们的项目就不能使用了吗？当然不是，我们可以点进去看一下他都做了些什么，实际上就是给我们提供了一个管理的依赖pom。
springboot项目如何不依赖spring-boot-parent
MuYIShan1的博客
09-25 707
springboot项目如何不依赖spring-boot-parent 在一个pom中只能存在一个<parent></parent>标签，正常情况我们创建一个springboot项目都要依赖spring-boot-starter-parent，但是有时我们项目已经有一个<parent></parent>标签，那我们可以使用dependency management的方案来解决不能依赖spring-boot-starter-parent问题。 传统spring-
Springboot项目中的spring-boot-starter-parent，spring-boot-dependencies依赖关系
热门推荐
一个喜欢诗和远方的程序媛
03-18 1万+
Springboot项目中spring-boot-dependencies或spring-boot-parent管理了那些常用的依赖，所以有些不需要加version版本标签了，可以统一项目的依赖，避免后续的版本冲突。而spring-boot-dependencies和spring-boot-starter-parent的关系是什么
spring-boot-starter-parent，spring-boot-dependencies区别
m0_51478572的博客
08-28 1930
Springboot项目中spring-boot-dependencies或spring-boot-parent管理了那些常用的依赖，所以有些不需要加version版本标签了，可以统一项目的依赖，避免后续的版本冲突。而spring-boot-dependencies是spring-boot-starter-parent的父级项目。
Spring Boot入门教程：轻松掌握自动配置与核心特性
文档提到了Spring Boot的四个核心特性：自动配置、起步依赖、命令行界面和Actuator，并简要介绍了系统要求，推荐使用Java 8、Spring Boot 1.5.1.RELEASE和Maven 3.3.9进行开发。" 在Spring Boot干货系列的第一篇中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值