基于AOP方式实现数据权限的校验

最新推荐文章于 2025-06-24 18:35:53 发布
原创 最新推荐文章于 2025-06-24 18:35:53 发布 · 1.2k 阅读 · 6 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring #java #spring boot

基于AOP方式实现数据权限的校验

本文大纲
一、数据权限注解
二、数据权限AOP
三、数据范围枚举
四、登录用户信息
五、权限相关的工具类
六、AOP数据权限校验基础类
七、AOP数据权限校验基础类

一、数据权限注解

package com.dashu.park.common.annotation;

import com.dashu.park.common.enums.DataScopeType;

import java.lang.annotation.*;

/**
 * 数据权限过滤注解
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataScope {
    /**
     * 是否校验角色，没有角色不然操作
     *
     * @return
     */
    boolean checkRole() default true;

    /**
     * 是否校验数据权限，没有权限，直接返回
     *
     * @return
     */
    boolean checkDataScope() default false;

    /**
     * 数据权限范围的类型，默认是本部门的数据
     *
     * @return
     */
    DataScopeType dataScopeType() default DataScopeType.DATA_SCOPE_DEPT;

}

二、数据权限AOP

package com.dashu.park.common.aspect;


import cn.hutool.core.util.ObjectUtil;
import com.dashu.park.common.annotation.DataScope;
import com.dashu.park.common.bean.DataScopeAopEntity;
import com.dashu.park.common.bean.LoginUser;
import com.dashu.park.common.enums.DataScopeType;
import com.dashu.park.common.exception.BaseException;
import com.dashu.park.common.util.SecurityUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.util.Optional;

@Aspect
@Component
public class DataScopeAspect {
    /**
     * 配置织入点
     */
    @Pointcut("@annotation(com.dashu.park.common.annotation.DataScope)")
    public void dataScopePointCut() {
    }

    @Before("dataScopePointCut()")
    public void before(JoinPoint point) {
//        handleDataScope(point);
    }


//    protected void handleDataScope(final JoinPoint joinPoint) {
//        // 获得注解
//        DataScope dataScope = getAnnotationLog(joinPoint);
//        if (ObjectUtil.isNull(dataScope)) {
//            return;
//        }
//        // 获取当前的用户
//        LoginUser loginUser = SecurityUtils.getLoginUser();
//
//        // 如果是超级管理员，则不过滤数据
//        if (SecurityUtils.isAdmin(loginUser)) {
//            return;
//        }
//
//        // 1.角色判断
//        if (dataScope.checkRole()) {
//            SecurityUtils.checkRole(loginUser);
//        }
//
//        // 2.权限判断，有权限才执行
//        if (dataScope.checkDataScope()) {
//            // 校验是否有权限
//            SecurityUtils.checkDataScope(loginUser);
//            // 加入查询的规则
//            // 拿到方法的参数，要求第一个参数为实体类且继承 DataScopeAopEntity
//            // 因为要将 DataScopeAopEntity 的属性设置为查询条件
//            Object params = joinPoint.getArgs()[0];
//
//            DataScopeType dataScopeType = dataScope.dataScopeType();
//
//            // 转为权限类型，向上转型
//            DataScopeAopEntity dataScopeAop = (DataScopeAopEntity) params;
//            // 基于数据权限的类型，设置用户的权限值
//            dataScopeType.fillDataScopeType(dataScopeAop, loginUser.getDeptIds());
//        }
//    }


    /**
     * 数据范围过滤
     * <p>
     * 是否存在注解，如果存在就获取
     */
    private DataScope getAnnotationLog(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method method = methodSignature.getMethod();
        return Optional.ofNullable(method).map(item -> method.getAnnotation(DataScope.class)).orElseGet(() -> null);
    }

    /**
     * 定制一个环绕通知
     *
     * @param joinPoint
     * @throws Throwable
     */
    @Around("dataScopePointCut()")
    public Object advice(ProceedingJoinPoint joinPoint) throws Throwable {
        try {
            // 获得注解
            DataScope dataScope = this.getAnnotationLog(joinPoint);
            if (ObjectUtil.isNull(dataScope)) {
                return joinPoint.proceed();
            }
            // 获取当前的用户
            LoginUser loginUser = SecurityUtils.getLoginUser();

            // 如果是超级管理员，则不过滤数据
            if (SecurityUtils.isAdmin(loginUser)) {
                // 执行proceed方法的作用是让目标方法执行
                return joinPoint.proceed();
            }

            // 1.角色判断
            if (dataScope.checkRole()) {
                SecurityUtils.checkRole(loginUser);
            }

            // 2.权限判断，有权限才执行
            if (dataScope.checkDataScope()) {
                // 校验是否有权限
                SecurityUtils.checkDataScope(loginUser);
                // 加入查询的规则
                // 拿到方法的参数，要求第一个参数为实体类且继承 DataScopeAopEntity
                // 因为要将 DataScopeAopEntity 的属性设置为查询条件
                Object params = joinPoint.getArgs()[0];

                DataScopeType dataScopeType = dataScope.dataScopeType();

                // 转为权限类型，向上转型
                DataScopeAopEntity dataScopeAop = (DataScopeAopEntity) params;
                // 基于数据权限的类型，设置用户的权限值
                dataScopeType.fillDataScopeType(dataScopeAop, loginUser.getDeptIds());
            }

            // 执行proceed方法的作用是让目标方法执行
            return joinPoint.proceed();
        } catch (Exception e) {
            return new BaseException(e.getMessage());
        }
    }

}

三、数据范围枚举

package com.dashu.park.common.enums;

import com.dashu.park.common.bean.DataScopeAopEntity;
import lombok.Getter;

import java.util.List;

/**
 * 数据权限的类型
 */
@Getter
public enum DataScopeType {
    /**
     * 基于用户自己的数据权限
     */
    DATA_SCOPE_USER {
        @Override
        public void fillDataScopeType(DataScopeAopEntity dataScopeAop, List<Long> dataScopeIds) {
            dataScopeAop.setUserId(dataScopeIds.get(0));
        }
    },

    /**
     * 基于岗位的数据权限
     */
    DATA_SCOPE_POST {
        @Override
        public void fillDataScopeType(DataScopeAopEntity dataScopeAop, List<Long> dataScopeIds) {
            dataScopeAop.setPostId(dataScopeIds);
        }
    },

    /**
     * 基于部门的数据权限
     */
    DATA_SCOPE_DEPT {
        @Override
        public void fillDataScopeType(DataScopeAopEntity dataScopeAop, List<Long> dataScopeIds) {
            dataScopeAop.setDeptIds(dataScopeIds);
        }
    },

    /**
     * 基于组织，用户组的数据权限
     */
    DATA_SCOPE_ORGANIZATION {
        @Override
        public void fillDataScopeType(DataScopeAopEntity dataScopeAop, List<Long> dataScopeIds) {
            dataScopeAop.setOrganizationIds(dataScopeIds);
        }
    };

    /**
     * 设置数据权限的校验类型
     *
     * @param dataScopeAop 范围类型
     * @param dataScopeIds 范围类型的Id列表
     */
    public abstract void fillDataScopeType(DataScopeAopEntity dataScopeAop, List<Long> dataScopeIds);
}

四、登录用户信息

package com.dashu.park.common.bean;

import com.dashu.park.api.bean.BaseEntity;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;

import java.util.List;

/**
 * @author HaiMa
 * @date 2021/6/30
 */
@EqualsAndHashCode(callSuper = true)
@Data
public class LoginUser extends BaseEntity {

    @ApiModelProperty(value = "项目ID")
    private Long pId;

    @ApiModelProperty(value = "用户名ID")
    private Long userId;

    @ApiModelProperty(value = "昵称")
    private String name;

    @ApiModelProperty(value = "用户名")
    private String username;

    @ApiModelProperty(value = "用户角色")
    private List<UserRole> userRoles;

    @ApiModelProperty(value = "登录时间")
    private Long loginTime;

    @ApiModelProperty(value = "场景 WEB(默认)  APP")
    private String scenes;

    @ApiModelProperty(value = "绑定权限ID")
    private List<Long> deptIds;

    @Data
    public static class UserRole {

        @ApiModelProperty(value = "角色ID")
        private Long roleId;

        @ApiModelProperty(value = "角色名")
        private String roleName;

        @ApiModelProperty("场景 WEB(默认)  APP")
        private String scenes;

    }

}

五、权限相关的工具类

package com.dashu.park.common.util;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.dashu.park.api.response.global.RC_C;
import com.dashu.park.common.bean.BaseDaoByEntity;
import com.dashu.park.common.bean.LoginUser;
import com.dashu.park.common.constants.CommonConstants;
import com.dashu.park.common.exception.BaseException;
import org.apache.commons.lang3.StringUtils;

import javax.servlet.http.HttpServletRequest;


public class SecurityUtils {

    /**
     * 获取登录的用户信息
     */
    public static LoginUser getLoginUser() {
        HttpServletRequest request = ServletUtils.getRequest();
        if (request == null) {
            throw new BaseException("request 不存在");
        }
        try {
            LoginUser loginUser = (LoginUser) request.getAttribute(CommonConstants.LOGIN_AUTH_USER);
            if (loginUser != null) {
                return loginUser;
            }
            String data = request.getHeader(CommonConstants.LOGIN_AUTH_USER);
            if (StringUtils.isEmpty(data)) {
                throw new BaseException(RC_C.NO_LOGIN);
            }
            data = EncodesUtils.decodeBase64ToStr(data);
            loginUser = JSON.parseObject(data, LoginUser.class);
            if (loginUser == null) {
                throw new BaseException(RC_C.NO_LOGIN);
            }
            request.setAttribute(CommonConstants.LOGIN_AUTH_USER, loginUser);
            return loginUser;
        } catch (Exception e) {
            throw new BaseException(RC_C.NO_LOGIN);
        }
    }

    /**
     * 获取登录的用户信息
     */
    public static LoginUser getLoginUserIgnoreError() {
        try {
            return getLoginUser();
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 获取项目ID
     */
    public static long getProjectId() {
        HttpServletRequest request = ServletUtils.getRequest();
        if (request == null) {
            Long projectId = CommonUtils.getAsynThreadDataProjectId();
            if (projectId != null) {
                return projectId;
            }
            throw new BaseException(RC_C.PROJECT_ERROR);
        }
        try {
//            return EnvUtils.isDev() ? 101 : Long.parseLong(request.getHeader(CommonConstants.PROJECT_ID));
            return Long.parseLong(request.getHeader(CommonConstants.PROJECT_ID));
        } catch (Exception e) {
            throw new BaseException(RC_C.PROJECT_ERROR);
        }
    }

    /**
     * 设置登录信息
     *
     * @param t
     * @param <T>
     */
    public static <T extends BaseDaoByEntity> void fillLoginUser(T t) {
        AssertUtil.isTrue(ObjectUtil.isNull(t), "填充登录用户信息的类不能为空");
        LoginUser loginUser = getLoginUser();
        if (ObjectUtil.isNull(t.getCreateId())) {
            t.setCreateId(loginUser.getUserId());
            t.setUpdateId(loginUser.getUserId());

            t.setCreateName(loginUser.getUsername());
            t.setUpdateName(loginUser.getUsername());
        }
    }

    public static <T extends BaseDaoByEntity> void fillUpdateLoginUser(T t) {
        AssertUtil.isTrue(ObjectUtil.isNull(t), "填充登录用户信息的类不能为空");
        LoginUser loginUser = getLoginUser();
        if (ObjectUtil.isNull(t.getUpdateId())) {
            t.setUpdateId(loginUser.getUserId());
            t.setUpdateName(loginUser.getUsername());
        }

    }

    /**
     * 是否是管理员
     */
    public static boolean isAdmin(LoginUser loginUser) {

        if (StrUtil.isBlank(loginUser.getUsername())) {
            return false;
        }
        return "admin".equals(loginUser.getUsername());
    }

    /**
     * 校验是否有角色
     *
     * @param loginUser
     */
    public static void checkRole(LoginUser loginUser) {
        AssertUtil.isTrue(CollUtil.isEmpty(loginUser.getUserRoles()), "用户没有分配角色");
    }

    /**
     * 校验是否有权限
     *
     * @param loginUser
     */
    public static void checkDataScope(LoginUser loginUser) {
        AssertUtil.isTrue(CollUtil.isEmpty(loginUser.getDeptIds()), "用户没有分配权限");
    }


}

六、AOP数据权限校验基础类

数据权限校验基础类

package com.dashu.park.common.bean;

import com.fasterxml.jackson.annotation.JsonIgnore;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.ToString;

import java.util.List;

@Data
@ToString
@EqualsAndHashCode
public class DataScopeAopEntity {
    /**
     * 用户ID
     */
    @ApiModelProperty(value = "用户ID",hidden = true)
    private  Long userId;
    /**
     * 岗位
     */
    @ApiModelProperty(value = "岗位",hidden = true)
    private  List<Long> postId;
    /**
     * 部门Id
     */
    @ApiModelProperty(value = "岗位",hidden = true)
    private  List<Long> deptIds;
    /**
     * 组织Id
     */
    @ApiModelProperty(value = "组织Id",hidden = true)
    private List<Long> organizationIds;

}

数据权限校验入参

package com.interfaces.dept.dto;

import com.dashu.park.common.bean.BasePageDTO;
import com.dashu.park.common.bean.DataScopeAopEntity;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;


/**
 * @author DASHU
 */
@Data
public class DeptPageDto extends DataScopeAopEntity {


    @ApiModelProperty("组织链Id")
    private Long deptLinkId;

    @ApiModelProperty("父级Id")
    private Long parentId;

    @ApiModelProperty("组织名称")
    private String name;

    @ApiModelProperty("表示最大获取级别")
    private Integer maxLevel;


    @ApiModelProperty("级别")
    private Integer level;

    @ApiModelProperty(
            value = "页码，缺省值：1",
            example = "1"
    )
    private int pageNum = 1;

    @ApiModelProperty(
            value = "页数，缺省值：10",
            example = "10"
    )
    private int pageSize = 10;

}

七、使用AOP校验数据权限

    /**
     * 分页获取组织信息
     * @param dto
     * @return
     */
    @ApiOperation(value = "分页获取组织信息")
    @GetMapping("/page")
    @DataScope(checkRole = true,checkDataScope = true,dataScopeType = DataScopeType.DATA_SCOPE_DEPT)
    R<DeptListVo> page(DeptPageDto dto){
        return deptService.page(dto);
    }

参数解析
checkRole = true,//检查角色
checkDataScope = true, //检查数据
dataScopeType = DataScopeType.DATA_SCOPE_DEP //使用部门方式校验

使用Spring AOP做接口权限校验和日志记录
m0_49692893的博客
01-30 1919
AOP： 翻译为面向切面编程（Aspect Oriented Programming），它是一种编程思想，是面向对象编程（OOP）的一种补充。它的目的是在不修改源代码的情况下给程序动态添加额外功能。
AOP结合自定义注解实现权限验证
nihao2q的博客
04-18 836
之前一篇文章提到AOP可以实现权限校验，本篇就详细介绍一下AOP是如何基于自定义注解实现权限校验的。假设list接口需要用户拥有view权限才能访问，则可以在接口上添加 @RequirePermission(“view”)注解，当然直接把权限写入字符串的形式有所不妥，在实际项目中可以使用常量类或枚举类的形式维护权限，然后在注解中进行使用。假设del接口需要用户拥有delete权限才能访问，则在接口添加@RequirePermission(“delete”)即可。//业务逻辑。
【SpringBoot-3】切面AOP实现权限校验：实例演示与注解全解
热门推荐
云深不知处
10-26 6万+
何为AOP，AOP的注解详解，AOP的使用详例，以上内容尽在本文
SpringBoot | 越权和数据权限控制的一种实现方案
最新发布
Andya_net的博客
06-24 513
首先，我们需要定义一个自定义的注解，这个注解会包含操作类型（CRUD）、资产ID和资产名称作为入参。@Target(ElementType.METHOD) // 该注解作用于方法@Retention(RetentionPolicy.RUNTIME) // 运行时生效// 操作类型，默认为 READ// 资产 ID// 资产名称通过以上的实现，我们使用了自定义注解、切面编程和用户权限服务的组合来对方法进行权限控制，确保只读用户无法进行修改操作，同时判断其他用户是否有权限访问特定的资产。
使用AOP来进行权限鉴定
xcxcxcxx1的博客
04-18 807
我们在开发一个系统的时候，对于不同的用户会有不同的操作权限，比如管理员和普通用户。不能让普通用户也能去调用一些只能管理员调用的接口。总的来说，需要提高系统安全性就需要权限校验。aop是面向切面编程，是oop的一种补充，可以对某些事务进行统一管理，比如（权限校验、日志、事务管理），将共性需求的代码抽离出来，通过配置的方式，声明这些代码什么时候调用，还不用修改原有的代码。还是我们对aop的解释中说到，aop能将共性代码抽离，通过配置的方式声明什么时候调用，还不用修改原有代码。再定义一个权限校验的aop类。
SpringBoot：切面AOP实现权限校验
weixin_43654699的博客
01-24 2650
spring,spring boot,AOP,切面
AOP权限验证
m0_47760827的博客
03-02 748
创建自定义注解--给方法加验证 @Target(ElementType.METHOD)//此注解只能放在方法用 @Retention(RetentionPolicy.RUNTIME)//运行时生效 public @interface Ano { //默认游客 一个判断 规则的枚举 Role[] value() default Role.CUST; } 创建枚举类 用来修饰权限 public enum Role { /** *用户 管理员 游客 */
aop实现权限校验的过程
03-15
本篇文章将深入探讨如何使用AOP来实现权限校验的过程。 一、AOP概念理解 AOP的核心思想是切面，它将分散在多个对象中的横切关注点（如日志、安全检查等）封装起来，形成独立的模块，称为切面。切面可以包含两个主要...
自定义注解结合AOP实现接口权限校验
Tyler.shi的博客
09-07 1470
在编写接口api时，基于数据安全的考虑，我们通常会在接口进行权限校验，有权限的才可以查询数据，没有权限我们可以抛出异常“没有权限，禁止访问“。通常，我们实现是这样的： @ApiOperation("根据id查询用户信息") @GetMapping("/data/{id}") public BaseResponse<String> getData(@PathVa...
springboot通过自定义注解实现AOP角色权限校验
万米高空的博客
05-03 6147
这里有几个地方需要注意：1.自定义注解 2.aop,拦截器，过滤器的区别？ 1.在定义自己的注解之前，我们就必须要了解Java为我们提供的元注解和相关定义注解的语法。 元注解： 　　元注解的作用就是负责注解其他注解。Java5.0定义了4个标准的meta-annotation类型，它们被用来提供对其它 annotation类型作说明。Java5.0定义的元注解：1.@Target,2.@Rete...
SpringBoot：切面AOP实现权限校验：实例演示与注解全解
2401_84152223的博客
05-04 752
蚂蚁面试比较重视基础，所以Java那些基本功一定要扎实。蚂蚁的工作环境还是挺赞的，因为我面的是稳定性保障部门，还有许多单独的小组，什么三年1班，很有青春的感觉。面试官基本水平都比较高，基本都P7以上，除了基础还问了不少架构设计方面的问题，收获还是挺大的。经历这次面试我还通过一些渠道发现了需要大厂真实面试主要有：蚂蚁金服、拼多多、阿里云、百度、唯品会、携程、丰巢科技、乐信、软通动力、OPPO、银盛支付、中国平安等初，中级，高级Java面试题集合，附带超详细答案，希望能帮助到大家。
Java之Spring AOP 实现用户权限验证
08-31
本篇文章主要介绍了Java之Spring AOP 实现用户权限验证，用户登录、权限管理这些是必不可少的业务逻辑，具有一定的参考价值，有兴趣的可以了解一下。
使用SpringAop使用Oracle数据权限控制
07-14
使用SpringAop使用Oracle数据权限控制
Spring AOP实现功能权限校验功能的示例代码
08-28
本篇文章主要介绍了Spring AOP实现功能权限校验功能的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring boot 项目（七）——AOP权限校验
weixin_45974176的博客
09-18 464
前言 之前写过AOP切面的详细解读以及通过AOP切面来进行操作日志的入库，本篇主要通过AOP切面来达到校验权限的目的 这是之前文章的链接 1、Spring boot 项目（五）——AOP切面：https://blog.csdn.net/weixin_45974176/article/details/120365438 2、 操作流程 1、新建权限校验注解 @Target(ElementType.METHOD) // 该注解可以作用于那些类型元素上：类、方法、字段 @Retention(Retentio
SpringBoot基础-AOP权限验证
weixin_46899412的博客
05-21 3256
AOP权限验证，@Around使用小案例
使用AOP思想实现项目中对数据权限的处理
jikeyeka的博客
08-04 1096
aop设置前置通知处理数据权限
AOP实现RBAC权限验证
博客
05-17 501
首先引入AOP的依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> TokenUtil工具类 作用：1.通过用户生成token ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值