Java AOP编程

原创 于 2025-07-23 22:32:09 发布 · 936 阅读 · 26 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言

切面编程（AOP）详解

切面编程（Aspect-Oriented Programming，AOP） 是一种编程范式，旨在将横切关注点（如日志、事务、安全等）从核心业务逻辑中分离，通过模块化的方式实现代码复用和解耦。

AOP 核心概念
  1. 切面（Aspect）：封装横切关注点的模块（如日志模块）
  2. 连接点（Join Point）：程序执行过程中的点（如方法调用）
  3. 切点（Pointcut）：匹配连接点的表达式（定义哪些方法需要增强）
  4. 通知（Advice）：切面在连接点执行的动作
    • @Before：方法执行前
    • @After：方法执行后（无论是否异常）
    • @AfterReturning：方法正常返回后
    • @AfterThrowing：方法抛出异常后
    • @Around：包裹方法执行（最强大）
  5. 织入（Weaving）：将切面应用到目标对象的过程

下面是一个完整的 Spring AOP 示例，包含正确的 Maven 依赖和完整的包导入：

Maven 配置 (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>

    <groupId>com.example</groupId>
    <artifactId>aop-demo</artifactId>
    <version>1.0.0</version>
    
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.0</version>
    </parent>
    
    <dependencies>
        <!-- Spring AOP 核心依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        
        <!-- 其他必要依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

完整的切面实现 (包含所有导入)

1. 业务服务类
package com.example.service;

import org.springframework.stereotype.Service;

@Service
public class PaymentService {
    
    public String processPayment(String userId, double amount) {
        System.out.println("处理支付: " + userId + " 金额: " + amount);
        // 模拟业务逻辑
        if (amount > 1000) {
            throw new RuntimeException("支付金额超过限额");
        }
        return "支付成功: " + amount;
    }
    
    public String refundPayment(String transactionId) {
        System.out.println("处理退款: " + transactionId);
        return "退款成功: " + transactionId;
    }
}
2. 切面类 (包含完整导入)
package com.example.aspect;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

@Aspect
@Component
public class PaymentAspect {
    
    // 定义切点：匹配 PaymentService 的所有方法
    @Pointcut("execution(* com.example.service.PaymentService.*(..))")
    public void paymentOperations() {}
    
    // 方法执行前通知
    @Before("paymentOperations()")
    public void logMethodCall(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        String args = Arrays.toString(joinPoint.getArgs());
        System.out.println("[日志] 调用方法: " + methodName + " | 参数: " + args);
    }
    
    // 方法返回后通知
    @AfterReturning(pointcut = "paymentOperations()", returning = "result")
    public void logReturn(JoinPoint joinPoint, Object result) {
        System.out.println("[日志] 方法返回: " + result);
    }
    
    // 异常通知
    @AfterThrowing(pointcut = "paymentOperations()", throwing = "ex")
    public void logException(JoinPoint joinPoint, Exception ex) {
        System.out.println("[错误] 方法异常: " + ex.getMessage());
    }
    
    // 环绕通知：性能监控
    @Around("paymentOperations()")
    public Object monitorPerformance(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        String methodName = joinPoint.getSignature().getName();
        
        try {
            // 执行目标方法
            Object result = joinPoint.proceed();
            return result;
        } finally {
            long duration = System.currentTimeMillis() - startTime;
            System.out.println("[监控] " + methodName + " 执行耗时: " + duration + "ms");
        }
    }
    
    // 安全校验切面
    @Before("execution(* com.example.service.PaymentService.processPayment(..)) && args(userId, amount)")
    public void checkSecurity(JoinPoint joinPoint, String userId, double amount) {
        if (!userId.startsWith("user_")) {
            throw new SecurityException("非法用户ID格式");
        }
        System.out.println("[安全] 用户验证通过: " + userId);
    }
}
3. 主应用类
package com.example;

import com.example.service.PaymentService;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class AopDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(AopDemoApplication.class, args);
    }

    @Bean
    public CommandLineRunner demo(PaymentService paymentService) {
        return args -> {
            System.out.println("===== 正常支付测试 =====");
            paymentService.processPayment("user_123", 500.0);
            
            System.out.println("\n===== 退款测试 =====");
            paymentService.refundPayment("txn_789");
            
            System.out.println("\n===== 异常支付测试 =====");
            try {
                paymentService.processPayment("user_456", 1500.0);
            } catch (Exception e) {
                System.out.println("捕获异常: " + e.getMessage());
            }
            
            System.out.println("\n===== 安全测试 =====");
            try {
                paymentService.processPayment("invalid_id", 200.0);
            } catch (Exception e) {
                System.out.println("安全拦截: " + e.getMessage());
            }
        };
    }
}

输出结果示例

===== 正常支付测试 =====
[日志] 调用方法: processPayment | 参数: [user_123, 500.0]
[安全] 用户验证通过: user_123
处理支付: user_123 金额: 500.0
[日志] 方法返回: 支付成功: 500.0
[监控] processPayment 执行耗时: 15ms

===== 退款测试 =====
[日志] 调用方法: refundPayment | 参数: [txn_789]
处理退款: txn_789
[日志] 方法返回: 退款成功: txn_789
[监控] refundPayment 执行耗时: 5ms

===== 异常支付测试 =====
[日志] 调用方法: processPayment | 参数: [user_456, 1500.0]
[安全] 用户验证通过: user_456
处理支付: user_456 金额: 1500.0
[错误] 方法异常: 支付金额超过限额
[监控] processPayment 执行耗时: 8ms
捕获异常: 支付金额超过限额

===== 安全测试 =====
[日志] 调用方法: processPayment | 参数: [invalid_id, 200.0]
[监控] processPayment 执行耗时: 0ms
安全拦截: 非法用户ID格式

AOP实现

  1. 切点表达式详解：

    • execution(* com.example.service.PaymentService.*(..))
      • *：任意返回类型
      • com.example.service.PaymentService：目标类
      • .*：所有方法
      • (..)：任意参数

  2. 参数绑定：

    @Before("execution(* processPayment(..)) && args(userId, amount)")
public void checkSecurity(String userId, double amount) {
    // 直接使用方法的参数
}

  3. 通知类型组合：

    • @Before：方法执行前（参数校验）
    • @AfterReturning：成功返回后（日志记录）
    • @AfterThrowing：异常时（错误处理）
    • @Around：包裹整个方法（性能监控）

  4. 执行顺序：

    1. Around 开始
2. Before
3. 目标方法执行
4. AfterReturning/AfterThrowing
5. Around 结束

关键点解析

一、整体架构

主应用 AopDemoApplication
PaymentService 业务类
PaymentAspect 切面类
切点定义
前置通知
返回通知
异常通知
环绕通知
参数化通知

二、核心组件详解

1. 切面类 (PaymentAspect)
@Aspect  // 声明这是一个切面
@Component  // 让Spring管理这个Bean
public class PaymentAspect {
    // 切点定义
    @Pointcut("execution(* com.example.service.PaymentService.*(..))")
    public void paymentOperations() {}
    
    // 各种通知类型...
}
2. 切点表达式解析
@Pointcut("execution(* com.example.service.PaymentService.*(..))")
  • execution: 匹配方法执行连接点
  • *: 任意返回类型
  • com.example.service.PaymentService: 目标类
  • .*: 所有方法
  • (..): 任意参数

三、五种通知类型详解

1. 前置通知 (@Before)
@Before("paymentOperations()")
public void logMethodCall(JoinPoint joinPoint) {
    // 获取方法信息
    String methodName = joinPoint.getSignature().getName();
    // 获取参数
    String args = Arrays.toString(joinPoint.getArgs());
    System.out.println("[日志] 调用方法: " + methodName + " | 参数: " + args);
}
  • 作用：方法执行前记录日志
  • 获取信息：
    • joinPoint.getSignature().getName(): 方法名
    • joinPoint.getArgs(): 方法参数
2. 返回通知 (@AfterReturning)
@AfterReturning(pointcut = "paymentOperations()", returning = "result")
public void logReturn(JoinPoint joinPoint, Object result) {
    System.out.println("[日志] 方法返回: " + result);
}
  • 作用：方法正常返回后记录结果
  • 关键参数：
    • returning = "result": 绑定返回值
    • Object result: 接收返回值
3. 异常通知 (@AfterThrowing)
@AfterThrowing(pointcut = "paymentOperations()", throwing = "ex")
public void logException(JoinPoint joinPoint, Exception ex) {
    System.out.println("[错误] 方法异常: " + ex.getMessage());
}
  • 作用：方法抛出异常时记录错误
  • 关键参数：
    • throwing = "ex": 绑定异常对象
    • Exception ex: 接收异常实例
4. 环绕通知 (@Around)
@Around("paymentOperations()")
public Object monitorPerformance(ProceedingJoinPoint joinPoint) throws Throwable {
    long startTime = System.currentTimeMillis();
    String methodName = joinPoint.getSignature().getName();
    
    try {
        // 执行目标方法
        Object result = joinPoint.proceed();
        return result;
    } finally {
        // 无论成功失败都执行
        long duration = System.currentTimeMillis() - startTime;
        System.out.println("[监控] " + methodName + " 执行耗时: " + duration + "ms");
    }
}
  • 作用：方法执行性能监控
  • 关键特性：
    • ProceedingJoinPoint: 可控制目标方法执行
    • joinPoint.proceed(): 执行目标方法
    • finally块确保始终记录耗时
5. 参数化通知 (带条件的前置通知)
@Before("execution(* processPayment(..)) && args(userId, amount)")
public void checkSecurity(JoinPoint joinPoint, String userId, double amount) {
    if (!userId.startsWith("user_")) {
        throw new SecurityException("非法用户ID格式");
    }
    System.out.println("[安全] 用户验证通过: " + userId);
}
  • 作用：特定方法的参数校验
  • 关键特性：
    • args(userId, amount): 直接绑定方法参数
    • 可访问具体参数值进行业务逻辑
    • 可抛出异常中断方法执行

四、执行流程分析

ClientProxyAspectTarget调用业务方法执行环绕通知(前半部分)记录开始时间执行前置通知日志/安全检查执行目标方法返回结果/抛出异常执行返回通知记录返回结果执行异常通知记录异常信息alt[正常返回][发生异常]执行环绕通知(后半部分)计算执行耗时返回最终结果ClientProxyAspectTarget

五、核心设计思想

1. 关注点分离 (Separation of Concerns)
  • 业务逻辑：PaymentService 只处理支付核心逻辑
  • 横切关注点：
    • 日志记录 → logMethodCall()
    • 性能监控 → monitorPerformance()
    • 安全控制 → checkSecurity()
    • 异常处理 → logException()
2. 非侵入式设计
  • 业务类无需修改：PaymentService 完全不知道切面的存在
  • 解耦：新增日志/监控功能不需改动业务代码
3. 声明式编程
  • 通过注解声明：而非硬编码
  • 集中管理：所有横切逻辑在切面中统一维护
4. 动态织入
  • 运行时代理：Spring 动态创建代理对象
  • 灵活组合：通过切点表达式控制织入位置

六、关键实现细节

1. 参数绑定技巧
// 精确绑定特定方法的参数
@Before("execution(* processPayment(..)) && args(userId, amount)")
public void checkSecurity(String userId, double amount) { ... }
2. 异常处理策略
@Around("paymentOperations()")
public Object monitorPerformance(ProceedingJoinPoint joinPoint) throws Throwable {
    try {
        return joinPoint.proceed(); // 执行目标方法
    } finally { // 确保总是执行耗时计算
        // 无论成功失败都记录
    }
}
3. 切点复用
// 定义公共切点
@Pointcut("execution(* com.example.service.PaymentService.*(..))")
public void paymentOperations() {}

// 多个通知复用同一切点
@Before("paymentOperations()")
@AfterReturning(pointcut = "paymentOperations()", ...)

七、实际输出解析

正常支付场景：
[日志] 调用方法: processPayment | 参数: [user_123, 500.0]
[安全] 用户验证通过: user_123
处理支付: user_123 金额: 500.0
[日志] 方法返回: 支付成功: 500.0
[监控] processPayment 执行耗时: 15ms
  1. 前置通知记录方法和参数
  2. 安全校验通过
  3. 执行业务逻辑
  4. 返回通知记录结果
  5. 环绕通知记录耗时
异常场景：
[日志] 调用方法: processPayment | 参数: [user_456, 1500.0]
[安全] 用户验证通过: user_456
处理支付: user_456 金额: 1500.0
[错误] 方法异常: 支付金额超过限额
[监控] processPayment 执行耗时: 8ms
  1. 前置通知和安全校验正常执行
  2. 业务方法抛出异常
  3. 异常通知捕获并记录
  4. 环绕通知仍执行耗时计算
安全拦截场景：
[日志] 调用方法: processPayment | 参数: [invalid_id, 200.0]
[监控] processPayment 执行耗时: 0ms
安全拦截: 非法用户ID格式
  1. 前置通知执行
  2. 安全校验抛出异常
  3. 业务方法未执行
  4. 直接进入异常处理
  5. 环绕通知仍执行（但耗时≈0）

八、最佳实践建议

  1. 切点命名规范：使用有意义的名称如 serviceLayer(), daoOperations()
  2. 表达式优化：避免过于宽泛的切点（如 execution(* *.*(..))）
  3. 通知顺序控制：使用 @Order 注解管理多个切面的执行顺序
  4. 性能考量：
    • 环绕通知中避免重操作
    • 生产环境移除调试日志
  5. 组合使用：
    @Around("transactionalOps()")
@Transactional(propagation = Propagation.REQUIRED)
public Object manageTransaction(ProceedingJoinPoint pjp) {...}

实际应用场景：

  • 安全控制：在方法执行前验证权限
  • 性能监控：测量方法执行时间
  • 事务管理：统一的事务处理
  • 日志记录：自动化的操作日志
  • 异常处理：统一异常处理机制
  • 缓存管理：自动缓存结果

最佳实践：将横切关注点（如日志、安全、事务）与业务逻辑分离，保持业务代码的纯净性，提高代码的可维护性和复用性。

Java切面编程（AOP）深度解析：原理、应用与最佳实践
m0_37825219的博客
03-01 1015
Java切面编程（AOP）深度解析：原理、应用与最佳实践
【JAVA基础】AOP详解
qq_54065582的博客
08-05 3071
AOP（Aspect OrientedProgramming）：面向切面编程，面向切面编程（也叫面向方面编程），是目前软件开发中的一个热点，也是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
java面向切面编程
03-26
NULL 博文链接：https://zhaoshijie.iteye.com/blog/1179594
Java--Spring之AOP面向切面编程
MinggeQingchun的博客
08-13 2357
一、JDK动态代理 具体可参考之前博文Java--JDK动态代理(AOP) 在这里只做简单说明 动态代理是指代理类在程序运行时进行创建的代理方式。这种情况下，代理类并不是在Java代码中定义的，而是在运行时根据Java代码中的“指示”动态生成的。（动态代理中的代理类并不要求在编译期就确定，而是可以在运行期动态生成，从而实现对目标对象的代理功能） 相比于静态代理，动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类的函数 动态代理又分为两种方式 （1）JDK动态代...
Java 面向切面编程（Aspect Oriented Programming，AOP）
weixin_34301132的博客
03-17 297
本文内容 实例 引入 原始方法 装饰者模式 JDK 动态代理和 cglib 代理 直接使用 AOP 框架——AspectWerkz 最近跳槽了，新公司使用了 AOP 相关的技术，于是查点资料，复习一下。之前，多少知道点，但没怎么在实际项目中使用过~ 下载 demo 实例 引入 ...
Java中的面向切面编程（AOP）
热门推荐
pedro7k的博客
04-03 2万+
一、什么是AOP？ Aspect Oriented Programming ，即面向切面编程。 AOP是对面向对象编程的一个补充。 它的目的是将复杂的需求分解为不同的切面，将散布在系统中的公共功能集中解决。 它的实际含义是在运行时将代码切入到类的指定方法、指定位置上，将不同方法的同一个位置抽象为一个切面对象，并对该对象进行编程。 下面是AOP的一个示意图 二、AOP的优点和一些概念 1、AOP的优点 降低模块之间的耦合度 使系统更容易扩展 更好的代码复用 非业务代码更加集中，不分散，便于统一管理
深入解析Spring AOP源码：从原理到实现，全方位掌握Java AOP编程精髓
12-13
Spring AOP，全称为Spring的面向切面编程，是Spring框架的重要组成部分，旨在实现关注点的分离，提高代码的可维护性和...对于那些需要更高级功能或对性能有更高要求的项目，可以考虑使用AspectJ进行更深入的AOP编程。
Java中的AOP编程：AspectJ与Spring AOP的应用
聚娃科技开发者博客
06-29 924
面向方面编程（AOP, Aspect-Oriented Programming）是一种编程范式，旨在将横切关注点（如日志记录、事务管理、性能监控等）与业务逻辑分离。AOP通过在运行时动态地将这些横切关注点织入到程序中，从而减少代码的重复，提高代码的可维护性。AspectJ是一个功能强大的AOP框架，它提供了基于注解和XML的配置方式，使得AOP编程更加灵活和易用。下面我们通过一个简单的示例来了解AspectJ的基本用法。Spring AOP是Spring框架提供的AOP实现，主要用于简化AOP编程。
Java中AOP编程实现.rar
07-09
Java中的AOP（Aspect ...通过这些知识点，你可以理解并实现Java中的AOP编程，有效地管理和组织代码，提高软件的模块化程度。在实际项目中，AOP能够帮助你更好地管理横切关注点，让代码更加整洁，更易于测试和维护。
编程语言+JAVAspring+AOP编程+面向切面
03-01
编程语言+JAVAspring+AOP编程+面向切面**：这是一个关于JAVAspring编程语言的AOP编程的面向切面的资源，适合有一定JAVAspring基础的开发者。它介绍了JAVAspring的AOP编程的概念、原理和作用，以及如何使用JAVAspring...
JAVA简单AOP切面编程；依赖注入；代码配置Bean源码
10-07
JAVA简单AOP切面编程；依赖注入；代码配置Bean源码 JAVA简单AOP切面编程；依赖注入；代码配置Bean源码
Java基础之面向切面编程（AOP）
qq_53350943的博客
02-19 1619
Java基础之面向切面编程（AOP）面向切面编程中，切面就是可以加入到源功能位置中的代码。
Java的AOP切面编程之快速入门案例(保姆级教程)
最新发布
Logic-Driven Thought Engineering
08-16 1922
保姆的Java的AOP切面编程快速入门案例。
面向切面编程——java
Leesire的专栏
08-11 1517
-AOP（面向切面编程）- AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用
JAVA切面编程简单实现
pk5201314pk的博客
05-30 433
}/*** 切入点} /*** 增强处理主流程// 获取方法名 String methodName = pjp . getSignature() . getName();// 获取方法所属类 Class <?// 获取方法参数类型 Class <?// 获取方法 Method objMethod = classTarget . getMethod(methodName , par);
Java中的切面编程(AOP)：理论与实践
小李同学的博客
03-07 1161
Java中的切面编程(AOP)：理论与实践
Java切面编程
qq_44031124的博客
03-29 498
3.Spring AOP使用纯java实现，不需要专门的编译过程和类加载器，在运行期间通过代理方式向目标类织入增强的代码。④Advice 通知/增强处理 ： AOP框架在特定的切入点执行的增强处理，即在定义好的切入点处理所要执行的程序代码。⑤Target Object 目标对象：是指所有被通知的对象，也称为被增强的对象。5.Spring 中的aop代理，可以是JDK动态代理，也可以是CGLIB代理。⑥Proxy 代理：将通知应用到目标对象之后，被动态创建的对象。6.Spring的通知类型。
实战探索AspectJ：Java AOP编程指南
AspectJ in Action 是一本由 Ramnivas Laddad 所著的实践性书籍，专注于Java的面向切面编程（AOP）技术。这本书提供了一手的实践经验，帮助读者深入了解AspectJ这一强大的工具在软件开发中的应用和优势。AspectJ是一...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值