Code Guide

外观

2、SpringBoot基础入门二

约 13601 字大约 45 分钟

2025-09-04

1、Helloword程序

需求：浏览发送/hello请求，响应 Hello，Spring Boot 2

1.1、创建Maven工程

引入依赖

1.2、创建主程序

1.3、编写业务

传统项目框架搭建好后，业务如何开发，还怎么开发。 springboot提供了@RestController标签，相当于 @ResponseBody + @Controller

@ResponseBody 注解既可以作用在类上，还可以作用在方法上。

知识补充：概念性理解

@ResponseBody 注解的作用是将Controller的方法返回的对象，通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回JSON数据或者是XML数据。 本质

@ResponseBody的作用其实是将java对象转为json格式的数据，然后直接写入HTTP response 的body中；一般在异步获取数据时使用 注意

在使用此注解之后不会再走视图处理器，而是直接将数据写入到输入流中，他的效果等同于通过response对象输出指定格式的数据。

1. @ResponseBody 是作用在方法上的。
2. @ResponseBody 表示该方法的返回结果直接写入 HTTP response body中，一般在异步获取数据时使用【也就是AJAX】。

在使用 @RequestMapping后，返回值通常解析为跳转路径，但是加上 @ResponseBody 后返回结果不会被解析为跳转路径，而是直接写入 HTTP response body 中。 比如异步获取 json 数据，加上 @ResponseBody 后，会直接返回 json 数据。@RequestBody 将 HTTP 请求正文插入方法中，使用适合的 HttpMessageConverter 将请求体写入某个对象。

1.4、测试

直接运行main方法

http://localhost:8080/hello

1.5、简化部署

  1. springboot是整合其它所有技术栈的总框架，springboot为了简化配置，将所有配置存放在同一个配置文件中：application.properties。
  2. 相比于传统spring，简化了很多配置，甚至tomcat都不用配置就能启动，以修改启动端口为例，不用再去tomcat中修改配置，直接声明即可。
server.port=8888

可用配置列表：

Common Application Properties

Untitled

1.6、简化配置

springboot可以将整个项目打包成一个jar包，自带了运行环境，可直接运行。又称为“Fat jars”，小胖jar。

Untitled

打包部署，pom文件中添加下面插件：

<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
</build>

在IDEA的Maven插件上点击运行 clean 、package，把helloworld工程项目的打包成jar包，

打包好的jar包被生成在helloworld工程项目的target文件夹内。

用cmd运行java -jar boot-01-helloworld-1.0-SNAPSHOT.jar，既可以运行helloworld工程项目。

如果不用maven插件打包，会产生打包没有主程序清单的情况。

将jar包直接在目标服务器执行即可。

Untitled

2、自动配置原理

2.1、springboot两大优点

2.1.1、依赖管理

父项目做依赖管理

在helloworld案例中，依赖只需要引入一个springboot父项目依赖、一个指定场景模块的子项目依赖，指定场景下将要使用的所有包就能自动导入到项目中。

每一个项目都有一个父依赖项目。父项目一般都是做依赖管理的，子项目以后继承父项目，不需要写依赖版本号。

一些常用的starter场景：

  1. spring-boot-starter-cache: Starter for using Spring Framework’s caching support
  2. spring-boot-starter-data-jdbc : Starter for using Spring Data JDBC
  3. spring-boot-starter-data-jpa:Starter for using Spring Data JPA with Hibernate
  4. spring-boot-starter-data-redis:Starter for using Redis key-value data store with Spring Data Redis and the Lettuce client
  5. spring-boot-starter-jdbc:Starter for using JDBC with the HikariCP connection pool

每个springboot工程，都要引入springboot父项目依赖，因为在maven中，父项目的作用，是用来做依赖管理，会声明非常多的依赖，子项目继承父项目后，就不用再写依赖的版本号。

无需关注版本号，自动版本仲裁

1、引入依赖默认都可以不写版本

2、但引入非版本仲裁的jar，要写版本号。

springboot的父项目spring-boot-starter-parent，又引用了spring-boot-dependencies作为父项目。其中properties属性几乎声明了所有开发中常用的依赖的版本号。

所以我们引入指定模块依赖时便会自动找到对应版本的包。这称为自动版本仲裁机制。

Untitled

可以修改默认版本号

按照Maven的就近原则，在pom中修改之后，先按照pom中的版本号，否则遵循父类中的版本。

要修改springboot中已声明的组件的版本号。

  1. 查看spring-boot-dependencies里面规定当前组件依赖声明，对应的properties中版本用的 key。
  2. 在pom.xml中properties重新指定该Key对应的版本号即可。

通过导入starter场景启动器，便捷开发

1、starter是一组依赖集合的描述。

2、只要引入一个starter，一个完整的开发场景的所有依赖就能被自动引入。

3、所有官方starter的命名规则：spring-boot-starter-*，*代表场景名称。

4、SpringBoot所有支持的场景清单：

https://docs.spring.io/spring-boot/docs/current/reference/html/using.html#using.build-systems.starters

5、支持创建自定义Starter场景启动器。但这些第三方的Starter，Springboot建议命名规则为：

  • *-spring-boot-starter。例如：thirdpartyproject-spring-boot-starter。

6、所有场景启动器最底层的依赖，都会引用springboot自动配置的核心依赖：

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter</artifactId>
  <version>2.3.4.RELEASE</version>
  <scope>compile</scope>
</dependency>

在pom文件中右击可以生成依赖图：

Untitled

2.1.2、自动配置

以pom.xml中引入 spring-boot-starter-web 为例。

Untitled

自动配置好tomcat

自动配置步骤：

  1. 引入Tomcat依赖。spring-boot-starter-web 默认依赖了spring-boot-starter-tomcat。
  2. 配置Tomcat。（自动配置原理章节会详解自动配置和启动的原理。）
<dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-tomcat</artifactId>
      <version>2.3.4.RELEASE</version>
      <scope>compile</scope>
</dependency>

自动配好SpringMVC

  1. 引入SpringMVC全套组件
  2. 自动配好SpringMVC常用组件（功能）

自动配好Web常见功能

以spring、springmvc整合为例，在web.xml中，

  • 要配置DispatcherServlet，拦截所有请求，
  • 要配置 CharacterEncodingFilter，解决字符乱码问题。
  • 要配置 ViewResolver ，视图解析器。
  • 要配置 multipartResolver ，文件上传解析器。

SpringBoot帮我们配置好了所有web开发的常见场景，上述所有的组件，都会自动配置在IOC容器中。

输出结果中能查到spring+springmvc中的组件。

规定了默认的包结构

spring、springmvc整合时，要指定controller、servce等包扫描路径，例如web.xml中：

<context:annotation-config />
	<context:component-scan base-package="com.cff.springwork">
</context:component-scan>

在springboot中：

  1. 主程序所在包及其下面的所有子包里面的组件都会被默认自动扫描进来。
  2. 以前包扫描配置不再必须做。
  3. 也支持修改扫描路径。

Untitled

https://docs.spring.io/spring-boot/docs/current/reference/html/using.html#using.structuring-your-code

各种配置拥有默认值

默认配置最终都是映射到某个类上，如：MultipartProperties。

配置文件的值最终会绑定每个类上，这个类会在容器中创建对象。

Untitled

所以，在springboot项目中，如果要用到这些配置值时，直接通过springboot底层容器，拿到这个类的对象，提取出默认值即可，至于这些默认值是如何在启动时绑定的，后续章节会讲。

按需加载所有自动配置项

springboot中有非常多的starter，只有在pom.xml中引入了对应场景依赖，这个场景的自动配置才会开启。

SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面。

Untitled

spring-boot-autoconfigure 中，集成了多个模块场景下的自动配置。

Untitled

没有导入对应的场景启动器starter，那么该场景的自动配置逻辑代码会报红，代表不会生效。

Untitled

2.1.3、kafka-starter

KafkaProperties:配置kafka的属性信息，通过@ConfigurationProperties(prefix = "spring.kafka")注解和yml配置文件中的配置绑定。

@ConfigurationProperties(prefix = "spring.kafka")
public class KafkaProperties {}

KafkaAutoConfiguration：kafka自动配置类

yml配置文件中的属性和属性类绑定有两种方式：

  1. 使用@ConfigurationProperties(prefix = "spring.datasource.mysql")注解。
  2. 使用@Value("${spring.datasource.mysql.url}")注解。

3、容器功能相关的注解

通过相应的注解，实现配置文件中的容器功能。

3.1、组件添加

@Configuration

@Configuration 声明当前类为配置类。使当前类的作用等同于一个xml配置文件。配置类本身也是组件，所以默认也是单实例的，通过配置类给容器中添加组件。

https://www.cnblogs.com/timetriesall/p/15735101.html

注意：默认Spring容器中所有bean都是单例的；

  • 优点：可以节省空间，减少资源浪费。
  • 缺点：可能会引发线程安全问题

如果在Bean标签上设置scope = “prototype”,当前bean对象就是多例的,每次获取当前类的实例，spring容器就会创建当前类的实例；

  • 优点：不会引发线程安全问题
  • 缺点：每次获取实例都会创建新的实例，会占用服务器的内存空间，造成浪费
<bean 
	id="helloWorld" 
	class="cn.edu.initdestroy.HelloWorld" 
	scope="prototype" 
	init-method="init" 
	destroy-method="destroy">
</bean>

注解中，在@Controller、@Service、@Repository（或@Component）注解旁加 @Scope= (scopeName="prototype") ，即多例，默认为单例。

  • proxyBeanMethods属性：

spring5.2版本后，新增 proxyBeanMethods 属性。

springboot2.0版本基于此，@Configuration新增了一个注解属性proxyBeanMethods。

  • 默认值true：表示是否对当前配置的bean下的方法开启代理。
    • 被代理的方法每次调用前都会经过代理对象，会检查容器中是否已经有对应实例，如果有，直接返回。可保持容器中组件是单实例。
    • 每次通过当前类的实例方法去获取的实例都是同一个单例。
    • 此时容器中的MyConfig实例，是被SpringCGLIB增强的代理对象。com.learn.boot.config.MyConfig$$EnhancerBySpringCGLIB$$fdb349b1@19542407
  • false时：每次通过当前类的实例的方法去获取的实例都是新的实例。
    • 此时容器中的MyConfig实例就是普通实例。
    • com.learn.boot.config.MyConfig@1d8e2eea
  • 由proxyBeanMethods，衍生出两种模式：
    • Full，全配置。即 proxyBeanMethods = true，保证外部无论对配置类中每个@Bean方法对应的组件调用多少次，获取的都是容器中的同一个组件，即单实例对象。
    • Lite，轻量级配置。即 proxyBeanMethods = false，容器中保存的不是当前配置类的代理对象，而是一个普通的当前配置类的实例对象。配置类中，每个给容器添加组件的方法，每次被调用，都会去产生新的实例对象。
  • 两种模式解决组件依赖的场景使用区别：
    • 场景1：如果配置类中添加组件的方法之间无依赖关系，用Lite模式，加速容器启动过程，减少判断。
    • 场景2：如果配置类中添加组件的方法之间有依赖关系，用Full模式，方法会被调用得到之前单实例组件，

配置类案例：

测试类

@Bean

@Bean的作用：@Configuration声明的配置类中，使用@Bean标注在方法上，给容器中注册组件。

@Component、@Controller、@Service、@Repository

@Component：标注在类上，表示当前类是一个组件。等同于配置文件中的

@Controller：标注在Controller类上，表示当前类是一个控制器。

@Service：标注在Service类上，表示当前类是一个业务逻辑组件。

@Repository：标注在Dao类上，表示当前类是一个数据库层组件。

@SpringBootConfiguration和@Configuration

  • @SpringBootConfiguration和@Configuration都是Spring框架中的注解，用于配置和定义应用程序的配置类。
  • @SpringBootConfiguration注解是@SpringBootApplication注解的元注解之一，用于指示该类是Spring Boot的配置类。配置类是一个专门用于配置和组织Bean的类。
  • @Configuration注解是Spring框架中的注解，用于标识一个类是配置类。配置类主要用于定义Bean的创建和配置，以提供给Spring容器进行管理。
  • @SpringBootConfiguration继承自@Configuration，二者功能也一致，标注当前类是配置类，并会将当前类内声明的一个或多个以@Bean注解标记的方法的实例纳入到spring容器中，并且实例名就是方法名。（springboot推荐用@SpringBootConfiguration）

@EnableAutoConfiguration和 @Configuration 的区别

@Configuration：表示作用的类是个配置类。我们平时也会写配置类，比如我们系统中的DataSourceConfig类，但是由于这个类是在Starter对应的子目录下，会自动加载，所以@EnableAutoConfiguration就作用不到了。

@EnableAutoConfiguration：是一个加载Starter目录包之外的需要Spring自动生成bean对象（是否需要的依据是"META-INF/spring.factories"中org.springframework.boot.autoconfigure.EnableAutoConfiguration后面是有能找到那个bean）的带有@Configuration注解的类。一般就是对各种引入的spring-boot-starter依赖包指定的（spring.factories）类进行实例化。

@SpringBootApplication中包含了@EnableAutoConfiguration注解，@EnableAutoConfiguration的作用是启用Spring的自动加载配置。

整体流程：

1、我们启动类中会加上@SpringBootApplication

2、@SpringBootApplication包含了@EnableAutoConfiguration，告知应用启动的时候需要扫描依赖包中需要实例化的类

3、Springboot启动的时候会去扫描META-INF/spring.factories，查看具体是哪些类需要实例化

4、扫描哪些需要实例化的类，看下是否有@Configuration注解，如果有，则实例化

5、实例化的时候可能需要一些配置属性，一般这些类都会加上@EnableConfigurationProperties(RocketMQProperties.class)

@ComponentScan

声明在主程序类（又称主配置类）上，指定包扫描路径，不配置时，默认扫描当前主程序类所在的包下的所有类。

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com.learn")
public class MainApplication {
  ..
}

@Import

给容器中导入组件。

Untitled

声明在容器中的组件类上，给容器中自动创建出指定类型的组件。

默认组件bean的名称默认为类的全类名。com.learn.boot.bean.User

@Import 高级用法： https://www.bilibili.com/video/BV1gW411W7wy?p=8

@Import({User.class, DBHelper.class})
@Configuration(proxyBeanMethods = true)
public class MyConfig {
    ...
}

@Conditional

条件装配：满足Conditional指定的条件，则进行组件注入

Untitled

常见派生注解有：

  • @ConditionalOnBean 当容器中存在指定的bean时
  • @ConditionalOnMissingBean 当容器中不存在指定的bean时
  • @ConditionalOnClass 当容器中存在某个类时
  • @ConditionalOnMissingClass 当容器中不存在某个类时
  • @ConditionalOnResource 当项目类路径下存在某个资源时
  • @ConditionalOnJava 当前使用的Java为指定版本号时
  • @ConditionalOnWebApplication 当前应用为Web应用时
  • @ConditionalOnNotWebApplication 当前应用不是Web应用时
  • @ConditionalOnSingleCandidate 当前容器中，指定的组件只有一个实例，或者，组件存在多个实例，但只有一个实例为主实例（@Primary标注）时
  • 以@ConditionalOnBean为例

3.2、原生配置文件引入

@ImportResource

如果项目中存在spring配置文件，可能是老项目迁移遗留、或者引入的第三方包比较老，用的是配置文件而不是注解。这些配置文件在springboot项目中默认是不生效的。

如果不想手动将配置文件中的组件声明，手写转化为配置类，这时可以用@ImportResource。

用法：在任意配置类上，指定配置文件路径，启动时会将文件中的组件配置加载到容器中。

MyConfig.java

@ImportResource("classpath:beans.xml")
@Import({User.class, DBHelper.class})
@Configuration(proxyBeanMethods = true)
public class MyConfig {
    ...
}

bean.xml

MainApplication.java

3.3、properties配置文件内容绑定

Java中，读取properties文件中的内容，封装至JavaBean中，用原生代码实现比较繁琐，如：

springboot简化了这个过程，叫做配置绑定。

3.3.1、@ConfigurationProperties

如果组件的属性值想要和核心配置文件application.properties中的KV进行绑定，则需要在组件类上加上该注解。

组件必须被声明在容器中，该注解才能生效。

该组件在springboot底层中经常被使用。

有两种使用方法：

3.3.2、方法一：@Component + @ConfigurationProperties

application.properties

mycar.brand=YD
mycar.price=100000

Car.java

测试

3.3.3、方法二：@EnableConfigurationProperties + @ConfigurationProperties

假设引用了第三方包中的组件，我们不可能在其源代码上声明@Component.

这时可通过在配置类上声明@EnableConfigurationProperties并指定组件。来实现指定组件的配置绑定。

@EnableConfigurationProperties

作用：

1、开启指定组件的属性配置功能，使得组件上的@ConfigurationProperties注解生效

2、将指定组件导入至容器中。（等同于在组件上添加了@Component）

4、自动配置原理

按执行步骤角度讲解，分为以下几步

4.1、引导加载自动配置类

主启动类上，@SpringBootApplication，实际封装了

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {

4.1.1、@SpringBootConfiguration

@SpringBootConfiguration 中，集成了 @Configuration，作用是代表当前是一个配置类。

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

4.1.2、@ComponentScan

指定扫描哪些包。

比较特殊的是，这里指定了自定义的扫描器。

@ComponentScan(excludeFilters = { 
    @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
	@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) 
})

4.1.3、@EnableAutoConfiguration （核心）

为三者中最核心的注解，

@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {

@AutoConfigurationPackage

  • 作用：将注解实际作用的类所在的包下的所有组件导入进来。

例如 @SpringBootApplication 合成了 @EnableAutoConfiguration、@EnableAutoConfiguration 又合成了 @AutoConfigurationPackage。所以@SpringBootApplication 具备了 @AutoConfigurationPackage 的功能，即，@SpringBootApplication可将主启动类所在的包下的所有组件导入进来。

自动配置包，指定了包导入规则。

该注解通过@Import导入了AutoConfigurationPackages.Registrar.class组件，

利用 AutoConfigurationPackages.Registrar，将该注解实际作用于的目标类所在的包路径下的所有组件批量导入进容器中。这里实际为MainApplication 所在的包路径。

// @Import 给容器中导入一个组件
// 
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {

AutoConfigurationPackages.Registrar 批量注册原理：

AutoConfigurationPackages 为抽象类，

AutoConfigurationPackages.Registrar 为AutoConfigurationPackages 中声明的静态类。

由下图AutoConfigurationPackages.Registrar.class 中的Registrar断点可以分析出来：

AnnotationMetadata metadata：代表注解（当前为 @AutoConfigurationPackage）的元信息，包含该注解被实际使用的位置（MainApplication）、及各个属性值信息。

register方法：获取注解元信息中，注解作用于的目标类所在的包路径。将指定包路径下的所有组件进行注册。实际为主程序类MainApplication所在文件夹内的所有组件。这也就是springboot默认包路径为主程序类所在文件夹的原因。

Untitled

@Import(AutoConfigurationImportSelector.class)

作用：加载项目中所有./META-INF/spring.factories 的文件内容，将文件中声明的组件信息加载到容器中。（但并非全部生效，仍需按照条件装配规则（@Conditional）按需配置。具体见下方“按需开启自动配置项”章节讲解。）

主要运行过程如下：

Untitled

以自动配置组件加载为例： spring-boot一启动就要给容器中加载的所有配置类（但不一定都生效，具体过程见下方“按需开启自动配置项”）， 例如在spring-boot-autoconfigure-2.3.4.RELEASE.jar 中META-INF/spring.factories文件里面写死了支持的自动配置清单，即# Auto Configure注释下，尾缀为xxxAutoConfiguration，自动配置相关的包。数量有127个。

4.2、按需开启自动配置项

如上@EnableAutoConfiguration生效后，虽然我们会将所有jar包中的META-INF/spring.factories下的配置全部加载，但并非全部生效，仍需按照条件装配规则（@Conditional）按需配置。

Untitled

常见的条件注解：

https://blog.csdn.net/qq_36850813/article/details/101597330

条件注解说明
@ConditionalOnBeanSpring容器中是否存在对应的实例。可以通过实例的类型、类名、注解、昵称去容器中查找(可以配置从当前容器中查找或者父容器中查找或者两者一起查找)这些属性都是数组，通过”与”的关系进行查找
@ConditionalOnClass类加载器中是否存在对应的类。可以通过Class指定(value属性)或者Class的全名指定(name属性)。如果是多个类或者多个类名的话，关系是”与”关系，也就是说这些类或者类名都必须同时在类加载器中存在
@ConditionalOnExpression判断SpEL 表达式是否成立
@ConditionalOnJava指定Java版本是否符合要求。内部有2个属性value和range。value表示一个枚举的Java版本，range表示比这个老或者新于等于指定的Java版本(默认是新于等于)。内部会基于某些jdk版本特有的类去类加载器中查询，比如如果是jdk9，类加载器中需要存在java.security.cert.URICertStoreParameters；如果是jdk8，类加载器中需要存在java.util.function.Function；如果是jdk7，类加载器中需要存在java.nio.file.Files；如果是jdk6，类加载器中需要存在java.util.ServiceLoader
@ConditionalOnMissingBeanSpring容器中是否缺少对应的实例。可以通过实例的类型、类名、注解、昵称去容器中查找(可以配置从当前容器中查找或者父容器中查找或者两者一起查找)这些属性都是数组，通过”与”的关系进行查找。还多了2个属性ignored(类名)和ignoredType(类名)，匹配的过程中会忽略这些bean
@ConditionalOnMissingClass跟ConditionalOnClass的处理逻辑一样，只是条件相反，在类加载器中不存在对应的类
@ConditionalOnWebApplication应用程序是否是Web程序，没有提供属性，只是一个标识。会从判断Web程序特有的类是否存在，环境是否是Servlet环境，容器是否是Web容器等
@ConditionalOnNotWebApplication应用程序是否是非Web程序，没有提供属性，只是一个标识。会从判断Web程序特有的类是否存在，环境是否是Servlet环境，容器是否是Web容器等
@ConditionalOnProperty应用环境中的屬性是否存在。提供prefix、name、havingValue以及matchIfMissing属性。prefix表示属性名的前缀，name是属性名，havingValue是具体的属性值，matchIfMissing是个boolean值，如果属性不存在，这个matchIfMissing为true的话，会继续验证下去，否则属性不存在的话直接就相当于匹配不成功
@ConditionalOnResource是否存在指定的资源文件。只有一个属性resources，是个String数组。会从类加载器中去查询对应的资源文件是否存在
@ConditionalOnSingleCandidateSpring容器中是否存在且只存在一个对应的实例。只有3个属性value、type、search。跟ConditionalOnBean中的这3种属性值意义一样

实际例子：

4.2.1、AopAutoConfiguration

引入springboot2核心包后，默认生效

4.2.2、CacheAutoConfiguration

4.2.3、DispatcherServletAutoConfiguration

引入 spring-boot-starter-web 依赖后生效。

WebMvcProperties.java

4.2.4、HttpEncodingAutoConfiguration

引入 spring-boot-starter-web 依赖后生效。

通过属性与配置文件的绑定，最终过滤器设置编码就支持从配置文件中获取。

Untitled

3.3、框架支持根据情况按需调整当前的配置

案例一：web 项目里，用户创建了文件上传解析器MultipartResolver，但是名称不是multipartResolver。使用条件注解将bean名称更改。

springmvc文件上传解析器MultipartResolver初始化的时候是通过唯一的id去容器中找有没有文件上传的组件。所以bean名称必须是multipartResolver。

案例二：SpringBoot默认会在底层配好所有的组件。但是通过@ConditionalOnMissingBean注解，如果用户自己配置了，这时则以用户的优先。

当用户自定义了CharacterEncodingFilter组件配置。

@Configuration(proxyBeanMethods = true)
public class MyConfig {

    @Bean
    public CharacterEncodingFilter filter(){
        return null;
    }
}

这时框架的HttpEncodingAutoConfiguration自动配置类中不再自动配置CharacterEncodingFilter。

3.4、总结

可用配置列表：https://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html#application-properties

Untitled

3.4.1、简化部署

配置文件属性与配置类对应关系

以HttpEncodingAutoConfiguration为例

Untitled

3.5、最佳实践经验，开发步骤

3.5.1、要开发什么场景，就引入对应的场景依赖

假设要开发缓存功能，要引入缓存的场景依赖。要去找springboot官方或第三方提供的场景依赖。

如果是第三方，要查看第三方提供的说明文档。

如果是springboot官方，从官方文档提供的列表中可找到对应的场景依赖：https://docs.spring.io/spring-boot/docs/current/reference/html/using-spring-boot.html#using-boot-starter

Untitled

3.5.2、可查看springboot帮我们配置了哪些对应场景下的组件（可选）。

偏向于底层原理，开发期间可不管这些。

查看方式：

1、自行分析：根据引入场景的标识，去 spring-boot-autoconfigure-2.3.4.RELEASE.jar 中，寻找对应标识同名文件夹下的配置类，根据代码分析哪些配置会生效，一般都生效了。这种方式比较麻烦。

Untitled

2、在application.properties配置文件中，开启debug模式，添加debug=true，启动时打印出自动配置报告。 Positive matches 生效的配置 Negative matches 未生效的配置

Untitled

3.5.3、引入依赖后，修改配置文件中对应的内容

如何得知引入场景依赖后要修改哪些配置项？有如下2种方式。

1、自行分析：根据引入场景的标识，去 spring-boot-autoconfigure-2.3.4.RELEASE.jar 中，寻找对应标识同名文件夹下的配置类，并根据绑定的配置属性类进行分析。

2、参考springboot官方或第三方依赖的文档。https://docs.spring.io/spring-boot/docs/current/reference/html/application-properties.html#application-properties

Untitled

以启动日志中的banner图为例。

Untitled

3.5.4、可自定义添加组件或替换组件

如果引入的场景中的功能不符合要求，可自定义添加组件或替换组件。通过@Bean、@Component .....。

springboot2自动配置的原理规定了，如果用户自定义了一个目标组件，那么该组件的运作方式就以用户写的为准。

后面还会讲解自定义器，XXXCustomizer，我们可以自定义一些自定义器来改变已有组件的运行行为。

3.5.5、业务逻辑

5、辅助开发技巧

5.1、Lombok

Lombok可以简化JavaBean开发。在项目编译时自动生成属性的get/set方法,程序编译的时候会生成方法。

  1. 引入lombok依赖

springboot的父项目中已经默认指定了lombok的版本。spring-boot-starter-parent --> spring-boot-dependencies 中，指定了默认版本： <lombok.version>1.18.12</lombok.version>

<dependency>
   <groupId>org.projectlombok</groupId>
   <artifactId>lombok</artifactId>
</dependency>
  1. lombok的使用

5.2、dev-tools

开发者工具，实现项目编译后的快速启动。

原理：dev tools快速重启，即Restart，底层有两个类加载器，一个负责加载第三方库，一个负责加载本地java类。第三方库源码是不会变的，也就是重新启动时，只需要加载本地java类就可以。节省了重新启动的时间。

这个东西用的时候得注意会存在奇奇怪怪的问题，破坏双亲委派机制~

如果想实现不重启的热部署，即重载Reload，用付费的Jrebel。https://blog.csdn.net/lianghecai52171314/article/details/105637251

注：IDEA的编译Bulid Project 按钮是Ctrl+F9。ctrl+shift+F9， 这个很快只编译修改的文件。Shift+F10 直接重启项目

  1. 使用方式
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
</dependency>
  1. 官网说明

https://docs.spring.io/spring-boot/docs/current/reference/html/using.html#using.devtools

Untitled

5.3、Spring Initailizr（项目初始化向导）

方便快速初始化创建Springboot项目。

操作步骤：

Untitled

Untitled

Untitled

Untitled

Untitled

效果

自动帮我们创建好了项目结构依赖、文件夹、主配置类、配置文件。

Untitled

Untitled

贡献者

codingLab

版权归属：codingLab

许可证：bugcode

Code Guide © 2020-2025