【Spring Boot从入门到精通】原理、实战与最佳实践 - 教程

文章目录前言1. Spring Boot核心认知：是什么与为什么1.1 定义与核心价值1.2 与传统Spring的核心差异1.3 版本选型与生态适配2. 环境搭建：从0到1创建Spring Boot项目2.1 开发环境要求2.2 三种创建方式对比2.3 项目结构解析（以Maven项目为例）3. 核心原理：自动配置的“黑魔法”3.1 @SpringBootApplication注解拆解3.2 自动配置流程3.3 条件注解体系（@Conditional家族）3.4 自动配置 vs 传统Spring配置4. 核心组件与功能实战4.1 Starter依赖：“一站式”依赖解决方案4.2 配置文件：application.properties/yaml详解配置优先级（从高到低）多环境配置实战常用配置示例（application.yml）4.3 核心注解：从Bean管理到业务开发4.4 Actuator：应用监控与运维核心端点对比启用Actuator实战5. 企业级实战：构建RESTful API与数据访问5.1 实战1：开发用户管理RESTful API步骤1：定义实体类（User.java）步骤2：数据访问层（UserRepository.java）步骤3：服务层（UserService.java）步骤4：控制器层（UserController.java）步骤5：测试API（用Postman）5.2 实战2：整合Redis实现缓存步骤1：引入Redis Starter步骤2：配置Redis（application.yml）步骤3：开启缓存并使用6. 常见问题与解决方案（表格汇总）7. 最佳实践：性能优化与规范7.1 代码结构规范7.2 性能优化技巧总结

前言若对您有帮助的话，请点赞收藏加关注哦，您的关注是我持续创作的动力！有问题请私信或联系邮箱：funian.gm@gmail.com

Spring Boot作为Spring生态的“简化器”，通过“约定优于配置”的理念彻底改变了Java后端开发模式——无需繁琐的XML配置，无需手动整合依赖，仅需几行代码即可快速搭建一个可运行的企业级应用。本文将从核心原理、环境搭建、实战开发到问题排查，全方位解析Spring Boot，结合大量表格对比与代码实例，帮你掌握从入门到精通的完整技能链。

1. Spring Boot核心认知：是什么与为什么1.1 定义与核心价值Spring Boot是由Pivotal团队开发的Spring生态子项目，核心定位是“简化Spring应用开发”——通过自动配置、 starter依赖、嵌入式服务器等特性，实现“开箱即用”，让开发者专注于业务逻辑而非框架配置。

其核心价值可概括为“三减一提”：

减少配置：消除90%以上的XML配置，改用注解或少量配置文件；减少依赖：通过starter整合依赖（如spring-boot-starter-web包含Spring MVC+Tomcat）；减少部署：支持嵌入式服务器（Tomcat/Jetty/Undertow），可直接打包为Jar运行；提升效率：从项目创建到上线的周期缩短50%以上，支持热部署。

1.2 与传统Spring的核心差异对比维度传统SpringSpring Boot配置方式以XML配置为主（如applicationContext.xml）注解配置为主（@Configuration）+自动配置依赖管理需手动维护各组件版本（易冲突）Starter自动管理版本，统一依赖快照服务器部署需打包为War，部署到外部Tomcat可打包为Jar（内置服务器），直接运行开发效率配置繁琐，启动慢（需加载大量XML）零配置启动，开发周期短监控能力需手动集成第三方监控（如Spring Boot Actuator）内置Actuator，开箱即用监控端点适用场景复杂企业级应用（需精细配置）快速开发、微服务、云原生应用1.3 版本选型与生态适配Spring Boot版本分为“快照版（SNAPSHOT） ”“里程碑版（M） ”“正式版（RELEASE） ”“长期支持版（LTS） ”，企业级开发优先选择LTS版，稳定性与兼容性更有保障。

版本类型特点推荐度适用场景SNAPSHOT开发中版本，不稳定，功能可能变更❌ 不推荐框架源码贡献者测试M（Milestone）里程碑版，功能初步稳定，待验证❌ 不推荐技术预研，非生产环境RELEASE正式版，功能稳定，但支持周期短（6-12个月）⭐⭐⭐ 一般推荐短期项目、非核心业务LTS（Long-Term Support）长期支持版，支持3-5年，修复安全漏洞与BUG⭐⭐⭐⭐⭐ 强烈推荐核心业务、企业级项目、微服务集群当前主流LTS版：Spring Boot 2.7.x（支持至2025年11月）、Spring Boot 3.2.x（支持至2026年11月），需注意：

Spring Boot 3.x要求JDK 17+，且依赖Jakarta EE（而非Java EE）；若项目需兼容JDK 8/11，选择Spring Boot 2.7.x。2. 环境搭建：从0到1创建Spring Boot项目2.1 开发环境要求工具/组件版本要求说明JDKSpring Boot 2.x：JDK 8/11/17Spring Boot 3.x：JDK 17+推荐JDK 17（LTS版，性能更优）Maven3.6.3+需配置阿里云镜像（加速依赖下载）Gradle7.5+（若用Gradle构建）替代Maven的构建工具，脚本更简洁IDEIntelliJ IDEA 2021.3+ / Eclipse 2022+IDEA对Spring Boot支持更友好浏览器Chrome/Firefox用于访问Swagger/Actuator监控页面Maven阿里云镜像配置（settings.xml）：

aliyunmaven

central

https://maven.aliyun.com/repository/public

2.2 三种创建方式对比创建方式步骤优点缺点适用场景IDEA可视化创建1. 新建项目→选择Spring Initializr2. 填写Group/Artifact3. 选择Starter（如Web/MySQL）4. 选择存储路径→完成操作直观，支持实时调整依赖需联网，IDEA社区版功能有限新手入门、Windows/macOS图形化操作终端命令创建1. 执行命令：curl https://start.spring.io/starter.zip -d dependencies=web,mysql -o demo.zip2. 解压zip包3. 用IDE打开跨平台（Linux/macOS/Windows），速度快需记命令，依赖选择不直观服务器环境、Linux终端操作start.spring.io创建1. 打开官网（https://start.spring.io/）2. 可视化配置项目信息与依赖3. 下载zip包→解压→IDE打开无需安装IDE，配置灵活需手动下载，依赖冲突需手动排查无IDE环境、临时快速创建项目2.3 项目结构解析（以Maven项目为例）

demo/ # 项目根目录

├── src/

│ ├── main/

│ │ ├── java/

│ │ │ └── com/

│ │ │ └── example/

│ │ │ └── demo/

│ │ │ ├── DemoApplication.java # 启动类（核心入口）

│ │ │ ├── controller/ # 控制器层（处理HTTP请求）

│ │ │ ├── service/ # 服务层（业务逻辑）

│ │ │ ├── dao/ # 数据访问层（数据库操作）

│ │ │ ├── entity/ # 实体类（与数据库表映射）

│ │ │ ├── config/ # 配置类（自定义Bean/拦截器）

│ │ │ └── exception/ # 异常处理（全局异常/自定义异常）

│ │ └── resources/

│ │ ├── application.properties # 主配置文件（properties格式）

│ │ ├── application.yml # 主配置文件（yaml格式，推荐）

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

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

│ └── test/ # 测试类目录（与main结构对应）

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

└── README.md # 项目说明文档

核心文件作用：

DemoApplication.java：启动类，含@SpringBootApplication注解，执行main方法启动应用；application.yml：全局配置文件，用于配置端口、数据库连接、日志等；pom.xml：管理依赖（如starter、第三方组件），控制项目构建流程。3. 核心原理：自动配置的“黑魔法”自动配置是Spring Boot的灵魂，其核心是“根据classpath中的依赖，自动注册Bean到Spring容器”，无需手动配置。

3.1 @SpringBootApplication注解拆解@SpringBootApplication是Spring Boot的“一站式注解”，本质是三个核心注解的组合：

注解名称作用关键细节@SpringBootConfiguration标记类为配置类，等价于@Configuration支持在类中用@Bean定义自定义Bean@EnableAutoConfiguration开启自动配置功能核心注解，触发自动配置流程@ComponentScan扫描组件（@Component/@Service/@Controller等）默认扫描启动类所在包及其子包注解等效代码：

// @SpringBootApplication 等效于以下三个注解

@SpringBootConfiguration

@EnableAutoConfiguration

@ComponentScan(basePackages = "com.example.demo") // 默认扫描启动类所在包

public class DemoApplication {

public static void main(String[] args) {

SpringApplication.run(DemoApplication.class, args);

}

}

3.2 自动配置流程扫描自动配置类：Spring Boot启动时，@EnableAutoConfiguration会加载META-INF/spring.factories文件，该文件中定义了所有自动配置类（如DataSourceAutoConfiguration、WebMvcAutoConfiguration）；条件匹配：自动配置类通过@Conditional家族注解判断是否生效（如@ConditionalOnClass判断classpath是否有指定类）；注册Bean：满足条件的自动配置类会将核心Bean（如DataSource、DispatcherServlet）注册到Spring容器；配置绑定：通过@ConfigurationProperties将application.yml中的配置（如spring.datasource.url）绑定到自动配置类的属性上。示例：DataSourceAutoConfiguration生效条件：

// 仅当classpath中有DataSource.class且容器中无DataSource Bean时生效

@ConditionalOnClass(DataSource.class)

@ConditionalOnMissingBean(type = "javax.sql.DataSource")

public class DataSourceAutoConfiguration {

// 绑定application.yml中的spring.datasource配置

@ConfigurationProperties(prefix = "spring.datasource")

public DataSourceProperties properties() {

return new DataSourceProperties();

}

// 注册DataSource Bean

@Bean

public DataSource dataSource(DataSourceProperties properties) {

return properties.initializeDataSourceBuilder().build();

}

}

3.3 条件注解体系（@Conditional家族）@Conditional是自动配置的“开关”，通过判断环境、类存在性、Bean存在性等决定配置是否生效：

条件注解作用示例场景@ConditionalOnClass当classpath中有指定类时生效有Servlet.class才加载Web相关配置@ConditionalOnMissingClass当classpath中无指定类时生效无RedisTemplate.class才加载默认缓存配置@ConditionalOnBean当容器中有指定Bean时生效有RedisConnectionFactory才注册RedisTemplate@ConditionalOnMissingBean当容器中无指定Bean时生效无自定义DataSource才注册默认数据源@ConditionalOnProperty当配置文件中有指定属性时生效配置spring.mvc.enable=true才加载MVC配置@ConditionalOnWebApplication当应用是Web应用时生效加载DispatcherServlet、WebMvcConfigurer@ConditionalOnNotWebApplication当应用不是Web应用时生效加载非Web相关的Bean（如定时任务）3.4 自动配置 vs 传统Spring配置配置场景传统Spring配置（XML）Spring Boot自动配置代码/配置量对比配置数据源需定义DataSource、SqlSessionFactory等Bean（约50行XML）仅需在application.yml配置spring.datasource（约5行）10:1（自动配置更简洁）配置Spring MVC需配置DispatcherServlet、视图解析器等（约30行XML）引入spring-boot-starter-web自动生效，无需额外配置30:0（自动配置零代码）配置事务管理需配置TransactionManager、开启事务注解（约20行XML）引入spring-boot-starter-jdbc后，加@Transactional即可20:1（仅需注解）配置日志需配置logback.xml（约20行）引入spring-boot-starter-logging自动生效，支持简单配置20:2（仅需配置日志级别）4. 核心组件与功能实战4.1 Starter依赖：“一站式”依赖解决方案Starter是Spring Boot的“依赖打包”机制——将某一领域的所有依赖（如Web开发、数据访问）整合为一个starter，开发者仅需引入一个依赖即可使用所有功能，无需手动管理依赖版本。

常用Starter对比：

Starter名称核心功能包含的关键依赖适用场景spring-boot-starter-webWeb开发（Spring MVC+嵌入式服务器）spring-web、spring-webmvc、tomcat-embed-core开发RESTful API、Web应用spring-boot-starter-data-jpa整合JPA（ORM框架）spring-data-jpa、hibernate-core、hikariCP简化数据库CRUD，支持自动生成SQLspring-boot-starter-mybatis整合MyBatis（持久层框架）mybatis、mybatis-spring、spring-jdbc复杂SQL场景（动态SQL、存储过程）spring-boot-starter-redis整合Redis（缓存/分布式锁）spring-data-redis、lettuce-core缓存热点数据、分布式锁、限流器spring-boot-starter-security安全认证与授权（登录/权限控制）spring-security-web、spring-security-config用户登录、API权限控制spring-boot-starter-actuator应用监控（健康检查/指标统计）spring-boot-actuator、micrometer-core运维监控、应用健康检查spring-boot-starter-test单元测试与集成测试junit、mockito、spring-test测试Service/Controller层代码使用示例：在pom.xml中引入Web Starter，即可开发Web应用：

org.springframework.boot

spring-boot-starter-web

4.2 配置文件：application.properties/yaml详解Spring Boot支持两种配置文件格式：application.properties（键值对）和application.yml（缩进式，推荐），核心作用是“外部化配置”——将配置与代码分离，便于不同环境（开发/测试/生产）切换。

配置优先级（从高到低）命令行参数（如java -jar demo.jar --server.port=8081）；系统环境变量（如SPRING_DATASOURCE_URL）；application-{profile}.yml（如application-prod.yml，激活指定环境）；application.yml（主配置文件）；application.properties（主配置文件，优先级低于yml）；内置默认配置（Spring Boot默认值）。多环境配置实战创建多环境配置文件：

application-dev.yml：开发环境（端口8080，连接本地MySQL）；application-test.yml：测试环境（端口8081，连接测试MySQL）；application-prod.yml：生产环境（端口80，连接生产MySQL，开启HTTPS）。激活指定环境：

方式1：在application.yml中配置（全局生效）：spring:

profiles:

active: dev # 激活开发环境 方式2：命令行激活（临时生效）：java -jar demo.jar --spring.profiles.active=prod 常用配置示例（application.yml）

# 1. 服务器配置

server:

port: 8080 # 端口

servlet:

context-path: /demo # 上下文路径（访问前缀）

# 2. 数据库配置（MySQL）

spring:

datasource:

url: jdbc:mysql://localhost:3306/demo_db?useSSL=false&serverTimezone=UTC

username: root

password: 123456

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

hikari:

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

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

# 3. MyBatis配置

mybatis:

mapper-locations: classpath:mapper/**/*.xml # Mapper XML文件路径

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

configuration:

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

# 4. 日志配置

logging:

level:

root: INFO # 全局日志级别

com.example.demo.dao: DEBUG # DAO层日志级别（打印SQL）

file:

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

# 5. Redis配置

redis:

host: localhost

port: 6379

password:

lettuce:

pool:

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

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

4.3 核心注解：从Bean管理到业务开发Spring Boot基于注解驱动开发，核心注解可分为“Bean管理注解”“业务开发注解”“配置注解”三类：

注解分类注解名称作用示例代码Bean管理@Component标记普通组件（通用Bean）@Component public class UserUtils {}@Service标记服务层组件（业务逻辑）@Service public class UserService {}@Controller标记控制器组件（处理HTTP请求）@Controller public class UserController {}@Repository标记数据访问层组件（DAO）@Repository public class UserDao {}@Bean在配置类中定义Bean（第三方组件）@Bean public RedisTemplate redisTemplate() {}业务开发@Autowired依赖注入（按类型）@Autowired private UserService userService;@Resource依赖注入（按名称，JDK原生）@Resource(name = "userService") private UserService userService;@RequestMapping映射HTTP请求（通用）@RequestMapping("/users")@GetMapping映射GET请求（简化版）@GetMapping("/users/{id}")@PostMapping映射POST请求（简化版）@PostMapping("/users")@Transactional开启事务管理@Transactional public void saveUser(User user) {}配置注解@Configuration标记配置类@Configuration public class RedisConfig {}@ConfigurationProperties绑定配置文件属性@ConfigurationProperties(prefix = "spring.datasource")@Value注入单个配置属性（简单值）@Value("${server.port}") private int port;4.4 Actuator：应用监控与运维Actuator是Spring Boot的“运维工具”，通过暴露HTTP端点（如/actuator/health、/actuator/metrics），提供应用健康检查、指标统计、环境配置等功能，无需手动开发监控系统。

核心端点对比端点路径作用权限控制适用场景/actuator/health应用健康状态（UP/DOWN/OUT_OF_SERVICE）无需认证（默认）运维监控（如Prometheus/Grafana）/actuator/metrics应用指标（JVM内存/CPU/请求数）无需认证（默认）性能排查（如内存泄漏、CPU过高）/actuator/env环境配置（系统变量/配置文件）需认证（敏感信息）配置排查（如确认配置是否生效）/actuator/beans容器中所有Bean信息需认证（敏感信息）开发排查（如Bean是否注册成功）/actuator/loggers日志级别管理（动态调整）需认证（敏感操作）线上排查（无需重启调整日志级别）/actuator/shutdown优雅关闭应用需认证+开启（默认关闭）线上部署（避免强制kill导致数据丢失）启用Actuator实战引入依赖：

org.springframework.boot

spring-boot-starter-actuator

配置端点（application.yml）：

management:

endpoints:

web:

exposure:

include: health,metrics,env,loggers # 暴露的端点

endpoint:

health:

show-details: always # 显示健康详情（如数据库连接状态）

shutdown:

enabled: true # 开启优雅关闭端点 访问端点：

健康检查：http://localhost:8080/demo/actuator/health指标统计：http://localhost:8080/demo/actuator/metrics/http.server.requests5. 企业级实战：构建RESTful API与数据访问5.1 实战1：开发用户管理RESTful API步骤1：定义实体类（User.java）

package com.example.demo.entity;

import lombok.Data;

import javax.persistence.*;

@Data // Lombok注解，自动生成getter/setter/toString

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

@Table(name = "t_user") // 映射数据库表t_user

public class User {

@Id // 主键

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

private Long id;

@Column(name = "username", nullable = false, unique = true) // 用户名（非空+唯一）

private String username;

@Column(name = "password", nullable = false) // 密码（非空）

private String password;

@Column(name = "email") // 邮箱（可选）

private String email;

}

步骤2：数据访问层（UserRepository.java）

package com.example.demo.dao;

import com.example.demo.entity.User;

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

import org.springframework.stereotype.Repository;

import java.util.Optional;

@Repository

// JpaRepository：泛型1=实体类，泛型2=主键类型，提供CRUD默认方法

public interface UserRepository extends JpaRepository {

// 自定义查询方法（JPA自动生成SQL：SELECT * FROM t_user WHERE username = ?）

Optional findByUsername(String username);

}

步骤3：服务层（UserService.java）

package com.example.demo.service;

import com.example.demo.dao.UserRepository;

import com.example.demo.entity.User;

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

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import java.util.List;

import java.util.Optional;

@Service

public class UserService {

@Autowired

private UserRepository userRepository;

// 查询所有用户

public List findAll() {

return userRepository.findAll();

}

// 根据ID查询用户

public Optional findById(Long id) {

return userRepository.findById(id);

}

// 新增/修改用户（含事务）

@Transactional // 开启事务，异常时回滚

public User save(User user) {

return userRepository.save(user);

}

// 根据ID删除用户

@Transactional

public void deleteById(Long id) {

userRepository.deleteById(id);

}

// 根据用户名查询用户

public Optional findByUsername(String username) {

return userRepository.findByUsername(username);

}

}

步骤4：控制器层（UserController.java）

package com.example.demo.controller;

import com.example.demo.entity.User;

import com.example.demo.service.UserService;

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

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

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

import java.util.List;

import java.util.Optional;

@RestController // @Controller + @ResponseBody（返回JSON）

@RequestMapping("/api/users") // 统一URL前缀

public class UserController {

@Autowired

private UserService userService;

// 1. 查询所有用户（GET /api/users）

@GetMapping

public List findAll() {

return userService.findAll();

}

// 2. 根据ID查询用户（GET /api/users/{id}）

@GetMapping("/{id}")

public ResponseEntity findById(@PathVariable Long id) {

Optional user = userService.findById(id);

// 存在则返回200+用户信息，不存在则返回404

return user.map(ResponseEntity::ok)

.orElseGet(() -> ResponseEntity.notFound().build());

}

// 3. 新增用户（POST /api/users）

@PostMapping

public ResponseEntity save(@RequestBody User user) {

User savedUser = userService.save(user);

// 返回201（创建成功）+新增用户信息+Location头（用户URL）

return ResponseEntity.status(HttpStatus.CREATED)

.body(savedUser);

}

// 4. 修改用户（PUT /api/users/{id}）

@PutMapping("/{id}")

public ResponseEntity update(@PathVariable Long id, @RequestBody User user) {

// 验证用户是否存在

if (!userService.findById(id).isPresent()) {

return ResponseEntity.notFound().build();

}

user.setId(id); // 确保修改的是指定ID的用户

User updatedUser = userService.save(user);

return ResponseEntity.ok(updatedUser);

}

// 5. 删除用户（DELETE /api/users/{id}）

@DeleteMapping("/{id}")

public ResponseEntity deleteById(@PathVariable Long id) {

if (!userService.findById(id).isPresent()) {

return ResponseEntity.notFound().build();

}

userService.deleteById(id);

return ResponseEntity.noContent().build(); // 返回204（无内容）

}

}

步骤5：测试API（用Postman）API接口请求方法请求体示例响应状态/api/usersGET无200 + 用户列表JSON/api/users/1GET无200 + 用户详情JSON（存在）/404（不存在）/api/usersPOST{"username":"test","password":"123","email":"test@xxx.com"}201 + 新增用户JSON/api/users/1PUT{"username":"test","password":"456","email":"test@xxx.com"}200 + 修改后用户JSON/api/users/1DELETE无204（成功）/404（不存在）5.2 实战2：整合Redis实现缓存步骤1：引入Redis Starter

org.springframework.boot

spring-boot-starter-redis

步骤2：配置Redis（application.yml）

spring:

redis:

host: localhost

port: 6379

password: # 无密码则留空

lettuce:

pool:

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

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

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

timeout: 3000 # 连接超时时间（毫秒）

步骤3：开启缓存并使用

// 1. 在启动类添加@EnableCaching开启缓存

@SpringBootApplication

@EnableCaching

public class DemoApplication {

public static void main(String[] args) {

SpringApplication.run(DemoApplication.class, args);

}

}

// 2. 在Service方法添加@Cacheable（查询缓存）、@CachePut（更新缓存）、@CacheEvict（删除缓存）

@Service

public class UserService {

// 查询用户时先查缓存，无缓存则查数据库并写入缓存

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

public Optional findById(Long id) {

System.out.println("从数据库查询用户：" + id); // 验证缓存是否生效

return userRepository.findById(id);

}

// 修改用户后更新缓存（确保缓存与数据库一致）

@CachePut(value = "userCache", key = "#user.id")

@Transactional

public User save(User user) {

return userRepository.save(user);

}

// 删除用户后删除缓存（避免缓存脏数据）

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

@Transactional

public void deleteById(Long id) {

userRepository.deleteById(id);

}

}

测试缓存生效：

第一次调用findById(1)：控制台打印“从数据库查询用户：1”，数据写入Redis；第二次调用findById(1)：控制台无打印，直接从Redis返回数据（缓存生效）。6. 常见问题与解决方案（表格汇总）问题现象可能原因解决方案启动报错：Port 8080 was already in use8080端口被其他进程占用1. 关闭占用进程：lsof -i :8080找到PID，kill -9 PID2. 修改端口：在application.yml配置server.port=8081自动配置失效（如DataSource未注册）1. 未引入对应starter（如spring-boot-starter-jdbc）2. 配置文件属性写错（如spring.datasouce.url少个s）1. 检查pom.xml是否引入正确starter2. 核对配置属性名（参考Spring Boot官方文档）依赖冲突（如ClassNotFoundException）1. 多个依赖包含相同类但版本不同2. Maven依赖传递导致版本冲突1. 用mvn dependency:tree分析依赖树2. 排除冲突依赖：xxxxxx事务不生效（@Transactional无效）1. 方法不是public（@Transactional仅对public方法生效）2. 自调用（同一类中方法调用，AOP无法拦截）3. 异常被捕获（未抛出异常，事务无法回滚）1. 确保方法为public2. 注入自身Bean调用（如@Autowired private UserService self; self.save(user);）3. 捕获异常后重新抛出：throw new RuntimeException(e);Redis缓存不生效1. 未添加@EnableCaching2. 方法参数不是Serializable（缓存key需序列化）3. 缓存注解属性错误（如key表达式写错）1. 在启动类添加@EnableCaching2. 确保参数实现Serializable接口3. 核对key表达式（如#id对应方法参数id）7. 最佳实践：性能优化与规范7.1 代码结构规范规范点具体要求示例包命名全小写，按功能分层：com.公司名.项目名.分层com.example.demo.controller、com.example.demo.service类命名首字母大写，驼峰式，后缀明确：Controller：XXXControllerService：XXXServiceDAO：XXXRepository/XXXDaoUserController、UserService、UserRepository方法命名首字母小写，驼峰式，动词+名词：查询：get/find/query新增：save/add/create修改：update删除：delete/removefindById()、saveUser()、deleteById()变量命名首字母小写，驼峰式，避免拼音，见名知意userId（而非yonghuming）、userList（而非list）7.2 性能优化技巧优化点具体做法效果提升连接池优化1. 数据库连接池：HikariCP（默认）配置maximum-pool-size=10-202. Redis连接池：Lettuce配置max-active=8减少连接创建开销，提升并发能力30%+JVM调优1. 设置堆内存：-Xms2g -Xmx2g（初始=最大，避免扩容）2. 使用G1垃圾收集器：-XX:+UseG1GC减少GC停顿时间，提升系统稳定性缓存优化1. 热点数据缓存（如首页商品列表）2. 设置合理缓存过期时间（如1小时）3. 避免缓存穿透（布隆过滤器）减少数据库访问量，接口响应速度提升10-100倍日志优化1. 线上环境日志级别设为INFO（避免DEBUG日志）2. 日志文件按天切割（避免单个文件过大）3. 禁用System.out.println（同步打印，性能差）减少磁盘I/O，提升系统吞吐量20%+总结Spring Boot的核心优势在于“简化开发、提升效率”——通过自动配置消除繁琐配置，通过starter整合依赖，通过嵌入式服务器简化部署，让开发者从“框架配置”回归“业务逻辑”。本文从原理到实战，覆盖了Spring Boot的核心知识点：

原理层：理解自动配置的“扫描→匹配→生效”流程，掌握@Conditional条件注解的作用；实战层：会用starter依赖、配置文件、Actuator，能开发RESTful API并整合数据库/Redis；问题层：能定位并解决端口冲突、依赖冲突、事务不生效等常见问题；规范层：遵循代码结构与性能优化最佳实践，开发可维护、高性能的应用。