吃透 Spring 体系结构

在Java企业级开发领域，Spring框架无疑是当之无愧的基石。无论是微服务架构、分布式系统，还是传统的单体应用，Spring都以其强大的扩展性、灵活性和易用性，成为开发者的首选框架。但很多开发者在使用Spring时，往往停留在“API调用”层面，对其底层体系结构、核心设计思想一知半解，导致遇到复杂问题时难以定位，更无法充分发挥Spring的强大能力。

一、Spring体系结构整体概览

Spring并非单一框架，而是一个庞大的生态体系，核心围绕“简化Java开发”这一目标展开。其整体架构采用分层设计和模块化拆分，既保证了核心功能的简洁性，又通过扩展模块满足不同场景的需求。

1.1 核心架构图

1.2 架构核心设计思想

Spring的所有功能都构建在两大核心思想之上，这也是理解整个Spring体系的关键：

1. 控制反转（IOC）：将对象的创建、依赖管理等控制权从业务代码转移到Spring容器，实现“依赖注入”，降低代码耦合度。
2. 面向切面编程（AOP）：在不修改原有代码的前提下，通过动态代理为代码添加通用功能（如日志、事务、权限校验），实现关注点分离。

这两大思想贯穿于Spring的所有核心模块，是Spring生态的“灵魂”。后续所有模块的解析，都会围绕这两个核心展开。

二、核心容器模块：Spring的“心脏”

核心容器（Core Container）是Spring的基础，负责对象的创建、管理和依赖注入，是所有其他模块的支撑。包含Beans、Core、Context、Expression Language四个子模块。

2.1 Core模块：核心工具类

Core模块提供了Spring框架的基础工具类，是整个Spring的“工具包”，其他模块都依赖于它。核心功能包括：

• 资源访问（Resource接口，统一文件、URL、类路径等资源的访问方式）
• 类型转换（TypeConverter接口，实现不同类型之间的安全转换）
• 日志适配（整合JCL、SLF4J等日志框架，提供统一的日志接口）

实战示例：Resource资源访问

package com.jam.demo.core; import lombok.extern.slf4j.Slf4j; import org.springframework.core.io.ClassPathResource; import org.springframework.core.io.Resource; import org.springframework.util.FileCopyUtils; import java.io.IOException; import java.nio.charset.StandardCharsets; /**  * Spring Core模块资源访问示例  * @author ken  */ @Slf4j public class ResourceDemo {     public static void main(String[] args) {         // 访问类路径下的配置文件         Resource resource = new ClassPathResource("application.properties");         try {             // 使用Spring工具类读取文件内容             byte[] content = FileCopyUtils.copyToByteArray(resource.getInputStream());             String contentStr = new String(content, StandardCharsets.UTF_8);             log.info("配置文件内容：\n{}", contentStr);         } catch (IOException e) {             log.error("读取配置文件失败", e);         }     } } 

2.2 Beans模块：Bean的核心管理

Beans模块是IOC思想的核心实现，负责Bean的定义、创建、注册和管理。核心概念包括：

• BeanDefinition：描述Bean的元数据（类名、属性、依赖、作用域等）
• BeanFactory：Bean容器的顶层接口，提供Bean的获取、创建功能
• BeanWrapper：对Bean对象进行包装，提供属性设置、类型转换等功能

核心底层逻辑

1. 开发者通过XML、注解（@Component、@Bean）等方式定义Bean；
2. Spring解析这些定义，生成BeanDefinition对象；
3. BeanFactory根据BeanDefinition创建Bean实例（默认单例，懒加载）；
4. 通过BeanWrapper为Bean设置属性和依赖。

实战示例：手动创建BeanFactory管理Bean

package com.jam.demo.beans; import lombok.Data; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.config.BeanDefinition; import org.springframework.beans.factory.support.DefaultListableBeanFactory; import org.springframework.beans.factory.support.RootBeanDefinition; /**  * BeanFactory手动管理Bean示例  * @author ken  */ @Slf4j public class BeanFactoryDemo {     public static void main(String[] args) {         // 1. 创建BeanFactory实例（默认实现类）         DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();                  // 2. 定义BeanDefinition（描述UserService）         BeanDefinition userServiceDefinition = new RootBeanDefinition(UserService.class);                  // 3. 向BeanFactory注册Bean         beanFactory.registerBeanDefinition("userService", userServiceDefinition);                  // 4. 从BeanFactory获取Bean（此时才创建Bean实例，懒加载）         UserService userService = beanFactory.getBean("userService", UserService.class);         userService.sayHello("Spring Beans");                  // 5. 验证单例特性（多次获取为同一实例）         UserService userService2 = beanFactory.getBean("userService", UserService.class);         log.info("是否为同一实例：{}", userService == userService2);     }          /**      * 测试Bean类      * @author ken      */     @Data     public static class UserService {         public void sayHello(String name) {             log.info("Hello, {}! 这是BeanFactory创建的Bean", name);         }     } } 

2.3 Context模块：应用上下文

Context模块基于Core和Beans模块，提供了更强大的应用上下文管理功能，是BeanFactory的增强版。核心优势：

• 非懒加载：默认启动时创建所有单例Bean（BeanFactory默认懒加载）
• 支持国际化、资源访问、事件发布等高级功能
• 提供多种实现类，适配不同环境（ClassPathXmlApplicationContext、AnnotationConfigApplicationContext等）

核心接口关系

实战示例：AnnotationConfigApplicationContext使用（注解驱动）

package com.jam.demo.context; import lombok.extern.slf4j.Slf4j; import org.springframework.context.annotation.AnnotationConfigApplicationContext; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; /**  * 注解驱动的应用上下文示例  * @author ken  */ @Slf4j public class AnnotationContextDemo {     public static void main(String[] args) {         // 1. 创建注解驱动的应用上下文，扫描指定包下的注解Bean         AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);                  // 2. 获取Bean（UserService被@Bean注解定义）         UserService userService = context.getBean(UserService.class);         userService.queryUser("1001");                  // 3. 关闭上下文         context.close();     }          /**      * 应用配置类，用于定义Bean      * @author ken      */     @Configuration     public static class AppConfig {         /**          * 定义UserService Bean          * @return UserService实例          */         @Bean         public UserService userService() {             return new UserService();         }     }          /**      * 用户服务类      * @author ken      */     public static class UserService {         public void queryUser(String userId) {             log.info("查询用户信息，用户ID：{}", userId);         }     } } 

2.4 Expression Language模块：Spring表达式语言

Spring EL（SpEL）是一种强大的表达式语言，支持在运行时查询和操作对象。核心功能包括：

• 访问对象属性和方法
• 执行算术运算、逻辑运算
• 读取配置文件、系统属性
• 集合操作、正则表达式匹配

实战示例：SpEL表达式使用

package com.jam.demo.el; import lombok.Data; import lombok.extern.slf4j.Slf4j; import org.springframework.expression.Expression; import org.springframework.expression.ExpressionParser; import org.springframework.expression.spel.standard.SpelExpressionParser; import org.springframework.expression.spel.support.StandardEvaluationContext; import java.util.ArrayList; import java.util.List; /**  * Spring EL表达式示例  * @author ken  */ @Slf4j public class Speldemo {     public static void main(String[] args) {         // 1. 创建SpEL解析器         ExpressionParser parser = new SpelExpressionParser();                  // 2. 简单表达式：算术运算         Expression exp1 = parser.parseExpression("100 + 200 * 3");         Integer result1 = exp1.getValue(Integer.class);         log.info("算术运算结果：{}", result1);                  // 3. 访问对象属性和方法         User user = new User("张三", 25);         StandardEvaluationContext context = new StandardEvaluationContext(user);                  Expression exp2 = parser.parseExpression("name");         String userName = exp2.getValue(context, String.class);         log.info("用户姓名：{}", userName);                  Expression exp3 = parser.parseExpression("getName().toUpperCase()");         String upperName = exp3.getValue(context, String.class);         log.info("姓名大写：{}", upperName);                  // 4. 集合操作         List<String> list = new ArrayList<>();         list.add("Spring");         list.add("Spring Boot");         list.add("Spring Cloud");         context.setVariable("list", list);                  Expression exp4 = parser.parseExpression("#list.stream().filter(s -> s.startsWith('Spring ')).collect(toList())");         List<String> resultList = exp4.getValue(context, List.class);         log.info("集合过滤结果：{}", resultList);     }          /**      * 测试用户类      * @author ken      */     @Data     public static class User {         private String name;         private Integer age;                  public User(String name, Integer age) {             this.name = name;             this.age = age;         }     } } 

三、AOP模块：面向切面编程的实现

AOP模块是Spring实现面向切面编程的核心，通过动态代理技术，在不修改原有代码的前提下，为程序添加通用功能（如日志、事务、权限）。核心依赖于Core和Beans模块。

3.1 AOP核心概念

• 切面（Aspect）：封装通用功能的类（如日志切面、事务切面）
• 连接点（JoinPoint）：程序执行过程中的特定点（如方法调用、属性赋值）
• 切入点（Pointcut）：通过表达式筛选出的需要增强的连接点
• 通知（Advice）：切面在连接点执行的具体操作（前置、后置、环绕、异常、最终通知）
• 目标对象（Target）：被增强的对象
• 代理对象（Proxy）：Spring为目标对象创建的代理对象，用于执行增强逻辑

3.2 底层实现原理

Spring AOP默认使用JDK动态代理（针对接口），如果目标对象没有实现接口，则使用CGLIB动态代理（通过继承目标类）。核心流程：

1. 开发者定义切面（@Aspect）和切入点（@Pointcut）；
2. Spring解析切面配置，生成Advisor（包含切入点和通知）；
3. 容器创建目标对象时，根据Advisor判断是否需要增强；
4. 若需要增强，通过动态代理创建代理对象；
5. 调用目标方法时，先执行代理对象的增强逻辑，再执行目标方法。

AOP执行流程

3.3 实战示例：AOP日志增强（结合最新Spring AOP）

1. 依赖配置（pom.xml）

<!-- Spring AOP核心依赖 --> <dependency>     <groupId>org.springframework</groupId>     <artifactId>spring-aop</artifactId>     <version>6.1.5</version> </dependency> <!-- AspectJ支持（Spring AOP依赖AspectJ表达式） --> <dependency>     <groupId>org.aspectj</groupId>     <artifactId>aspectjweaver</artifactId>     <version>1.9.21</version> </dependency> <!-- Lombok --> <dependency>     <groupId>org.projectlombok</groupId>     <artifactId>lombok</artifactId>     <version>1.18.30</version>     <scope>provided</scope> </dependency> 

2. 切面类定义

package com.jam.demo.aop; import lombok.extern.slf4j.Slf4j; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.*; import org.springframework.stereotype.Component; import org.springframework.util.StringUtils; import java.util.Arrays; /**  * 日志切面类，用于增强服务层方法的日志输出  * @author ken  */ @Aspect @Component @Slf4j public class LogAspect {     /**      * 切入点表达式：匹配com.jam.demo.service包下所有类的所有公共方法      */     @Pointcut("execution(public * com.jam.demo.service..*(..))")     public void servicePointcut() {}          /**      * 前置通知：方法执行前执行      * @param joinPoint 连接点对象，包含方法信息、参数等      */     @Before("servicePointcut()")     public void beforeAdvice(JoinPoint joinPoint) {         String methodName = joinPoint.getSignature().getName();         String className = joinPoint.getTarget().getClass().getSimpleName();         Object[] args = joinPoint.getArgs();         log.info("【前置通知】{}类的{}方法开始执行，参数：{}", className, methodName, Arrays.toString(args));     }          /**      * 后置通知：方法执行后执行（无论成功与否）      * @param joinPoint 连接点对象      */     @After("servicePointcut()")     public void afterAdvice(JoinPoint joinPoint) {         String methodName = joinPoint.getSignature().getName();         String className = joinPoint.getTarget().getClass().getSimpleName();         log.info("【后置通知】{}类的{}方法执行结束", className, methodName);     }          /**      * 返回通知：方法成功执行后执行，可获取返回值      * @param joinPoint 连接点对象      * @param result 方法返回值      */     @AfterReturning(pointcut = "servicePointcut()", returning = "result")     public void afterReturningAdvice(JoinPoint joinPoint, Object result) {         String methodName = joinPoint.getSignature().getName();         String className = joinPoint.getTarget().getClass().getSimpleName();         log.info("【返回通知】{}类的{}方法执行成功，返回值：{}", className, methodName, result);     }          /**      * 异常通知：方法执行异常时执行      * @param joinPoint 连接点对象      * @param e 异常对象      */     @AfterThrowing(pointcut = "servicePointcut()", throwing = "e")     public void afterThrowingAdvice(JoinPoint joinPoint, Exception e) {         String methodName = joinPoint.getSignature().getName();         String className = joinPoint.getTarget().getClass().getSimpleName();         log.error("【异常通知】{}类的{}方法执行异常，异常信息：{}", className, methodName, e.getMessage(), e);     }          /**      * 环绕通知：包围方法执行，可控制方法是否执行、执行时机      * @param proceedingJoinPoint 可执行的连接点对象      * @return 方法返回值      * @throws Throwable 方法执行异常      */     @Around("servicePointcut()")     public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {         String methodName = proceedingJoinPoint.getSignature().getName();         String className = proceedingJoinPoint.getTarget().getClass().getSimpleName();         long startTime = System.currentTimeMillis();                  Object result = null;         try {             // 执行前置逻辑             log.info("【环绕通知-前置】{}类的{}方法开始计时", className, methodName);             // 执行目标方法             result = proceedingJoinPoint.proceed();             // 执行返回后逻辑             log.info("【环绕通知-返回】{}类的{}方法计时结束", className, methodName);         } catch (Exception e) {             // 执行异常逻辑             log.error("【环绕通知-异常】{}类的{}方法执行异常", className, methodName, e);             throw e;         } finally {             // 计算方法执行时间             long costTime = System.currentTimeMillis() - startTime;             log.info("【环绕通知-最终】{}类的{}方法执行耗时：{}ms", className, methodName, costTime);         }         return result;     } } 

3. 服务类（被增强的目标对象）

package com.jam.demo.service; import com.jam.demo.entity.User; import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Service; import org.springframework.util.ObjectUtils; /**  * 用户服务类，被AOP增强  * @author ken  */ @Service @Slf4j public class UserService {     /**      * 根据用户ID查询用户      * @param userId 用户ID      * @return User对象      */     public User queryUserById(String userId) {         // 模拟参数校验         if (ObjectUtils.isEmpty(userId)) {             throw new IllegalArgumentException("用户ID不能为空");         }         // 模拟数据库查询         User user = new User();         user.setUserId(userId);         user.setUserName("张三");         user.setAge(25);         user.setPhone("13800138000");         return user;     }          /**      * 新增用户      * @param user 用户对象      * @return 新增成功的用户ID      */     public String addUser(User user) {         // 模拟参数校验         if (ObjectUtils.isEmpty(user) || !org.springframework.util.StringUtils.hasText(user.getUserName())) {             throw new IllegalArgumentException("用户名不能为空");         }         // 模拟数据库新增         String userId = "user_" + System.currentTimeMillis();         user.setUserId(userId);         log.info("用户新增成功，用户信息：{}", user);         return userId;     } } 

4. 实体类

package com.jam.demo.entity; import lombok.Data; /**  * 用户实体类  * @author ken  */ @Data public class User {     /**      * 用户ID      */     private String userId;     /**      * 用户名      */     private String userName;     /**      * 年龄      */     private Integer age;     /**      * 手机号      */     private String phone; } 

5. 配置类（开启AOP自动代理）

package com.jam.demo.config; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.EnableAspectJAutoProxy; /**  * 应用配置类，开启AOP自动代理并扫描组件  * @author ken  */ @Configuration @ComponentScan(basePackages = "com.jam.demo") @EnableAspectJAutoProxy(proxyTargetClass = true) // proxyTargetClass=true：强制使用CGLIB代理 public class AopConfig { } 

6. 测试类

package com.jam.demo.aop; import com.jam.demo.config.AopConfig; import com.jam.demo.entity.User; import com.jam.demo.service.UserService; import org.springframework.context.annotation.AnnotationConfigApplicationContext; /**  * AOP测试类  * @author ken  */ public class AopTest {     public static void main(String[] args) {         // 初始化Spring上下文         AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AopConfig.class);                  // 获取UserService代理对象         UserService userService = context.getBean(UserService.class);                  // 测试正常方法调用         System.out.println("===== 测试查询用户 =====");         User user = userService.queryUserById("1001");                  // 测试新增用户         System.out.println("\n===== 测试新增用户 =====");         User newUser = new User();         newUser.setUserName("李四");         newUser.setAge(30);         newUser.setPhone("13900139000");         userService.addUser(newUser);                  // 测试异常情况         System.out.println("\n===== 测试参数异常 =====");         try {             userService.queryUserById(null);         } catch (Exception e) {             // 异常已被切面捕获并日志输出         }                  // 关闭上下文         context.close();     } } 

四、数据访问/集成模块：连接数据层

数据访问/集成模块提供了Spring对数据访问层的支持，简化了JDBC、ORM框架（MyBatis、Hibernate）、事务管理等操作。核心模块包括JDBC、ORM、Transactions等。

4.1 事务管理模块（Transactions）

Spring事务管理是该模块的核心功能，通过AOP实现声明式事务（注解@Transactional）或编程式事务，支持多种事务管理器（JDBC事务、JTA事务等）。

核心底层逻辑

1. 事务管理器（PlatformTransactionManager）：统一的事务管理接口，不同数据访问技术有不同实现（如DataSourceTransactionManager用于JDBC/MyBatis）；
2. 事务定义（TransactionDefinition）：描述事务属性（隔离级别、传播行为、超时时间、是否只读）；
3. 事务状态（TransactionStatus）：描述事务的当前状态（是否新建、是否已提交、是否回滚）；
4. 核心流程：通过AOP拦截标注@Transactional的方法，在方法执行前开启事务，执行成功后提交事务，执行异常时回滚事务。

实战示例：编程式事务（最新Spring 6.x）

1. 依赖配置（pom.xml）

<!-- Spring 事务核心依赖 --> <dependency>     <groupId>org.springframework</groupId>     <artifactId>spring-tx</artifactId>     <version>6.1.5</version> </dependency> <!-- Spring JDBC --> <dependency>     <groupId>org.springframework</groupId>     <artifactId>spring-jdbc</artifactId>     <version>6.1.5</version> </dependency> <!-- MySQL驱动 --> <dependency>     <groupId>com.mysql</groupId>     <artifactId>mysql-connector-j</artifactId>     <version>8.3.0</version> </dependency> <!-- MyBatis-Plus --> <dependency>     <groupId>com.baomidou</groupId>     <artifactId>mybatis-plus-boot-starter</artifactId>     <version>3.5.5</version> </dependency> <!-- HikariCP连接池（Spring默认） --> <dependency>     <groupId>com.zaxxer</groupId>     <artifactId>HikariCP</artifactId>     <version>5.1.0</version> </dependency> <!-- FastJSON2 --> <dependency>     <groupId>com.alibaba.fastjson2</groupId>     <artifactId>fastjson2</artifactId>     <version>2.0.45</version> </dependency> <!-- Google Guava 集合工具 --> <dependency>     <groupId>com.google.guava</groupId>     <artifactId>guava</artifactId>     <version>33.2.1-jre</version> </dependency> <!-- Swagger3 --> <dependency>     <groupId>io.springfox</groupId>     <artifactId>springfox-boot-starter</artifactId>     <version>3.0.0</version> </dependency> 

2. 数据库表SQL（MySQL 8.0）

-- 用户表 CREATE TABLE `t_user` (   `user_id` varchar(64) NOT NULL COMMENT '用户ID',   `user_name` varchar(32) NOT NULL COMMENT '用户名',   `age` int DEFAULT NULL COMMENT '年龄',   `phone` varchar(20) DEFAULT NULL COMMENT '手机号',   `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',   PRIMARY KEY (`user_id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户表'; -- 订单表 CREATE TABLE `t_order` (   `order_id` varchar(64) NOT NULL COMMENT '订单ID',   `user_id` varchar(64) NOT NULL COMMENT '用户ID',   `order_amount` decimal(10,2) NOT NULL COMMENT '订单金额',   `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',   PRIMARY KEY (`order_id`),   KEY `idx_user_id` (`user_id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='订单表'; 

3. 实体类

package com.jam.demo.entity; import com.baomidou.mybatisplus.annotation.TableField; import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import lombok.Data; import java.math.BigDecimal; import java.time.LocalDateTime; /**  * 订单实体类  * @author ken  */ @Data @TableName("t_order") public class Order {     /**      * 订单ID      */     @TableId("order_id")     private String orderId;          /**      * 用户ID      */     @TableField("user_id")     private String userId;          /**      * 订单金额      */     @TableField("order_amount")     private BigDecimal orderAmount;          /**      * 创建时间      */     @TableField("create_time")     private LocalDateTime createTime; } 

4. Mapper接口（MyBatis-Plus）

package com.jam.demo.mapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.jam.demo.entity.Order; import com.jam.demo.entity.User; import org.springframework.stereotype.Repository; /**  * 订单Mapper  * @author ken  */ @Repository public interface OrderMapper extends BaseMapper<Order> { } 

package com.jam.demo.mapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.jam.demo.entity.User; import org.springframework.stereotype.Repository; /**  * 用户Mapper  * @author ken  */ @Repository public interface UserMapper extends BaseMapper<User> { } 

5. 服务类（编程式事务）

package com.jam.demo.service; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.jam.demo.entity.Order; import com.jam.demo.entity.User; import com.jam.demo.mapper.OrderMapper; import com.jam.demo.mapper.UserMapper; import com.google.common.collect.Lists; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Service; import org.springframework.transaction.PlatformTransactionManager; import org.springframework.transaction.TransactionDefinition; import org.springframework.transaction.TransactionStatus; import org.springframework.transaction.support.DefaultTransactionDefinition; import org.springframework.util.CollectionUtils; import org.springframework.util.ObjectUtils; import org.springframework.util.StringUtils; import java.math.BigDecimal; import java.time.LocalDateTime; import java.util.List; import java.util.UUID; /**  * 订单服务类（编程式事务）  * @author ken  */ @Service @Slf4j @RequiredArgsConstructor public class OrderService {     private final OrderMapper orderMapper;     private final UserMapper userMapper;     private final PlatformTransactionManager transactionManager;          /**      * 创建订单（包含用户创建，编程式事务）      * @param userName 用户名      * @param age 年龄      * @param phone 手机号      * @param orderAmount 订单金额      * @return 订单ID      */     public String createOrderWithUser(String userName, Integer age, String phone, BigDecimal orderAmount) {         // 1. 参数校验         if (!StringUtils.hasText(userName, "用户名不能为空")) {             throw new IllegalArgumentException("用户名不能为空");         }         if (ObjectUtils.isEmpty(orderAmount) || orderAmount.compareTo(BigDecimal.ZERO) <= 0) {             throw new IllegalArgumentException("订单金额必须大于0");         }                  // 2. 定义事务属性：默认隔离级别、传播行为REQUIRED、非只读         DefaultTransactionDefinition transactionDefinition = new DefaultTransactionDefinition();         transactionDefinition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);         transactionDefinition.setIsolationLevel(TransactionDefinition.ISOLATION_DEFAULT);         transactionDefinition.setTimeout(30); // 超时时间30秒                  // 3. 开启事务         TransactionStatus transactionStatus = transactionManager.getTransaction(transactionDefinition);                  try {             // 3.1 创建用户             User user = new User();             String userId = "user_" + UUID.randomUUID().toString().replace("-", "");             user.setUserId(userId);             user.setUserName(userName);             user.setAge(age);             user.setPhone(phone);             int userInsertCount = userMapper.insert(user);             log.info("创建用户，影响行数：{}，用户ID：{}", userInsertCount, userId);                          // 模拟异常（测试事务回滚）             // if (true) {             //     throw new RuntimeException("模拟创建订单异常");             // }                          // 3.2 创建订单             Order order = new Order();             String orderId = "order_" + UUID.randomUUID().toString().replace("-", "");             order.setOrderId(orderId);             order.setUserId(userId);             order.setOrderAmount(orderAmount);             order.setCreateTime(LocalDateTime.now());             int orderInsertCount = orderMapper.insert(order);             log.info("创建订单，影响行数：{}，订单ID：{}", orderInsertCount, orderId);                          // 4. 提交事务             transactionManager.commit(transactionStatus);             log.info("创建订单和用户成功，事务提交");             return orderId;         } catch (Exception e) {             // 5. 回滚事务             transactionManager.rollback(transactionStatus);             log.error("创建订单和用户失败，事务回滚", e);             throw new RuntimeException("创建订单失败：" + e.getMessage());         }     }          /**      * 根据用户ID查询订单列表      * @param userId 用户ID      * @return 订单列表      */     public List<Order> queryOrdersByUserId(String userId) {         if (!StringUtils.hasText(userId, "用户ID不能为空")) {             throw new IllegalArgumentException("用户ID不能为空");         }                  LambdaQueryWrapper<Order> queryWrapper = new LambdaQueryWrapper<>();         queryWrapper.eq(Order::getUserId, userId);         List<Order> orderList = orderMapper.selectList(queryWrapper);                  if (CollectionUtils.isEmpty(orderList)) {             log.info("用户ID：{} 暂无订单", userId);             return Lists.newArrayList();         }         return orderList;     } } 

6. 配置类（数据源、事务管理器、MyBatis-Plus）

package com.jam.demo.config; import com.baomidou.mybatisplus.annotation.DbType; import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor; import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor; import com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean; import org.apache.ibatis.session.SqlSessionFactory; import org.mybatis.spring.annotation.MapperScan; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.jdbc.datasource.DataSourceTransactionManager; import org.springframework.transaction.PlatformTransactionManager; import com.zaxxer.hikari.HikariDataSource; import javax.sql.DataSource; import java.util.Properties; /**  * 数据访问层配置（数据源、事务管理器、MyBatis-Plus）  * @author ken  */ @Configuration @MapperScan(basePackages = "com.jam.demo.mapper") // 扫描Mapper接口 public class DataSourceConfig {     /**      * 配置HikariCP数据源（Spring 6.x默认）      * @return 数据源      */     @Bean     public DataSource dataSource() {         HikariDataSource dataSource = new HikariDataSource();         dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/spring_demo?useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true");         dataSource.setUsername("root");         dataSource.setPassword("root123456");         dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");         // 连接池配置         dataSource.setMaximumPoolSize(10); // 最大连接数         dataSource.setMinimumIdle(5); // 最小空闲连接数         dataSource.setIdleTimeout(300000); // 空闲连接超时时间（5分钟）         dataSource.setConnectionTimeout(30000); // 连接超时时间（30秒）         return dataSource;     }          /**      * 配置事务管理器（JDBC事务）      * @param dataSource 数据源      * @return 事务管理器      */     @Bean     public PlatformTransactionManager transactionManager(DataSource dataSource) {         return new DataSourceTransactionManager(dataSource);     }          /**      * 配置MyBatis-Plus SqlSessionFactory      * @param dataSource 数据源      * @return SqlSessionFactory      * @throws Exception 异常      */     @Bean     public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {         MybatisSqlSessionFactoryBean sessionFactory = new MybatisSqlSessionFactoryBean();         sessionFactory.setDataSource(dataSource);                  // 配置MyBatis-Plus插件（分页插件）         MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();         interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));         sessionFactory.setPlugins(interceptor);                  // 配置MyBatis属性         Properties properties = new Properties();         properties.setProperty("mapUnderscoreToCamelCase", "true"); // 下划线转驼峰         properties.setProperty("logImpl", "SLF4J"); // 日志实现         sessionFactory.setConfigurationProperties(properties);                  return sessionFactory.getObject();     } } 

7. 控制器（结合Swagger3）

package com.jam.demo.controller; import com.jam.demo.entity.Order; import com.jam.demo.service.OrderService; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperation; import io.swagger.annotations.ApiParam; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.springframework.web.bind.annotation.*; import java.math.BigDecimal; import java.util.List; /**  * 订单控制器  * @author ken  */ @RestController @RequestMapping("/api/order") @Api(tags = "订单管理接口") @RequiredArgsConstructor @Slf4j public class OrderController {     private final OrderService orderService;          /**      * 创建订单（包含用户创建）      * @param userName 用户名      * @param age 年龄      * @param phone 手机号      * @param orderAmount 订单金额      * @return 订单ID      */     @PostMapping("/create")     @ApiOperation(value = "创建订单", notes = "创建订单并自动创建关联用户，包含编程式事务")     public String createOrder(             @ApiParam(value = "用户名", required = true) @RequestParam String userName,             @ApiParam(value = "年龄") @RequestParam(required = false) Integer age,             @ApiParam(value = "手机号") @RequestParam(required = false) String phone,             @ApiParam(value = "订单金额", required = true) @RequestParam BigDecimal orderAmount     ) {         return orderService.createOrderWithUser(userName, age, phone, orderAmount);     }          /**      * 根据用户ID查询订单列表      * @param userId 用户ID      * @return 订单列表      */     @GetMapping("/list")     @ApiOperation(value = "查询订单列表", notes = "根据用户ID查询关联的订单列表")     public List<Order> queryOrderList(             @ApiParam(value = "用户ID", required = true) @RequestParam String userId     ) {         return orderService.queryOrdersByUserId(userId);     } } 

8. 启动类

package com.jam.demo; import io.swagger.annotations.Api; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import springfox.documentation.oas.annotations.EnableOpenApi; /**  * 应用启动类  * @author ken  */ @SpringBootApplication @EnableOpenApi // 开启Swagger3 public class SpringDemoApplication {     public static void main(String[] args) {         SpringApplication.run(SpringDemoApplication.class, args);         System.out.println("Spring Demo应用启动成功！访问Swagger3文档：http://localhost:8080/swagger-ui/index.html");     } } 

4.2 ORM模块：整合MyBatis-Plus

Spring的ORM模块提供了对主流ORM框架的整合支持，通过Spring的事务管理和资源管理，简化ORM框架的使用。上面的实战示例已结合MyBatis-Plus实现了ORM操作，核心优势：

• 统一的事务管理：MyBatis-Plus的操作自动纳入Spring事务；
• 资源统一管理：数据源由Spring统一配置和管理，避免重复配置；
• 简化依赖注入：Mapper接口由Spring自动扫描并注入到Service中。

五、Web模块：Spring的Web开发支持

Web模块提供了Spring对Web开发的全面支持，包含Web、WebMVC、WebFlux等子模块，分别对应传统的Servlet开发、MVC开发和响应式开发。

5.1 WebMVC模块：Spring MVC核心

Spring MVC是基于Servlet的MVC框架，实现了请求的接收、处理和响应的完整流程。核心组件包括：

• 前端控制器（DispatcherServlet）：统一接收请求，分发到对应的处理器；
• 处理器映射器（HandlerMapping）：根据请求路径查找对应的处理器（Controller方法）；
• 处理器适配器（HandlerAdapter）：调用处理器方法，执行业务逻辑；
• 视图解析器（ViewResolver）：将处理器返回的结果解析为视图（JSP、JSON等）；
• 拦截器（HandlerInterceptor）：拦截请求，执行前置、后置处理（如登录校验）。

Spring MVC请求处理流程

实战示例：Spring MVC拦截器（登录校验）

1. 拦截器实现类

package com.jam.demo.interceptor; import lombok.extern.slf4j.Slf4j; import org.springframework.web.servlet.HandlerInterceptor; import org.springframework.web.servlet.ModelAndView; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpSession; import org.springframework.util.StringUtils; /**  * 登录校验拦截器  * @author ken  */ @Slf4j public class LoginInterceptor implements HandlerInterceptor {     /**      * 前置处理：请求执行前拦截      * @param request 请求对象      * @param response 响应对象      * @param handler 处理器      * @return true：放行；false：拦截      * @throws Exception 异常      */     @Override     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {         // 1. 获取请求路径         String requestURI = request.getRequestURI();         log.info("登录拦截器拦截请求：{}", requestURI);                  // 2. 放行登录接口         if (requestURI.contains("/api/login")) {             log.info("登录接口，直接放行");             return true;         }                  // 3. 校验登录状态（从Session获取用户信息）         HttpSession session = request.getSession();         Object user = session.getAttribute("loginUser");         if (!StringUtils.isEmpty(user)) {             log.info("用户已登录，放行请求");             return true;         }                  // 4. 未登录，返回401未授权         log.info("用户未登录，拦截请求");         response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);         response.setContentType("application/json;charset=utf-8");         response.getWriter().write("{\"code\":401,\"msg\":\"未登录，请先登录\"}");         return false;     }          /**      * 后置处理：处理器方法执行后，视图渲染前      * @param request 请求对象      * @param response 响应对象      * @param handler 处理器      * @param modelAndView 模型和视图      * @throws Exception 异常      */     @Override     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {         log.info("登录拦截器后置处理");     }          /**      * 完成处理：视图渲染后，请求完成      * @param request 请求对象      * @param response 响应对象      * @param handler 处理器      * @param ex 异常对象      * @throws Exception 异常      */     @Override     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {         log.info("登录拦截器完成处理");     } } 

2. 拦截器配置类

package com.jam.demo.config; import com.jam.demo.interceptor.LoginInterceptor; import org.springframework.context.annotation.Configuration; import org.springframework.web.servlet.config.annotation.InterceptorRegistry; import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; /**  * Web MVC配置类，注册拦截器  * @author ken  */ @Configuration public class WebMvcConfig implements WebMvcConfigurer {     @Override     public void addInterceptors(InterceptorRegistry registry) {         // 注册登录拦截器，拦截所有/api/**路径的请求         registry.addInterceptor(new LoginInterceptor())                 .addPathPatterns("/api/**")                 .excludePathPatterns("/api/login"); // 放行登录接口     } } 

3. 登录控制器

package com.jam.demo.controller; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperation; import io.swagger.annotations.ApiParam; import lombok.extern.slf4j.Slf4j; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import org.springframework.util.StringUtils; import javax.servlet.http.HttpSession; /**  * 登录控制器  * @author ken  */ @RestController @RequestMapping("/api") @Api(tags = "登录管理接口") @Slf4j public class LoginController {     /**      * 登录接口      * @param username 用户名      * @param password 密码      * @param session Session对象      * @return 登录结果      */     @PostMapping("/login")     @ApiOperation(value = "用户登录", notes = "用户登录并将用户信息存入Session")     public String login(             @ApiParam(value = "用户名", required = true) @RequestParam String username,             @ApiParam(value = "密码", required = true) @RequestParam String password,             HttpSession session     ) {         // 简单校验（实际开发中需查询数据库）         if (!StringUtils.hasText(username, "用户名不能为空") || !StringUtils.hasText(password, "密码不能为空")) {             return "{\"code\":400,\"msg\":\"用户名或密码不能为空\"}";         }         if ("admin".equals(username) && "admin123".equals(password)) {             // 登录成功，存入Session             session.setAttribute("loginUser", username);             log.info("用户{}登录成功", username);             return "{\"code\":200,\"msg\":\"登录成功\"}";         }         log.info("用户{}登录失败，用户名或密码错误", username);         return "{\"code\":401,\"msg\":\"用户名或密码错误\"}";     } } 

六、易混淆技术点辨析

6.1 BeanFactory vs ApplicationContext

6.2 JDK 动态代理 vs CGLIB 动态代理

核心差异总结

1. 底层依赖不同：JDK动态代理依赖JDK原生的java.lang.reflect.Proxy和InvocationHandler，CGLIB依赖ASM字节码操作框架；
2. 适用场景不同：JDK动态代理仅支持接口实现类，CGLIB支持任意非final类；
3. 性能特点不同：JDK动态代理创建快、执行慢，CGLIB创建慢、执行快（适合单例Bean的长期使用场景）。

实战示例：JDK 动态代理 vs CGLIB 动态代理对比

1. JDK 动态代理实现（基于接口）

package com.jam.demo.proxy; import lombok.extern.slf4j.Slf4j; import org.springframework.util.ObjectUtils; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; /**  * JDK 动态代理示例（基于接口）  * @author ken  */ @Slf4j public class JdkProxyDemo {     // 目标接口     public interface UserDao {         /**          * 保存用户          * @param userName 用户名          * @return 保存结果          */         boolean saveUser(String userName);     }     // 目标对象（实现接口）     public static class UserDaoImpl implements UserDao {         @Override         public boolean saveUser(String userName) {             if (!org.springframework.util.StringUtils.hasText(userName)) {                 log.error("用户名不能为空");                 return false;             }             log.info("JDK动态代理-保存用户：{}", userName);             return true;         }     }     // JDK动态代理处理器     public static class JdkProxyHandler implements InvocationHandler {         // 目标对象         private final Object target;         public JdkProxyHandler(Object target) {             this.target = target;         }         /**          * 代理方法执行逻辑          * @param proxy 代理对象          * @param method 目标方法          * @param args 方法参数          * @return 方法返回值          * @throws Throwable 异常          */         @Override         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {             // 前置增强：日志输出             log.info("【JDK代理-前置】执行方法：{}，参数：{}", method.getName(), args);                          // 执行目标方法             Object result = method.invoke(target, args);                          // 后置增强：结果输出             log.info("【JDK代理-后置】方法执行完成，返回值：{}", result);             return result;         }     }     // 测试方法     public static void main(String[] args) {         // 1. 创建目标对象         UserDao target = new UserDaoImpl();                  // 2. 创建JDK动态代理对象         UserDao proxy = (UserDao) Proxy.newProxyInstance(                 target.getClass().getClassLoader(),                 target.getClass().getInterfaces(),                 new JdkProxyHandler(target)         );                  // 3. 调用代理方法         proxy.saveUser("张三");                  // 验证代理对象类型         log.info("代理对象类型：{}", proxy.getClass().getName());         log.info("是否为目标对象实例：{}", proxy instanceof UserDaoImpl);     } } 

2. CGLIB 动态代理实现（基于继承）

package com.jam.demo.proxy; import lombok.extern.slf4j.Slf4j; import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; import org.springframework.util.StringUtils; import java.lang.reflect.Method; /**  * CGLIB 动态代理示例（基于继承）  * @author ken  */ @Slf4j public class CglibProxyDemo {     // 目标对象（无需实现接口）     public static class OrderDao {         /**          * 创建订单          * @param orderId 订单ID          * @return 创建结果          */         public boolean createOrder(String orderId) {             if (!StringUtils.hasText(orderId)) {                 log.error("订单ID不能为空");                 return false;             }             log.info("CGLIB动态代理-创建订单：{}", orderId);             return true;         }     }     // CGLIB方法拦截器     public static class CglibProxyInterceptor implements MethodInterceptor {         /**          * 拦截目标方法，执行增强逻辑          * @param obj 代理对象（目标类的子类）          * @param method 目标方法          * @param args 方法参数          * @param proxy 方法代理对象（用于调用目标方法）          * @return 方法返回值          * @throws Throwable 异常          */         @Override         public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {             // 前置增强：日志输出             log.info("【CGLIB代理-前置】执行方法：{}，参数：{}", method.getName(), args);                          // 执行目标方法（使用proxy.invokeSuper避免递归调用）             Object result = proxy.invokeSuper(obj, args);                          // 后置增强：结果输出             log.info("【CGLIB代理-后置】方法执行完成，返回值：{}", result);             return result;         }     }     // 测试方法     public static void main(String[] args) {         // 1. 创建CGLIB增强器         Enhancer enhancer = new Enhancer();         // 2. 设置父类（目标类）         enhancer.setSuperclass(OrderDao.class);         // 3. 设置方法拦截器         enhancer.setCallback(new CglibProxyInterceptor());                  // 4. 创建代理对象（目标类的子类）         OrderDao proxy = (OrderDao) enhancer.create();                  // 5. 调用代理方法         proxy.createOrder("order_1001");                  // 验证代理对象类型         log.info("代理对象类型：{}", proxy.getClass().getName());         log.info("是否为目标对象实例：{}", proxy instanceof OrderDao);     } } 

3. 依赖配置（pom.xml，CGLIB 依赖）

<!-- CGLIB 依赖（Spring AOP已包含，单独使用时需引入） --> <dependency>     <groupId>cglib</groupId>     <artifactId>cglib</artifactId>     <version>3.3.0</version> </dependency> 

6.3 声明式事务 vs 编程式事务

核心差异总结

1. 核心思想不同：声明式事务是“面向配置”，通过注解简化事务管理；编程式事务是“面向代码”，通过API精确控制事务流程；
2. 代码侵入性不同：声明式事务几乎无侵入，符合“开闭原则”；编程式事务侵入业务代码，维护成本高；
3. 适用场景不同：绝大多数简单业务用声明式事务；复杂业务（如多步骤事务控制、动态决定事务属性）用编程式事务。

实战示例：声明式事务快速实现

package com.jam.demo.transaction; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.jam.demo.entity.User; import com.jam.demo.mapper.UserMapper; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import org.springframework.util.StringUtils; /**  * 声明式事务示例  * @author ken  */ @Service @Slf4j @RequiredArgsConstructor public class DeclarativeTransactionService {     private final UserMapper userMapper;     /**      * 声明式事务：修改用户信息      * 事务属性：默认传播行为REQUIRED，默认回滚RuntimeException      * @param userId 用户ID      * @param newUserName 新用户名      */     @Transactional(rollbackFor = Exception.class) // 指定所有异常都回滚     public void updateUserName(String userId, String newUserName) {         // 参数校验         if (!StringUtils.hasText(userId, "用户ID不能为空") || !StringUtils.hasText(newUserName, "新用户名不能为空")) {             throw new IllegalArgumentException("用户ID或新用户名不能为空");         }         // 1. 查询用户         LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();         queryWrapper.eq(User::getUserId, userId);         User user = userMapper.selectOne(queryWrapper);         if (user == null) {             throw new RuntimeException("用户不存在，用户ID：" + userId);         }         // 2. 修改用户名         user.setUserName(newUserName);         userMapper.updateById(user);         log.info("修改用户{}的用户名为：{}", userId, newUserName);         // 模拟异常（测试事务回滚）         // if (true) {         //     throw new RuntimeException("模拟修改用户信息异常");         // }     } } 

6.4 Spring AOP vs AspectJ

核心差异总结

1. 增强机制本质不同：Spring AOP是“运行时增强”，基于动态代理；AspectJ是“编译期/类加载期增强”，基于字节码织入；
2. 功能完备性不同：AspectJ功能更强大，支持更多增强点；Spring AOP聚焦方法增强，满足大部分业务需求；
3. 易用性不同：Spring AOP集成简单，无需额外编译工具；AspectJ需额外配置编译器（如ajc），使用成本高；
4. 性能不同：AspectJ编译期织入无运行时开销，性能优于Spring AOP；Spring AOP运行时动态代理有轻微性能损耗，但可忽略不计。

七、Spring 体系结构核心总结

Spring 体系结构的核心是“分层设计+模块化拆分”，围绕“IOC容器”和“AOP”两大核心思想，构建了覆盖核心容器、数据访问、Web开发、测试等全链路的生态体系。

7.1 核心模块依赖关系

1. 核心容器（Core Container）是基础，所有其他模块都依赖于它；
2. AOP模块依赖核心容器，通过IOC容器管理切面和目标对象；
3. 数据访问/集成模块依赖核心容器和AOP，通过AOP实现事务管理；
4. Web模块依赖核心容器和AOP，通过IOC管理Controller、Service等Bean，通过AOP实现拦截器等功能；
5. 测试模块依赖核心容器，提供对Spring Bean的测试支持。

7.2 核心设计思想落地

1. IOC容器：将对象的创建、依赖管理交给Spring，实现“组件解耦”，核心载体是BeanFactory和ApplicationContext；
2. AOP：通过“关注点分离”，将通用功能（日志、事务、权限）从业务代码中抽离，通过动态代理/字节码增强织入业务流程，实现“代码复用”。

7.3 实践选型建议

1. 容器选择：优先使用ApplicationContext（AnnotationConfigApplicationContext/AnnotationConfigServletWebServerApplicationContext），注解驱动开发更高效；
2. 代理选择：默认使用Spring AOP的动态代理，无需手动干预；若目标对象无接口且需增强final方法，可考虑AspectJ；
3. 事务选择：简单业务用声明式事务（@Transactional），复杂业务用编程式事务；
4. 数据访问：整合MyBatis-Plus简化ORM操作，使用HikariCP连接池提升性能；
5. Web开发：Spring MVC用于传统Servlet开发，Spring WebFlux用于响应式开发（高并发场景）。

八、附录：实战项目依赖汇总（pom.xml完整配置）

<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0"          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">     <modelVersion>4.0.0</modelVersion>     <parent>         <groupId>org.springframework.boot</groupId>         <artifactId>spring-boot-starter-parent</artifactId>         <version>3.2.4</version> <!-- Spring Boot最新稳定版本，对应Spring 6.1.5 -->         <relativePath/>     </parent>     <groupId>com.jam.demo</groupId>     <artifactId>spring-system-demo</artifactId>     <version>1.0.0</version>     <name>spring-system-demo</name>     <description>Spring体系结构实战演示项目</description>     <properties>         <java.version>17</java.version>         <lombok.version>1.18.30</lombok.version>         <mybatis-plus.version>3.5.5</mybatis-plus.version>         <fastjson2.version>2.0.45</fastjson2.version>         <guava.version>33.2.1-jre</guava.version>         <swagger.version>3.0.0</swagger.version>         <cglib.version>3.3.0</cglib.version>     </properties>     <dependencies>         <!-- Spring Boot核心依赖 -->         <dependency>             <groupId>org.springframework.boot</groupId>             <artifactId>spring-boot-starter</artifactId>         </dependency>         <!-- Spring Web依赖（Spring MVC） -->         <dependency>             <groupId>org.springframework.boot</groupId>             <artifactId>spring-boot-starter-web</artifactId>         </dependency>         <!-- Spring AOP依赖 -->         <dependency>             <groupId>org.springframework.boot</groupId>             <artifactId>spring-boot-starter-aop</artifactId>         </dependency>         <!-- Spring 事务依赖 -->         <dependency>             <groupId>org.springframework.boot</groupId>             <artifactId>spring-boot-starter-jdbc</artifactId>         </dependency>         <!-- Lombok -->         <dependency>             <groupId>org.projectlombok</groupId>             <artifactId>lombok</artifactId>             <version>${lombok.version}</version>             <scope>provided</scope>         </dependency>         <!-- MyBatis-Plus -->         <dependency>             <groupId>com.baomidou</groupId>             <artifactId>mybatis-plus-boot-starter</artifactId>             <version>${mybatis-plus.version}</version>         </dependency>         <!-- MySQL驱动 -->         <dependency>             <groupId>com.mysql</groupId>             <artifactId>mysql-connector-j</artifactId>             <scope>runtime</scope>         </dependency>         <!-- FastJSON2 -->         <dependency>             <groupId>com.alibaba.fastjson2</groupId>             <artifactId>fastjson2</artifactId>             <version>${fastjson2.version}</version>         </dependency>         <!-- Google Guava -->         <dependency>             <groupId>com.google.guava</groupId>             <artifactId>guava</artifactId>             <version>${guava.version}</version>         </dependency>         <!-- Swagger3 -->         <dependency>             <groupId>io.springfox</groupId>             <artifactId>springfox-boot-starter</artifactId>             <version>${swagger.version}</version>         </dependency>         <!-- CGLIB -->         <dependency>             <groupId>cglib</groupId>             <artifactId>cglib</artifactId>             <version>${cglib.version}</version>         </dependency>         <!-- 测试依赖 -->         <dependency>             <groupId>org.springframework.boot</groupId>             <artifactId>spring-boot-starter-test</artifactId>             <scope>test</scope>         </dependency>     </dependencies>     <build>         <plugins>             <!-- Spring Boot Maven插件 -->             <plugin>                 <groupId>org.springframework.boot</groupId>                 <artifactId>spring-boot-maven-plugin</artifactId>                 <configuration>                     <excludes>                         <exclude>                             <groupId>org.projectlombok</groupId>                             <artifactId>lombok</artifactId>                         </exclude>                     </excludes>                 </configuration>             </plugin>             <!-- Java编译插件 -->             <plugin>                 <groupId>org.apache.maven.plugins</groupId>                 <artifactId>maven-compiler-plugin</artifactId>                 <version>3.8.1</version>                 <configuration>                     <source>${java.version}</source>                     <target>${java.version}</target>                     <encoding>UTF-8</encoding>                 </configuration>             </plugin>         </plugins>     </build> </project> 

总结

Spring 体系结构并非孤立的模块堆砌，而是以“IOC容器”为核心、以“AOP”为扩展手段，层层递进、相互支撑的完整生态。理解Spring体系结构，关键在于抓住“IOC解耦”和“AOP复用”两大核心思想，明确各模块的定位和依赖关系。