UserService方法访问统计

## 1. Spring 进阶：AOP & 声明式事务 ### 1.1 AOP 面向切面编程思维 #### 1.1.1 AOP 主要解决问题 AOP（ Aspect Oriented Programming 面向切面编程）是对 OOP（ Object Oriented Programming 面向对象编程）的补充，核心解决**业务逻辑与非业务逻辑耦合、重复代码冗余**的问题，以下结合开发场景说明： **核心问题 1：**非业务逻辑散落在业务代码中，耦合严重 **场景**：用户管理模块（UserService）的`login`/`saveUser`/`updateUserById`等业务方法，都需要加「权限校验」「事务控制」逻辑。 - 无 AOP 时：需在每个业务方法内手动编写日志、权限、事务代码，业务方法既包含核心业务（如登录校验、新增用户），又混杂非业务逻辑； - 有 AOP 时：将日志、权限、事务等 “横切逻辑” 抽离成独立的「切面」，无需修改业务方法代码，自动织入到目标方法中。 **核心问题 2：重复代码冗余，维护成本高** **场景**：10 个业务 Service 的方法都需要打印 “方法入参 / 出参日志”。 - 无 AOP 时：需在 10 个 Service 的所有方法中重复编写日志代码，后续修改日志格式（如新增打印时间），需逐个修改所有方法； - 有 AOP 时：仅需在切面中编写一次日志逻辑，通过 “切入点” 指定要增强的方法，所有目标方法自动复用该逻辑，修改仅需改切面。 **核心价值总结** | 无 AOP 的问题 | AOP 的解决方案 | | ---------------------------- | --------------------------------------- | | 业务与非业务逻辑耦合 | 抽离非业务逻辑为 “切面”，与业务代码解耦 | | 重复代码冗余 | 切面逻辑一次编写，多处复用 | | 非业务逻辑修改需改动业务代码 | 仅修改切面，不影响核心业务代码 | 一句话总结：**AOP 可以把业务代码里重复的非核心功能（如日志、事务）抽出来，在不改动业务代码的前提下动态加到目标方法里。** #### 1.1.2 AOP 底层依赖的技术 ##### 1.1.2.1 代理模式 ###### ① 介绍代理模式，是二十三种设计模式中的一种，属于结构型模式。它的作用就是通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用。让不属于目标方法核心逻辑的代码从目标方法中剥离出来——解耦。调用目标方法时先调用代理对象的方法，减少对目标方法的调用和打扰，同时让附加功能能够集中在一起也有利于统一维护。 ./images

使用代理后：

###### ② 生活中的代理 - 广告商找大明星拍广告需要经过经纪人 - 合作伙伴找大老板谈合作要约见面时间需要经过秘书 - 房产中介是买卖双方的代理 - 太监是大臣和皇上之间的代理 ###### ③ 相关术语 - 代理：将非核心逻辑剥离出来以后，封装这些非核心逻辑的类、对象、方法。 - 目标：被代理“套用”了非核心逻辑代码的类、对象、方法，负责封装核心业务。 ##### 1.1.2.2 静态代理生活小案例：你有一套房子要出租，为了省却找租客、核验身份、签合同、收房租这些繁琐事，**你专门招了一个固定的中介，作为你这套房子的专属代理**。所有租房相关的对接工作，都由这个中介全权帮你处理，他只服务你这一套房源的出租业务。 ```java // ========== 1. 业务接口（规范核心方法） ========== interface UserService { // 核心业务方法：登录校验 boolean login(String username, String password); } // ========== 2. 真实实现类（目标类：只做核心业务） ========== public class UserServiceImpl implements UserService { // 仅实现核心登录逻辑，无任何非业务代码 @Override public boolean login(String username, String password) { System.out.println("UserServiceImpl - login username=" + username + " password=" + password); // 核心业务：判断账号密码是否正确 return "admin".equals(username) && "123456".equals(password); } } // ========== 3. 静态代理类（替目标类执行，加增强逻辑） ========== public class UserServiceStaticProxy implements UserService { // 持有目标对象（代理的核心：关联真实业务类） private UserService target = new UserServiceImpl(); // 代理目标方法，包裹增强逻辑 @Override public boolean login(String username, String password) { // 增强逻辑1：方法执行前（如打印入参日志） System.out.println("Before login: username = " + username); // 调用真实目标类的核心方法 boolean result = target.login(username, password); // 增强逻辑2：方法执行后（如打印结果日志） System.out.println("After login: result = " + result); return result; } } // ========== 4. 测试调用（仅接触代理类，不直接调目标类） ========== public class TestStaticProxy { public static void main(String[] args) { // 创建代理对象（而非直接new UserServiceImpl） UserService proxy = new UserServiceStaticProxy(); // 调用代理方法（自动触发增强+核心业务） proxy.login("admin", "123456"); } } ``` 静态代理确实实现了解耦，但是由于代码都写死了，完全不具备任何的灵活性。就拿日志功能来说，将来其他地方也需要附加日志，那还得再声明更多个静态代理类，那就产生了大量重复的代码，日志功能还是分散的，没有统一管理。提出进一步的需求：将日志功能集中到一个代理类中，将来有任何日志需求，都通过这一个代理类来实现。这就需要使用动态代理技术了。 ##### 1.1.2.3 动态代理生活小案例：你有房子要出租，没有特意找某个固定的中介，而是直接联系了**我爱我家、链家这类大型房产平台**。你不用管具体是谁来帮你办事，平台会根据你的房源位置、租客需求、当前中介的忙碌程度，**动态为你匹配最合适的中介人员**处理租房事宜；等下次你有另一套房子要出租，平台可能会根据当时的情况，给你分配另一位更合适的中介。你只需要对接平台，具体的代理人员由平台按需生成、动态分配 —— 这就是动态代理。动态代理是 AOP（面向切面编程）的核心底层技术，与静态代理的核心区别是：**无需手动编写代理类，程序运行时由 JVM 自动生成代理类**，一个通用的增强逻辑可适配多个目标类，是 Spring AOP 的默认实现方式。动态代理主要分为两种类型： 1. **JDK 动态代理**：基于接口实现，要求目标类必须实现至少一个接口； 2. **CGLIB 动态代理**：基于继承实现，无需目标类实现接口，直接继承目标类生成代理对象。 ###### ① JDK 动态代理（基于接口）核心特点 - 依赖接口：目标类必须实现接口，代理类与目标类实现相同接口； - 核心 API：`java.lang.reflect.Proxy`（生成代理对象）、`InvocationHandler`（定义增强逻辑）； - 适用场景：目标类实现了业务接口（开发中最常见，如 Service 接口）。极简伪代码： ```java // ========== 1. 业务接口（JDK动态代理必须依赖接口） ========== interface UserService { boolean login(String username, String password); } // ========== 2. 目标类（实现接口，仅做核心业务） ========== public class UserServiceImpl implements UserService { @Override public boolean login(String username, String password) { // 核心业务：登录校验 return "admin".equals(username) && "123456".equals(password); } } // ========== 3. JDK动态代理核心：通用增强逻辑 + 生成代理 ========== public class JdkDynamicProxyDemo { public static void main(String[] args) { // 步骤1：创建目标对象 UserService target = new UserServiceImpl(); // 步骤2：生成动态代理对象（运行时自动创建代理类，无需手动写） UserService proxy = (UserService) Proxy.newProxyInstance( target.getClass().getClassLoader(), // 类加载器 target.getClass().getInterfaces(), // 目标类实现的接口（核心） (proxyObj, method, argsArr) -> { // 增强逻辑（InvocationHandler） // 增强逻辑1：方法执行前（如打印日志） System.out.println("Before " + method.getName() + ": " + argsArr[0]); // 调用目标类的核心方法 Object result = method.invoke(target, argsArr); // 增强逻辑2：方法执行后（如打印结果） System.out.println("After " + method.getName() + ": " + result); return result; } ); // 步骤3：调用代理方法（自动触发增强+核心业务） proxy.login("admin", "123456"); } } ``` ###### ② CGLIB 动态代理（基于继承）核心特点 - 无需接口：直接继承目标类生成代理，目标类可无任何接口； - 核心 API：`Enhancer`（生成代理对象）、`MethodInterceptor`（定义增强逻辑）； - 适用场景：目标类未实现任何接口（如自定义工具类）。导包： ```xml cglib cglib 3.3.0 ``` 测试代码： ```java // ========== 1. 目标类（无需实现接口，仅做核心业务） ========== class UserService { public boolean login(String username, String password) { // 核心业务：登录校验 return "admin".equals(username) && "123456".equals(password); } } // ========== 2. CGLIB动态代理核心：通用增强逻辑 + 生成代理 ========== import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; public class CglibDynamicProxyDemo { public static void main(String[] args) { // 步骤1：创建目标对象 UserService target = new UserService(); // 步骤2：生成动态代理对象（运行时自动创建代理类，继承目标类） UserService proxy = (UserService) Enhancer.create( UserService.class, // 目标类的Class对象（核心：继承目标类） (MethodInterceptor) (proxyObj, method, argsArr, methodProxy) -> { // 增强逻辑1：方法执行前（如打印日志） System.out.println("Before " + method.getName() + ": " + argsArr[0]); // 调用目标类的核心方法 Object result = methodProxy.invoke(target, argsArr); // 增强逻辑2：方法执行后（如打印结果） System.out.println("After " + method.getName() + ": " + result); return result; } ); // 步骤3：调用代理方法（自动触发增强+核心业务） proxy.login("admin", "123456"); } } ``` ``` Unable to make protected final java.lang.Class java.lang.ClassLoader.defineClass(...) accessible: module java.base does not "opens java.lang" to unnamed module 关键机制：从 Java 9 开始引入的模块系统（JPMS）对反射做了严格限制。具体表现：CGLIB 尝试通过反射调用 ClassLoader.defineClass() 方法来动态生成类，但该方法属于 java.lang 包且未被暴露给“未命名模块”（即你的普通 Java 项目）。添加 JVM 启动参数（最直接有效）: --add-opens java.base/java.lang=ALL-UNNAMED ``` ###### ③ 核心总结 | 特性 | JDK 动态代理 | CGLIB 动态代理 | | --------------- | ------------------------- | ---------------------------- | | 依赖条件 | 目标类必须实现接口 | 目标类无需实现接口 | | 实现方式 | 实现与目标类相同的接口 | 继承目标类 | | 核心 API | Proxy + InvocationHandler | Enhancer + MethodInterceptor | | Spring AOP 适配 | 目标类有接口时默认使用 | 目标类无接口时自动切换使用 | #### 1.1.3 AOP 核心概念介绍 ##### 1.1.3.1 核心概念 AOP（Aspect Oriented Programming，面向切面编程）是 OOP（Object Oriented Programming，面向对象编程）的**补充与完善**。 OOP 通过封装、继承、多态构建纵向的对象层次结构，专注于实现业务模块的核心功能，但它不擅长处理**横向的公共逻辑**。比如日志记录、权限校验、异常处理这类功能，往往需要嵌入到多个业务对象中，与核心业务无关却重复出现，既造成代码冗余，又提升了模块间的耦合度，不利于复用和维护。 AOP 则恰恰解决这一痛点，它利用**横切技术**，将这些分散在各处的非核心公共逻辑，封装成独立可重用的模块 —— 也就是**切面（Aspect）**。借助 AOP，我们可以在**不修改原有业务代码**的前提下，将切面逻辑动态 “织入” 到目标业务方法中，以此减少重复代码、降低模块耦合，提升系统的可维护性与扩展性。 ##### 1.1.3.2 AOP 涉及核心名词 * 横切关注点从每个方法中抽取出来的同一类非核心业务。在同一个项目中，我们可以使用多个横切关注点对相关方法进行多个不同方面的增强。这个概念不是语法层面天然存在的，而是根据附加功能的逻辑上的需要：有十个附加功能，就有十个横切关注点 AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证、日志、事务、异常等。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。

* 通知(增强) 每一个横切关注点上要做的事情都需要写一个方法来实现，这样的方法就叫通知方法。 * 前置通知：在被代理的目标方法前执行 * 返回通知：在被代理的目标方法成功结束后执行（**寿终正寝**） * 异常通知：在被代理的目标方法异常结束后执行（**死于非命**） * 后置通知：在被代理的目标方法最终结束后执行（**盖棺定论**） * 环绕通知：使用try...catch...finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置

* 连接点 joinpoint 这也是一个纯逻辑概念，不是语法定义的。指那些被拦截到的点。在 Spring 中，可以被动态代理拦截目标类的方法

* 切入点 pointcut 定位连接点的方式，或者可以理解成被选中的连接点！是一个表达式，比如execution(\* com.spring.service.impl.*.*(..))。符合条件的每个方法都是一个具体的连接点。 * 切面 aspect 切入点和通知的结合。是一个类。

* 目标 target 被代理的目标对象 * 代理 proxy 向目标对象应用通知之后创建的代理对象 * 织入 weave 指把通知应用到目标上，生成代理对象的过程。可以在编译期织入，也可以在运行期织入，Spring采用后者。 ##### 1.1.3.3 Spring AOP梳理和底层技术组成 1. AOP一种区别于OOP的编程思维，用来完善和解决OOP的非核心代码冗余和不方便统一维护问题！ 2. 代理技术（动态代理|静态代理）是实现AOP思维编程的具体技术，但是自己使用动态代理实现代码比较繁琐！ 3. Spring AOP 框架，基于 AOP 编程思维，封装动态代理技术，简化动态代理技术实现的框架！Spring AOP 内部帮助我们实现动态代理，我们只需写少量的配置，指定生效范围即可，即可完成面向切面思维编程的实现！注意：AspectJ：早期的 AOP 实现框架，Spring AOP 借用了 AspectJ 中的 AOP 注解。

#### 1.1.4 AOP快速体验 ##### ① 加入依赖在 IoC 测试工程环境的基础上，额外再增加下面依赖： ```xml org.springframework.boot spring-boot-starter-aop ``` ##### ② 准备被代理的目标资源接口 ```java public interface Calculator { int add(int i, int j); int sub(int i, int j); int mul(int i, int j); int div(int i, int j); } ``` 纯净的实现类在 Spring 下工作，所有的一切都必须放在 IoC 容器中。现在接口的实现类是 AOP 要代理的目标类，所以它也必须放入 IoC 容器。 ```java @Component public class CalculatorPureImpl implements Calculator { @Override public int add(int i, int j) { int result = i + j; System.out.println("方法内部 result = " + result); return result; } @Override public int sub(int i, int j) { int result = i - j; System.out.println("方法内部 result = " + result); return result; } @Override public int mul(int i, int j) { int result = i * j; System.out.println("方法内部 result = " + result); return result; } @Override public int div(int i, int j) { int result = i / j; System.out.println("方法内部 result = " + result); return result; } } ``` ##### ③ 创建切面类 ```java // @Aspect表示这个类是一个切面类 @Aspect // @Component注解保证这个切面类能够放入 IoC 容器 @Component public class LogAspect { // @Before注解：声明当前方法是前置通知方法 // value属性：指定切入点表达式，由切入点表达式控制当前通知方法要作用在哪一个目标方法上 @Before(value = "execution(public int com.atguigu.aop.api.Calculator.add(int,int))") public void printLogBeforeCore() { System.out.println("[AOP前置通知] 方法开始了"); } @AfterReturning(value = "execution(public int com.atguigu.aop.api.Calculator.add(int,int))") public void printLogAfterSuccess() { System.out.println("[AOP返回通知] 方法成功返回了"); } @AfterThrowing(value = "execution(public int com.atguigu.aop.api.Calculator.add(int,int))") public void printLogAfterException() { System.out.println("[AOP异常通知] 方法抛异常了"); } @After(value = "execution(public int com.atguigu.aop.api.Calculator.add(int,int))") public void printLogFinallyEnd() { System.out.println("[AOP后置通知] 方法最终结束了"); } } ``` ##### ④ 测试 ```java @SpringBootTest public class AOPTest { @Autowired private Calculator calculator; @Test public void testAnnotationAOP() { int add = calculator.add(10, 2); System.out.println("方法外部 add = " + add); } } ``` 打印效果如下： > [AOP前置通知] 方法开始了 > 方法内部 result = 12 > [AOP返回通知] 方法成功返回了 > [AOP后置通知] 方法最终结束了 > 方法外部 add = 12 **Spring Boot 2.0+ 配置覆盖问题** 从 Spring Boot 2.0 及以上版本开始，`spring.aop.proxy-target-class` 配置项的默认值为 `true`（即默认启用 CGLIB 代理）。即便你在自定义的 `AppConfig` 配置类中，通过 `@EnableAspectJAutoProxy(proxyTargetClass = false)` 显式指定要使用 JDK 代理，若未通过配置文件覆盖自动配置的 AOP 全局属性，注解中的配置依然会被默认值覆盖，最终导致 JDK 代理无法生效。 **解决方法**：在 `application.properties` 配置文件中显式声明该属性（配置文件的优先级高于注解配置），强制启用 JDK 代理： ```properties # application.properties spring.aop.proxy-target-class=false # 覆盖默认值true，强制有接口时使用JDK动态代理 ``` 即便你已经正确配置 `proxyTargetClass = false`，若目标类满足以下任一条件，Spring 仍会兜底使用 CGLIB 代理（而非预期的 JDK 动态代理）： - 目标类实现的是**非公开的内部接口**（即接口未使用 `public` 修饰）； - 目标类本身已是代理对象（例如项目存在循环依赖，导致 Spring 提前为该类生成了代理）； - 目标类包含 `final` 修饰的方法（尽管 JDK 代理本身不影响 final 方法的执行，但 Spring 会优先选择 CGLIB 代理来兜底处理）。 #### 1.1.5 AOP 细节技术详解 ##### 1.1.5.1 获取目标细节信息 ###### ① JoinPoint接口 org.aspectj.lang.JoinPoint: - 要点1：JoinPoint 接口通过 getSignature() 方法获取目标方法的签名（方法声明时的完整信息） - 要点2：通过目标方法签名对象获取方法名 - 要点3：通过 JoinPoint 对象获取外界调用目标方法时传入的实参列表组成的数组 ```java // @Before注解标记前置通知方法 // value属性：切入点表达式，告诉Spring当前通知方法要套用到哪个目标方法上 // 在前置通知方法形参位置声明一个JoinPoint类型的参数，Spring就会将这个对象传入 // 根据JoinPoint对象就可以获取目标方法名称、实际参数列表 @Before(value = "execution(public int com.atguigu.aop.api.Calculator.add(int,int))") public void printLogBeforeCore(JoinPoint joinPoint) { // 1.通过JoinPoint对象获取目标方法签名对象 // 方法的签名：一个方法的全部声明信息 Signature signature = joinPoint.getSignature(); // 2.通过方法的签名对象获取目标方法的详细信息 String methodName = signature.getName(); System.out.println("methodName = " + methodName); int modifiers = signature.getModifiers(); System.out.println("modifiers = " + modifiers); String declaringTypeName = signature.getDeclaringTypeName(); System.out.println("declaringTypeName = " + declaringTypeName); // 3.通过JoinPoint对象获取外界调用目标方法时传入的实参列表 Object[] args = joinPoint.getArgs(); // 4.由于数组直接打印看不到具体数据，所以转换为List集合 List

05 Web&框架：Spring & Spring Boot 核心进阶