首页 > 软件编程 > java > Spring面向切面编程

Spring面向切面编程AOP详情

2022-09-23 10:53:44 作者：旭日的芬芳

这篇文章主要介绍了Spring面向切面编程AOP详情，文章围绕主题展开详细的内容介绍，具有一定的参考价值，需要的小伙伴可以参考一下

1. 面向切面编程

定义：面向切面编程（AOP，Aspect Oriented Programming）是通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。
作用：利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
主要功能：日志记录、性能统计、安全控制、事务处理、异常处理等。
总结：面向切面编程是希望能够将通用需求功能从不相关的类当中分离出来，能够使得很多类共享一个行为，一旦发生变化，不必修改很多类，而只是修改这个行为即可。

AOP通过提供另一种思考程序结构的方式来补充了面向对象编程（OOP）。OOP中模块化的基本单元是类(class)，而AOP中模块化的基本单元是切面(aspect)。可以这么理解，OOP是解决了纵向的代码复用问题，AOP是解决了横向的代码复用问题。

Spring的关键组件之一是AOP框架。虽然Spring IOC容器不依赖于AOP，意味着如果你不想使用AOP，则可以不使用AOP，但AOP补充了Spring IOC以提供一个非常强大的中间件解决方案。

2. AOP核心概念

切面（aspect）：在AOP中，切面一般使用@Aspect注解来标识。
连接点（Join Point）：在Spring AOP，一个连接点总是代表一次方法的执行。
增强（Advice）：在连接点执行的动作。
切入点（Pointcout）：说明如何匹配到连接点。引
介（Introduction）：为现有类型声明额外的方法和属性。
目标对象（Target Object）：由一个或者多个切面建议的对象，也被称为“建议对象”，由于Spring AOP是通过动态代理来实现的，这个对象永远是一个代理对象。
AOP代理（AOP proxy）：一个被AOP框架创建的对象，用于实现切面约定（增强方法的执行等）。在Spring Framework中，一个AOP代理是一个JDK动态代理或者CGLIB代理。
织入（Weaving）：连接切面和目标对象或类型创建代理对象的过程。它能在编译时（例如使用AspectJ编译器）、加载时或者运行时完成。Spring AOP与其他的纯Java AOP框架一样是在运行时进行织入的。

Spring AOP包括以下类型的增强：

前置增强(Before advice)：在连接点之前运行，但不能阻止到连接点的流程继续执行（除非抛出异常）
返回增强(After returning advice)：在连接点正常完成后运行的增强（例如，方法返回没有抛出异常）
异常增强(After thorwing advice)：如果方法抛出异常退出需要执行的增强
后置增强(After (finally) Advice)：无论连接点是正常或者异常退出，都会执行该增强
环绕增强(Around advice)：围绕连接点的增强，例如方法的调用。环绕增强能在方法的调用之前和调用之后自定义行为。它还可以选择方法是继续执行或者去缩短方法的执行通过返回自己的值或者抛出异常。

3. AOP的实现

AOP的两种实现方式：静态织入（以AspectJ为代表）和动态代理（Spring AOP实现）

AspectJ是一个采用Java实现的AOP框架，它能够对代码进行编译（在编译期进行），让代码具有AspectJ的AOP功能，当然它也可支持动态代理的方式；

Spring AOP实现：通过动态代理技术来实现，Spring2.0集成了AspectJ，主要用于PointCut的解析和匹配，底层的技术还是使用的Spring1.x中的动态代理来实现。

Spring AOP采用了两种混合的实现方式：JDK动态代理和CGLib动态代理。

JDK动态代理：Spring AOP的首选方法。每当目标对象实现一个接口时，就会使用JDK动态代理。目标对象必须实现接口。

CGLIB：如果目标对象没有实现接口，则可以使用CGLIB代理。

4. Spring 对AOP支持

Spring可以使用两种方式来实现AOP：基于注解式配置和基于XML配置

下面介绍基于注解配置的形式

4.1 支持@Aspect

如果是Spring Framework，需要使用aspectjweaver.jar包，然后创建我们自己的AppConfig，如下，并加上@EnableAspectJAutoProxy注解开启AOP代理自动配置(Spring Boot默认是开启的，则不需要增加配置)，

如下：

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
 
}

4.2 声明一个切面

@Aspect //告诉Spring 这是一个切面
@Component  //交给Spring容器管理
public class MyAspect {
 
}

可以使用@Aspect来定义一个类作为切面，但是这样，该类并不会自动被Spring加载，还是需要加上@Component注解

4.3 声明一个切入点

一个切入点的生命包含两个部分：一个包含名称和任何参数的签名和一个切入点的表达式，这个表达式确定了我们对哪些方法的执行感兴趣。

我们以拦截Controller层中的MyController中的test方法为例子，代码如下：

@RestController
@RequestMapping("/my")
public class MyController {
 
    @GetMapping("/test")
    public void test() {
        System.out.println("test 方法");
    }
}

下面定义一个名为controller的切入点，该切入点与上述的test方法相匹配，切入点需要用@Pointcut注解来标注，如下：

  //表达式
  @Pointcut("execution (public * com.yc.springboot.controller.MyController.test())")
  public void controller(){}; //签名

切入点表达式的格式如下：

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?)
execution(方法修饰符(可选) 返回类型 类路径 方法名 参数 异常模式（可选）)

AspectJ描述符如下：

AspectJ描述符	描述
arg()	限制连接点匹配参数为指定类型的执行方法
@args()	限制连接点匹配参数由指定注解标注的执行方法
execution()	用于匹配是连接点的执行方法

this()	限制连接点匹配的AOP代理的bean引用为指定类型的类
target	限制连接点匹配目标对象为指定类型的类
@target()	限制连接点匹配特定的执行对象，这些对象对应的类要具有指定类型的注解

within()	限制连接点匹配指定的类型
@within()	限制连接点匹配指定注解所标注的类型
@annotationn	限定匹配带有指定注解的连接点

常用的主要是：execution()

AspectJ类型匹配的通配符：

within()	限制连接点匹配指定的类型
@within()	限制连接点匹配指定注解所标注的类型
@annotationn	限定匹配带有指定注解的连接点

常用的匹配规则：

表达式	内容
execution(public * *(..))	匹配所有public方法
execution(* set*(..))	匹配所有方法名开头为set的方法

execution(* com.xyz.service.AccountService.*(..))	匹配AccountService下的所有方
execution(* com.xyz.service..(..))	匹配service包下的所有方法

execution(* com.xyz.service..*.*(..))

匹配service包或其子包下的所有方法

@annotation(org.springframework.transaction.annotation.Transactional)

匹配所有打了@Transactional注解的方法

bean(*Service)

匹配命名后缀为Service的类的方法

4.4 声明增强

增强与切点表达式相关联，并且在与切点匹配的方法之前、之后或者前后执行。

在3当中已经对各类增强做了绍，这里就不详细展开了，下面直接罗列了各种增强的声明，用于拦截MyController中的各个方法

 
@Aspect //告诉Spring 这是一个切面
@Component  //告诉Spring容器需要管理该对象
public class MyAspect {
 
    //通过规则确定哪些方法是需要增强的
    @Pointcut("execution (public * com.yc.springboot.controller.MyController.*(..))")
    public void controller() {
    }
 
    //前置增强
    @Before("controller()")
    public void before(JoinPoint joinPoint) {
        System.out.println("before advice");
    }
 
    //返回增强
    @AfterReturning(
            pointcut = "controller()",
            returning = "retVal"
    )
    public void afterReturning(Object retVal) {
        System.out.println("after returning advice, 返回结果 retVal:" + retVal);
    }
 
    //异常增强
    @AfterThrowing(
            pointcut = "controller()",
            throwing = "ex"
    )
    public void afterThrowing(Exception ex) {
        System.out.println("after throwing advice, 异常 ex:" + ex.getMessage());
    }
 
    //后置增强
    @After("controller()")
    public void after(JoinPoint joinPoint) {
        System.out.println("after advice");
    }
 
    //环绕增强
    @Around("controller()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("before advice");
        //相当于是before advice
        Object reVal = null;
        try {
            reVal = joinPoint.proceed();
        } catch (Exception e) {
            //相当于afterthrowing advice
            System.out.println("afterthrowing advice");
        }
        //相当于是after advice
        System.out.println("after advice");
        return reVal;
    }
}

需要注意的是：

在返回增强中，我们需要给@AfterReturing设置returning的值，且需要与方法的参数名一致，用于表示业务方法的返回值
在异常增强中，需要给@AfterThrowing设置throwing的值，且需要与方法的参数名一致，用于表示业务方法产生的异常在环绕增强中，参数为ProceedingJoinPoint类型，它是JoinPoint的子接口，我们需要在这个方法中手动调用其proceed方法来触发业务方法
在所有的增强方法中都可以申明第一个参数为JoinPoint(注意的是，环绕增强是使用ProceedingJoinPoint来进行申明，它实现了JoinPoint接口)
JoinPoint接口提供了几个有用的方法：
- getArgs()：返回这个方法的参数
- getThis()：返回这个代理对象
- getTarget()：返回目标对象(被代理的对象)
- getSignature()：返回被增强方法的描述
- toString()：打印被增强方法的有用描述

下面为Mycontroller测试类：

@RestController
@RequestMapping("/my")
public class MyController {
 
    @GetMapping("/testBefore")
    public void testBefore() {
        System.out.println("testBefore 业务方法");
    }
 
    @GetMapping("/testAfterReturning")
    public String testAfterReturning() {
        System.out.println("testAfterReturning 业务方法");
        return "我是一个返回值";
    }
 
    @GetMapping("/testAfterThrowing")
    public void testAfterThrowing() {
        System.out.println("testAfterThrowing 业务方法");
        int a = 0;
        int b = 1 / a;
    }
 
    @GetMapping("/testAfter")
    public void testAfter() {
        System.out.println("testAfter 业务方法");
    }
 
    @GetMapping("/around")
    public void around() {
        System.out.println("around 业务方法");
    }
}

5. 用AOP实现日志拦截

5.1 一般的实现

打印日志是AOP的一个常见应用场景，我们可以对Controller层向外提供的接口做统一的日志拦截，用日志记录请求参数、返回参数、请求时长以及异常信息，方便我们线上排查问题，下面是核心类LogAspect的实现

/**
 * 日志的切面
 */
@Aspect
@Component
public class LogAspect {
 
    @Resource
    private IdWorker idWorker;
 
    @Pointcut("execution (public * com.yc.core.controller.*.*(..))")
    public void log(){}
 
    /**
     * 使用环绕增强实现日志打印
     * @param joinPoint
     * @return
     * @throws Throwable
     */
    @Around("log()")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        //获得执行方法的类和名称
        String className = joinPoint.getTarget().getClass().getName();
        //获得方法名
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        String methodName = signature.getMethod().getName();
        //获得参数
        Object[] args = joinPoint.getArgs();
        long requestId = idWorker.nextId();
        //打印参数
        LogHelper.writeInfoLog(className, methodName, "requestId:" + requestId + ",params:" + JSONObject.toJSONString(args));
        long startTime = System.currentTimeMillis();
        //执行业务方法
        Object result = null;
        try {
            result = joinPoint.proceed();
        } catch (Exception e) {
            LogHelper.writeErrLog(className, methodName, "requestId:" + requestId + ",异常啦：" + LogAspect.getStackTrace(e));
        }
        long endTime = System.currentTimeMillis();
        //打印结果
        LogHelper.writeInfoLog(className, methodName, "requestId:" + requestId + ",耗时：" + (endTime - startTime) +  "ms，result:" + JSONObject.toJSONString(result));
        //返回
        return result;
    }
 
    /**
     * 获取异常的堆栈信息
     * @param throwable
     * @return
     */
    public static String getStackTrace(Throwable throwable)
    {
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        try
        {
            throwable.printStackTrace(pw);
            return sw.toString();
        } finally
        {
            pw.close();
        }
    }
}

在proceed()方法之前，相当于前置增强，收集类名、方法名、参数，记录开始时间，生成requestId
在proceed()方法之后，相当于后置增强，并能获取到返回值，计算耗时
在前置增强时，生成requestId，用于串联多条日志
使用try、catch包裹proceed()方法，在catch中记录异常日志
提供了getStackTrace方法获取异常的堆栈信息，便于排查报错详细情况

5.2 仅拦截需要的方法

但是上面的日志是针对所有controller层中的方法进行了日志拦截，如果我们有些方法不想进行日志输出，比如文件上传的接口、大量数据返回的接口，这个时候定义切入点的时候可以使用@annotation描述符来匹配加了特定注解的方法，步骤如下：

1. 先定义一个日志注解Log

/**
 * 自定义日志注解
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Log {
}

2.用@annotation定义切入点

    @Pointcut("@annotation(com.yc.core.annotation.Log)")
    public void logAnnotation(){}

3.在想做日志输出的方法上使用注解Log

    @Log
    @PostMapping(value = "testannotation")
    public AOPTestVO testannotation(@RequestBody AOPTestDTO aopTestDTO) {
        AOPTestVO aopTestVO = new AOPTestVO();
        aopTestVO.setCode(1);
        aopTestVO.setMsg("哈哈哈");
        return aopTestVO;
    }

这样，我们就可以自定义哪些方法需要日志输出了

5.3 requestId传递

后来有同事提到，如果这是针对Controller层的拦截，但是Service层也有自定义的日志输出，怎么在Service层获取到上述的requestId呢？

其实就是我们拦截之后，是否可以针对方法的参数进行修改呢？其实注意是看

result = joinPoint.proceed();

我们发现ProceedingJoinPoint还有另外一个带有参数的proceed方法，定义如下：

public Object proceed(Object[] args) throws Throwable;

我们可以利用这个方法，在环绕增强中去增加requestId，这样后面的增强方法或业务方法中就能获取到这个requestId了。

首先，我们先定义一个基类AOPBaseDTO，只有一个属性requestId

@Data
@ApiModel("aop参数基类")
public class AOPBaseDTO {
    @ApiModelProperty(value = "请求id", hidden = true)
    private long requestId;
}

然后我们让Controller层接口的参数AOPTestDTO继承上述AOPBaseDTO，如下：

@Data
@ApiModel("aop测试类")
public class AOPTestDTO extends AOPBaseDTO{
 
    @ApiModelProperty(value = "姓名")
    private String name;
 
    @ApiModelProperty(value = "年龄")
    private int age;
}

最后在环绕的增强中添加上requestId，如下：

    /**
     * 使用环绕增强实现日志打印
     * @param joinPoint
     * @return
     * @throws Throwable
     */
    @Around("logAnnotation()")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        //获得执行方法的类和名称
        String className = joinPoint.getTarget().getClass().getName();
        //获得方法名
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        String methodName = signature.getMethod().getName();
        //获得参数
        Object[] args = joinPoint.getArgs();
        long requestId = idWorker.nextId();
        for(int i = 0; i < args.length; i++) {
            if (args[i] instanceof AOPBaseDTO) {
                //增加requestId
                ((AOPBaseDTO) args[i]).setRequestId(requestId);
            }
        }
        //打印参数
        LogHelper.writeInfoLog(className, methodName, "requestId:" + requestId + ",params:" + JSONObject.toJSONString(args));
        long startTime = System.currentTimeMillis();
        //执行业务方法
        Object result = null;
        try {
            result = joinPoint.proceed(args);
        } catch (Exception e) {
            LogHelper.writeErrLog(className, methodName, "requestId:" + requestId + ",异常啦：" + LogAspect.getStackTrace(e));
        }
        long endTime = System.currentTimeMillis();
        //打印结果
        LogHelper.writeInfoLog(className, methodName, "requestId:" + requestId + ",耗时：" + (endTime - startTime) +  "ms，result:" + JSONObject.toJSONString(result));
        //返回
        return result;
    }

我们运行起代码，访问一下，下面是运行结果：

可以看到，我们的业务方法中已经能获取到requestId，如果Service层需要，可以通过传递AOPTestDTO，从中获取。

5.4 关于增强执行的顺序

1. 针对不同类型的增强，顺序固定的，比如before在after前面
2. 针对同一切面的相同类型的增强，根据定义先后顺序依次执行
3. 针对不同切面的相同增强，可以通过使我们的切面实现Ordered接口，重写getOrder方法，返回值最小，优先级越高。注意的是before和after的相反的，before的优先级越高越早执行，after的优先级越高，越晚执行

6. 思考

1. 代理对象是什么时候创建的？
2. 当存在多个不同类型增强时，执行顺序是怎么保证的？
3. 真正的业务方法是什么时候调用的，怎么做到只调用一次？

到此这篇关于Spring面向切面编程AOP详情的文章就介绍到这了,更多相关Spring面向切面编程内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！