Spring框架

[!abstract] 一句话定义 Spring 是 Java 生态中最核心的企业级开发框架，通过 IoC 容器管理对象生命周期，通过 AOP处理横切关注点，让开发者专注于业务逻辑而非基础设施。

为什么需要它？

想象 2002 年的 Java 企业开发（EJB 时代）：

// 只是为了查一个用户，你需要写这么多样板代码
public class UserDao {
    public User findById(int id) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = DataSourceUtils.getConnection(dataSource);
            ps = conn.prepareStatement("SELECT * FROM users WHERE id = ?");
            ps.setInt(1, id);
            rs = ps.executeQuery();
            if (rs.next()) {
                return new User(rs.getInt("id"), rs.getString("name"));
            }
            return null;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            // 还要手动关闭资源...
            JdbcUtils.closeResultSet(rs);
            JdbcUtils.closeStatement(ps);
            DataSourceUtils.releaseConnection(conn, dataSource);
        }
    }
}

痛点：

• 80% 代码是样板代码，只有 20% 是业务逻辑
• 对象之间紧耦合，测试必须启动整个容器
• 事务管理、日志、安全检查散落在每个方法里

Spring 的出现，把这些”脏活累活”接管了。

核心直觉

类比：Spring 是一家”全能管家公司”

核心理念：你只管”需要什么”，Spring 负责”怎么提供”。

它是怎么工作的？

Spring 核心架构

graph TD
    A[Spring Framework] --> B[Core Container<br/>核心容器]
    A --> C[AOP<br/>面向切面编程]
    A --> D[Data Access<br/>数据访问]
    A --> E[Web<br/>Web 开发]
    A --> F[Test<br/>测试支持]
    
    B --> B1[IoC 容器<br/>对象创建与管理]
    B --> B2[DI<br/>依赖注入]
    B --> B3[Bean 生命周期<br/>初始化/销毁]
    
    C --> C1[切面 Aspect]
    C --> C2[通知 Advice]
    C --> C3[切点 Pointcut]
    
    D --> D1[JDBC 模板]
    D --> D2[事务管理]
    D --> D3[ORM 集成]
    
    E --> E1[Spring MVC]
    E --> E2[WebFlux]
    
    style A fill:#ff9999
    style B fill:#99ccff
    style C fill:#99ff99
    style D fill:#ffcc99
    style E fill:#cc99ff

IoC 容器工作流程

sequenceDiagram
    participant Dev as 开发者
    participant Config as 配置文件/注解
    participant Container as IoC 容器
    participant Bean1 as UserService
    participant Bean2 as UserDao
    
    Note over Dev: 1. 定义 Bean
    Dev->>Config: @Component / @Bean
    
    Note over Container: 2. 容器启动，扫描配置
    Container->>Config: 读取配置
    Container->>Container: 创建 Bean 定义
    
    Note over Container: 3. 实例化 & 注入依赖
    Container->>Bean2: new UserDao()
    Container->>Bean1: new UserService(userDao)
    Container->>Bean1: 注入 UserDao
    
    Note over Dev: 4. 获取 Bean 使用
    Dev->>Container: getBean("userService")
    Container-->>Dev: 返回 UserService 实例
    Dev->>Bean1: userService.findById(1)

AOP 工作原理

graph LR
    A[业务方法] --> B{AOP 代理}
    B -->|方法执行前| C[前置通知<br/>@Before]
    B -->|方法执行后| D[后置通知<br/>@After]
    B -->|返回结果后| E[返回通知<br/>@AfterReturning]
    B -->|抛异常时| F[异常通知<br/>@AfterThrowing]
    
    C --> G[执行目标方法]
    D --> G
    E --> G
    F --> G
    
    style B fill:#ffcc99

AOP 示例：事务管理

// 没有 AOP：每个方法都要写事务代码
public void transferMoney(int from, int to, BigDecimal amount) {
    TransactionStatus tx = transactionManager.getTransaction(new DefaultTransactionDefinition());
    try {
        accountDao.debit(from, amount);
        accountDao.credit(to, amount);
        transactionManager.commit(tx);
    } catch (Exception e) {
        transactionManager.rollback(tx);
        throw e;
    }
}

// 有 AOP：一个注解搞定
@Transactional
public void transferMoney(int from, int to, BigDecimal amount) {
    accountDao.debit(from, amount);
    accountDao.credit(to, amount);
    // 事务自动管理，异常自动回滚
}

关键组件 / 核心要素

与相关概念的关系

[!info] vs Spring Boot

• Spring 是核心框架，提供 IoC、AOP 等基础能力
• Spring Boot 是 Spring 的”快速启动器”，自动配置、内嵌服务器、开箱即用
• 关系：Spring Boot = Spring + 自动配置 + 内嵌服务器 + Actuator
• 现在新项目几乎都用 Spring Boot，但底层仍是 Spring

[!note] 依赖于 依赖注入

• Spring 的核心就是 IoC 容器 + DI
• 理解 DI 是理解 Spring 的前提
• Spring 让 DI 从”手动组装”变成”自动装配”

[!tip] 被 Spring Cloud 扩展

• Spring Cloud 基于 Spring Boot，提供微服务基础设施
• 配置中心、服务发现、熔断器、网关等
• Spring → Spring Boot → Spring Cloud 是技术栈递进关系

[!tip] 实现了 AOP面向切面编程

• Spring AOP 是 AOP 思想的轻量级实现
• 通过动态代理在运行时织入切面
• 比 AspectJ 更简单，但功能也更受限

典型应用场景

• 企业级 Web 应用 — Spring MVC + MyBatis/Hibernate，传统 B/S 架构
• 微服务架构 — Spring Boot + Spring Cloud，服务拆分与治理
• RESTful API 开发 — Spring Boot 内嵌 Tomcat，快速构建 API 服务
• 批处理任务 — Spring Batch，处理大量数据的定时任务
• 消息驱动应用 — Spring Integration + Kafka/RabbitMQ，异步消息处理

Spring 生态全景

graph TD
    A[Spring Framework<br/>核心框架] --> B[Spring Boot<br/>快速启动]
    B --> C[Spring Cloud<br/>微服务]
    B --> D[Spring Data<br/>数据访问]
    B --> E[Spring Security<br/>安全框架]
    B --> F[Spring Batch<br/>批处理]
    B --> G[Spring Integration<br/>企业集成]
    
    C --> C1[配置中心]
    C --> C2[服务发现]
    C --> C3[熔断器]
    C --> C4[API 网关]
    
    D --> D1[JPA]
    D --> D2[Redis]
    D --> D3[MongoDB]
    
    style A fill:#ff9999
    style B fill:#99ccff
    style C fill:#99ff99

常见误解与陷阱

[!danger] ❌ 误以为：Spring = Spring Boot ✅ 实际上：Spring Boot 是 Spring 的”快速启动器”，底层仍是 Spring Framework。Spring 有 20 年历史，Spring Boot 是 2014 年才出现的

[!danger] ❌ 误以为：Spring 太重，不适合小项目 ✅ 实际上：Spring Boot 启动只需几秒，内存占用几十 MB。小项目用 Spring Boot 反而更快（自动配置省时间）

[!danger] ❌ 误以为：Spring 只是 DI 容器 ✅ 实际上：Spring 的核心是 IoC + AOP，DI 只是 IoC 的实现方式之一。Spring 还提供事务管理、Web 开发、数据访问等完整解决方案

[!danger] ❌ 误以为：用 Spring 就不需要懂设计模式 ✅ 实际上：Spring 大量使用工厂模式、代理模式、模板方法模式等。不懂这些模式，遇到问题很难调试

延伸阅读

• 想深入理解原理 → 阅读《Spring 实战》（Spring in Action），理解 IoC 容器源码
• 想看工程实践 → 官方文档 spring.io，跟着指南做项目
• 想了解前沿进展 → 关注 Spring Native（GraalVM 编译）、Spring Modulith（模块化架构）

关联笔记

前置知识：依赖注入 · 控制反转 IoC · Java基础 同族概念：Spring Boot · Spring Cloud · Jakarta EE 核心机制：Spring注解 · AOP面向切面编程 应用场景：微服务架构 · RESTful API · 企业级开发