Spring 面向切面编程（AOP）

王小白杂货店

已于 2023-12-11 01:16:01 修改

阅读量926

点赞数 25

分类专栏： spring系列文章标签： spring

于 2023-12-11 01:13:57 首次发布

本文链接：https://blog.csdn.net/qq_39464523/article/details/134217529

版权

spring系列专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一、aop介绍

（一）前言

一般的后端开发流程是纵向开发，就是controller（控制层）->service（业务层）->mapper（数据持久层），Spring采用动态代理技术可以在程序的运行过程中对每一层进行增强，也就是面向切面编程（Aspect Oriented Programming）。
在这里插入图片描述

（二）使用场景

（1）想要在每类业务处理的时候保存日志，包含业务处理的具体数据、具体时间、具体用户；
（2）如果业务方法是异步的，可以监控业务方法是否报错；
（3）可以实现数据库事务；

（三）相关术语

1、Joinpoint（连接点）

类里面可以被增强的方法即是连接点；

2、Pointcut（切入点）

对连接点进行拦截的定义即是切入点。
切入点的实现方式有两种：
（1）使用@Pointcut注解定义切入点；
（2）自定义注解作为连接点，对注解进行拦截；

3、Advice（通知）

拦截到切入点之后要做的事情
通知分为以下几类：
（1）前置通知（@Before）：目标方法执行之前执行；
（2）后置通知（@After）：目标方法执行之后执行，无论连接点是否出现异常，都会执行；
（3）异常通知（@AfterThrowing）：连接点出现异常后才会执行；
（4）返回通知（@AfterReturning）：连接点成功执行后，执行返回通知方法，如果连接点方法出现异常，该通知不执行；
（5）环绕通知（@Around）：以上四种通知可以通过环绕通知实现；

4、Aspect（切面）

切入点和通知的结合

5、Target（目标对象）

要增强的类

二、代码实现

（一）准备工作

1、控制层（Controller）

package com.xiaobai.aroundtest.controller;

import com.xiaobai.aroundtest.entity.Article;
import com.xiaobai.aroundtest.service.IAroundTestService;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author wangtw
 * @date 2023/12/6 0:20
 * @description 切面测试控制器
 */
@AllArgsConstructor
@RestController
public class AroundTestController {

    private final IAroundTestService aroundTestService;

    @PostMapping("aroundTest")
    public void aroundTest(@RequestParam String name, @RequestBody Article article) {
        aroundTestService.aroundTest(name, article);
    }
}

2、业务层（Service）

（1）业务层接口

package com.xiaobai.aroundtest.service;

import com.xiaobai.aroundtest.annotation.AroundTest;
import com.xiaobai.aroundtest.entity.Article;

/**
 * @author wangtw
 * @date 2023/12/6 0:39
 * @description 环绕通知测试服务类
 */
public interface IAroundTestService {

    void aroundTest(String name, Article article);
}

（2）业务层实现类

package com.xiaobai.aroundtest.service.impl;

import com.xiaobai.aroundtest.annotation.AroundTest;
import com.xiaobai.aroundtest.entity.Article;
import com.xiaobai.aroundtest.service.IAroundTestService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

/**
 * @author wangtw
 * @date 2023/12/6 0:42
 * @description
 */
@Slf4j
@Service
public class AroundTestServiceImpl implements IAroundTestService {

    @AroundTest // 自定义注解
    @Override
    public void aroundTest(String name, Article article) {
        log.info("保存文章");
    }
}

（二）使用@Pointcut定义切入点

1、前言

@Pointcut 可以使用 annotation、within、execution 等方式将 方法(method)、类(class)、接口(interface)、包(package) 等作为切入点，
以下代码使用的是execution指定切入点。

2、execution语法

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)

（1）修饰符匹配（modifier-pattern?）
（2）返回值匹配（ret-type-pattern）可以为*表示任何返回值,全路径的类名等
（3）类路径匹配（declaring-type-pattern?）
（4）方法名匹配（name-pattern）可以指定方法名或者代表所有, set 代表以set开头的所有方法
（5）参数匹配（(param-pattern)）可以指定具体的参数类型，多个参数间用“,”隔开，各个参数也可以用“”来表示匹配任意类型的参数，如(String)表示匹配一个String参数的方法；(,String) 表示匹配有两个参数的方法，第一个参数可以是任意类型，而第二个参数是String类型；可以用(…)表示零个或多个任意参数
（6）异常类型匹配（throws-pattern?）
其中后面跟着“?”的是可选项

3、定义切面

以下表达式指定的是com.xiaobai及其子包下service.impl的所有方法

execution(* com.xiaobai..*.service.impl..*.*(..))

切面类需要使用@Aspect指定，使用@Component注解将切面交由Spring容器管理，切面类代码如下：

package com.xiaobai.aroundtest.aspect;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * @author wangtw
 * @date 2023/12/6 0:47
 * @description service切面
 */
@Aspect
@Component
@Slf4j
public class TransactionalAspect {

    @Pointcut("execution(* com.xiaobai..*.service.impl..*.*(..))")
    private void pointCut() {}

    /**
     * 开启事务(前置通知)
     */
    @Before("pointCut()")
    public  void beginTransaction(){
        try {
            log.info("开启事务");
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
     * 提交事务（后置返回通知）
     */
    @AfterReturning("pointCut()")
    public  void commit(){
        try {
            log.info("提交事务");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    /**
     * 回滚事务（异常通知）
     */
    @AfterThrowing("pointCut()")
    public  void rollback(){
        try {
            log.info("回滚事务");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    /**
     * 释放连接（后置通知）
     */
    @After("pointCut()")
    public  void release(){
        try {
            log.info("释放连接");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

（三）通过拦截注解的方式实现切面

1、自定义注解

（1）使用@Target指定目标元素，这个注解是用于拦截方法，使用ElementType.METHOD
（2）使用@Retention指定注解的生命周期： RetentionPolicy.RUNTIME 表示此注解被保存到class文件中，jvm加载class文件后，此注解仍存在；RetentionPolicy.SOURCE 表示此注解只会保留到源文件中，文件编译成class文件后，此注解就会消失；RetentionPolicy.CLASS 表示此注解会被保存到class文件中，但jvm加载class文件后，此注解会被遗弃；

package com.xiaobai.aroundtest.annotation;

import java.lang.annotation.*;

/**
 * @author wangtw
 * @date 2023/12/6 0:45
 * @description
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface AroundTest {

    /**
     * 实体类属性名
     * @return
     */
    String name() default "name";
}

2、定义切面

@Around 用于实现环绕通知，使用 @annotation(aroundTest) 指定需要拦截的注解，环绕通知需要携带 ProceedingJoinPoint 类型的参数。
可以使用 (MethodSignature) ProceedingJoinPoint.getSignature() 获取方法参数，具体代码如下：

// 获取参数名称
MethodSignature methodSignature = (MethodSignature) point.getSignature();
String[] parameterNames = methodSignature.getParameterNames();

使用 ProceedingJoinPoint.getArgs() 方法获取参数值

// 获取参数
Object[] args = point.getArgs();

切面代码如下：

package com.xiaobai.aroundtest.aspect;

import com.xiaobai.aroundtest.annotation.AroundTest;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Component;

import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @author wangtw
 * @date 2023/12/6 0:47
 * @description
 */
@Aspect
@Component
@Slf4j
public class AroundTestAspect {

    @Around("@annotation(aroundTest)")
    public Object around(ProceedingJoinPoint point, AroundTest aroundTest) {
        // 获取参数名称
        MethodSignature methodSignature = (MethodSignature) point.getSignature();
        String[] parameterNames = methodSignature.getParameterNames();
        // 获取参数
        Object[] args = point.getArgs();
        for (int i = 0; i < parameterNames.length; i++) {
            if (parameterNames[i].equals(aroundTest.name())) {
                log.info("保存{}为{}的文章", parameterNames[i], args[i]);
            }
        }

        String info = "";
        for (Object arg : args) {
            if (arg instanceof String) {

            } else {
                // 获取文章信息
                PropertyDescriptor[] propertyDescriptors = BeanUtils.getPropertyDescriptors(arg.getClass());
                for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
                    if (!String.class.isAssignableFrom(propertyDescriptor.getPropertyType())) {
                        continue;
                    }
                    Method readMethod = propertyDescriptor.getReadMethod();
                    if (readMethod == null) {
                        continue;
                    }

                    Object propertyValue = null;
                    try {
                        propertyValue = readMethod.invoke(arg, null);
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    } catch (InvocationTargetException e) {
                        e.printStackTrace();
                    }

                    info = info.concat(propertyDescriptor.getName())
                            .concat(":")
                            .concat(propertyValue == null ? "" : propertyValue.toString())
                            .concat(",");
                }
            }
        }
        Object result = null;
        try {
            result = point.proceed(point.getArgs());
        } catch (Throwable e) {
            e.printStackTrace();
            log.error("方法异常，文章信息：{}", info);
        }
        log.info("修改成功, 文章信息:{}", info);
        return result;
    }
}

三、总结

1、Spring使用Cglib增强了service，注入到controller的service实际上是个代理对象
在这里插入图片描述

2、使用postman测试controller接口，输出结果如下：
在这里插入图片描述

保存name为java核心技术的文章
开启事务
保存文章
提交事务
释放连接
修改成功, 文章信息:description:囊括了Java平台标准版(JavaSE/J2SE)的全部基础知识，提供了大量完整且具有实际意义的应用实例，详细介绍了Java语言基础知识、面向对象程序设计、接口与内部类、事件监听器模型、swing图形用户界面程序设计、打包应用程序、异常处理、登录与调试、泛型程序设计、集合框架、多线程等内容,name:java核心技术,

参考

SpringBoot+Vue全栈开发实战王松清华大学出版社
@Retention注解详解自由的棉花
 Spring AOP中@Pointcut切入点表达式使用介绍 Roc Lau
【Spring AOP】@Aspect结合案例详解（一）: @Pointcut使用@annotation + 五种通知Advice注解（已附源码）天罡gg
AspectJ 切面注解中五种通知注解：@Before、@After、@AfterReturning、@AfterThrowing、@Around 苍鹰蛟龙
 Spring——面向切面编程(AOP) 行者无疆_ty

王小白杂货店

关注

25
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
Spring 面向切面编程（AOP）

一般的后端开发流程是纵向开发，就是controller（控制层）->service（业务层）->mapper（数据持久层），Spring采用动态代理技术可以在程序的运行过程中对每一层进行增强，也就是面向切面编程（Aspect Oriented Programming）可以使用 (MethodSignature) ProceedingJoinPoint.getSignature() 获取方法参数使用 ProceedingJoinPoint.getArgs() 方法获取参数值
复制链接

扫一扫