java切面实现权限控制

package com.htsc.gtp.bss.permission;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 数据权限注解
 *
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DataPermission {

    /**
     * 业务类型，如"用户管理"、"角色管理" 等
     */
    String businessType() default "";

    /**
     * 权限类型，如"新增"、"删除"、"修改"、"查询"、"导入"、"导出" 等
     */
    String permissionType() default "";

    /**
     * 是否启用该权限检查，默认为true，即默认开启
     */
    boolean enabled() default true;
}

package com.htsc.gtp.bss.permission;

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.htsc.boot.groovy.model.ThreadLocalContext;
import com.htsc.gtp.tmds.risk.dto.RcRuleConfigDto;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestClientException;

import javax.annotation.PostConstruct;
import java.util.concurrent.TimeUnit;

/**
 * 数据权限拦截器
 *
 */
@Aspect
@Component
public class DataPermissionInterceptor {
    private static final Logger LOGGER = LoggerFactory.getLogger(DataPermissionInterceptor.class);

    private Cache<String, Boolean> permissionCache;

    @PostConstruct
    public void init() {
        // 创建一个Caffeine缓存实例，设置超时时间为1分钟
        permissionCache = Caffeine.newBuilder().expireAfterWrite(1, TimeUnit.MINUTES).build();
    }

    @Around("@annotation(dataPermission)")
    public Object checkPermission(ProceedingJoinPoint joinPoint, DataPermission dataPermission) throws Throwable {
        LOGGER.info("DataPermissionInterceptor checkPermission start，user：{} ", ThreadLocalContext.getLoginEmpId());

        // 如果权限检查已关闭，则直接执行原方法
        if (!dataPermission.enabled()) {
            return joinPoint.proceed();
        }

        // 检查用户是否有权限操作
        if (!checkPermission(joinPoint, ThreadLocalContext.getLoginEmpId(), dataPermission.businessType(), dataPermission.permissionType())) {
            throw new RestClientException("暂无操作权限，请联系管理员");
        }

        // 如果有权限，则继续执行原方法
        LOGGER.info("DataPermissionInterceptor checkPermission end，user：{} ", ThreadLocalContext.getLoginEmpId());
        return joinPoint.proceed();
    }

    /**
     * 权限验证
     *
     * @param joinPoint      切点
     * @param loginEmpId     用户
     * @param businessType   业务类型
     * @param permissionType 权限类型
     * @return 返回true表示有权限，false则表示无权限
     */
    private boolean checkPermission(ProceedingJoinPoint joinPoint, String loginEmpId, String businessType, String permissionType) {
        // 先从缓存中获取数据权限
        Boolean hasPermission = permissionCache.getIfPresent(loginEmpId);

        //缓存中是否存在该用户的权限，不存在则重新获取数据权限放入缓存
        if (hasPermission == null) {

        }

        //todo 获取登录用户权限数据（用户部门信息，获取用户角色，获取数据权限，获取对应的rmCode）


        //获取操作用户数据
        Object[] args = joinPoint.getArgs();
        // 遍历参数列表，查找具有getUnifiedAcct()方法的对象并调用该方法
        for (Object arg : args) {
            if (arg instanceof RcRuleConfigDto) {
                RcRuleConfigDto userRequest = (RcRuleConfigDto) arg;
                String unifiedAcct = userRequest.getUnifiedAcct();
                System.out.println("Unified Acct from UserRequest: " + unifiedAcct);
            }

            if (arg instanceof RcRuleConfigDto) {
                RcRuleConfigDto userRequest = (RcRuleConfigDto) arg;
                String unifiedAcct = userRequest.getUnifiedAcct();
                System.out.println("Unified Acct from UserRequest: " + unifiedAcct);
            }

        }


        //根据数据权限判断是否有权限执行，用户下辖unifiedAcct与入参中的unifiedAcct进行匹配


        // 返回true表示有权限，false则表示无权限
        return false;
    }


}