返回学习记录

Learning archive

Spring 与 Spring Boot 学习记录

系统记录 Spring 核心原理与 Spring Boot 自动配置、Web 开发、数据访问和工程实践。

2026年10月30日
  • Spring
  • Spring Boot
  • Java

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 的关系#

对比项SpringSpring 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.properties
  • application.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 配置文件加载优先级#

从高到低(部分):

  1. 命令行参数 --server.port=8081
  2. application-{profile}.yml
  3. application.yml
  4. @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 事务失效的常见场景(重点)#

场景原因
方法非 publicSpring 事务基于代理,私有方法不生效
同类内部方法调用绕过代理,this.method() 不触发事务
异常被捕获未抛出未检查到异常,不触发回滚
抛出受检异常但没配置 rollbackFor默认只回滚 RuntimeException 和 Error
类未被 Spring 管理没有代理对象
数据库引擎不支持事务如 MyISAM

口诀: 事务失效 → 自调用、非 public、吞异常、类没管、引擎错。


十三、常见面试题 & 易错点#

13.1 Spring 的循环依赖如何解决?#

  • 单例 + 字段/setter 注入 可以解决,通过 三级缓存:
    1. 一级缓存 singletonObjects:完整 Bean
    2. 二级缓存 earlySingletonObjects:早期引用(未完成属性赋值)
    3. 三级缓存 singletonFactories:Bean 工厂,用于生成早期引用
  • 构造器注入的循环依赖无法解决(需用 @Lazy 或重构)。

13.2 @Autowired 和 @Resource 的区别?#

对比项@Autowired@Resource
来源SpringJDK(JSR-250)
匹配方式按类型,可配合 @Qualifier 按名称默认按名称,名称找不到再按类型
依赖Spring 专有可脱离 Spring 使用

13.3 Spring Boot 自动配置如何实现?#

  1. @SpringBootApplication 包含 @EnableAutoConfiguration
  2. @EnableAutoConfiguration 导入 AutoConfigurationImportSelector
  3. 读取 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports(2.x 为 spring.factories)
  4. 根据 @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 管理、引擎不支持事务等。


十四、知识总结#

  1. Spring 核心是 IoC 和 AOP。 IoC 把对象创建交给容器,AOP 把横切逻辑与业务解耦。
  2. Bean 的生命周期: 实例化 → 属性注入 → 初始化前 → 初始化 → 初始化后 → 使用 → 销毁。
  3. AOP 五类通知: 前置、后置、返回、异常、环绕;底层是动态代理。
  4. Spring MVC 核心流程: DispatcherServlet → HandlerMapping → Controller → ViewResolver。
  5. Spring Boot 核心特性: 自动配置、Starter、内置服务器、外部化配置、Actuator。
  6. 自动配置原理: 读取自动配置类清单 → 按 @Conditional 条件按需加载。
  7. 事务管理: @Transactional + rollbackFor,注意事务失效的 6 种常见场景。
  8. Spring、Spring MVC、Spring Boot 关系: 基础框架 → Web 模块 → 快速开发脚手架。

学习建议:多动手搭建一个 Spring Boot 项目,实际整合 MyBatis + Redis + 事务,并阅读自动配置类的源码。

页内目录14 章