Spring Boot_⯐

概述

Spring Boot是由Pivotal团队开发的基于Spring Framework构建的快速开发脚手架，核心设计理念为约定优于配置，用于简化Spring应用的搭建、配置、部署与运维。它不替代Spring，而是通过自动配置、起步依赖、内嵌容器等特性，实现独立运行、开箱即用，是Java后端、微服务、云原生开发的主流基础框架。

发展历程

Spring Boot的发展历程可以分为以下几个阶段：

诞生背景（2012年前） 传统Spring配置繁琐、依赖复杂、部署麻烦，急需轻量化解决方案。
1.x 奠基（2014） 2014年发布1.0，推出自动配置、Starter依赖、内嵌服务器、Actuator监控，实现开箱即用，快速普及。
2.x 升级（2018） 基于Spring 5，支持JDK8+、WebFlux响应式编程，优化性能，适配云原生与微服务。
3.x 革新（2022） 全面切换Jakarta EE，基线升至JDK17，支持GraalVM原生镜像，启动更快、占用更低。
4.x 演进（2025） 基于Spring7、Jakarta EE10，深化云原生与AI集成，持续优化安全与性能。

Spring Boot程序组织思路

Spring Boot通过自动装配好了Spring MVC天然实现了MVC模式，只需分层编写代码即可。具体业务流程如下：

浏览器/前端请求 → Controller（C） 接收
Controller 调用 Service（M 的业务层）
Service 调用 Mapper 操作数据库
返回 User 对象（M 的数据层）
Controller 转为 JSON 返回
前端展示 → View（V）

Spring Boot程序业务流程原理图

C → Controller（控制器）M → Model（模型）V → View（视图）

负责接收请求、分发、返回结果

注解：@RestController / @Controller
接收：URL 请求、参数
调用：Service
返回：JSON / 视图

示例

StudentController
@RestController
@RequestMapping("/student")
public class StudentController {
    @Autowired
    private StudentService studentService;

    @GetMapping("/{id}")
    public Student get(@PathVariable Long id) {
        return studentService.getById(id);
    }
}

Spring Boot 里把 Model 拆成两层，职责更清晰：

业务模型：Service

注解：@Service
职责：业务逻辑、事务、组合数据

示例

StudentService
@Service
public class StudentService {
    @Autowired
    private StudentMapper studentMapper;

    public Student getById(Long id) {
        return studentMapper.selectById(id);
    }
}

数据模型：Entity + Mapper

Entity：数据载体
Mapper：数据访问

示例

StudentEntity
public class Student {
    private Long id;
    private String name;
}

@Mapper
public interface StudentMapper {
    Student selectById(Long id);
}

在前后端分离项目中：

后端不写 View
前端（Vue/React/小程序）充当 View
Spring Boot 只返回 JSON 数据

Spring Boot程序体系结构

1 业务代码2 配置与资源3 依赖与构建4 测试与资源

启动入口
- 启动类（含 @SpringBootApplication）
分层业务代码
- Controller：接口层
- Service：业务逻辑层
- Mapper/DAO：数据访问层
数据模型
- Entity/PO：数据库实体
- DTO/VO：参数与返回对象
框架扩展类
- Configuration：配置类
- Interceptor / AOP：拦截、切面
- GlobalExceptionHandler：全局异常
- Util：工具类

配置文件
- application.yml / properties
- 多环境配置（dev/test/prod）
注解配置
- @Value、@ConfigurationProperties
- @MapperScan、@EnableXXX
扩展配置
- @PropertySource 自定义配置文件
- 外置配置文件、环境变量

依赖管理
- pom.xml（Maven）
- build.gradle（Gradle）
基础依赖
- spring-boot-starter-web 等官方 Starter
第三方整合依赖
- MyBatis、Redis、MQ、OSS 等
驱动与工具
- 数据库驱动、工具包、测试依赖
构建文件
- pom.xml（Maven）
- build.gradle（Gradle）

测试代码
- 单元测试、集成测试
测试注解与环境
- @SpringBootTest
- 测试专用配置
测试资源
- 测试配置文件
- 测试数据脚本

Hello World!

开发环境

使用Eclipse开发；默认支持Java Web应用

需要额外安装Spring Boot等插件
使用STS（Spring Tool Suite）默认支持Spring Boot应用

STS是一个专为Spring开发定制的Eclipse，方便创建、调试、运行及维护Spring应用。通过该工具，可以很方便地生成一个Spring工程，比如Web工程。

创建Spring Boot Web工程

选择向导输入工程信息选择依赖目录结构pom.xml创建HelloController创建ViewController启动运行

在STS中创建新工程，选择Spring Starter Project向导

Spring Starter Project

输入工程基本信息：

Service URL: https://start.aliyun.com
Name: HelloSpringBoot

Project info

为工程选择Spring Web依赖，支持Spring及Spring MVC

Dependences

向导完成后生成的目录结构如下：

HelloSpringBoot:.
│  HELP.md
│  mvnw
│  mvnw.cmd
│  pom.xml  // Maven配置文件
└─src
    ├─main
    │  ├─java
    │  │  └─com
    │  │      └─example
    │  │          └─demo
    │  │                  HelloController.java //HelloController
    │  │                  ViewController.java //ViewController    
    │  │                  HelloSpringBootApplication.java //主程序入口
    │  │
    │  └─resources
    │      │  application.properties  //配置文件
    │      ├─static
    │      └─templates  //模板文件
    │         hello.html    
    └─test
        └─java
            └─com
                └─example
                    └─demo
                            HelloSpringBootApplicationTests.java  

工程创建向导完成后，Mavan配置文件pom.xml的关键依赖如下：

<?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>4.0.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>HelloSpringBoot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>HelloSpringBoot</name>
    <description/>
    <url/>
    <licenses>
        <license/>
    </licenses>
    <developers>
        <developer/>
    </developers>
    <scm>
        <connection/>
        <developerConnection/>
        <tag/>
        <url/>
    </scm>
    <properties>
        <java.version>21</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webmvc</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webmvc-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>

源代码

HelloSpringBoot/pom.xml
<?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>4.0.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>HelloSpringBoot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>HelloSpringBoot</name>
    <description/>
    <url/>
    <licenses>
        <license/>
    </licenses>
    <developers>
        <developer/>
    </developers>
    <scm>
        <connection/>
        <developerConnection/>
        <tag/>
        <url/>
    </scm>
    <properties>
        <java.version>21</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webmvc</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webmvc-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>

在com.example.demo下创建类HelloController：

// http://localhost:8080/hello
@RestController
public class HelloController{
  @RequestMapping("/hello")
  public String hello(){
      return "Hello Spring Boot！";
  }
}

源代码

HelloSpringBoot/src/main/java/com/example/demo/HelloController.java
package com.example.demo;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController{
  @RequestMapping("/hello")
  public String hello(){
      return "Hello Spring Boot！";
  }
}

在com.example.demo下创建类ViewController：

// http://localhost:8080/hello
@Controller
public class ViewController {

    @GetMapping("/view")
    public String view(Model model) {
        model.addAttribute("msg", "这是来自后端的数据");
        return "hello"; // 视图名，自动找 templates/hello.html
    }
}

源代码

HelloSpringBoot/src/main/java/com/example/demo/ViewController.java
package com.example.demo;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class ViewController {

    @GetMapping("/view")
    public String view(Model model) {
        model.addAttribute("msg", "这是来自后端的数据");
        return "hello"; // 视图名，自动找 templates/hello.html
    }
}

在resources/templates下创建文件hello.html：

<h1>Spring Boot 视图渲染</h1>
<p th:text="${msg}"></p>

源代码

HelloSpringBoot/src/main/resources/templates/hello.html
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Hello View</title>
</head>
<body>
    <h1>Spring Boot 视图渲染</h1>
    <p th:text="${msg}"></p>
</body>
</html>

开发模式

在Boot Dashboard中启动HelloSpringBoot

生产模式

1	`java -jar HelloSpringBoot.jar`

在浏览器访问http://localhost:8080/hello，结果如下：

Hello World执行原理图

graph TB %% 启动流程 A["启动类
@SpringBootApplication"]:::success --> B["SpringApplication.run()"] B --> C["自动配置核心"] C --> C1["自动包扫描
创建Bean到IOC容器"] C --> C2["自动装配MVC、Tomcat、Thymeleaf"] C --> C3["启动内嵌Tomcat :8080"] %% 视图相关自动配置 C2 --> D["视图解析器 ViewResolver"]:::warning D --> D1["Thymeleaf 模板渲染"]:::warning D --> D2["静态资源映射 /static/**"] %% 请求入口 E[浏览器]:::primary -->|请求| F[内嵌Tomcat] F --> G[DispatcherServlet
中央分发器]:::danger G --> H[HandlerMapping
URL匹配Controller方法] H --> I[执行对应Controller]:::danger %% 两种返回分支 I -->|RestController
返回字符串/JSON| J["直接响应数据给浏览器"] I -->|Controller
返回视图名| K["视图解析器渲染HTML"] K --> D1 D1 --> L["返回动态页面"] J --> E L --> E %% 整体特性框 subgraph Spring Boot 核心特性 C1 C2 C3 D D1 D2 end

Hello World执行原理图

标准项目结构

src
├── main
│   ├── java/com/example
│   │   ├── DemoApplication.java       // 启动类（必须在根包）
│   │   ├── controller                 // 控制层：接收请求、参数校验、返回结果
│   │   ├── service                    // 业务逻辑层
│   │   │   └── impl                   // 业务实现类
│   │   ├── mapper                     // 数据访问层（MyBatis）
│   │   ├── entity                     // 数据库映射实体
│   │   ├── dto                        // 接口入参/出参对象
│   │   ├── config                     // 配置类（Mvc、线程池等）
│   │   ├── common                     // 工具类、统一返回、常量
│   │   ├── exception                  // 全局异常、自定义异常
│   │   └── interceptor                // 请求拦截器
│   └── resources
│       ├── application.yml            // 主配置
│       ├── application-dev.yml        // 开发环境
│       ├── application-prod.yml       // 生产环境
│       ├── mapper                     // MyBatis XML 文件
│       ├── static                     // 静态资源（js/css/img）
│       └── templates                  // 模板页面（Thymeleaf）
└── test
    └── java/com/example
        └── DemoApplicationTests.java   // 单元测试

核心特性

起步依赖Starter自动配置内嵌Web容器外部化配置生产级特性（Actuator）

对常用场景依赖进行聚合与版本管理，引入一个 Starter 即可获得整套技术栈，避免依赖冲突。

示例（Maven）

pom.xml
<!-- 统一版本管理 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.0</version>
</parent>

<!-- Web 开发：包含 Spring MVC + Tomcat + Jackson -->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

根据类路径下的依赖，自动装配 Bean，无需 XML 配置。例如引入 web 自动配置 DispatcherServlet，引入 jdbc 自动配置数据源。

内置 Tomcat（默认）、Jetty、Undertow，项目可打包为 Jar 直接运行，无需外部服务器。

运行命令

1	`java -jar demo.jar`

支持 .properties / .yml，可配置端口、数据源、日志、多环境等。

yaml示例

application.yml
server:
port: 8088
servlet:
    context-path: /demo

spring:
datasource:
    url: jdbc:mysql://localhost:3306/test_db
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver

properties示例

application.properties
# 服务器配置
server.port=8088
server.servlet.context-path=/demo

# 数据源配置
spring.datasource.url=jdbc:mysql://localhost:3306/test_db
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

提供应用监控、健康检查、配置查看等能力。

依赖

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

配置开启端点

management:
endpoints:
    web:
    exposure:
        include: "*"

访问：http://localhost:8088/demo/actuator/health

注解

使用注解，以更简洁、更直观、更紧凑的方式替代XML配置，实现Spring容器的自动管理与依赖注入，降低耦合、提升开发效率，并支持声明式事务、定时、异步等能力，最终让代码更易维护、更易扩展。

替代繁琐XML，让配置更简洁；XML 配置文件多、结构复杂、维护麻烦；注解写在代码旁边，简洁直观，大幅减少配置量。
配置与代码在一起，可读性更强；代码即配置，逻辑一目了然，不用在多个文件间跳转。
降低使用门槛，开箱即用；注解简单直观，学习成本低。只需一个 @SpringBootApplication、@RestController 就能快速搭建可用功能，无需理解底层复杂机制，极大提升开发效率。
让 Spring 自动管理对象（IOC）；通过 @Service、@Component、@Repository 等注解，告诉 Spring 哪些类需要被实例化、管理。由容器统一创建、销毁、维护 Bean，开发者不再手动 new 对象，实现控制反转。
自动依赖注入（DI），解耦代码；使用 @Autowired、@Resource 可以自动注入依赖对象，不用手动传递、不用关心对象创建顺序，模块间耦合度大幅降低，便于扩展和测试。
声明式编程，专注业务而非底层细节；像 @Transactional、@Async、@Scheduled、@Cacheable 这类注解， 只需要声明功能，不需要手动编写事务、线程、定时、缓存的底层代码，让开发者专注业务逻辑。
便于静态检查与编译期校验；注解在编译期就能被 IDE 识别，可提前提示错误；相比 XML 这种运行时才加载的配置，注解更安全、更容易排查问题。
支持高度灵活的扩展与切面能力；Spring 可以基于注解做 AOP、权限校验、日志、监控等统一增强。 通过注解就能给方法附加通用能力，不用侵入业务代码，实现无侵入增强。
适配 Spring Boot 自动配置机制；Spring Boot 的自动配置就是基于类路径和注解来判断是否加载组件，没有注解，自动配置无法生效。注解是 Spring Boot “约定优于配置”的核心实现方式。

核心注解

启动与容器类

Spring Boot 项目的“入口”和“容器管理核心”，负责启动项目、声明配置类、将对象（Bean）交给 Spring 容器管理，是所有功能的基础。

注解	作用说明
`@SpringBootApplication`	项目启动类唯一核心注解，整合 `@Configuration`（配置类）、`@EnableAutoConfiguration`（自动配置）、`@ComponentScan`（包扫描）三大功能
`@Configuration`	标记当前类为配置类，替代传统 XML 配置文件，用于编写自定义配置
`@Bean`	配合 `@Configuration` 使用，手动创建 Bean 并注入 Spring 容器，供其他组件调用
`@Component`	通用组件注解，标记不属于三层（Controller/Service/Mapper）的普通类，让 Spring 管理该类实例
`@SpringBootTest`	测试类专用注解，用于启动 Spring 容器，进行单元测试或集成测试

Web 控制层

专门处理前端 HTTP 请求，负责路径映射、参数接收、响应结果（JSON 为主），是前后端交互的核心层。

注解	作用说明
`@RestController`	整合 `@Controller`（标记控制器）和 `@ResponseBody`（返回 JSON 格式），无需单独加 `@ResponseBody`
`@GetMapping`	专门处理 GET 请求，简化 `@RequestMapping(method = RequestMethod.GET)`
`@PostMapping`	专门处理 POST 请求，简化 `@RequestMapping(method = RequestMethod.POST)`
`@PathVariable`	接收 URL 路径中的参数（如 `/user/1` 中的 1），需配合路径占位符使用
`@RequestParam`	接收 URL 查询参数（如 `/user?name=张三`）或表单参数，支持设置默认值
`@RequestBody`	接收前端传递的 JSON 格式请求体，自动将 JSON 转换为 Java 对象

业务与持久层

分层开发的核心，负责封装业务逻辑、处理数据库操作，保证数据一致性（事务），是项目的“业务核心”。

注解	作用说明
`@Service`	标记当前类为业务逻辑层组件，让 Spring 管理，便于依赖注入
`@Mapper`	MyBatis 专用注解，标记数据访问层接口，MyBatis 会自动生成接口的代理实现类，无需手动编写实现
`@Repository`	标记数据访问层组件（多用于 JPA 或传统 JDBC），与 `@Mapper` 功能类似，侧重非 MyBatis 场景
`@Transactional`	声明式事务管理，标记在方法或类上，保证方法内的数据库操作原子性（要么全成、要么全败）

依赖注入类

Spring 核心特性，无需手动 new 对象，从 Spring 容器中自动获取已注册的 Bean，降低组件间耦合度。

注解	作用说明
`@Autowired`	Spring 提供的依赖注入注解，按类型注入（优先匹配 Bean 的类型），若有多个同类型 Bean 会报错
`@Resource`	JDK 提供的依赖注入注解，按名称注入（优先匹配 Bean 的名称），也可按类型注入，兼容性更强
`@Qualifier`	配合 `@Autowired` 使用，指定要注入的 Bean 名称，解决同类型 Bean 冲突问题

配置读取类

读取项目配置文件（application.yml 或 application.properties）中的参数，避免硬编码，提高配置灵活性。

注解	作用说明
`@Value`	读取单个配置项，语法 `${配置项key}`，适合读取简单配置（如端口、密码）
`@ConfigurationProperties`	批量读取配置项，通过 `prefix` 指定配置前缀，自动绑定到实体类的属性上，适合读取复杂配置（如数据源、Redis）

全局增强类

全局统一处理 Controller 层的异常、统一响应格式，避免重复编码，提升项目规范性。

注解	作用说明
`@RestControllerAdvice`	全局增强 Controller，作用于所有带 `@RestController` 的类，可用于全局异常处理、响应格式封装
`@ExceptionHandler`	配合 `@RestControllerAdvice` 使用，指定要捕获的异常类型，处理该类型的所有异常

定时任务 & 异步

用于实现定时执行任务（如定时备份数据）、异步调用（如异步发送短信），提升项目性能和灵活性。

注解	作用说明
`@EnableScheduling`	开启定时任务功能，必须加在启动类上，否则定时任务不生效
`@Scheduled`	标记方法为定时任务，通过 `cron` 表达式或 `fixedRate` 设定执行规则
`@EnableAsync`	开启异步调用功能，必须加在启动类上，否则异步方法不生效
`@Async`	标记方法为异步执行，调用该方法时会开启新线程，不阻塞主线程

Lombok 简化代码

第三方工具注解，无需手动编写 getter/setter、构造方法、日志对象，大幅简化代码，提升开发效率（需导入 Lombok 依赖）。

注解	作用说明
`@Data`	整合 `@Getter`、`@Setter`、`@ToString`、`@EqualsAndHashCode`、`@RequiredArgsConstructor`，一键生成常用方法
`@Slf4j`	自动注入日志对象 `log`，可直接使用 `log.info()`、`log.error()` 打印日志
`@NoArgsConstructor`	生成无参构造方法
`@AllArgsConstructor`	生成全参构造方法（所有属性都作为参数）

集成第三方库

Spring Boot集成第三方库时，不同第三方库的配置方式不同，不同阶段的配置也不同（MyBatis 等库）。可能的配置方式包括：

步骤	主要操作	示例
依赖引入	1. 在 `pom.xml`（Maven）或 `build.gradle`（Gradle）中添加依赖； 2. 优先使用 Spring Boot Starter 自动整合包； 3. 处理版本冲突、依赖排除； 4. 多环境区分依赖（可选）
配置文件配置（application.yml / properties）	1. 连接地址、端口、账号密码； 2. 连接池、超时、重试、线程数； 3. 日志、开关、模式配置； 4. 第三方专属配置项
启用类/注解配置	1. 很多第三方需要 @EnableXXX 开启功能
Java 配置类（手动配置 Bean）	1. 手动创建第三方客户端实例; 2. 自定义连接池、拦截器、序列化方式; 3. 覆盖自动配置
编写业务代码（核心使用）	1. DAO / Mapper 层（如 MyBatis 的 Mapper 接口）; 2. Service 层调用; 3. Controller 暴露接口; 4. 工具类封装（RedisUtil、OssUtil 等）
映射/模型类编写	1. 实体类 Entity; 2. DTO / VO; 3. 第三方要求的配置类（如 MyBatis 的 TypeHandler）
XML / 映射文件（部分框架需要）	1.MyBatis、MyBatis-Plus 等需要：mapper.xml;配置文件扫描路径
AOP / 拦截器 / 插件	1. 分页插件; 2. 监控拦截; 3. 日志、性能统计; 4. 第三方提供的插件
事务/异常处理	1. 事务管理器配置; 2. 自定义异常; 3. 全局异常捕获; 4. 失败重试、熔断降级
日志与监控	1. 打印执行日志（SQL、请求日志）; 2. 对接 Actuator; 3. 性能监控、慢查询监控
测试相关	1. 测试依赖; 2. 测试配置; 3. 单元测试、集成测试
多环境适配	1. dev / test / prod 不同配置； 2. 不同环境的连接信息隔离
安全与权限	1. 密钥、证书配置； 2. 权限认证； 3. 加密传输
打包与部署	1. 驱动、依赖是否打包； 2. 外部配置文件； 3. 环境变量注入
外部配置文件	1. 外部配置文件（如 application.yml、application.properties）； 2. 环境变量注入； 3. 环境变量注入
版本与兼容性	1. JDK 版本； 2. Spring Boot版本； 3. 第三方库版本匹配

打包

在STS（Spring Tool Suite）中，Spring Boot项目的打包方式本质上由构建工具（Maven/Gradle）决定，主要分为以下两种标准类型，并可通过IDE界面或命令行执行：

可执行JAR包（Fat Jar /Uber Jar）——默认推荐方式

核心特性

包含应用程序代码、所有依赖库及内嵌Servlet容器（Tomcat/Jetty）。
独立可运行，直接使用java -jar xxx.jar命令启动。
适用于微服务、云原生、容器化（Docker）等独立部署场景。

STS操作方式

Maven项目

配置：pom.xml中默认packaging为jar，并自动集成spring-boot-maven-plugin插件。

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

- 执行：

- 右键项目→`Run As`→`Maven build...`→Goals输入`clean package`。

产物：target目录下生成${project.name}-${version}.jar。

Gradle项目
- 配置：build.gradle应用org.springframework.boot插件。
1 2 3 4 5
plugins { id 'java' id 'org.springframework.boot' version '3.2.0' id 'io.spring.dependency-management' version '1.1.4' }
- 执行：
  - 右键项目→Run As→Gradle build。
  - 或在右侧Gradle视图中，执行bootJar任务。
- 产物：build/libs目录下生成可执行JAR包。

传统 WAR 包

核心特性

仅包含应用程序代码与依赖，不包含内嵌容器。
需部署至外部独立Servlet容器（如Tomcat、WebLogic）运行。
适用于需集成至现有服务器集群、多应用共享容器的传统企业场景。

STS操作与配置

修改pom.xml

将打包方式改为war。
将内嵌Tomcat依赖范围设为provided（由外部容器提供）。

<packaging>war</packaging>

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

修改启动类

启动类继承SpringBootServletInitializer并重写configure 方法，支持外部容器启动。

@SpringBootApplication
public class Application extends SpringBootServletInitializer {
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(Application.class);
    }
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

执行打包
- 同JAR包方式，执行clean package，在target目录生成.war文件。

补充：两种特殊打包形态

普通JAR包（非可执行）
- 仅打包项目自身代码，不含依赖与内嵌容器，仅供其他项目依赖使用。
- 需在spring-boot-maven-plugin中配置classifier以区分可执行JAR。
多环境Profile打包
- 利用Maven Profile或Gradle特性，为开发、测试、生产等不同环境打包不同配置。
- 执行命令：clean package -Pprod（指定prod环境）。

总结

STS中Spring Boot项目的核心打包方式为两种：可执行JAR（默认，独立运行）与WAR（部署到外部容器）。所有操作均基于IDE内置的Maven/Gradle工具链执行，配置与标准Spring Boot项目完全一致。

Spring Boot⯐

概述

发展历程

Spring Boot程序组织思路

Spring Boot程序体系结构

Hello World!

开发环境

创建Spring Boot Web工程

Hello World执行原理图

标准项目结构

核心特性

注解

核心注解

启动与容器类

Web 控制层

业务与持久层

依赖注入类

配置读取类

全局增强类

定时任务 & 异步

Lombok 简化代码

集成第三方库

打包

可执行JAR包（Fat Jar /Uber Jar）——默认推荐方式

传统 WAR 包

补充：两种特殊打包形态

总结

Spring Boot_⯐