相逢便是 缘 ，路过点个 赞 ^.^

源码：https://github.com/yulc-coding/java-note/tree/master/aop

思路

• 自定义权限注解
• 在需要验证的接口上加上注解，并设置具体权限值
• 数据库权限表中加入对应接口需要的权限
• 用户登录时，获取当前用户的所有权限列表放入Redis缓存中
• 定义AOP，将切入点设置为自定义的权限
• AOP中获取接口注解的权限值，和Redis中的数据校验用户是否存在该权限，如果Redis中没有，则从数据库获取用户权限列表，再校验

pom文件 引入AOP

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

        <!-- AOP 切面-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

自定义注解 VisitPermission

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface VisitPermission {
    /**
     * 用于配置具体接口的权限值
     * 在数据库中添加对应的记录
     * 用户登录时，将用户所有的权限列表放入redis中
     * 用户访问接口时，将对应接口的值和redis中的匹配看是否有访问权限
     * 用户退出登录时，清空redis中对应的权限缓存
     */
    String value() default "";
}

需要设置权限的接口上加入注解 @VisitPermission(value)

@RestController
@RequestMapping("/permission")
public class PermissionController {
    /**
     * 配置权限注解 @VisitPermission("permission-test")
     * 只用拥有该权限的用户才能访问，否则提示非法操作
     */
    @VisitPermission("permission-test")
    @GetMapping("/test")
    public String test() {
        System.out.println("================== step 3: doing ==================");
        return "success";
    }
}

定义权限AOP

设置切入点为@annotation(VisitPermission)
获取请求中的token，校验是否token是否过期或合法
获取注解中的权限值，校验当前用户是否有访问权限
MongoDB 记录访问日志（IP、参数、接口、耗时等）

@Aspect
@Component
public class PermissionAspect {

    /**
     * 切入点
     * 切入点为包路径下的：execution(public * org.ylc.note.aop.controller..*(..))：
     * org.ylc.note.aop.Controller包下任意类任意返回值的 public 的方法
     * <p>
     * 切入点为注解的： @annotation(VisitPermission)
     * 存在 VisitPermission 注解的方法
     */
    @Pointcut("@annotation(org.ylc.note.aop.annotation.VisitPermission)")
    private void permission() {

    }

    /**
     * 目标方法调用之前执行
     */
    @Before("permission()")
    public void doBefore() {
        System.out.println("================== step 2: before ==================");
    }

    /**
     * 目标方法调用之后执行
     */
    @After("permission()")
    public void doAfter() {
        System.out.println("================== step 4: after ==================");
    }

    /**
     * 环绕
     * 会将目标方法封装起来
     * 具体验证业务数据
     */
    @Around("permission()")
    public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("================== step 1: around ==================");
        long startTime = System.currentTimeMillis();
        /*
         * 获取当前http请求中的token
         * 解析token :
         * 1、token是否存在
         * 2、token格式是否正确
         * 3、token是否已过期（解析信息或者redis中是否存在）
         * */
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        String token = request.getHeader("token");
        if (StringUtils.isEmpty(token)) {
            throw new RuntimeException("非法请求，无效token");
        }
        // 校验token的业务逻辑
        // ...

        /*
         * 获取注解的值，并进行权限验证:
         * redis 中是否存在对应的权限
         * redis 中没有则从数据库中获取权限
         * 数据空中没有，抛异常，非法请求，没有权限
         * */
        Method method = ((MethodSignature) proceedingJoinPoint.getSignature()).getMethod();
        VisitPermission visitPermission = method.getAnnotation(VisitPermission.class);
        String value = visitPermission.value();
        // 校验权限的业务逻辑
        // List<Object> permissions = redis.get(permission)
        // db.getPermission
        // permissions.contains(value)
        // ...
        System.out.println(value);
        
        // 执行具体方法
        Object result = proceedingJoinPoint.proceed();

        long endTime = System.currentTimeMillis();

        /*
         * 记录相关执行结果
         * 可以存入MongoDB 后期做数据分析
         * */
        // 打印请求 url
        System.out.println("URL            : " + request.getRequestURL().toString());
        // 打印 Http method
        System.out.println("HTTP Method    : " + request.getMethod());
        // 打印调用 controller 的全路径以及执行方法
        System.out.println("controller     : " + proceedingJoinPoint.getSignature().getDeclaringTypeName());
        // 调用方法
        System.out.println("Method         : " + proceedingJoinPoint.getSignature().getName());
        // 执行耗时
        System.out.println("cost-time      : " + (endTime - startTime) + " ms");

        return result;
    }
}

单元测试

package org.ylc.note.aop;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.ylc.note.aop.controller.PermissionController;

@SpringBootTest
class AopApplicationTests {

    @Autowired
    private PermissionController permissionController;

    private MockMvc mvc;

    @BeforeEach
    void setupMockMvc() {
        mvc = MockMvcBuilders.standaloneSetup(permissionController).build();
    }

    @Test
    void apiTest() throws Exception {
        MvcResult result = mvc.perform(MockMvcRequestBuilders.get("/permission/test")
                .accept(MediaType.APPLICATION_JSON)
                .header("token", "9527"))
                .andReturn();
        System.out.println("api test result : " + result.getResponse().getContentAsString());
    }

}

求关注