Spring AOP

最新推荐文章于 2024-07-11 14:56:13 发布

辉z

最新推荐文章于 2024-07-11 14:56:13 发布

阅读量92

点赞数

分类专栏： spring 文章标签： spring java 后端

本文链接：https://blog.csdn.net/qq_39469143/article/details/125839024

版权

spring 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Spring AOP

定义注解

package com.ways.mount.annotation;

import java.lang.annotation.*;


@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataScope {
    /**
     * 部门表的别名
     */
    String deptAlias() default "";

    /**
     * 用户表的别名
     */
    String userAlias() default "";
}

定义目标方法

package com.ways.mount.service;

import com.ways.mount.annotation.DataScope;
import com.ways.mount.controller.request.UserRequest;
import com.ways.mount.controller.response.UserVO;
import org.springframework.stereotype.Service;

@Service
public class TestService {

    @DataScope(userAlias = "1111", deptAlias = "2222")
    public UserVO getUser(UserRequest request, Integer age) {
        try {
            int i = 1 / 0;
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException("测试一下");
        }
        return new UserVO("张三",request.getSalary());
    }

}

定义切面

package com.ways.mount.aspect;

import com.ways.mount.annotation.DataScope;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * 数据过滤处理
 *
 * @author ruoyi
 */
@Aspect
@Component
@Slf4j
public class DataScopeAspect {

    @Before("@annotation(dataScope)")
    public void doBefore(JoinPoint point, DataScope dataScope) {
        // 在目标方法被调用之前调用通知功能
        log.error("执行了doBefore");

//        String deptAlias = dataScope.deptAlias();
//        log.error("deptAlias = " + deptAlias);
//        MethodSignature signature = (MethodSignature) point.getSignature();
//        Class<?> declaringClass = signature.getMethod().getDeclaringClass();
//        log.error("declaringClass = " + declaringClass);
//        DataScope annotation = signature.getMethod().getAnnotation(DataScope.class);
//        String b = annotation.deptAlias();
//        log.error("b = " + b);
    }

    @After("@annotation(dataScope)")
    public void doAfter(JoinPoint point, DataScope dataScope) {
        // 在目标方法完成之后调用通知，此时不会关心方法的输出是什么
        log.error("执行了doAfter");
    }

    @AfterReturning(value = "@annotation(dataScope)",returning = "result")
    public void doAfterReturning(JoinPoint point, DataScope dataScope, Object result) {
        // 在目标方法成功执行之后调用通知
        log.error("doAfterReturning");
    }

    @AfterThrowing(value = "@annotation(dataScope)", throwing = "exception")
    public void doAfterThrowing(JoinPoint point, DataScope dataScope, Exception exception) {
        // 在目标方法抛出异常后调用通知
        log.error("doAfterThrowing");
    }

    @Around("@annotation(dataScope)")
    public Object doAround(ProceedingJoinPoint pjp, DataScope dataScope) {
        String methodName = pjp.getSignature().getName();
        log.error("==========环绕通知开始了==========");
        Object result = null;
        try{
            // == 前置通知
            log.error("【目标方法】"+methodName);
            // 执行目标方法
            result = pjp.proceed();
            // == 结果通知
            log.error("目标方法返回结果为："+result);
        }catch (Throwable e) {
            // == 异常通知
            log.error(e.getMessage());
        }
        // == 后置通知
        log.error("后置通知执行");
        return result;
    }

}