首页 > 编程语言 >Java的AOP切面编程之快速入门案例(保姆级教程)

Java的AOP切面编程之快速入门案例(保姆级教程)

时间：2024-08-16 21:54:43浏览次数：13  
标签：execution Java public 切面 AOP org 执行 方法 example

1. Java中的切面编程（AOP）概述

​ 切面编程（Aspect-Oriented Programming，AOP）是一种编程范式，旨在将那些贯穿于多个模块的横切关注点（如日志记录、安全检查、事务管理）与核心业务逻辑分离开来。通过AOP，我们可以提高代码的模块化程度，减少代码重复，并使代码更加可维护。

概念定义
切面（Aspect）切面是横切关注点的模块化实现，它包含多个通知（Advice）和切入点（Pointcut）。
通知（Advice）通知是在特定连接点（Join Point）上执行的操作。它可以在方法执行前、执行后、抛出异常后或包围整个方法的执行过程。
切入点（Pointcut）切入点是通过（execution）表达式定义的，用于指定在哪些连接点上应用通知。
连接点（Join Point）程序执行的具体点，如方法调用或异常抛出，切入点通常匹配这些连接点。
代理（Proxy）代理是AOP框架生成的对象，负责在目标对象方法调用前后插入通知逻辑。

类比：

切面（Aspect）：影院的自动灯光系统控制电影放映时的灯光。

通知（Advice）：当电影开始时，灯光变暗；电影结束时，灯光变亮。

切入点（Pointcut）：灯光系统只在“电影开始”和“电影结束”这两个时刻进行操作。

连接点（Join Point）：实际发生的时刻，比如电影开场的那一瞬间。

代理（Proxy）：灯光系统自动帮你完成这些操作，你不需要亲自去调节灯光。

2. execution 表达式(定义切入点)

execution表达式用于定义切入点，它指定了在什么方法上应用通知。表达式的结构如下：

execution(修饰符模式? 返回类型模式 声明类型模式? 方法名模式(参数模式) 异常模式?)
部分说明
修饰符模式可选。方法的修饰符，如public、protected。
返回类型模式方法的返回类型，可以是具体类型或*（表示任意类型）。
声明类型模式可选。方法所在的类或接口。
方法名模式方法名称，可以是具体名称或*（表示任意方法）。
参数模式方法的参数列表，可以具体匹配参数类型，或使用..表示任意数量和类型的参数。
异常模式可选。方法可能抛出的异常。
?表示该部分是可选的，而不是必须要包含的。

2.1 匹配特定方法

execution(public void org.example.service.UserService.registerUser(String))

解释：这个表达式匹配UserService类中名为registerUser的方法。该方法必须是public修饰符，返回类型为void，且接受一个String类型的参数。

2.2 匹配包中的所有方法

execution(* org.example.service..*.*(..))

解释：这个表达式匹配com.example.service包及其所有子包中的所有类的所有方法。..表示递归地匹配包及其子包，*.*(..)表示所有类中的所有方法，不论返回类型和参数类型。

2.3 匹配特定类中的所有方法

execution(* org.example.service.UserService.*(..))

解释：这个表达式匹配UserService类中的所有方法，不论方法的返回类型、方法名或参数列表。具体来说，*表示任意返回类型，com.example.service.UserService.*表示UserService类中的所有方法，(..)表示任意数量和类型的参数。

2.4 匹配带有特定参数的方法

execution(* org.example.service.UserService.*(String, ..))

解释：这个表达式匹配UserService类中所有以String作为第一个参数的方法。*表示任意返回类型，UserService.*表示UserService类中的所有方法，(String, ..)表示方法的第一个参数是String类型，后面可以有任意数量和类型的其他参数。

2.5 匹配带有特定返回值的方法

execution(String org.example.service.*.*(..))

解释：这个表达式匹配com.example.service包下所有类中返回类型为String的所有方法。String指定了返回类型，*.*(..)表示匹配所有类中的所有方法，不论方法名和参数类型。

3. Advice（通知）

Advice是切面中定义的实际操作。Spring AOP提供了五种类型的Advice，用于在程序执行的不同阶段插入代码。

3.1 前置通知（Before Advice）

@Before("execution(* org.example.service.UserService.*(..))")
public void logBefore() {
    System.out.println("方法执行前: 准备注册用户");
}

解释：在目标方法执行前执行，用于日志记录、权限检查等。

3.2 后置通知（After Advice）

@After("execution(* org.example.service.UserService.*(..))")
public void logAfter() {
    System.out.println("方法执行后: 用户注册过程完成");
}

解释：在目标方法执行后执行，可以用于释放资源、记录日志等操作。

3.3 返回通知（After Returning Advice）

语法：
@AfterReturning(pointcut = "execution(表达式)", returning = "变量名")
public void 方法名(变量类型 变量名) {
    // 使用返回值的逻辑
}
案例：
@AfterReturning(pointcut = "execution(* org.example.service.UserService.*(..))", returning = "result")
public void logAfterReturning(Object result) {
    System.out.println("方法返回: " + result);
}

解释：在目标方法成功返回结果后执行，可以用于处理返回值、记录返回值日志等操作。

3.4 异常通知（After Throwing Advice）

语法：
@AfterThrowing(pointcut = "execution(表达式)", throwing = "异常变量名")
public void 方法名(异常类型 异常变量名) {
    // 使用异常对象的逻辑
}
案例：
@AfterThrowing(pointcut = "execution(* org.example.service.UserService.*(..))", throwing = "error")
public void logAfterThrowing(Throwable error) {
    System.out.println("方法执行时发生异常: " + error.getMessage());
}

解释：在目标方法抛出异常后执行，可以用于记录异常信息、执行补偿逻辑等操作。

3.5 环绕通知（Around Advice）

@Around("execution(* org.example.service.UserService.*(..))")
public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
    System.out.println("环绕通知: 方法执行前");
    Object result;
    try {
        result = joinPoint.proceed();  // 执行目标方法
    } catch (Throwable throwable) {
        System.out.println("环绕通知: 方法执行时发生异常: " + throwable.getMessage());
        throw throwable;
    }
    System.out.println("环绕通知: 方法执行后");
    return result;
}

解释：包裹目标方法的执行，在方法执行前后都插入逻辑，甚至可以完全控制方法执行。

目标方法：指的是在你的业务代码中实际被AOP切面拦截的方法。**joinPoint.proceed() 是环绕通知中的核心，它决定了目标方法的执行。**如果你不调用 proceed()，目标方法将不会被执行。在调用 proceed() 之前和之后，你可以插入任何自定义的逻辑，这使得环绕通知非常灵活。

4. 简单代码案例

4.1 项目结构

在这里插入图片描述

4.1 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>org.example</groupId>
    <artifactId>aop</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-aop -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
            <version>3.3.2</version>
        </dependency>
    </dependencies>
</project>

4.2 UserService.java (业务逻辑类)

package org.example.service;

import org.springframework.stereotype.Service;

@Service
public class UserService {

    public String registerUser(String username) {
        if (username == null) {
            throw new IllegalArgumentException("用户名不能为空");
        }
        System.out.println("正在注册用户: " + username);
        return "用户 " + username + " 注册成功";
    }
}

4.3 LoggingAspect.java (切面类)

package org.example.aspect;

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

@Aspect
@Component
public class LoggingAspect {

    /**
     * 前置通知 (Before Advice)
     * 这个方法会在目标方法 `registerUser(String)` 执行之前执行。
     * `execution` 表达式指定了要拦截的目标方法。
     */
    @Before("execution(public void org.example.service.UserService.registerUser(String))")
    public void logBefore() {
        System.out.println("方法执行前(Before): 准备注册用户");
    }

    /**
     * 后置通知 (After Advice)
     * 这个方法会在目标方法执行之后执行，无论方法是否成功完成或抛出异常。
     * 这里的 `execution` 表达式匹配 `org.example.service` 包及其子包中的所有方法。
     */
    @After("execution(* org.example.service..*.*(..))")
    public void logAfter() {
        System.out.println("方法执行后(After): 用户注册过程完成");
    }

    /**
     * 返回通知 (After Returning Advice)
     * 这个方法会在目标方法成功返回结果之后执行。
     * `returning` 属性指定了一个参数，用来接收目标方法的返回值。
     * `execution` 表达式匹配 `UserService` 类中的所有方法。
     *
     * @param result 目标方法的返回值
     */
    @AfterReturning(pointcut = "execution(* org.example.service.UserService.*(..))", returning = "result")
    public void logAfterReturning(Object result) {
        System.out.println("方法返回(AfterReturning): " + result);
    }

    /**
     * 异常通知 (After Throwing Advice)
     * 这个方法会在目标方法抛出异常时执行。
     * `throwing` 属性指定了一个参数，用来接收目标方法抛出的异常。
     * `execution` 表达式匹配 `UserService` 类中接受一个 `String` 参数的所有方法。
     *
     * @param error 目标方法抛出的异常
     */
    @AfterThrowing(pointcut = "execution(* org.example.service.UserService.*(String, ..))", throwing = "error")
    public void logAfterThrowing(Throwable error) {
        System.out.println("方法执行时发生异常(AfterThrowing): " + error.getMessage());
    }

    /**
     * 环绕通知 (Around Advice)
     * 这个方法会包裹住目标方法的执行，即在目标方法执行前后都可以插入逻辑。
     * `execution` 表达式匹配 `org.example.service` 包中的所有返回类型为 `String` 的方法。
     *
     * @param joinPoint 提供对目标方法的访问控制
     * @return 目标方法的返回值
     * @throws Throwable 如果目标方法抛出异常，则重新抛出该异常
     */
    @Around("execution(String org.example.service.*.*(..))")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕通知(Around): 方法执行前");
        Object result;
        try {
            // 执行目标方法
            result = joinPoint.proceed();
        } catch (Throwable throwable) {
            System.out.println("环绕通知: 方法执行时发生异常: " + throwable.getMessage());
            throw throwable;  // 重新抛出异常
        }
        System.out.println("环绕通知(Around): 方法执行后");
        return result;  // 返回目标方法的返回值
    }
}

4.3 AopApplication.java（测试类）

package org.example;

import org.example.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class AopApplication implements CommandLineRunner {

    // 自动注入 UserService 实例
    @Autowired
    private UserService userService;

    // 主方法，Spring Boot 应用的入口
    public static void main(String[] args) {
        SpringApplication.run(AopApplication.class, args);
    }

    // 在应用启动后执行的方法
    @Override
    public void run(String... args) {
        // 测试用例1：注册用户 "张三"
        try {
            System.out.println(userService.registerUser("张三"));
        } catch (Exception e) {
            e.printStackTrace();  // 打印异常堆栈信息
        }
        
        System.out.println("--------------------------------------------");

        // 测试用例2：尝试注册 null 用户，触发异常
        try {
            userService.registerUser(null);
        } catch (Exception e) {
            e.printStackTrace();  // 打印异常堆栈信息
        }
    }
}

4.4 测试

测试1：

前提准备：把这部分注释掉。

@Around("execution(String org.example.service.*.*(..))")
public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕通知(Around): 方法执行前");
        Object result;
        try {
            // 执行目标方法
            result = joinPoint.proceed();
        } catch (Throwable throwable) {
            System.out.println("环绕通知: 方法执行时发生异常: " + throwable.getMessage());
            throw throwable;  // 重新抛出异常
        }
        System.out.println("环绕通知(Around): 方法执行后");
        return result;  // 返回目标方法的返回值        
}

运行结果：

在这里插入图片描述

测试2：

前提准备：把这部分注释掉。

@Before("execution(public void org.example.service.UserService.registerUser(String))")
public void logBefore() {
        System.out.println("方法执行前(Before): 准备注册用户");
    }
    
@After("execution(* org.example.service..*.*(..))")
public void logAfter() {
        System.out.println("方法执行后(After): 用户注册过程完成");
    }    
@AfterReturning(pointcut = "execution(* org.example.service.UserService.*(..))", returning = "result")
public void logAfterReturning(Object result) {
        System.out.println("方法返回(AfterReturning): " + result);
    }
    
@AfterThrowing(pointcut = "execution(* org.example.service.UserService.*(String, ..))", throwing = "error")
public void logAfterThrowing(Throwable error) {
        System.out.println("方法执行时发生异常(AfterThrowing): " + error.getMessage());
}

运行结果：
在这里插入图片描述

5. 总结

环绕通知 VS 其他四种通知

通知类型适用场景不适用场景
环绕通知（Around）需要在方法执行前后都执行逻辑，例如记录日志或性能监控。
需要决定是否执行目标方法。
需要统一捕获并处理异常。
需要修改方法的返回值。		只需在方法前或方法后做简单的操作时，使用环绕通知会显得过于复杂。
前置通知（Before）仅在方法执行前执行逻辑，如参数验证、日志记录、权限检查等。需要在方法执行后、处理返回值或捕获异常的场景。
后置通知（After）仅在方法执行后执行逻辑，如资源清理、记录状态等。需要处理返回值或捕获异常，或在方法执行前执行逻辑的场景。
返回通知（After Returning）仅在方法成功返回结果后执行逻辑，如记录返回值或对返回值进行处理。需要捕获异常，或在方法执行前/后执行逻辑的场景。
异常通知（After Throwing）仅在方法抛出异常时执行逻辑，如记录异常信息、发送报警或执行补偿逻辑。需要在方法执行前、执行后或成功返回时执行逻辑的场景。

解释：

  • 环绕通知适用于对方法的执行有全面控制的需求，包括方法执行前、后，异常处理，以及返回值的修改。
  • 前置通知适用于只需要在方法执行前执行逻辑的场景。
  • 后置通知适用于只需要在方法执行后执行逻辑的场景。
  • 返回通知适用于只关心方法成功返回后的处理逻辑。
  • 异常通知适用于只处理方法抛出异常的情况。

标签：execution,Java,public,切面,AOP,org,执行,方法,example
From： https://blog.csdn.net/qq_71387716/article/details/141260664

相关文章

  • Java反射机制快速入门与通配符
    1.Java反射的原理​在Java中，每个类在编译后都会生成一个.class文件，JVM会为每个加载的类创建一个Class对象，这个对象包含了类的全部结构信息，包括类名、方法、字段、构造函数等。Class对象存储了类的元数据，这些元数据可以在运行时被访问。通过Class对象，程序可以......
  • JavaSE基础知识分享(八)
    写在前面前面讲的是java中集合这部分的内容，今天给大家发一个上期题目参考答案！Person类：packagecom.shujia.TiMu_1000.ten2.Ti15;/***@authorcjy*@create2024-08-07-20:47*/publicabstractclassPerson{privateStringname;privateintage;pri......
  • 【Java Lambda系列】新玩法，用Lambda重构设计模式
    前言前面三章通过理论+案例的方式对Lambda的描述，应该能基本上解决大家日常开发中所遇到的Lambda问题，为了更好的展现Lambda魅力，和加深巩固Lambda知识点，今天咱们讨论Lambda如何重构设计模式！关于设计模式众所周知，设计模式是一群大佬程序员将对程序设计的经验归纳总结起来的......
  • Java 开发者必备：一文解决 AES 加密中的“非法密钥大小”异常
    彻底告别java.security.InvalidKeyException，轻松应对不同JDK版本引言在Java开发过程中，我们经常会遇到各种各样的安全相关的问题。其中一个常见的问题是当使用Java的加密功能时遇到的“Illegalkeysizeordefaultparameters”错误。本文将详细介绍如何解决这一问......
  • 暑假Java自学进度总结06
    一.今日所学：1.for循环for(初始化语句;条件判断语句;条件控制语句){循环体语句;}执行流程：1>执行初始化语句2>执行条件判断语句，若为true则执行循环体语句，若为false，循环结束3>执行条件控制语句4>回到2>继续执行条件判断语句注：初始化语句只执行一次2.while循环初始化语句;......
  • Java基础
    Java基础1注释单行注释格式：//注释信息多行注释格式:/*注释信息*/文档注释格式:/**注释信息*/注：新手小白，文档注释暂时用不上。publicclassHelloWorld{publicstaticvoidmain(String[]args）{//叫做main方法，程序的主入口S......
  • Java入门基础篇
    一、java简介：java是一种广泛使用的高级编程语言，由SunMicrosystems公司于1995年推出。Java的设计目标之一是实现“一次编写，到处运行”的能力，即编写的代码可以在任何支持Java的平台上运行，而无需进行额外的修改。Java广泛应用于企业级应用、桌面应用、移动应用和Web开发等领域。......
  • 【蓝桥杯】第七届蓝桥杯大赛个人赛省赛（软件类）Java 大学C组 真题
    第七届蓝桥杯大赛个人赛省赛（软件类）Java大学C组真题及部分解析A 有奖猜谜小明很喜欢猜谜语。最近，他被邀请参加了X星球的猜谜活动。每位选手开始的时候都被发给777个电子币。规则是：猜对了，手里的电子币数目翻倍，猜错了，扣除555个电子币,扣完为止。小明一共猜了15条谜语......
  • 10步打造专业级Java FX应用：从入门到放弃的艺术
    ......
  • 文心快码Baidu Comate 帮你解大厂面试题：Java G1 GC中，region是什么意思？有哪些不同的reg
    ......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99