Spring Boot：基本应用和源码解析_springboot源码工程-优快云博客

本文链接：https://blog.youkuaiyun.com/bier_zm/article/details/121308931

本文详细介绍了Spring Boot的基本应用，包括约定优于配置的理念、Spring Boot的概念和解决问题的方式，以及快速入门、配置文件、单元测试与热部署等方面。在源码剖析部分，探讨了依赖管理，特别是spring-boot-starter-parent和spring-boot-starter-web的用途，以及自动配置的原理，如@EnableAutoConfiguration注解的作用和加载流程。文章通过实例展示了Spring Boot如何简化开发流程，提高效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.2.2 Spring Boot 解决上述 Spring 的问题

1.6.1 application.properties 配置文件

1.6.2 application.yaml 配置文件

1.7 配置文件属性值的注入

1.7.1 使用 @ConfigurationProperties 注入属性

1.7.2 使用 @Value 注入属性

1.8 自定义配置

1.8.1 使用 @PropertySource 加载配置文件

1.8.2 使用 @Configuration 编写自定义配置类

2.SpringBoot 原理深入及源码剖析

2.1 依赖管理

2.1.1 spring-boot-starter-parent 依赖

2.1.2 spring-boot-starter-web 依赖

2.2 自动配置

2.2.1 @SpringBootConfiguration 注解

2.2.2 @EnableAutoConfiguration 注解

2.2.3 @ComponentScan 注解

2.2.4 总结

1. SpringBoot 基本应用

1.1 约定优于配置

约定优于配置（Convention over Configuration），又称按约定编程，是一种软件设计范式。

本质上是说，系统、类库或框架应该假定合理的默认值，而非要求提供不必要的配置。比如说模型中有一个名为 User 的类，那么数据库中对应的表就会默认命名为 User。只有在偏离这一个约定的时候，例如想要将该表命名为 person，才需要写有关这个名字的配置。

比如平时架构师搭建项目就是限制软件开发随便写代码，制定出一套规范，让开发人员按统一的要求进行开发编码测试之类的，这样就加强了开发效率与审查代码效率。所以说写代码的时候就需要按要求命名，这样统一规范的代码就有良好的可读性与维护性了。

约定优于配置简单来理解，就是遵循约定。

Spring Boot 是所有基于 Spring 开发的项目的起点。Spring Boot 的设计是为了尽可能快的跑起来 Spring 应用程序并且尽可能减少配置文件。

1.2 SpringBoot 概念

1.2.1 Spring 优缺点分析

优点：Spring 是 Java 企业版（Java Enterprise Edition，JEE，也称 J2EE）的轻量级代替品。无需开发重量级的 Enterprise Java Bean - EJB，Spring 为企业级 Java 开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单的 Java 对象（Plain Old Java Object，POJO）实现了 EJB 的功能。

缺点：虽然 Spring 的组件代码是轻量级的，但它的配置却是重量级的。一开始，Spring 用 XML 配置，而且是很多 XML 配置。Spring 2.5 引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显式 XML 配置。Spring 3.0 引入了基于 Java 的配置，这是一种类型安全的可重构配置方式，可以代替 XML。

所有这些配置都代表了开发时的损耗。因为在思考 Spring 特性配置和解决业务问题之间需要进行思维切换，所以编写配置挤占了编写应用程序逻辑的时间。和所有框架一样，Spring 实用，但与此同时它要求的回报也不少。

除此之外，项目的依赖管理也是一件耗时耗力的事情。在环境搭建时，需要分析要导入哪些库的坐标，而且还需要分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本，随之而来的不兼容问题就会严重阻碍项目的开发进度。SSM 整合：Spring、Spring MVC、Mybatis、Spring-Mybatis 整合包、数据库驱动，引入依赖的数量繁多、容易存在版本冲突。

1.2.2 Spring Boot 解决上述 Spring 的问题

SpringBoot 对上述 Spring 的缺点进行的改善和优化，基于约定优于配置的思想，可以让开发人员不必在配置与逻辑业务之间进行思维的切换，全身心的投入到逻辑业务的代码编写中，从而大大提高了开发的效率，一定程度上缩短了项目周期。

起步依赖：

起步依赖本质上是一个 Maven 项目对象模型 (Project Object Model，POM)，定义了对其他库的传递依赖，这些东西加在一起即支持某项功能。
简单的说，起步依赖就是将具备某种功能的依赖坐标打包到一起，并提供一些默认的功能。

自动配置：

springboot 的自动配置，指的是 springboot 会自动将一些配置类的 bean 注册进 ioc 容器，在需要的地方使用 @autowired 或者 @resource 等注解来使用它。
“自动”的表现形式就是只需要引想用功能的包，相关的配置完全不用管，springboot 会自动注入这些配置 bean，直接使用这些 bean 即可。

Springboot 可以简单、快速、方便地搭建项目；对主流开发框架的无配置集成；极大提高了开发、部署效率。

1.3 SpringBoot 入门案例

案例需求：请求 Controller 中的方法，并将返回值响应到页面。
1. 依赖管理

pom.xml

<!--
    所用的 springBoot 项目都会直接或者间接的继承 spring-boot-starter-parent
    1.指定项目的编码格式为 UTF-8
    2.指定 JDK 版本为 1.8
    3.对项目依赖的版本进行管理，当前项目再引入其他常用的依赖时就需要再指定版本号，避免版本冲突的问题
    4.默认的资源过滤和插件管理
-->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.2.RELEASE</version>
</parent>

<dependencies>
    <!-- 引入 Spring Web 及 Spring MVC 相关的依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

<!-- 可以将 project 打包为一个可以执行的 jar -->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

2. 启动类
com.zm.SpringBootDemo1Application

/**
 * SpringBoot 的启动类通常放在二级包中，
 * 比如：com.zm.SpringBootDemo1Application。
 * 因为 SpringBoot 项目在做包扫描，
 * 会扫描启动类所在的包及其子包下的所有内容。
 *
 * @author ZM
 * @since 2021-10-28 23:11
 */
@SpringBootApplication // 标识当前类为 SpringBoot 项目的启动类
public class SpringBootDemo1Application {

    public static void main(String[] args) {
        // 样板代码
        SpringApplication.run(SpringBootDemo1Application.class, args);
    }

}

3. Controller
com.zm.controller.HelloController

@RestController
@RequestMapping("/hello")
public class HelloController {

    @RequestMapping("/boot")
    public String helloSpringBoot() {
        return "Hello Spring Boot";
    }

}

1.4 SpringBoot 快速构建

案例需求：请求 Controller 中的方法，并将返回值响应到页面。

1. 使用 Spring Initializr 方式构建 Spring Boot 项目

本质上说，Spring Initializr 是一个 Web 应用，它提供了一个基本的项目结构，能够快速构建一个基础的 Spring Boot 项目。

Project SDK 用于设置创建项目使用的 JDK 版本，这里，使用之前初始化设置好的 JDK 版本即可；在 Choose Initializr Service URL 下使用默认的初始化服务地址 https://start.spring.io 进行 Spring Boot 项目创建。

创建完成后的 pom 文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

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

    <groupId>com.zm</groupId>
    <artifactId>springboot_demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot_demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>11</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

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

</project>

创建完成后，可以删除自动生成的 .mvn、.gitignore、HELP.md、mvnw、mvnw.cmd。

创建好的 Spring Boot 项目结构如图：

使用 Spring Initializr 方式构建的 Spring Boot 项目会默认生成项目启动类、存放前端静态资源和页面的文件夹、编写项目配置的配置文件以及进行项目单元测试的测试类。

2. 创建一个用于 Web 访问的 Controller

com.zm 包下创建名称为 controller 的包，在该包下创建一个请求处理控制类 HelloController ，

并编写一个请求处理方法 ( 注意：将项目启动类 SpringBootDemoApplication 移动到 com.zm 包下 )

com.zm.controller.HelloController

@RestController// 该注解为组合注解，等同于Spring中@Controller+@ResponseBody注解
@RequestMapping("/hello")
public class HelloController {

    @RequestMapping("/boot")
    public String hello() {
        return "What's up! Spring Boot!";
    }

}

3. 运行项目

运行主程序启动类 SpringBootDemoApplication，项目启动成功后，在控制台上会发现 Spring Boot 项目默认启动的端口号为 8080，此时，可以在浏览器上访问 http://localhost:8080/hello/boot。（也可以将默认端口8080修改掉，比如将端口改为8888-->在项目的配置文件application.properties中加入“server.port =8888”即可）。

页面输出的内容是 “What's up! Spring Boot!”，至此，构建 Spring Boot 项目就完成了。

1.5 单元测试与热部署

1.5.1 单元测试

开发中，每当完成一个功能接口或业务方法的编写后，通常都会借助单元测试验证该功能是否正确。
1. 添加 spring-boot-starter-test 测试依赖启动器，在项目的 pom.xml 文件中添加 spring-boot-starter-test 测试依赖启动器，示例代码如下：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
    <exclusions>
        <exclusion>
            <groupId>org.junit.vintage</groupId>
            <artifactId>junit-vintage-engine</artifactId>
        </exclusion>
    </exclusions>
</dependency>

注意：使用 Spring Initializr 方式搭建的 Spring Boot 项目，会自动加入 spring-boot-starter-test 测试依赖启动器，无需再手动添加。

2. 编写单元测试类和测试方法：

/**
 *  SpringJUnit4ClassRunner.class: Spring 运行环境
 *  JUnit4.class: JUnit 运行环境
 *  SpringRunner.class: Spring Boot 运行环境
 */
@RunWith(SpringRunner.class) // @RunWith: 运行器
@SpringBootTest // 标记为当前类为 SpringBoot 测试类，加载项目的 ApplicationContext 上下文环境
class Springbootdemo2ApplicationTests {

    @Autowired
    private HelloController helloController;

    @Test
    void contextLoads() {
        String result = helloController.hello();
        System.out.println(result);
    }

}

上述代码中，先使用 @Autowired 注解注入了 HelloController 实例对象，然后在 contextLoads() 方法中调用了 HelloController 类中对应的请求控制方法 hello()，并输出打印结果。