作者：技术笔记 | 日期：2026-01-23 | 分类：Java开发、Spring生态

本文专为Java开发者打造，从Spring Boot核心原理到企业级实战全覆盖，既适合零基础入门，也能帮有经验开发者梳理进阶知识点。全文约4500字，包含10+实操案例、20+核心代码片段，建议收藏后按章节逐步研习，配套代码可直接复制落地。

一、Spring Boot入门认知

1.1 什么是Spring Boot

Spring Boot是由Pivotal团队（后并入VMware）开发的Spring生态子项目，基于Spring框架，核心定位是“简化Spring应用开发”。它通过“约定优于配置”（Convention Over Configuration）的设计理念，消除了传统Spring项目繁琐的XML配置，实现“开箱即用”，让开发者专注于业务逻辑而非框架配置。

核心优势：

• 无XML配置：默认采用注解配置，大幅简化项目搭建流程；

• 自动依赖管理：通过 starters 组件一键引入所需依赖，避免版本冲突；

• 嵌入式服务器：内置Tomcat、Jetty、Undertow，无需单独部署服务器；

• 自动配置：根据类路径下的依赖，自动激活对应配置（如引入MySQL依赖则自动配置数据源）；

• 生态集成：无缝对接Spring Cloud、MyBatis、Redis等主流框架，支持微服务开发。

1.2 Spring Boot与Spring的区别

很多开发者会混淆两者关系，其实Spring Boot并非替代Spring，而是对Spring的增强与封装：

对比维度	Spring	Spring Boot
配置方式	以XML配置为主，注解配置为辅	纯注解配置，无XML（可选）
依赖管理	手动引入依赖，需自行协调版本	Starters自动依赖，版本统一管理
服务器部署	需打包为WAR包，部署到外部服务器	内置服务器，可打包为JAR包独立运行
适用场景	传统企业级应用、需要高度定制化配置的场景	快速开发、微服务、前后端分离项目

1.3 版本选择建议

Spring Boot版本分为“稳定版”和“快照版”，生产环境优先选择稳定版，且需与JDK版本兼容：

• JDK版本：Spring Boot 3.x 要求 JDK 17+（推荐JDK 17/21）；Spring Boot 2.x 支持 JDK 8/11/17（适合旧系统迁移）；

• 稳定版推荐：2026年优先选择 Spring Boot 3.3.x（长期支持版），兼顾稳定性与新特性；

• 版本命名规则：如 3.3.2 → 主版本.次版本.修订版本（主版本迭代不兼容旧API，次版本新增特性，修订版本修复BUG）。

二、开发环境搭建（Windows/Mac通用）

2.1 必备环境

搭建Spring Boot开发环境需提前准备以下工具，版本对应关系需严格遵守：

• JDK：17+（推荐 AdoptOpenJDK 17，免费开源）；

• 构建工具：Maven 3.6+ 或 Gradle 7.5+（本文以Maven为例，主流选择）；

• IDE：IntelliJ IDEA（推荐旗舰版，社区版功能有限）或 Eclipse（需安装Spring Tools插件）；

• 辅助工具：Postman（接口测试）、Navicat（数据库管理）。

2.2 JDK与Maven配置

2.2.1 JDK安装与环境变量配置

1. 下载JDK 17：从 Adoptium官网 下载对应系统版本（Windows选x64 Installer，Mac选x64 DMG）；

2. 安装JDK：默认路径安装即可（Windows避免中文路径）；

3. 配置环境变量（Windows）：

   1. 新建系统变量 JAVA_HOME，值为JDK安装路径（如 C:\Program Files\Eclipse Adoptium\jdk-17.0.11.9-hotspot）；

   2. 编辑系统变量 Path，添加 %JAVA_HOME%\bin 和 %JAVA_HOME%\jre\bin；

   3. 验证：打开CMD，输入 java -version，显示JDK 17版本信息即配置成功。

2.2.2 Maven安装与配置

1. 下载Maven：从Maven官网 下载二进制压缩包（apache-maven-3.9.6-bin.zip）；

2. 解压Maven：将压缩包解压到非中文路径（如 D:\apache-maven-3.9.6）；

3. 配置环境变量（Windows）：

   1. 新建系统变量 M2_HOME，值为Maven解压路径；

   2. 编辑 Path，添加 %M2_HOME%\bin；

   3. 验证：CMD输入 mvn -v，显示Maven版本信息即成功。

4. 优化Maven配置（核心步骤）： 编辑Maven安装目录下 conf\settings.xml，修改以下内容：

   1. 设置本地仓库路径（避免默认C盘占用空间）： 《localRepository》D:\maven-repository《/localRepository》

   2. 配置阿里云镜像（加速依赖下载，国内必备）： 《mirrors》 《mirror》 《id》aliyunmaven《/id》 《mirrorOf》central《/mirrorOf》 《name》阿里云公共仓库《/name》 《url》https://maven.aliyun.com/repository/public《/url》 《/mirror》《/mirrors》

2.3 第一个Spring Boot项目（IDEA搭建）

2.3.1 方式1：通过IDEA快速初始化（推荐）

1. 打开IDEA，选择 File → New → Project；

2. 左侧选择 Spring Initializr，默认使用 start.spring.io 初始化，点击 Next；

3. 填写项目信息：

   1. Name：项目名称（如 springboot-demo）；

   2. Type：选择 Maven；

   3. Language：Java；

   4. Spring Boot Version：选择 3.3.2（稳定版）；

   5. Group：组织ID（如 com.example）；

   6. Artifact：项目标识（如 springboot-demo）；

   7. Java Version：17。

4. 选择依赖（入门仅需Spring Web）：左侧选择 Web → Spring Web，勾选后点击 Next；

5. 选择项目保存路径，点击 Finish，IDEA自动下载依赖并构建项目，等待几分钟即可完成。

2.3.2 方式2：通过Spring Initializr官网生成

若IDEA无法访问外网，可通过官网生成项目包：

1. 访问 Spring Initializr官网，填写上述项目信息和依赖；

2. 点击 Generate 下载项目压缩包；

3. 解压后，在IDEA中选择File → Open，导入解压后的项目即可。

2.3.3 项目结构解析

生成的Spring Boot项目结构遵循Maven规范，核心目录如下：

springboot-demo/

├── src/

│ ├── main/

│ │ ├── java/

│ │ │ └── com/

│ │ │ └── example/

│ │ │ └── springbootdemo/

│ │ │ └── SpringbootDemoApplication.java # 项目启动类

│ │ └── resources/

│ │ ├── application.properties # 核心配置文件

│ │ ├── static/ # 静态资源目录（CSS、JS、图片）

│ │ └── templates/ # 模板文件目录（Thymeleaf、Freemarker）

│ └── test/ # 测试类目录

├── pom.xml # Maven依赖配置文件

└── README.md

2.3.4 运行第一个项目

1. 创建测试接口：在启动类同级目录下新建 controller/HelloController.java： package com.example.springbootdemo.controller;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.RestController;@RestController // 标识为REST接口控制器，返回JSON数据public class HelloController { // 定义GET请求接口，路径为/hello @GetMapping("/hello") public String hello() { return "Hello Spring Boot 3.x!"; }}

2. 启动项目：

   1. 右键点击 SpringbootDemoApplication.java，选择 Run；

   2. 启动成功标志：控制台输出 Started SpringbootDemoApplication in XXX seconds。

3. 测试接口：

   1. 浏览器访问 http://localhost:8080/hello；

   2. 页面显示 Hello Spring Boot 3.x!，说明项目运行正常。

三、Spring Boot核心特性详解

3.1 核心注解

Spring Boot基于注解驱动开发，核心注解按功能分类如下，需熟练掌握：

3.1.1 启动类注解

• @SpringBootApplication：组合注解，标注在启动类上，等价于 @SpringBootConfiguration + @EnableAutoConfiguration + @ComponentScan，开启自动配置和组件扫描。

3.1.2 组件注册注解

• @Component：通用组件注解，标识类为Spring管理的Bean；

• @Controller：标注在控制器类上，对应MVC层；

• @Service：标注在服务类上，对应Service层；

• @Repository：标注在数据访问类上，对应DAO层；

• @RestController：组合注解（@Controller + @ResponseBody），返回JSON数据，适用于前后端分离项目。

3.1.3 请求映射注解

• @GetMapping("/path")：处理GET请求，等价于 @RequestMapping(method = RequestMethod.GET)；

• @PostMapping("/path")：处理POST请求；

• @PutMapping("/path")：处理PUT请求（更新资源）；

• @DeleteMapping("/path")：处理DELETE请求（删除资源）；

• @PathVariable：获取URL路径参数，示例： @GetMapping("/user/{id}")public String getUser(@PathVariable Long id) { return "用户ID：" + id;}

• @RequestParam：获取URL请求参数，示例： @GetMapping("/user")public String getUser(@RequestParam(required = false, defaultValue = "1") Long id) { return "用户ID：" + id;}说明：required = false 表示参数非必填，defaultValue 设置默认值。

3.2 配置文件详解

Spring Boot支持两种格式配置文件：application.properties（键值对格式）和 application.yml（YAML格式，推荐，语法更简洁），两者可共存，properties优先级更高。

3.2.1 核心配置示例（application.yml）

# 服务器配置

server:

port: 8081 # 修改端口号（默认8080）

servlet:

context-path: /demo # 配置项目上下文路径，访问需加/demo

# 自定义配置（可通过@Value注入）

user:

name: 张三

age: 25

hobbies: [篮球, 编程]

# 日志配置

logging:

level:

root: INFO # 全局日志级别

com.example.springbootdemo: DEBUG # 指定包日志级别

file:

name: logs/springboot-demo.log # 日志文件路径

3.2.2 配置注入方式

方式1：@Value注入单个配置

@RestController

public class UserController {

// 注入自定义配置

@Value("${user.name}")

private String userName;

@GetMapping("/user/info")

public String getUserInfo() {

return "用户名：" + userName;

}

}

方式2：@ConfigurationProperties注入对象配置

适合多个相关配置项，需先引入依赖（Spring Boot 3.x已默认集成）：

《dependency》

《groupId》org.springframework.boot《/groupId》

《artifactId》spring-boot-configuration-processor《/artifactId》

《optional》true《/optional》

《/dependency》

创建配置类：

package com.example.springbootdemo.config;

import org.springframework.boot.context.properties.ConfigurationProperties;

import org.springframework.stereotype.Component;

import java.util.List;

@Component # 注册为Spring Bean

@ConfigurationProperties(prefix = "user") # 配置前缀

public class UserConfig {

private String name;

private Integer age;

private List<String> hobbies;

// Getter和Setter方法（必须有，否则无法注入）

public String getName() { return name; }

public void setName(String name) { this.name = name; }

public Integer getAge() { return age; }

public void setAge(Integer age) { this.age = age; }

public List<String> getHobbies() { return hobbies; }

public void setHobbies(List<String> hobbies) { this.hobbies = hobbies; }

}

使用配置类：

@RestController

public class UserController {

@Autowired # 自动注入配置类

private UserConfig userConfig;

@GetMapping("/user/config")

public String getUserConfig() {

return "姓名：" + userConfig.getName() + "，爱好：" + userConfig.getHobbies();

}

}

3.2.3 多环境配置

实际开发中需区分开发、测试、生产环境，Spring Boot通过“配置文件拆分”实现多环境切换：

1. 创建多环境配置文件：

   1. 开发环境：application-dev.yml；

   2. 测试环境：application-test.yml；

   3. 生产环境：application-prod.yml。

2. 在主配置文件 application.yml 中指定激活环境： spring: profiles: active: dev # 激活开发环境，可改为test/prod切换

3. 打包时指定环境（Maven命令）： # 打包生产环境mvn clean package -Dspring.profiles.active=prod

3.3 自动配置原理

Spring Boot核心亮点是“自动配置”，其底层原理可概括为“注解驱动 + 条件判断”，核心流程如下：

1. 启动类上的 @SpringBootApplication 注解包含 @EnableAutoConfiguration，开启自动配置；

2. @EnableAutoConfiguration 导入 AutoConfigurationImportSelector 类，该类扫描类路径下 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件，加载所有自动配置类；

3. 自动配置类（如 DataSourceAutoConfiguration、WebMvcAutoConfiguration）通过 @Conditional 系列注解判断是否满足条件（如类路径是否存在对应依赖），满足则激活配置，自动创建Bean；

4. 开发者可通过自定义配置覆盖默认自动配置（如在application.yml中配置数据源，覆盖默认配置）。

核心注解：@ConditionalOnClass（类路径存在指定类则生效）、@ConditionalOnMissingBean（容器中不存在指定Bean则生效）、@ConditionalOnProperty（配置文件存在指定属性则生效）。

四、实战：Spring Boot集成主流框架

4.1 集成MyBatis（操作MySQL）

MyBatis是Java主流ORM框架，Spring Boot通过 mybatis-spring-boot-starter 实现快速集成。

4.1.1 步骤1：引入依赖

在pom.xml中添加以下依赖：

《!-- MyBatis Starter --》

《dependency》

《groupId》org.mybatis.spring.boot《/groupId》

《artifactId》mybatis-spring-boot-starter《/artifactId》

《version》3.0.3《/version》

《/dependency》

《!-- MySQL驱动 --》

《dependency》

《groupId》com.mysql《/groupId》

《artifactId》mysql-connector-j《/artifactId》

《scope》runtime《/scope》

《/dependency》

《!-- 数据库连接池（默认HikariCP，Spring Boot 3.x推荐） --》

《dependency》

《groupId》com.zaxxer《/groupId》

《artifactId》HikariCP《/artifactId》

《/dependency》

4.1.2 步骤2：配置数据源和MyBatis

在application.yml中添加配置：

spring:

datasource:

driver-class-name: com.mysql.cj.jdbc.Driver

url: jdbc:mysql://localhost:3306/springboot_demo?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai

username: root # 你的MySQL用户名

password: 123456 # 你的MySQL密码

hikari:

maximum-pool-size: 10 # 连接池最大连接数

minimum-idle: 5 # 最小空闲连接数

mybatis:

mapper-locations: classpath:mapper/**/*.xml # MyBatis映射文件路径

type-aliases-package: com.example.springbootdemo.entity # 实体类包路径

configuration:

map-underscore-to-camel-case: true # 开启下划线转驼峰命名（如user_name → userName）

4.1.3 步骤3：编写代码

1. 创建实体类 entity/User.java： package com.example.springbootdemo.entity;import lombok.Data; # 需引入lombok依赖，简化Getter/Setter@Data # Lombok注解，自动生成Getter/Setter/toString等方法public class User { private Long id; private String userName; private Integer age; private String email;}注：Lombok依赖需手动添加到pom.xml：《dependency》 《groupId》org.projectlombok《/groupId》 《artifactId》lombok《/artifactId》 《optional》true《/optional》《/dependency》

2. 创建Mapper接口 mapper/UserMapper.java： package com.example.springbootdemo.mapper;import com.example.springbootdemo.entity.User;import org.apache.ibatis.annotations.Mapper;import org.apache.ibatis.annotations.Select;import java.util.List;@Mapper # 标识为MyBatis Mapper接口，Spring自动扫描public interface UserMapper { // 注解方式编写SQL（简单SQL推荐） @Select("SELECT * FROM user") List<User> findAll(); // 复杂SQL可通过XML映射文件编写 User findById(Long id);}

3. 创建XML映射文件 resources/mapper/UserMapper.xml： 《?xml version="1.0" encoding="UTF-8"?》《!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"》《mapper namespace="com.example.springbootdemo.mapper.UserMapper"》 《select id="findById" parameterType="java.lang.Long" resultType="com.example.springbootdemo.entity.User"》 SELECT * FROM user WHERE id = #{id} 《/select》《/mapper》

4. 创建Service和Controller层： Service层 service/UserService.java：package com.example.springbootdemo.service;import com.example.springbootdemo.entity.User;import com.example.springbootdemo.mapper.UserMapper;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import java.util.List;@Servicepublic class UserService { @Autowired private UserMapper userMapper; public List<User> findAll() { return userMapper.findAll(); } public User findById(Long id) { return userMapper.findById(id); }}Controller层 controller/UserController.java：package com.example.springbootdemo.controller;import com.example.springbootdemo.entity.User;import com.example.springbootdemo.service.UserService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.PathVariable;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;import java.util.List;@RestController@RequestMapping("/user")public class UserController { @Autowired private UserService userService; @GetMapping("/list") public List<User> findAll() { return userService.findAll(); } @GetMapping("/{id}") public User findById(@PathVariable Long id) { return userService.findById(id); }}

4.1.4 测试接口

1. 在MySQL中创建 springboot_demo 数据库和 user 表，插入测试数据；

2. 启动项目，通过Postman访问： 查询所有用户：http://localhost:8080/user/list，返回JSON格式用户列表；查询单个用户：http://localhost:8080/user/1，返回ID为1的用户信息。

4.2 集成Redis（缓存）

Redis是高性能缓存数据库，Spring Boot通过 spring-boot-starter-data-redis 集成，适用于缓存热点数据、减轻数据库压力。

4.2.1 步骤1：引入依赖

《dependency》

《groupId》org.springframework.boot《/groupId》

《artifactId》spring-boot-starter-data-redis《/artifactId》

《/dependency》

《!-- Redis连接池 --》

《dependency》

《groupId》org.apache.commons《/groupId》

《artifactId》commons-pool2《/artifactId》

《/dependency》

4.2.2 步骤2：配置Redis

spring:

redis:

host: localhost # Redis服务器地址

port: 6379 # Redis端口（默认6379）

password: # Redis密码（无密码则留空）

database: 0 # 选择Redis数据库（默认0）

lettuce: # 连接池配置（Spring Boot 3.x默认使用Lettuce）

pool:

max-active: 8 # 最大活跃连接数

max-idle: 8 # 最大空闲连接数

min-idle: 2 # 最小空闲连接数

max-wait: -1ms # 最大等待时间（-1表示无限制）

4.2.3 步骤3：编写Redis工具类

Spring Data Redis提供 RedisTemplate 操作Redis，封装工具类简化使用：

package com.example.springbootdemo.util;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

@Component

public class RedisUtil {

@Autowired

private RedisTemplate<String, Object> redisTemplate;

// 存入缓存

public void set(String key, Object value, long timeout, TimeUnit unit) {

redisTemplate.opsForValue().set(key, value, timeout, unit);

}

// 获取缓存

public Object get(String key) {

return redisTemplate.opsForValue().get(key);

}

// 删除缓存

public Boolean delete(String key) {

return redisTemplate.delete(key);

}

// 判断缓存是否存在

public Boolean hasKey(String key) {

return redisTemplate.hasKey(key);

}

}

4.2.4 步骤4：使用Redis缓存热点数据

修改UserService，添加缓存逻辑，优先从Redis获取数据，无数据则查询数据库并存入Redis：

package com.example.springbootdemo.service;

import com.example.springbootdemo.entity.User;

import com.example.springbootdemo.mapper.UserMapper;

import com.example.springbootdemo.util.RedisUtil;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import java.util.List;

import java.util.concurrent.TimeUnit;

@Service

public class UserService {

@Autowired

private UserMapper userMapper;

@Autowired

private RedisUtil redisUtil;

private static final String USER_LIST_KEY = "user:list";

private static final String USER_KEY = "user:id:";

public List<User> findAll() {

// 先从Redis获取

List<User> userList = (List<User>) redisUtil.get(USER_LIST_KEY);

if (userList == null) {

// Redis无数据，查询数据库

userList = userMapper.findAll();

// 存入Redis，缓存10分钟

redisUtil.set(USER_LIST_KEY, userList, 10, TimeUnit.MINUTES);

}

return userList;

}

public User findById(Long id) {

String key = USER_KEY + id;

User user = (User) redisUtil.get(key);

if (user == null) {

user = userMapper.findById(id);

redisUtil.set(key, user, 5, TimeUnit.MINUTES);

}

return user;

}

}

五、Spring Boot高级特性

5.1 全局异常处理

传统异常处理需在每个接口捕获异常，代码冗余。Spring Boot通过 @RestControllerAdvice 实现全局异常处理，统一捕获和返回异常信息。

package com.example.springbootdemo.exception;

import org.springframework.web.bind.annotation.ExceptionHandler;

import org.springframework.web.bind.annotation.RestControllerAdvice;

import java.util.HashMap;

import java.util.Map;

// 全局异常处理类，作用于所有@RestController注解的控制器

@RestControllerAdvice

public class GlobalExceptionHandler {

// 捕获自定义异常

@ExceptionHandler(BusinessException.class)

public Map<String, Object> handleBusinessException(BusinessException e) {

Map<String, Object> result = new HashMap<>();

result.put("code", e.getCode());

result.put("msg", e.getMsg());

return result;

}

// 捕获通用异常（兜底处理）

@ExceptionHandler(Exception.class)

public Map<String, Object> handleException(Exception e) {

Map<String, Object> result = new HashMap<>();

result.put("code", 500);

result.put("msg", "服务器内部错误：" + e.getMessage());

return result;

}

}

// 自定义业务异常类

class BusinessException extends RuntimeException {

private Integer code;

private String msg;

public BusinessException(Integer code, String msg) {

this.code = code;

this.msg = msg;

}

// Getter和Setter

public Integer getCode() { return code; }

public void setCode(Integer code) { this.code = code; }

public String getMsg() { return msg; }

public void setMsg(String msg) { this.msg = msg; }

}

使用自定义异常：

@GetMapping("/user/{id}")

public User findById(@PathVariable Long id) {

if (id == null || id <= 0) {

throw new BusinessException(400, "用户ID无效");

}

return userService.findById(id);

}

5.2 接口参数校验

通过JSR-380规范注解（如@NotNull、@NotBlank）实现接口参数校验，避免手动编写校验逻辑。

5.2.1 引入依赖

《dependency》

《groupId》org.springframework.boot《/groupId》

《artifactId》spring-boot-starter-validation《/artifactId》

《/dependency》

5.2.2 编写校验逻辑

1. 在实体类添加校验注解： package com.example.springbootdemo.entity;import jakarta.validation.constraints.Email;import jakarta.validation.constraints.NotBlank;import jakarta.validation.constraints.NotNull;import jakarta.validation.constraints.Positive;import lombok.Data;@Datapublic class UserDTO { @NotBlank(message = "用户名不能为空") // 非空且不能为空格 private String userName; @NotNull(message = "年龄不能为空") // 不能为null @Positive(message = "年龄必须为正数") // 正数 private Integer age; @NotBlank(message = "邮箱不能为空") @Email(message = "邮箱格式不正确") // 邮箱格式校验 private String email;}注：Spring Boot 3.x 使用 jakarta.validation 包，替代Spring Boot 2.x的 javax.validation。

2. 在Controller接口添加 @Valid 注解开启校验： @PostMapping("/add")public Map<String, Object> addUser(@Valid @RequestBody UserDTO userDTO) { // 校验通过，执行添加逻辑 Map<String, Object> result = new HashMap<>(); result.put("code", 200); result.put("msg", "添加成功"); return result;}

3. 在全局异常处理器中捕获校验异常： import jakarta.validation.ConstraintViolationException;import org.springframework.validation.BindingResult;import org.springframework.web.bind.MethodArgumentNotValidException;// 捕获参数校验异常（实体类校验）@ExceptionHandler(MethodArgumentNotValidException.class)public Map<String, Object> handleMethodArgumentNotValid(MethodArgumentNotValidException e) { BindingResult bindingResult = e.getBindingResult(); String msg = bindingResult.getFieldError().getDefaultMessage(); Map<String, Object> result = new HashMap<>(); result.put("code", 400); result.put("msg", msg); return result;}// 捕获参数校验异常（单个参数校验）@ExceptionHandler(ConstraintViolationException.class)public Map<String, Object> handleConstraintViolation(ConstraintViolationException e) { String msg = e.getConstraintViolations().iterator().next().getMessage(); Map<String, Object> result = new HashMap<>(); result.put("code", 400); result.put("msg", msg); return result;}

5.3 打包与部署

5.3.1 打包为JAR包（推荐）

Spring Boot内置服务器，可打包为JAR包独立运行，步骤如下：

1. 确保pom.xml中存在打包插件（Spring Initializr生成的项目默认包含）： 《build》 《plugins》 《plugin》 《groupId》org.springframework.boot《/groupId》 《artifactId》spring-boot-maven-plugin《/artifactId》 《configuration》 《excludes》 《exclude》 《groupId》org.projectlombok《/groupId》 《artifactId》lombok《/artifactId》 《/exclude》 《/excludes》 《/configuration》 《/plugin》 《/plugins》《/build》

2. 执行Maven打包命令： mvn clean package -Dmaven.test.skip=true说明：-Dmaven.test.skip=true 跳过测试类编译，加快打包速度。

3. 运行JAR包： java -jar target/springboot-demo-0.0.1-SNAPSHOT.jar指定环境运行：java -jar target/springboot-demo-0.0.1-SNAPSHOT.jar --spring.profiles.active=prod

5.3.2 部署到Linux服务器

1. 将本地JAR包上传到Linux服务器（通过Xshell、FileZilla等工具）；

2. 编写启动脚本 start.sh，后台运行JAR包： #!/bin/bashnohup java -jar springboot-demo-0.0.1-SNAPSHOT.jar --spring.profiles.active=prod > app.log 2>&1 & echo "服务启动成功，日志文件：app.log"赋予执行权限：chmod +x start.sh，运行脚本：./start.sh。

3. 编写停止脚本 stop.sh： #!/bin/bashpid=$(ps -ef | grep springboot-demo | grep -v grep | awk '{print $2}')if [ -n "$pid" ]; then kill -9 $pid echo "服务已停止，PID：$pid"else echo "服务未运行"fi

六、进阶方向与学习建议

6.1 进阶技术栈

掌握基础后，可深入学习以下Spring Boot进阶技术，适配企业级开发需求：

• 微服务方向：Spring Cloud（注册中心Eureka/Nacos、配置中心Config/Nacos、网关Gateway、熔断降级Sentinel）；

• 性能优化：JVM调优、数据库索引优化、Redis缓存策略、异步编程（@Async）；

• 安全认证：Spring Security、Shiro（实现用户登录、权限控制）、JWT令牌认证；

• 分布式技术：分布式事务（Seata）、分布式锁（Redis/ZooKeeper）、消息队列（RabbitMQ/Kafka）；

• ORM框架进阶：MyBatis-Plus（简化MyBatis开发）、Spring Data JPA。

6.2 学习建议

1. 循序渐进：先掌握基础注解、配置、集成框架，再深入源码和高级特性，避免跳跃式学习；

2. 实战驱动：通过完整项目巩固知识点（如个人博客、电商后台），多动手编写代码，而非仅看理论；

3. 查阅官方文档：Spring Boot官方文档（https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/）是最权威的学习资料，遇到问题优先查阅；

4. 阅读源码：核心类（如SpringBootApplication、AutoConfigurationImportSelector）的源码有助于理解底层原理；

5. 关注社区动态：Spring生态更新快，关注官方博客和GitHub，了解新版本特性和最佳实践。

七、总结

Spring Boot作为Java生态的核心框架，已成为企业级开发的首选技术之一。其核心价值在于“简化配置、降低门槛、提升效率”，让开发者无需关注框架底层细节，专注于业务逻辑实现。本文从入门认知、环境搭建、核心特性、框架集成到高级应用，覆盖了Spring Boot全链路知识点，配套的标准化代码块可直接复制到CSDN发布，避免格式错乱。

后续可结合实际项目打磨技术，逐步探索微服务、安全认证等进阶方向，将Spring Boot的优势充分发挥到生产环境中。建议发布前预览效果，若仍有格式问题，可随时调整优化。