Aop切面编程（1）

猴子微胖

已于 2024-07-09 16:45:54 修改

阅读量137

点赞数 8

分类专栏： Spring 文章标签： java 开发语言

于 2024-07-09 15:45:35 首次发布

本文链接：https://blog.csdn.net/qq_39522120/article/details/140297327

版权

Spring 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1、aop的使用思想：面向切面的编程，不改变原有代码的基础上，进行拓展，减少代码的冗余，降低耦合性；

2、使用注解进行aop编程，使用自定义注解

2.1导入aop的依赖

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

2.2新建注解类：TestCut

package com.example.demo.annotations;


import java.lang.annotation.*;

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TestCut {

    String module() default "测试";

    String descript() default "描述";

}

2.3新建切面类：TestCutAspect

package com.example.demo.aop;

import com.example.demo.annotations.TestCut;
import com.example.demo.common.RestResponse;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;


@Component
@Aspect
public class TestCutAspect {

    @Pointcut("@annotation(com.example.demo.annotations.TestCut)")
    public void testCut(){

    }

    @Before("testCut()")
    public void beforeFun(JoinPoint joinPoint){
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        Object[] args = joinPoint.getArgs();
        for (Object arg : args) {
            System.out.println(arg.toString());
        }
        //请注意，这种修改是在切面内部进行的，不会影响原始方法中的参数值。
        // 如果你想要修改的是传入原方法的实际参数，而不仅仅是在切面中使用的参数的副本，那么这种方式可能不适用，
        // 因为join point提供的参数是只读的。在这种情况下，你可能需要考虑使用@Around建议来完全控制方法的执行，包括参数的传递。
        args[0]="789";
        System.out.println("注解方式AOP开始拦截, 当前拦截的方法名: " + method.getName());
    }

    @After("testCut()")
    public void afterFun(JoinPoint joinPoint){
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        System.out.println("注解方式AOP执行的方法 :" + method.getName() + " 执行完了");
    }


    //1、注意一定要将@Around修饰的方法用Object修饰其返回值，并且返回原方法执行的结果。
    //2、@Around比较万能，尤其是配合ProceedingJoinPoint的使用。使AOP能做的事情更多了。
    //3、@Around如果不执行proceed()，那么原方法将不会执行
    //4、ProceedingJoinPoint 只能在@Around中使用
    @Around("testCut()")
    public Object testCutAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("注解方式AOP拦截开始进入环绕通知.......");
        Object[] args = joinPoint.getArgs();
        //修改args的值，相当于篡改了原方法入参的参数值
        args[0] ="***";
        //获取注解属性
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature =(MethodSignature)signature;
        Method method = methodSignature.getMethod();
        TestCut annotation = method.getAnnotation(TestCut.class);
        String descript = annotation.descript();
        String module = annotation.module();
        System.out.println(module+"|||"+descript);
        //执行原方法
        Object proceed = joinPoint.proceed(args);
        //修改proceed的值，相当于篡改了原方法执行完成之后的返回值
        proceed = RestResponse.error();
        System.out.println("准备退出环绕......");
        return proceed;
    }

    /**
     * returning属性指定连接点方法返回的结果放置在result变量中
     *
     * @param joinPoint 连接点
     * @param result    返回结果
     */
    @AfterReturning(value = "testCut()", returning = "result")
    public void afterReturn(JoinPoint joinPoint, Object result) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        System.out.println("注解方式AOP拦截的方法执行成功, 进入返回通知拦截, 方法名为: " + method.getName() + ", 返回结果为: " + result.toString());
    }

    @AfterThrowing(value = "testCut()", throwing = "e")
    public void afterThrow(JoinPoint joinPoint, Exception e) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        System.out.println("注解方式AOP进入方法异常拦截, 方法名为: " + method.getName() + ", 异常信息为: " + e.getMessage());
    }

}

2.4新建测试类，在需要切面的方法添加注解@TestCut(module = "测试aop",descript = "我是aop的描述属性")

@RestController
@RequestMapping("/aop")
public class AopRestController {

    @RequestMapping("/test")
    @TestCut(module = "测试aop",descript = "我是aop的描述属性")
    public RestResponse test(String aaa,String bbb){
        System.out.println("我是test方法");
        String c = aaa+bbb;
        return RestResponse.successMsg(c);
    }
}

2.5定义统一返回结果

package com.zlkj.file.exception;

import io.swagger.annotations.ApiModelProperty;

/**
 * @author ycy
 */

public class RestResponse {

    @ApiModelProperty(
            name = "success",
            value = "是否成功",
            required = true,
            dataType = "Boolean"
    )
    private Boolean success;

    @ApiModelProperty(
            name = "data",
            value = "返回结果",
            required = false,
            dataType = "Object"
    )
    private Object data;

    @ApiModelProperty(
            name = "msg",
            value = "提示信息",
            required = false,
            dataType = "String"
    )
    private String msg;

    public RestResponse(Boolean success, String msg, Object data){
        this.success = success;
        this.msg = msg;
        this.data = data;
    }

    public static RestResponse success(){
        return new RestResponse(true, null,null);
    }

    public static RestResponse error(){
        return new RestResponse(false, null, null);
    }

    public static RestResponse successMsg(String msg){
        return new RestResponse(true, msg, null);
    }

    public static RestResponse errorMsg(String msg){
        return new RestResponse(false, msg, null);
    }

    public static RestResponse successResult(String msg, Object data){
        return new RestResponse(true, msg, data);
    }

    public static RestResponse errorResult(String msg, Object data){
        return new RestResponse(false, msg, data);
    }

    public Boolean getSuccess() {
        return success;
    }

    public void setSuccess(Boolean success) {
        this.success = success;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    @Override
    public String toString() {
        return "RestResponse{" +
                "success=" + success +
                ", data=" + data +
                ", msg='" + msg + '\'' +
                '}';
    }
}

3、项目结构

4、执行接口

5、通过测试发现常用的aop注解的执行顺序，around包在最外侧；
@around-方法前

@before

@afterReturning

@after

@around-方法后

有异常：

无异常：

通过测试看就是：

1、afterReturning和afterThrow是互斥的二选一；
2、after一定会执行，around后置方法在抛出异常之后不会执行了；

6、around可以修改入参、出参的值；

注意一定要将@Around修饰的方法用Object修饰其返回值，并且返回原方法执行的结果。
@Around比较万能，尤其是配合ProceedingJoinPoint的使用。使AOP能做的事情更多了。
@Around如果不执行proceed()，那么原方法将不会执行
ProceedingJoinPoint 只能在@Around中使用