深入浅出Spring Boot 起步依赖和自动配置

三、Spring Boot起步依赖和自动配置原理 三、SpringBoot起步依赖和自动配置原理 1、起步依赖 2、自动配置原理 ## 1、起步依赖 在SpringBoot项目中所有依赖继承来自spring-boot-starter-parent。 ctrl+右键进入后。 在spring-boot-dependencies pom文件中,可以看到该文件管理了所有依赖的版本号,不会产生依赖冲突。 继承spring-boot-starter-parent的同时,还需要导入相应的spring-boot-starter-web依赖。 ctrl+鼠标左键 阅读详情

我们知道 Spring Boot 能快速的搭建起一个应用,简化了大量的配置过程,那到底有多”简”呢?

我们通过一个例子来说明,平时我们通过 Spring 和 Spring MVC 搭建一个 helloword 的 Web 应用,需要做以下工作:

  1. 配置 pom.xml 添加 Spring 、 Spring MVC 框架的依赖,同时还需要考虑这些不同的框架的不同版本是否存在不兼容的问题。
  2. 配置 Web.xml,加载 Spring、Spring MVC。
  3. 配置 Spring 。
  4. 配置 Spring MVC。
  5. 编写业务逻辑代码。

而使用 Spring Boot 搭建的话,需要做以下工作:

  1. 配置 pom.xml 继承 Spring Boot 的 pom.xml ,添加 Web 起步依赖。
  2. 创建启动引导类。
  3. 编写业务逻辑代码。

单从步骤数量上看就知道通过 Spring、Spring MVC 搭建比通过 Spring Boot 搭建更复杂,需要编写大量的配置,这还仅仅是在很少框架和 Spring 整合情况下,如果需要将多个第三方框架和 Spring 整合,恐怕就要陷入”配置地狱”了,此外这些配置基本都是固化的,也就是搭建新的应用,你仍然需要再次编写相同的配置信息,特别是在微服务这么火的当下,一个应用可能由十几个甚至几十个小型服务无组成,如果每个小型服务都重复的做着这些配置工作……。

那有没有什么办法解决这个局面呢?答案是有的,那就是使用 Spring Boot ,上从上面的例子就可以发现,使用 Spring Boot 的最大优点就是减少了配置的工作,那么是不是说使用 Spring Boot 就不需要这些配置过程了?当然不是,而是 Spring Boot 帮我们把这些工作给做了。

那 Spring Boot 是如何帮我们把这些配置工作给做了呢?这就是本文需要探讨的问题了,在探讨之前,我们需要了解两个概念 起步依赖 和 自动配置 ,这里暂且知道这两个东西是 Spring Boot 的核心、是 Spring Boot 的精华所在、是我们不需要再进行大量配置工作的原因所在就行了。

起步依赖

起步依赖说白了就是 Spring Boot 通过对常用的依赖进行再一次封装,例如我们平时需要搭建一个 Web 应用的时候,一般都会导入以下几个依赖:

<pre style="box-sizing: border-box; font-family: monospace; font-size: 18px; margin: 20px 0px; padding: 15px; border: 0px; background-color: rgb(244, 245, 246); white-space: pre-wrap; word-break: break-all; color: rgb(34, 34, 34); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;"><dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-webmvc</artifactId>
 <version>5.1.3.RELEASE</version>
</dependency>
<dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-web</artifactId>
 <version>5.1.3.RELEASE</version>
</dependency>

也就是需要将 spring-web 和 spring mvc 分别导入,而使用 Spring Boot 的话只需要导入一个:

<pre style="box-sizing: border-box; font-family: monospace; font-size: 18px; margin: 20px 0px; padding: 15px; border: 0px; background-color: rgb(244, 245, 246); white-space: pre-wrap; word-break: break-all; color: rgb(34, 34, 34); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;"><dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
</dependency>

也就是只需要导入一个名为 web 的起步依赖即可,我们点 spring-boot-starter-web 进去可以看到,其实这个起步依赖集成了常用的 web 依赖,如下:

<pre style="box-sizing: border-box; font-family: monospace; font-size: 18px; margin: 20px 0px; padding: 15px; border: 0px; background-color: rgb(244, 245, 246); white-space: pre-wrap; word-break: break-all; color: rgb(34, 34, 34); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;"><dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter</artifactId>
 <version>2.1.4.RELEASE</version>
 <scope>compile</scope>
</dependency>
<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-json</artifactId>
 <version>2.1.4.RELEASE</version>
 <scope>compile</scope>
</dependency>
<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-tomcat</artifactId>
 <version>2.1.4.RELEASE</version>
 <scope>compile</scope>
</dependency>
<dependency>
 <groupId>org.hibernate.validator</groupId>
 <artifactId>hibernate-validator</artifactId>
 <version>6.0.16.Final</version>
 <scope>compile</scope>
</dependency>
<dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-web</artifactId>
 <version>5.1.6.RELEASE</version>
 <scope>compile</scope>
</dependency>
<dependency>
 <groupId>org.springframework</groupId>
 <artifactId>spring-webmvc</artifactId>
 <version>5.1.6.RELEASE</version>
 <scope>compile</scope>
</dependency>

也就是前面所说的,Spring Boot的起步依赖说白了就是对常用的依赖进行再一次封装,方便我们引入,简化了 pom.xml 配置,但是更重要的是将依赖的管理交给了 Spring Boot,我们无需关注不同的依赖的不同版本是否存在冲突的问题,Spring Boot 都帮我们考虑好了,我们拿来用即可!

在使用 Spring Boot 的起步依赖之前,我们需要在 pom.xml 中添加配置:

<pre style="box-sizing: border-box; font-family: monospace; font-size: 18px; margin: 20px 0px; padding: 15px; border: 0px; background-color: rgb(244, 245, 246); white-space: pre-wrap; word-break: break-all; color: rgb(34, 34, 34); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;"><parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.1.4.RELEASE</version>
 <relativePath/> <!-- lookup parent from repository -->
</parent>

即让 pom.xml 继承 Spring Boot 的 pom.xml ,而 Spring Boot 的 pom.xml 里面定义了常用的框架的依赖以及相应的版本号。

总结一下 Spring Boot 的起步依赖的优点:

  1. 无需考虑不同框架的不同版本的冲突问题。
  2. 简化了 pom.xml 配置。

自动配置

如果将开发一个应用比喻成装修房子的过程,那么 Spring Boot 就像是一个全能型公司一样存在,而起步依赖可以比喻成购买装修用品的过程,自动配置比喻成用装修用品进行装修的过程。

我们可以通过 Spring Boot 的起步依赖获取到你想要的涂料、瓷砖、装饰品等, Spring Boot 公司会根据最佳的组合将这些装修用品打包好给我们,我们无需考虑各种装修用品是否搭配、是否冲突等问题。

通过起步依赖我们获取到了想要的装修用品,那接下来我们需要做的就是进行装修了,前面我们说过 Spring Boot 就像一个全能型公司一样,所以我们在他那里购买装修用品之后, 他不仅将装修用品送上门还会帮我们完成装修(自动配置) ,让我们享受一站式的服务,从购买装饰品(起步依赖)到装修完成(自动配置)都不用我们考虑,我们只需要在装修完成之后入住(编写自己的业务逻辑代码)即可。

说了这么多,我们还不知道 Spring Boot 是如何完成自动配置的,接下来我们来分析 Spring Boot 神奇的自动配置!

首先我们知道 Spring Boot 启动需要有一个启动引导类,这个类除了是应用的入口之外,还发挥着配置的 Spring Boot 的重要作用。下面是一个简单的启动引导类:

<pre style="box-sizing: border-box; font-family: monospace; font-size: 18px; margin: 20px 0px; padding: 15px; border: 0px; background-color: rgb(244, 245, 246); white-space: pre-wrap; word-break: break-all; color: rgb(34, 34, 34); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">@SpringBootApplication
public class DemoApplication {
 public static void main(String[] args) {
 SpringApplication.run(DemoApplication.class, args);
 }
}

我们发现有一个名为 @SpringBootApplication 的注解,点击进去可以发现,这个注解发挥着多个注解的作用:

<pre style="box-sizing: border-box; font-family: monospace; font-size: 18px; margin: 20px 0px; padding: 15px; border: 0px; background-color: rgb(244, 245, 246); white-space: pre-wrap; word-break: break-all; color: rgb(34, 34, 34); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">@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}
)}
)

这里简要的说下 @SpringBootConfiguration 和 @ComponentScan 注解。前者实质为 @Configuration 注解,这个注解相比大家都接触过,也就是起到声明这个类为配置类的作用,而后者起到开启自动扫描组件的作用。

这里需要重点分析的是 @EnableAutoConfiguration 这个注解,这个注解的作用是开启 Spring Boot 的自动配置功能,我们来分析一下它是如何开启的,点击进去可以看到:

<pre style="box-sizing: border-box; font-family: monospace; font-size: 18px; margin: 20px 0px; padding: 15px; border: 0px; background-color: rgb(244, 245, 246); white-space: pre-wrap; word-break: break-all; color: rgb(34, 34, 34); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">@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 {};
}

@EnableAutoConfiguration 这个注解同样发挥着多个注解的功能,我们重点分析 @Import({
AutoConfigurationImportSelector.class}) 这个注解,我们知道 @import 的作用是将组件添加到 Spring 容器中,而在这里即是将 AutoConfigurationImportSelector 这个组件添加到 Spring 容器中。

我们进一步分析
AutoConfigurationImportSelector

<pre style="box-sizing: border-box; font-family: monospace; font-size: 18px; margin: 20px 0px; padding: 15px; border: 0px; background-color: rgb(244, 245, 246); white-space: pre-wrap; word-break: break-all; color: rgb(34, 34, 34); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) {
 if (!this.isEnabled(annotationMetadata)) {
 return EMPTY_ENTRY;
 } else {
 AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
 List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes); 
 configurations = this.removeDuplicates(configurations);
 Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
 this.checkExcludedClasses(configurations, exclusions);
 configurations.removeAll(exclusions);
 configurations = this.filter(configurations, autoConfigurationMetadata);
 this.fireAutoConfigurationImportEvents(configurations, exclusions);
 return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
 }
}
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
 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;
}

有一个名为 getAutoConfigurationEntry 的方法,这个方法发挥的作用是扫描 ClassPath 下的所有 jar 包的 spring.factories 文件,将 spring.factories 文件 key 为 EnableAutoConfiguration 的所有值取出,然后这些值其实是类的全限定名, 也就是自动配置类的全限定名 ,然后 Spring Boot 通过这些全限定名进行类加载(反射),将这些自动配置类添加到 Spring 容器中。

那这些自动配置类有哪些?发挥什么作用呢?我们接着往下看,我们找到一个名为
spring-boot-autoconfigure-2.1.4.RELEASE.jar 的 jar 包,打开它的 spring.factories 文件,发现这个文件有 key 为 EnableAutoConfiguration 的键值对

<pre style="box-sizing: border-box; font-family: monospace; font-size: 18px; margin: 20px 0px; padding: 15px; border: 0px; background-color: rgb(244, 245, 246); white-space: pre-wrap; word-break: break-all; color: rgb(34, 34, 34); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;"># 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,\
......

也就是这个 jar 包有自动配置类,可以发现这些自动配置配都是以 xxxAutoConfiguration 的命名规则来取名的,这些自动配置类包含我了们常用的框架的自动配置类,比如 aop 、 elasticsearch 、 redis 和 web 等等,基本能满足我们日常开发的需求。

那这些自动配置类又是如何发挥配置作用的呢,我们取一个较为简单的配置类进行分析,名为
HttpEncodingAutoConfiguration ,它的部分代码如下:

<pre style="box-sizing: border-box; font-family: monospace; font-size: 18px; margin: 20px 0px; padding: 15px; border: 0px; background-color: rgb(244, 245, 246); white-space: pre-wrap; word-break: break-all; color: rgb(34, 34, 34); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">@Configuration //声明这个类为配置类
@EnableConfigurationProperties({HttpProperties.class}) //开启ConfigurationProperties功能,同时将配置文件和HttpProperties.class绑定起来
@ConditionalOnWebApplication( //只有在web应用下自动配置类才生效
 type = Type.SERVLET
)
@ConditionalOnClass({CharacterEncodingFilter.class}) //只有存在CharacterEncodingFilter.class情况下 自动配置类才生效
@ConditionalOnProperty( //判断配置文件是否存在某个配置spring.http.encoding,如果存在其值为enabled才生效,如果不存在这个配置类也生效。
 prefix = "spring.http.encoding",
 value = {"enabled"},
 matchIfMissing = true
)
//将字符编码过滤器组件添加到 Spring 容器中
@Bean
@ConditionalOnMissingBean
public CharacterEncodingFilter characterEncodingFilter() {
 CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
 filter.setEncoding(this.properties.getCharset().name());
 filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.REQUEST));
 filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.RESPONSE));
 return filter;
}
@Bean
public HttpEncodingAutoConfiguration.LocaleCharsetMappingsCustomizer localeCharsetMappingsCustomizer() {
 return new HttpEncodingAutoConfiguration.LocaleCharsetMappingsCustomizer(this.properties);
}

首先它同样有许多注解,我们一个一个分析:

  • Configuration:这个注解声明了这个类为配置类(和我们平时写的配置类一样,同样是在类上加这个注解)。
  • EnableConfigurationProperties:开启 ConfigurationProperties 功能,也就是将配置文件和 HttpProperties.class 这个类绑定起来,将配置文件的相应的值和 HttpProperties.class 的变量关联起来,可以点击 HttpProperties.class 进去看看,下面截取了部分代码进行分析:
<pre style="box-sizing: border-box; font-family: monospace; font-size: 18px; margin: 20px 0px; padding: 15px; border: 0px; background-color: rgb(244, 245, 246); white-space: pre-wrap; word-break: break-all; color: rgb(34, 34, 34); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">@ConfigurationProperties(
 prefix = "spring.http"
)
public static final Charset DEFAULT_CHARSET;
private Charset charset;
private Boolean force;
private Boolean forceRequest;
private Boolean forceResponse;
private Map<Locale, Charset> mapping;

通过 ConfigurationProperties 指定前缀,将配置文件 application.properties 前缀为 spring.http 的值和 HttpProperties.class 的变量关联起来,通过类的变量可以发现,我们可以设置的属性是 charset 、 force 、 forceRequest 、 forceResponse 和 mapping 。也就是我们除了使用 Spring Boot 默认提供的配置信息之外,我们还可以通过配置文件指定配置信息。

<pre style="box-sizing: border-box; font-family: monospace; font-size: 18px; margin: 20px 0px; padding: 15px; border: 0px; background-color: rgb(244, 245, 246); white-space: pre-wrap; word-break: break-all; color: rgb(34, 34, 34); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;">CharacterEncodingFilter

可以发现后面几个注解都是 ConditionalXXXX 的命名规则,这些注解是 Spring 制定的条件注解,只有在符合条件的情况下自动配置类才会生效。

接下来的 characterEncodingFilter 方法,创建一个 CharacterEncodingFilter 的对象,也就是字符编码过滤器,同时设置相关属性,然后将对象返回,通过 @Bean 注解,将返回的对象添加到 Spring 容器中。这样字符编码过滤器组件配置好了,而平时的话,我们需要在 web.xml 进行如下配置:

<pre style="box-sizing: border-box; font-family: monospace; font-size: 18px; margin: 20px 0px; padding: 15px; border: 0px; background-color: rgb(244, 245, 246); white-space: pre-wrap; word-break: break-all; color: rgb(34, 34, 34); font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: 2; text-align: justify; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration-style: initial; text-decoration-color: initial;"><filter>
 <filter-name>springUtf8Encoding</filter-name>
 <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
 <init-param>
 <param-name>encoding</param-name>
 <param-value>utf-8</param-value>
 </init-param>
 <init-param>
 <param-name>forceEncoding</param-name>
 <param-value>true</param-value>
 </init-param> 
 </filter>
 <filter-mapping>
 <filter-name>springUtf8Encoding</filter-name>
 <url-pattern>/*</url-pattern>
 </filter-mapping>

到这里是不是感受到了 Spring Boot 自动配置带来的好处了?

接下来的
localeCharsetMappingsCustomizer 方法同理,就不分析了。

最后我们用一句话总结一下 Spring Boot 的自动配置:Spring Boot 启动的时候,会扫描 ClassPath 下的所有 jar 包,将其 spring.factories 文件中 key 为 EnableAutoConfiguration 的所有值取出,然后这些值其实是类的全限定名, 也就是自动配置类的全限定名 ,然后 Spring Boot 通过这些全限定名进行类加载(反射),将这些自动配置类添加到 Spring 容器中。这些自动配置类根据不同的条件(@ConditionalXXX)决定自动配置类是否生效,生效的话自动配置类会将相关组件添加到 Spring 容器中,也就不用我们再进行配置。

 

OpenCV实现物体尺寸的测量 物体尺寸测量的思路是找一个确定尺寸的物体作为参照物,根据已知的计算未知物体尺寸。如下图所示,绿色的板子尺寸为220*300(单位:毫米),通过程序计算白色纸片的长度。 阅读详情

相关推荐

Windows MCP 安装教程:让 AI 代理与 Windows 系统无缝交互

通过以上步骤,你已经成功安装和配置了 Windows MCP 服务。现在你的 Cursor 编辑器可以通过 MCP 协议与 Windows 系统进行深度交互,AI 代理能够:启动和控制应用程序执行系统命令自动化 UI 操作获取系统状态信息这为 AI 辅助开发和工作流程自动化提供了强大的基础。如果你在使用过程中遇到任何问题,欢迎在评论区讨论或查看项目的官方文档。

chenchihwen的专栏 3358

SpringBoot起步依赖和自动配置

等进一步熟练它的使用后,可以再进一步往底层挖掘,虽然有些太细节的东西,在项目开发中基本用不到,但是自己有一定了解的话,在使用过程中碰到问题可以有更清晰的思路去定位并解决。在这个.json文件中,可以找到跟刚才相关的配置,也就是说,这个json文件里面的值,就是SpringBoot自动配置时帮我们配置的值,如果我们需要更改这些配置,只需要在我们的配置文件中配置一下就行了,就会覆盖这里的默认配置,而使用我们的自定义配置。简单的说,起步依赖就是将具备某种功能的坐标打包到一起,并提供一些默认的功能。

Crush_kylin的博客 2170

告别模糊与偏色:使用RKISP Tuner为RK3588s+IMX415进行图像质量调优的实战心得

本文详细介绍了如何使用RKISP Tuner为RK3588s+IMX415进行图像质量调优的实战经验。从调试环境搭建到3A算法优化,再到画质增强模块的深度调参,提供了全面的技术指导和参数建议,帮助工程师解决噪声、色偏和细节模糊等常见问题,显著提升成像质量。

weixin_28729205的博客 455

SpringBoot:起步依赖-自动配置

SpringBoot:起步依赖-自动配置

qq_45779998的博客 4738

别再搞错了!ERA5-Land小时数据里的辐射值,原来不是你想的那个‘瞬时值’

本文深入解析ERA5-Land小时数据中辐射值的累积特性,揭示其与瞬时值的本质区别。通过详细的数据处理方法和Python代码示例,指导研究者正确转换累积辐射量为实用瞬时值,避免常见误区,提升气候模型验证的准确性。

weixin_28700411的博客 211

WinCC与PLC在西门子逻辑赛项中的通信配置避坑指南

本文针对西门子逻辑赛项中WinCC与PLC通信配置的常见问题,提供了一套实战避坑指南。重点解析了WinCC、PLC与EET仿真平台的三角通信架构,强调了IP地址规划、防火墙设置等关键环节的注意事项,并给出了系统化的故障诊断流程与排查技巧,帮助选手和技术人员快速定位并解决通信故障,确保监控系统稳定运行。

weixin_29165725的博客 109

SpringBoot——解析SpringBoot启动类:起步依赖、自动配置

解释为什么通过启动类的 SpringApplication.run方法就可以启动一个项目,启动类注解@SpringBootApplication注解的作用是什么,源码查看SpringBoot是怎么做到起步依赖和自动配置的

YR_112233的博客 1万+

大地坐标系与经纬度转换(一):大地坐标系简介

一、大地坐标系 大地坐标系是大地测量中以参考椭球面为基准面建立起来的坐标系。地面点的位置用大地经度、大地纬度和大地高度表示。 二、地心坐标系 ...

qq_42895926的博客 6万+

Spring Boot起步依赖和自动配置

起步依赖 在Spring Boot项目中,必须继承依赖spring-boot-starter-parent,所以从这个继承依赖开始。 在点击进入spring-boot-starter-parent后,其pom文件又继承了一个依赖spring-boot-dependencies,在看这个依赖前,先来看下这个文件的内容。 spring-boot-starter-parent 其中有对配置文件的引...

sscout的博客 9170

国科大学习资料--自然语言处理(宗成庆)-2019期末考试题

国科大学习资料–自然语言处理(宗成庆)-2019期末考试题 国科大学习资料–自然语言处理(宗成庆)-2019期末考试题 国科大学习资料–自然语言处理(宗成庆)-2019期末考试题

无名何许人的博客 2441

C#上位机与西门子PLC全链路通信实战教程:数据采集+SQL存储+数据库报表查询+报警历史完整实现

在工业自动化领域,西门子PLC(S7-200Smart/1200/1500)凭借稳定的性能、强大的功能、完善的生态,稳居工业控制器的主流地位;而凭借开发效率高、界面美观、兼容性强、数据库操作便捷的优势,成为工业上位机开发的首选编程语言。二者的组合,是目前制造业、自动化产线、智能仓储、暖通自控等场景的绝对主流方案,也是工业上位机工程师必须吃透的核心技术栈。

这里只有干货:从 Modbus 通信到 MES 对接,从 YOLO 训练到工控机部署,带你搞定工业软件开发全流程。 1868

MRAM与TM4C1294嵌入式实战:从SPI驱动到掉电保存方案

在工业控制与嵌入式系统设计中,非易失性存储是不可或缺的底层能力。传统NOR Flash虽然容量大、成本低,但擦除慢、寿命有限,难以满足高频日志与掉电保护场景。SPI接口是这类存储芯片最常见的通信方式,而MRAM凭借无需擦除、按字节覆盖写入和近乎无限的写寿命,成为工业存储方案越来越受关注的替代选项。通过理解SPI时序、指令集与驱动封装,开发者可以把MRAM无缝接入TM4C1294等Cortex-M主控平台。结合CRC校验与双镜像机制,更能构建出高可靠性的参数保存方案。本文从一个可跑的SPI硬件接线与初始化出发

weixin_34292402的博客 690

聊聊蓝牙配对技术-CTKD OVER BR/EDR

摘要:本文探讨了蓝牙设备通过跨传输密钥派生(CTKD)机制实现双模连接的技术细节。研究发现,手机在连接双模耳机时优先通过BR/EDR配对,再利用CTKD派生BLE连接所需的密钥。关键条件包括:设备地址一致性、启用安全连接(Secure Connection)及禁用justworks配对方式。文章详细剖析了从BR/EDR链路密钥派生BLE长期密钥(LTK)的算法流程,重点解析了H6/H7加密函数的作用机制与安全差异。研究还通过HCI日志验证了密钥交换和加密建立的完整过程,指出蓝牙5.1版本对CTKD安全性的强

十多年蓝牙协议软件开发,擅长蓝牙协议分析 2705

boot的几个依赖 spring_深入浅出Spring Boot 起步依赖和自动配置

我们知道 Spring Boot 能快速的搭建起一个应用,简化了大量的配置过程,那到底有多”简”呢?我们通过一个例子来说明,平时我们通过 Spring 和 Spring MVC 搭建一个 helloword 的 Web 应用,需要做以下工作:配置 pom.xml 添加 Spring 、 Spring MVC 框架的依赖,同时还需要考虑这些不同的框架的不同版本是否存在不兼容的问题。配置 Web.x...

weixin_30189603的博客 519

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

spring boot pom配置_深入浅出Spring Boot 起步依赖和自动配置

我们知道 Spring Boot 能快速的搭建起一个应用,简化了大量的配置过程,那到底有多”简”呢?我们通过一个例子来说明,平时我们通过 Spring 和 Spring MVC 搭建一个 helloword 的 Web 应用,需要做以下工作:配置 pom.xml 添加 Spring 、 Spring MVC 框架的依赖,同时还需要考虑这* 些不同的框架的不同版本是否存在不兼容的问题。配置 Web....

weixin_39956350的博客 455

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

深入浅出Spring Boot框架:从入门到精通

Spring Boot 是基于 Spring 框架的一个开源框架,其主要目的是简化 Spring 应用程序的创建和开发过程。它通过自动配置(Auto-Configuration)、嵌入式服务器(Embedded Server)等功能,极大地减少了开发者在配置上的工作量,使快速搭建生产级别的 Spring 应用程序成为可能。Spring Boot 的设计哲学是“约定优于配置”,这意味着开发者只需遵循一些默认规则,就可以避免大量的样板代码和复杂的 XML 配置文件。

weixin_50552218的博客 2351

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

万字笔记,史上最全的Spring Boot快速入门笔记

Spring Boot是Spring家族下的一个全新开发框架,其设计目的主要是用来简化Spring应用的创建及开发过程,它提供了自动配置,starter依赖等特性,从而使开发人员从大量的XML配置中解脱出来,Spring Boot致力于在蓬勃发展的快速应用开发领域成为领导者。 动力节点的springboot本课程由浅入深,带你体验Spring Boot的极速开发过程,内容丰富,涵盖了SpringBoot开发的方方面面,并且同步更新到Spring Boot 2.x系列的最新版本,让你一次性拿下Spring B

f5465245的博客 289

从零开始学 Spring Boot:小白也能快速上手的全栈开发入门指南

本文面向编程零基础读者,用通俗语言+分阶段实操,带你从‘Spring Boot 是什么’到‘自己写出一个可运行的 Web 接口’,涵盖用途、环境搭建、Hello World、进阶原理与技术评估,全程无门槛、有代码、能落地。

qq5621的博客 636

SpringBoot核心特性:自动配置与起步依赖

Spring Boot 的最大魅力在于它能够最大限度地减少开发者的手动配置工作。起步依赖(Starter)是 Spring Boot 提供的一组预定义的 Maven 依赖集合。是 Spring Boot 自动配置的核心注解。它告诉 Spring Boot 根据classpath中的依赖,自动加载相应的配置类(Configuration Class)。是 Spring Boot 最为核心的功能之一。Spring Boot 通过一系列创新的设计和特性,极大地简化了 Spring 应用的开发和配置工作。

2302_76552486的博客 1705

Spring Boot 起步依赖

参考书《Spring Boot实战》 1.Spring Boot起步依赖 Spring项目的依赖管理也很费力。需要决定项目要用哪些库,还要考虑库的版本和其他库的版本不会用冲突。 原来的Spring项目中,如果要使用某项功能,需要考虑支持该功能需要什么库?需要考虑库的Group和Artifact?库的版本号?哪个版本不会和项目中的其他依赖发生冲突? ...

dream_heheda的博客 7429

Spring boot起步依赖、自动配置与启动执行流程原理

什么是 Spring Boot? Spring Boot :起步依赖 自动配置 Spring Boot 并不是一个框架,它是一种创建独立应用程序的更简单方法,只需要很少或没有配置(相比于 Spring 来说)。Spring Boot最好的特性之一是它利用现有的 Spring 项目和第三方项目来开发适合生产的应用程序。 spring boot来简化spring应用开发,约定大于配置,去繁从简,just run就能创建一个独立的,产品级别的应用,无需打包部署,直接运行 springBoot约定大于配置到底是什么

九曜 6379

Spring Boot 的自动配置 和 起步依赖

Spring Boot 的自动配置是为了提高开发效率和简化配置流程,而 SSM 框架则提供了更多的手动配置选项,适合那些需要精细控制的场景。随着 Spring Boot 的流行,许多传统的 SSM 项目也被迁移到 Spring Boot,以利用其自动配置和简化的配置管理。这些配置文件用于覆盖自动配置的默认值或提供额外的配置。Spring Boot 的自动配置特性正是为了简化传统 Spring 框架(如 SSM 框架)中繁琐的 XML 配置或注解配置而设计的。如,如果项目中包含了。

jkl12345669的博客 665

SpringBoot实战课堂笔记Spring Boot 核心之(起步依赖+自动配置)

这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能,丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好! 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar

wo1de2yi3jia的博客 1248

深入核心:理解Spring Boot的三大基石:起步依赖、自动配置与内嵌容器

本文深入剖析了Spring Boot框架背后三大核心基石。首先,通过“依赖套餐”的比喻,并结合`mvn dependency:tree`实战,解释了“起步依赖”如何简化依赖管理。接着,通过流程图和自定义代码示例,阐明了“自动配置”如何基于条件注解智能装配Bean。最后,讲解了“内嵌容器”如何让应用打包成可独立运行的JAR文件。文章通过时序图将三大基石的协同工作流程可视化,清晰地揭示了Spring Boot高效、便捷的本质,是帮助开发者建立核心知识体系的关键章节。

杨小扩的博客 2236
上一篇: 大型网站应该如何设计其高并发架构?
下一篇: 阿里面试常问Spring IOC解析,看看你都会哪些?
Java_ttcd
博客等级 码龄4年 198粉丝 190原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值