Spring 与 Spring Boot 学习记录#
本文档将 Spring 与 Spring Boot 整合在一起,记录核心知识点、原理讲解与实战示例。 适合作为学习笔记、复习资料与面试准备。
一、Spring 概述#
Spring 是一个开源的 Java 企业级应用开发框架,核心是 IoC(控制反转) 和 AOP(面向切面编程)。
1.1 Spring 的核心优势#
- 轻量级: 非侵入式,不强制继承特定类
- IoC/DI: 对象创建和依赖管理交给容器
- AOP: 横切关注点(日志、事务、权限)与业务解耦
- 方便集成: 整合 MyBatis、Redis、MQ 等
- 声明式事务: 用注解管理事务
1.2 Spring 体系结构#
Spring Framework
├── Core Container(核心容器:IoC、Bean 管理)
├── AOP(面向切面编程)
├── Data Access(JDBC、事务管理)
├── Web(Spring MVC)
└── Test(测试支持)
1.3 Spring 与 Spring Boot 的关系#
| 对比项 | Spring | Spring Boot |
|---|---|---|
| 定位 | 基础框架 | 基于 Spring 的快速开发脚手架 |
| 配置 | 大量 XML/Java 配置 | 自动配置,约定优于配置 |
| 依赖 | 手动管理版本 | Starter 一键引入 |
| 部署 | 需部署到 Tomcat | 内置服务器,可独立运行 |
| 启动 | 手动创建容器 | SpringApplication.run() 一行启动 |
一句话: Spring Boot 不是替代 Spring,而是简化 Spring 的使用。
二、IoC 与 DI(控制反转与依赖注入)#
2.1 概念#
- IoC(Inversion of Control,控制反转): 对象的创建权交给 Spring 容器,而不是由程序
new。 - DI(Dependency Injection,依赖注入): 容器在创建对象时,自动将其依赖的对象注入进来。
传统方式 vs IoC:
// ❌ 传统方式:自己创建依赖,耦合度高
public class UserService {
private UserDao userDao = new UserDao(); // 强耦合
}
// ✅ IoC 方式:依赖由容器注入
@Service
public class UserService {
@Autowired
private UserDao userDao; // 由 Spring 注入
}
2.2 IoC 容器#
| 容器 | 说明 |
|---|---|
BeanFactory | 基础容器,懒加载(用到才创建) |
ApplicationContext | 高级容器,继承 BeanFactory,启动时创建所有单例 Bean |
AnnotationConfigApplicationContext | 基于注解的容器 |
// 基于注解的容器示例
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
UserService userService = context.getBean(UserService.class);
2.3 Bean 的注入方式#
@Service
public class OrderService {
// 方式一:字段注入(简单,但不推荐)
@Autowired
private UserDao userDao;
// 方式二:构造器注入(推荐,Spring 官方推荐)
private final ProductDao productDao;
public OrderService(ProductDao productDao) {
this.productDao = productDao;
}
// 方式三:Setter 注入
private PayService payService;
@Autowired
public void setPayService(PayService payService) {
this.payService = payService;
}
}
推荐构造器注入: 依赖不可变、便于测试、避免循环依赖问题。
2.4 Bean 的作用域(scope)#
| 作用域 | 说明 |
|---|---|
singleton | 单例(默认),容器中只有一个实例 |
prototype | 原型,每次获取都创建新实例 |
request | 每个 HTTP 请求一个实例(Web) |
session | 每个会话一个实例(Web) |
application | 整个 ServletContext 一个实例(Web) |
@Component
@Scope("prototype")
public class PrototypeBean {
}
三、Bean 的生命周期#
3.1 生命周期流程#
实例化(构造方法)
↓
属性赋值(依赖注入)
↓
初始化前(BeanPostProcessor#postProcessBeforeInitialization)
↓
初始化(@PostConstruct / InitializingBean#afterPropertiesSet / init-method)
↓
初始化后(BeanPostProcessor#postProcessAfterInitialization)
↓
使用中
↓
销毁(@PreDestroy / DisposableBean#destroy / destroy-method)
3.2 生命周期示例#
import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;
import org.springframework.stereotype.Component;
@Component
public class LifecycleBean {
public LifecycleBean() {
System.out.println("1. 构造方法:实例化");
}
@PostConstruct
public void init() {
System.out.println("2. @PostConstruct:初始化");
}
@PreDestroy
public void destroy() {
System.out.println("3. @PreDestroy:销毁");
}
}
四、AOP(面向切面编程)#
4.1 核心概念#
| 概念 | 说明 |
|---|---|
| Aspect(切面) | 横切关注点的模块化(如日志、事务) |
| JoinPoint(连接点) | 程序执行的点(如方法调用) |
| Pointcut(切入点) | 匹配连接点的表达式(哪些方法被增强) |
| Advice(通知) | 在连接点执行的动作(前置、后置等) |
| Target(目标对象) | 被代理的对象 |
| Proxy(代理) | AOP 生成的代理对象 |
4.2 五种通知类型#
| 通知 | 说明 |
|---|---|
@Before | 方法执行前 |
@After | 方法执行后(无论是否异常) |
@AfterReturning | 方法正常返回后 |
@AfterThrowing | 方法抛出异常后 |
@Around | 环绕,可控制方法执行 |
4.3 AOP 示例:方法耗时统计#
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class TimeAspect {
@Around("execution(* com.example.service..*.*(..))")
public Object around(ProceedingJoinPoint point) throws Throwable {
long start = System.currentTimeMillis();
Object result = point.proceed(); // 执行目标方法
long cost = System.currentTimeMillis() - start;
System.out.println(point.getSignature() + " 耗时:" + cost + "ms");
return result;
}
}
4.4 AOP 底层原理#
- JDK 动态代理: 目标类实现了接口时使用,基于
InvocationHandler - CGLIB 动态代理: 目标类没有实现接口时使用,通过继承生成子类
- Spring Boot 2.x 以后默认使用 CGLIB
五、Spring 常用注解#
5.1 声明 Bean#
| 注解 | 说明 |
|---|---|
@Component | 通用组件 |
@Service | 业务层 |
@Repository | 数据访问层 |
@Controller | 控制层 |
@RestController | @Controller + @ResponseBody |
@Configuration | 配置类 |
@Bean | 在配置类中声明 Bean |
5.2 依赖注入#
| 注解 | 说明 |
|---|---|
@Autowired | 按类型注入 |
@Qualifier | 配合 @Autowired 按名称注入 |
@Resource | 按名称注入(JDK 提供) |
@Value | 注入配置值 |
5.3 配置类示例#
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
@Bean
public UserService userService(UserDao userDao) {
return new UserService(userDao);
}
@Bean
public UserDao userDao() {
return new UserDao();
}
}
六、Spring MVC#
6.1 请求处理流程#
用户请求
↓
DispatcherServlet(前端控制器)
↓
HandlerMapping(找到对应的 Controller 方法)
↓
HandlerAdapter(调用 Controller)
↓
Controller(处理业务,返回 ModelAndView 或数据)
↓
ViewResolver(解析视图)
↓
响应结果
6.2 常用注解#
| 注解 | 说明 |
|---|---|
@RequestMapping | 映射请求路径 |
@GetMapping / @PostMapping | 限定请求方法 |
@PathVariable | 获取路径变量 |
@RequestParam | 获取请求参数 |
@RequestBody | 接收 JSON 请求体 |
@ResponseBody | 返回 JSON |
@RestController | 组合注解 |
6.3 Controller 示例#
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/api/users")
public class UserController {
private final UserService userService;
public UserController(UserService userService) {
this.userService = userService;
}
// GET /api/users/1
@GetMapping("/{id}")
public User getUser(@PathVariable Long id) {
return userService.getById(id);
}
// GET /api/users?page=1&size=10
@GetMapping
public PageResult<User> list(
@RequestParam(defaultValue = "1") int page,
@RequestParam(defaultValue = "10") int size) {
return userService.page(page, size);
}
// POST /api/users (请求体 JSON)
@PostMapping
public User create(@RequestBody User user) {
return userService.create(user);
}
// PUT /api/users/1
@PutMapping("/{id}")
public User update(@PathVariable Long id, @RequestBody User user) {
return userService.update(id, user);
}
// DELETE /api/users/1
@DeleteMapping("/{id}")
public void delete(@PathVariable Long id) {
userService.delete(id);
}
}
七、Spring Boot 介绍#
7.1 核心特性#
- 自动配置(Auto Configuration): 根据依赖自动配置 Spring
- Starter 依赖: 一键引入功能所需的所有依赖
- 内置服务器: 内置 Tomcat/Jetty/Undertow,可直接运行
- 外部化配置:
application.yml/properties - Actuator: 健康检查与监控
- 无需 XML: 完全基于注解
7.2 快速创建项目#
方式一:Spring Initializr 网站 —— https://start.spring.io
方式二:IDEA 创建 —— New Project → Spring Initializr
项目结构:
my-project
├── src/main/java/com/example
│ ├── MyApplication.java # 启动类
│ ├── controller/ # 控制层
│ ├── service/ # 业务层
│ ├── mapper/ # 数据访问层
│ └── entity/ # 实体类
├── src/main/resources
│ ├── application.yml # 配置文件
│ └── mapper/ # MyBatis XML
└── pom.xml # 依赖管理
7.3 启动类#
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}
@SpringBootApplication 是组合注解:
| 组合注解 | 作用 |
|---|---|
@SpringBootConfiguration | 标记配置类 |
@EnableAutoConfiguration | 开启自动配置 |
@ComponentScan | 扫描当前包及子包 |
八、Spring Boot 自动配置原理(重点)#
8.1 核心流程#
@SpringBootApplication
↓
@EnableAutoConfiguration
↓
@Import(AutoConfigurationImportSelector.class)
↓
读取 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
↓
(Spring Boot 2.x 为 META-INF/spring.factories)
↓
根据 @Conditional 条件按需加载配置类
8.2 自动配置类示例#
以 DataSourceAutoConfiguration 为例:
- 检测到
DataSource.class存在时生效 - 读取
spring.datasource.*配置 - 自动创建
DataSource、JdbcTemplate等 Bean
8.3 条件注解#
| 注解 | 说明 |
|---|---|
@ConditionalOnClass | 类路径存在某类时生效 |
@ConditionalOnMissingClass | 类路径不存在某类时生效 |
@ConditionalOnBean | 容器存在某 Bean 时生效 |
@ConditionalOnMissingBean | 容器不存在某 Bean 时生效 |
@ConditionalOnProperty | 配置属性满足条件时生效 |
一句话总结: 自动配置 = 一堆带条件的
@Configuration类,Spring Boot 根据依赖和配置自动加载它们。
九、Spring Boot 配置文件#
9.1 配置文件格式#
application.propertiesapplication.yml(推荐,层次清晰)
server:
port: 8080
servlet:
context-path: /api
spring:
datasource:
url: jdbc:mysql://localhost:3306/demo?useSSL=false
username: root
password: "123456"
driver-class-name: com.mysql.cj.jdbc.Driver
redis:
host: 127.0.0.1
port: 6379
password: "123456"
9.2 多环境配置#
application.yml # 公共配置
application-dev.yml # 开发环境
application-test.yml # 测试环境
application-prod.yml # 生产环境
# application.yml
spring:
profiles:
active: dev # 激活开发环境
9.3 读取配置#
方式一:@Value
@Value("${server.port}")
private int port;
方式二:@ConfigurationProperties(推荐)
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Data
@Component
@ConfigurationProperties(prefix = "app")
public class AppProperties {
private String name;
private String version;
private boolean enabled;
}
app:
name: my-app
version: 1.0.0
enabled: true
9.4 配置文件加载优先级#
从高到低(部分):
- 命令行参数
--server.port=8081 application-{profile}.ymlapplication.yml@PropertySource指定的文件
十、Spring Boot 整合常用组件#
10.1 整合 MyBatis#
依赖:
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>3.0.3</version>
</dependency>
配置:
mybatis:
mapper-locations: classpath:mapper/*.xml
type-aliases-package: com.example.entity
configuration:
map-underscore-to-camel-case: true
Mapper 接口:
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
@Mapper
public interface UserMapper {
@Select("SELECT * FROM user WHERE id = #{id}")
User selectById(Long id);
}
启动类扫描 Mapper:
@SpringBootApplication
@MapperScan("com.example.mapper")
public class MyApplication {
}
10.2 整合 Redis#
依赖:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
使用:
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;
@Service
public class RedisService {
@Autowired
private StringRedisTemplate redisTemplate;
public void set(String key, String value, long timeoutSeconds) {
redisTemplate.opsForValue().set(key, value, timeoutSeconds, TimeUnit.SECONDS);
}
public String get(String key) {
return redisTemplate.opsForValue().get(key);
}
}
10.3 整合 Spring MVC + 全局异常处理#
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
@RestControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(RuntimeException.class)
public Result<?> handleRuntime(RuntimeException e) {
return Result.error(500, e.getMessage());
}
@ExceptionHandler(Exception.class)
public Result<?> handleException(Exception e) {
return Result.error(500, "系统异常");
}
}
十一、Spring Boot 高级特性#
11.1 Actuator 健康检查#
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
management:
endpoints:
web:
exposure:
include: "*" # 生产环境按需暴露
访问:http://localhost:8080/actuator/health
11.2 打包部署#
# 打包(跳过测试)
mvn clean package -DskipTests
# 运行
java -jar target/my-project-0.0.1-SNAPSHOT.jar
# 指定配置文件
java -jar app.jar --spring.profiles.active=prod
11.3 拦截器#
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
@Component
public class LoginInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request,
HttpServletResponse response,
Object handler) {
// 返回 true 放行,false 拦截
String token = request.getHeader("Authorization");
return token != null;
}
}
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class WebConfig implements WebMvcConfigurer {
private final LoginInterceptor loginInterceptor;
public WebConfig(LoginInterceptor loginInterceptor) {
this.loginInterceptor = loginInterceptor;
}
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(loginInterceptor)
.addPathPatterns("/**")
.excludePathPatterns("/api/login", "/api/register");
}
}
11.4 过滤器与拦截器对比#
| 对比项 | 过滤器(Filter) | 拦截器(Interceptor) |
|---|---|---|
| 所属 | Servlet 规范 | Spring MVC |
| 作用范围 | 所有请求 | Controller 请求 |
| 依赖容器 | 是 | 否(Spring 管理) |
| 能否获取 Bean | 不方便 | 可以 |
| 典型用途 | 编码、跨域 | 登录校验、日志 |
十二、Spring 事务管理#
12.1 使用 @Transactional#
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
public class OrderService {
private final OrderMapper orderMapper;
private final StockMapper stockMapper;
public OrderService(OrderMapper orderMapper, StockMapper stockMapper) {
this.orderMapper = orderMapper;
this.stockMapper = stockMapper;
}
@Transactional(rollbackFor = Exception.class)
public void createOrder(Order order) {
orderMapper.insert(order); // 插入订单
stockMapper.decStock(order.getGoodsId()); // 扣减库存
// 任一步骤异常,整体回滚
}
}
12.2 事务失效的常见场景(重点)#
| 场景 | 原因 |
|---|---|
方法非 public | Spring 事务基于代理,私有方法不生效 |
| 同类内部方法调用 | 绕过代理,this.method() 不触发事务 |
| 异常被捕获未抛出 | 未检查到异常,不触发回滚 |
抛出受检异常但没配置 rollbackFor | 默认只回滚 RuntimeException 和 Error |
| 类未被 Spring 管理 | 没有代理对象 |
| 数据库引擎不支持事务 | 如 MyISAM |
口诀: 事务失效 → 自调用、非 public、吞异常、类没管、引擎错。
十三、常见面试题 & 易错点#
13.1 Spring 的循环依赖如何解决?#
- 单例 + 字段/setter 注入 可以解决,通过 三级缓存:
- 一级缓存
singletonObjects:完整 Bean - 二级缓存
earlySingletonObjects:早期引用(未完成属性赋值) - 三级缓存
singletonFactories:Bean 工厂,用于生成早期引用
- 一级缓存
- 构造器注入的循环依赖无法解决(需用
@Lazy或重构)。
13.2 @Autowired 和 @Resource 的区别?#
| 对比项 | @Autowired | @Resource |
|---|---|---|
| 来源 | Spring | JDK(JSR-250) |
| 匹配方式 | 按类型,可配合 @Qualifier 按名称 | 默认按名称,名称找不到再按类型 |
| 依赖 | Spring 专有 | 可脱离 Spring 使用 |
13.3 Spring Boot 自动配置如何实现?#
@SpringBootApplication包含@EnableAutoConfiguration@EnableAutoConfiguration导入AutoConfigurationImportSelector- 读取
META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports(2.x 为spring.factories) - 根据
@Conditional条件按需加载配置类
13.4 Spring、Spring MVC、Spring Boot 的区别?#
- Spring: 基础框架,提供 IoC、DI、AOP
- Spring MVC: Spring 的 Web 模块,处理 HTTP 请求
- Spring Boot: 基于 Spring 的快速开发脚手架,自动配置 + Starter + 内置服务器
13.5 Bean 的作用域有哪些?#
singleton(默认)、prototype、request、session、application。
13.6 AOP 的底层原理?#
JDK 动态代理(有接口)或 CGLIB 动态代理(无接口)。Spring Boot 2.x 默认 CGLIB。
13.7 事务为什么会失效?#
见 12.2 节:自调用、非 public、吞异常、类未被 Spring 管理、引擎不支持事务等。
十四、知识总结#
- Spring 核心是 IoC 和 AOP。 IoC 把对象创建交给容器,AOP 把横切逻辑与业务解耦。
- Bean 的生命周期: 实例化 → 属性注入 → 初始化前 → 初始化 → 初始化后 → 使用 → 销毁。
- AOP 五类通知: 前置、后置、返回、异常、环绕;底层是动态代理。
- Spring MVC 核心流程: DispatcherServlet → HandlerMapping → Controller → ViewResolver。
- Spring Boot 核心特性: 自动配置、Starter、内置服务器、外部化配置、Actuator。
- 自动配置原理: 读取自动配置类清单 → 按
@Conditional条件按需加载。 - 事务管理:
@Transactional+rollbackFor,注意事务失效的 6 种常见场景。 - Spring、Spring MVC、Spring Boot 关系: 基础框架 → Web 模块 → 快速开发脚手架。
学习建议:多动手搭建一个 Spring Boot 项目,实际整合 MyBatis + Redis + 事务,并阅读自动配置类的源码。