Spring boot学习心得

一、引言：为什么 Spring Boot 是 Java 开发者的必备技能？

Spring Boot 作为 Spring 生态的核心子项目，以“约定优于配置”为核心理念，彻底解决了传统 Spring 框架配置繁琐、依赖冲突等痛点。截至 2024 年，Spring Boot 3.x 已成为微服务开发、企业级应用的首选框架，其核心优势包括：

• 零配置启动：无需 XML 配置，自动装配核心组件

• 内嵌服务器：默认集成 Tomcat/Jetty，直接打包为 JAR 运行

• starter 依赖：一键引入场景化依赖（如 web、数据库、缓存）

• 生产级特性：内置 Actuator 监控、健康检查、日志管理

• 无缝兼容 Spring 生态：Spring MVC、Spring Data、Spring Security 等

本文将从环境搭建 → 核心特性 → 实战开发 → 性能优化 → 问题排查全方位讲解 Spring Boot，适合零基础入门和有经验开发者查漏补缺。

二、环境搭建：3 分钟启动第一个 Spring Boot 项目（2024 最新版）

2.1 前置环境要求

2.2 两种创建方式（推荐方式一）

方式一：Spring Initializr 可视化创建（最便捷）

1. 访问官方地址：https://start.spring.io/

1. 配置项目信息：

• • Project：Maven/Gradle（本文以 Maven 为例）

• • Language：Java

• • Spring Boot：3.2.5（稳定版）

• • Group/Artifact：自定义（如 com.example/demo）

• • Packaging：JAR（推荐，无需部署服务器）

• • Java：17

1. 选择依赖（入门必选）：

• • Spring Web（web 开发核心依赖）

• • Lombok（简化实体类代码）

1. 点击「Generate」下载项目压缩包，解压后用 IDEA 打开

方式二：IDEA 内置工具创建

1. 打开 IDEA → New Project → Spring Initializr

1. 配置项与方式一一致，直接选择依赖后创建

1. 等待 Maven 下载依赖（首次创建需耐心，可配置阿里云镜像加速）

2.3 启动第一个 Spring Boot 应用

1. 项目结构说明（核心目录）：

demo/

├── src/main/java/com/example/demo/

│ ├── DemoApplication.java // 启动类（入口）

│ └── controller/ // 控制器（接口层）

└── src/main/resources/

├── application.properties // 配置文件（默认）

└── application.yml // 推荐配置文件（yaml 格式更简洁）

1. 编写测试接口：

在 controller 目录下创建 HelloController.java：

package com.example.demo.controller;

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

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

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

@RestController // 等同于 @Controller + @ResponseBody（返回 JSON 数据）

public class HelloController {

// GET 请求：http://localhost:8080/hello?name=SpringBoot

@GetMapping("/hello")

public String hello(@RequestParam(defaultValue = "World") String name) {

return "Hello, " + name + "! 这是我的第一个 Spring Boot 应用～";

}

}

1. 启动应用：

• • 右键运行 DemoApplication.java 中的 main 方法

• • 控制台输出 Started DemoApplication in x.x seconds 表示启动成功

1. 测试接口：

打开浏览器访问：http://localhost:8080/hello?name=CSDN

响应结果：Hello, CSDN! 这是我的第一个 Spring Boot 应用～

三、核心特性深度解析：约定优于配置的底层逻辑

3.1 启动类注解：@SpringBootApplication 的本质

@SpringBootApplication // 核心注解，等同于以下 3 个注解的组合

public class DemoApplication {

public static void main(String[] args) {

SpringApplication.run(DemoApplication.class, args);

}

}

拆解核心注解：

• @SpringBootConfiguration：标记当前类为配置类（替代传统 XML 配置）

• @EnableAutoConfiguration：开启自动配置（核心！）

• • 原理：Spring Boot 启动时扫描 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件，加载所有自动配置类（如 TomcatAutoConfiguration、DataSourceAutoConfiguration）

• • 条件注解：自动配置类需满足特定条件才生效（如 @ConditionalOnClass 表示依赖存在时生效）

• @ComponentScan：扫描当前包及子包下的 @Controller、@Service、@Repository 等组件

3.2 配置文件：application.yml 核心配置（推荐）

application.properties 格式繁琐，推荐使用 yaml 格式（缩进敏感，需用空格）：

# 服务器配置

server:

port: 8081 # 自定义端口（默认 8080）

servlet:

context-path: /demo # 接口前缀（访问路径变为 http://localhost:8081/demo/hello）

# Spring 配置

spring:

# 数据库配置（后续实战会用到）

datasource:

url: jdbc:mysql://localhost:3306/test_db?useSSL=false&serverTimezone=Asia/Shanghai

username: root

password: 123456

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

# 缓存配置（如 Redis）

redis:

host: localhost

port: 6379

password:

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

app:

name: SpringBoot-Demo

version: 3.2.5

3.3 Starter 依赖：场景化依赖的秘密

Starter 是 Spring Boot 的 “依赖套餐”，无需手动配置版本号（Spring Boot 统一管理）。常用 Starter：

示例：引入 Web + 数据库 + 缓存依赖（pom.xml）：

>

开发 -->

>

.springframework.boot -starter-web

<groupId>org.springframework.boot</groupId>

>spring-boot-starter-data-jpa <groupId>org.springframework.boot</groupId>

>spring-boot-starter-data-redis <dependency>

<groupId>org.projectlombok</groupId>

>lombok

</optional>

</dependency>

测试 -->

>

.springframework.boot -starter-test

</scope>

</dependency>

>

四、实战案例：构建一个完整的 RESTful API 项目

4.1 需求说明

实现一个 “用户管理系统”，包含以下功能：

• 新增用户（POST）

• 查询所有用户（GET）

• 根据 ID 查询用户（GET）

• 更新用户（PUT）

• 删除用户（DELETE）

4.2 步骤 1：配置数据库（MySQL）

1. 先创建 MySQL 数据库 test_db：

CREATE DATABASE test_db CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

1. 在 application.yml 中配置数据源（已在 3.2 节给出）

4.3 步骤 2：创建实体类（User）

使用 Lombok 的 @Data 注解简化 getter/setter：

package com.example.demo.entity;

import jakarta.persistence.*;

import lombok.Data;

import java.time.LocalDateTime;

@Data // Lombok 注解：自动生成 getter/setter/toString 等方法

@Entity // JPA 注解：标记为数据库实体

@Table(name = "t_user") // 对应数据库表名

public class User {

@Id // 主键

@GeneratedValue(strategy = GenerationType.IDENTITY) // 自增主键

private Long id;

@Column(nullable = false, unique = true) // 字段非空，唯一

private String username;

@Column(nullable = false)

private String password;

private String email;

private LocalDateTime createTime; // 创建时间

// 自动填充创建时间（JPA 回调）

@PrePersist

public void prePersist() {

this.createTime = LocalDateTime.now();

}

}

4.4 步骤 3：创建数据访问层（Repository）

JPA 提供 JpaRepository 接口，无需手动写 SQL：

package com.example.demo.repository;

import com.example.demo.entity.User;

import org.springframework.data.jpa.repository.JpaRepository;

import org.springframework.stereotype.Repository;

// JpaRepository主键类型>：提供 CRUD 及分页查询方法

@Repository

public interface UserRepository extends JpaRepository<User, Long> {

// 自定义查询：根据用户名查询（JPA 自动解析方法名生成 SQL）

User findByUsername(String username);

}

4.5 步骤 4：创建业务逻辑层（Service）

4.5.1 Service 接口

package com.example.demo.service;

import com.example.demo.entity.User;

import java.util.List;

public interface UserService {

// 新增用户

User saveUser(User user);

// 查询所有用户

ListUsers();

// 根据 ID 查询用户

User getUserById(Long id);

// 更新用户

User updateUser(Long id, User user);

// 删除用户

void deleteUser(Long id);

}

4.5.2 Service 实现类

package com.example.demo.service.impl;

import com.example.demo.entity.User;

import com.example.demo.repository.UserRepository;

import com.example.demo.service.UserService;

import jakarta.annotation.Resource;

import org.springframework.stereotype.Service;

import java.util.List;

import java.util.Optional;

@Service

public class UserServiceImpl implements UserService {

@Resource // 注入 Repository

private UserRepository userRepository;

@Override

public User saveUser(User user) {

// 这里可添加业务逻辑（如密码加密）

return userRepository.save(user);

}

@Override

public List {

return userRepository.findAll();

}

@Override

public User getUserById(Long id) {

// Optional 避免空指针

return userRepository.findById(id)

.orElseThrow(() -> new RuntimeException("用户不存在"));

}

@Override

public User updateUser(Long id, User user) {

// 先查询用户是否存在

User existingUser = getUserById(id);

// 更新字段（仅更新非空字段）

if (user.getUsername() != null) {

existingUser.setUsername(user.getUsername());

}

if (user.getPassword() != null) {

existingUser.setPassword(user.getPassword());

}

if (user.getEmail() != null) {

existingUser.setEmail(user.getEmail());

}

return userRepository.save(existingUser);

}

@Override

public void deleteUser(Long id) {

userRepository.deleteById(id);

}

}

4.6 步骤 5：创建控制器（Controller）

实现 RESTful API：

package com.example.demo.controller;

import com.example.demo.entity.User;

import com.example.demo.service.UserService;

import jakarta.annotation.Resource;

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

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

import java.util.List;

@RestController

@RequestMapping("/api/users") // 接口前缀

public class UserController {

@Resource

private UserService userService;

// 新增用户：POST /api/users

@PostMapping

public ResponseEntity<User> saveUser(@RequestBody User user) {

User savedUser = userService.saveUser(user);

return new ResponseEntity, HttpStatus.CREATED);

}

// 查询所有用户：GET /api/users

@GetMapping

public ResponseEntity<User>> getAllUsers() {

List = userService.getAllUsers();

return ResponseEntity.ok(users);

}

// 根据 ID 查询用户：GET /api/users/{id}

@GetMapping("/{id}")

public ResponseEntityById(@PathVariable Long id) {

User user = userService.getUserById(id);

return ResponseEntity.ok(user);

}

// 更新用户：PUT /api/users/{id}

@PutMapping("/{id}")

public ResponseEntityPathVariable Long id, @RequestBody User user) {

User updatedUser = userService.updateUser(id, user);

return ResponseEntity.ok(updatedUser);

}

// 删除用户：DELETE /api/users/{id}

@DeleteMapping("/{id}")

public ResponseEntity deleteUser(@PathVariable Long id) {

userService.deleteUser(id);

return ResponseEntity.noContent().build(); // 204 无内容

}

}

4.7 步骤 6：测试接口（Postman）

五、性能优化：Spring Boot 应用调优实战

5.1 JVM 调优（最核心）

在 application.yml 中配置 JVM 参数（或启动时指定）：

# JVM 调优参数（适用于 4G 内存服务器）

spring:

profiles:

active: prod # 生产环境配置

# 生产环境 JVM 参数（启动脚本中配置更灵活）

# java -jar -Xms2G -Xmx2G -XX:+UseG1GC -XX:MaxGCPauseMillis=200 demo-0.0.1-SNAPSHOT.jar --spring.profiles.active=prod

核心 JVM 参数说明：

• -Xms2G：初始堆内存（与最大堆内存一致，避免频繁扩容）

• -Xmx2G：最大堆内存（根据服务器内存调整，如 8G 内存设为 4G）

• -XX:+UseG1GC：使用 G1 垃圾收集器（适合大内存、低延迟场景）

• -XX:MaxGCPauseMillis=200：最大 GC 停顿时间（目标 200ms）

5.2 内嵌 Tomcat 调优

server:

tomcat:

max-threads: 200 # 最大工作线程数（默认 200，根据 CPU 核心数调整）

min-spare-threads: 50 # 最小空闲线程数

accept-count: 100 # 等待队列大小

connection-timeout: 30000 # 连接超时时间（30 秒）

5.3 缓存优化（Redis）

1. 开启缓存注解：在启动类添加 @EnableCaching

1. 在 Service 方法添加缓存注解：

// 查询用户时缓存结果（key 为用户 ID）

@Cacheable(value = "userCache", key = "#id")

@Override

public User getUserById(Long id) {

return userRepository.findById(id)

.orElseThrow(() -> new RuntimeException("用户不存在"));

}

// 更新用户时删除缓存

@CacheEvict(value = "userCache", key = "#id")

@Override

public User updateUser(Long id, User user) {

// 业务逻辑...

}

5.4 数据库优化

• 使用连接池：Spring Boot 2.x 默认使用 HikariCP（性能最优），无需额外配置

• 分页查询：避免一次性查询大量数据

// Service 中添加分页方法

public Page getUsersByPage(int pageNum, int pageSize) {

Pageable pageable = PageRequest.of(pageNum - 1, pageSize); // pageNum 从 0 开始

return userRepository.findAll(pageable);

}

六、常见问题排查：避坑指南

6.1 端口占用问题

• 错误信息：Address already in use: bind

• 解决方案：

1. 1. 更换端口（在 application.yml 中修改 server.port）

1. 1. 查找占用端口的进程并关闭（Windows：netstat -ano | findstr 8080；Linux：lsof -i:8080）

6.2 依赖冲突问题

• 错误信息：NoSuchMethodError 或 ClassNotFoundException

• 解决方案：

<groupId>org.springframework.boot</groupId>

>spring-boot-starter-web</artifactId>

<exclusions>

<exclusion>

<groupId>org.springframework.boot>

spring-boot-starter-tomcat </dependency>

引入 Jetty 依赖 -->

.boot arter-jetty

1. 1. 排除冲突依赖（如排除 Spring Web 中的 Tomcat 依赖，改用 Jetty）：

1. 1. 使用 mvn dependency:tree 命令查看依赖树，定位冲突包

6.3 自动配置失效问题

• 现象：引入依赖后，自动配置类未生效（如 Redis 连接失败）

• 排查步骤：

debug: true # 启动时输出自动配置日志

日志中会显示「Positive matches」（生效的自动配置）和「Negative matches」（未生效的自动配置及原因）

1. 1. 检查依赖是否正确引入（pom.xml 无拼写错误）

1. 1. 检查是否存在 @Conditional 注解不满足的情况（如缺少核心类）

1. 1. 开启 debug 模式，查看自动配置报告：

七、进阶方向：Spring Boot 3.x 新特性与生态整合

7.1 Spring Boot 3.x 核心新特性

• 基于 Java 17+：支持密封类、Record 类型等新特性

• 原生镜像（GraalVM）：编译为原生可执行文件，启动时间从秒级降至毫秒级

• 支持 Spring Native：通过 spring-boot-starter-native 依赖实现原生镜像打包

• 简化配置：支持 application.properties 中的占位符嵌套（如 ${app.${env}.url}）

7.2 生态整合推荐

• 微服务：Spring Boot + Spring Cloud Alibaba（Nacos 注册中心、Sentinel 限流、Seata 分布式事务）

• 接口文档：SpringDoc-OpenAPI（替代 Swagger，支持 OpenAPI 3.0）

• 任务调度：Spring Boot + Quartz 或 Spring Scheduled

• 消息队列：Spring Boot + RabbitMQ/Kafka（异步解耦）

• 监控告警：Spring Boot Actuator + Prometheus + Grafana

7.3 学习资源推荐

• 官方文档：Spring Boot 3.2 官方指南

• 实战项目：Spring Boot Demo（GitHub 10k+ Star）

• 视频教程：尚硅谷 Spring Boot 3.x 实战教程

总结

本文从环境搭建、核心特性、实战开发、性能优化、问题排查五个维度，全面讲解了 Spring Boot 3.x 的使用技巧。掌握 Spring Boot 的核心是理解「约定优于配置」的设计思想，同时结合实战案例多练多测。

如果本文对你有帮助，欢迎点赞、收藏、转发！如果遇到问题或有进阶需求（如微服务整合、原生镜像打包），可以在评论区留言，我会持续更新相关内容～