java切面实现权限控制

Bertha 。 2024-04-20 12:10 80阅读 0赞

#### 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;
        }
    
    
    }