若依框架中的数据权限

于 2024-07-25 15:48:22 发布
阅读量309 收藏 3
点赞数 2
分类专栏： 若依系统相关问题 文章标签： java ruoyi
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tq18112086449/article/details/140691193
版权

一、图示

在这里插入图片描述
在这里插入图片描述

二、具体实现

2.1数据权限过滤注解

该注解DataScope是若依中自己定义的一个注解

package com.ruoyi.common.annotation;

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

/**
 * 数据权限过滤注解
 * 
 * @author ruoyi
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataScope
{
    /**
     * 部门表的别名
     */
    public String deptAlias() default "";

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

    /**
     * 权限字符（用于多个角色匹配符合要求的权限）默认根据权限注解@ss获取，多个权限用逗号分隔开来
     */
    public String permission() default "";
}

2.2数据过滤处理

权限分为全部数据权限、自定义数据权限、部门数据权限、部门及以下数据权限、仅本人数据权限。

package com.haichen.aspectj;

import java.util.ArrayList;
import java.util.List;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.haichen.common.entity.BaseEntity;
import com.haichen.common.text.Convert;
import com.haichen.common.annotation.PermissionContextHolder;
import com.haichen.common.annotation.DataScope;
import com.haichen.common.entity.SysRoleEntity;
import com.haichen.common.entity.SysUserEntity;
import com.haichen.common.utils.JedisUtil;
import com.haichen.common.utils.StringUtils;
import com.haichen.common.utils.jwt.JwtUtils;
import com.haichen.shiro.service.SysUserService;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import redis.clients.jedis.Jedis;


/**
 * 数据过滤处理
 *
 * @author ruoyi
 */
@Aspect
@Component
public class DataScopeAspect {
    /**
     * 全部数据权限
     */
    public static final String DATA_SCOPE_ALL = "1";

    /**
     * 自定数据权限
     */
    public static final String DATA_SCOPE_CUSTOM = "2";

    /**
     * 部门数据权限
     */
    public static final String DATA_SCOPE_DEPT = "3";

    /**
     * 部门及以下数据权限
     */
    public static final String DATA_SCOPE_DEPT_AND_CHILD = "4";

    /**
     * 仅本人数据权限
     */
    public static final String DATA_SCOPE_SELF = "5";

    /**
     * 数据权限过滤关键字
     */
    public static final String DATA_SCOPE = "dataScope";

    @Autowired
    private JwtUtils jwtUtils;

    @Autowired
    private JedisUtil jedisUtil;

    @Autowired
    private SysUserService sysUserService;

    @Before("@annotation(controllerDataScope)")
    public void doBefore(JoinPoint point, DataScope controllerDataScope) throws Throwable {
        clearDataScope(point);
        handleDataScope(point, controllerDataScope);
    }

    protected void handleDataScope(final JoinPoint joinPoint, DataScope controllerDataScope){
        ServletRequestAttributes sra = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        String token = sra.getRequest().getHeader("token");
        String userId = jwtUtils.getUserId(token);
        //获取当前的用户
        Jedis jedis = jedisUtil.getJedis();
        String jsonStr = jedis.get(userId);
        JSONObject jsonObject = JSONObject.parseObject(jsonStr);
//        SysUserEntity currentUser=new SysUserEntity();
//        currentUser.setUserId(jsonObject.getLong("userId"));
//        currentUser.setDeptId(jsonObject.getLong("deptId"));
//        JSONArray jsonArray=jsonObject.getJSONArray("roles");
//        List<SysRoleEntity> roles=jsonArray.toJavaList(SysRoleEntity.class);
//        currentUser.setRoles(roles);
        SysUserEntity currentUser = jsonObject.toJavaObject(SysUserEntity.class);
        jedisUtil.returnJedis(jedis);
//        jedisUtil.getJedis().close();
        if (currentUser != null) {
            // 如果是超级管理员，则不过滤数据
            if (!currentUser.isAdmin()) {
                String permission = StringUtils.defaultIfEmpty(controllerDataScope.permission(), PermissionContextHolder.getContext());
                dataScopeFilter(joinPoint, currentUser, controllerDataScope.deptAlias(),
                        controllerDataScope.userAlias(), permission);
            }
        }
    }

    /**
     * 数据范围过滤
     *
     * @param joinPoint  切点
     * @param user       用户
     * @param deptAlias  部门别名
     * @param userAlias  用户别名
     * @param permission 权限字符
     */
    public static void dataScopeFilter(JoinPoint joinPoint, SysUserEntity user, String deptAlias, String userAlias, String permission) {
        StringBuilder sqlString = new StringBuilder();
        List<String> conditions = new ArrayList<String>();

        for (SysRoleEntity role : user.getRoles())
        {
            String dataScope = role.getDataScope();
            if (!DATA_SCOPE_CUSTOM.equals(dataScope) && conditions.contains(dataScope))
            {
                continue;
            }
            if (StringUtils.isNotEmpty(permission) && StringUtils.isNotEmpty(role.getPermissions())
                    && !StringUtils.containsAny(role.getPermissions(), Convert.toStrArray(permission)))
            {
                continue;
            }
            if (DATA_SCOPE_ALL.equals(dataScope))
            {
                sqlString = new StringBuilder();
                conditions.add(dataScope);
                break;
            }
            else if (DATA_SCOPE_CUSTOM.equals(dataScope))
            {
                sqlString.append(StringUtils.format(
                        " OR {}.org_id IN ( SELECT dept_id FROM sys_role_dept WHERE role_id = {} ) ", deptAlias,
                        role.getRoleId()));
            }
            else if (DATA_SCOPE_DEPT.equals(dataScope))
            {
                sqlString.append(StringUtils.format(" OR {}.org_id = {} ", deptAlias, user.getDeptId()));
            }
            else if (DATA_SCOPE_DEPT_AND_CHILD.equals(dataScope))
            {
                sqlString.append(StringUtils.format(
                        " OR {}.org_id IN ( SELECT org_id FROM sys_org WHERE org_id = {} or find_in_set( {} , ancestors ) )",
                        deptAlias, user.getDeptId(), user.getDeptId()));
            }
            else if (DATA_SCOPE_SELF.equals(dataScope))
            {
                if (StringUtils.isNotBlank(userAlias))
                {
                    sqlString.append(StringUtils.format(" OR {}.user_id = {} ", userAlias, user.getUserId()));
                }
                else
                {
                    // 数据权限为仅本人且没有userAlias别名不查询任何数据
                    sqlString.append(StringUtils.format(" OR {}.dept_id = 0 ", deptAlias));
                }
            }
            conditions.add(dataScope);
        }

        // 多角色情况下，所有角色都不包含传递过来的权限字符，这个时候sqlString也会为空，所以要限制一下,不查询任何数据
//        if (StringUtils.isEmpty(conditions)) {
//            sqlString.append(StringUtils.format(" OR {}.dept_id = 0 ", deptAlias));
//        }

        if (StringUtils.isNotBlank(sqlString.toString())) {
            Object params = joinPoint.getArgs()[0];
            if (StringUtils.isNotNull(params) && params instanceof BaseEntity) {
                BaseEntity baseEntity = (BaseEntity) params;
                baseEntity.getParams().put(DATA_SCOPE, " AND (" + sqlString.substring(4) + ")");
            }
        }
    }


    /**
     * 拼接权限sql前先清空params.dataScope参数防止注入
     */
    private void clearDataScope(final JoinPoint joinPoint) {
        Object params = joinPoint.getArgs()[0];
        if (StringUtils.isNotNull(params) && params instanceof BaseEntity) {
            BaseEntity baseEntity = (BaseEntity) params;
            baseEntity.getParams().put(DATA_SCOPE, "");
        }
    }
}

2.3使用注解

    /**
     * 根据条件分页查询用户列表
     * 
     * @param user 用户信息
     * @return 用户信息集合信息
     */
    @Override
    @DataScope(deptAlias = "d", userAlias = "u")
    public List<SysUser> selectUserList(SysUser user)
    {
        return userMapper.selectUserList(user);
    }

重点：

@DataScope(deptAlias = "d", userAlias = "u")

deptAlias的 “d” 代表部门表的别名，userAlias的 “u” 代表用户表的别名，同sql保持一致。

2.4编写sql

<select id="selectUserList" parameterType="SysUser" resultMap="SysUserResult">
		select u.user_id, u.dept_id, u.nick_name, u.user_name, u.email, u.avatar, u.phonenumber, u.sex, u.status, u.del_flag, u.login_ip, u.login_date, u.create_by, u.create_time, u.remark, d.dept_name, d.leader from sys_user u
		left join sys_dept d on u.dept_id = d.dept_id
		where u.del_flag = '0'
		<if test="userId != null and userId != 0">
			AND u.user_id = #{userId}
		</if>
		<if test="userName != null and userName != ''">
			AND u.user_name like concat('%', #{userName}, '%')
		</if>
		<if test="status != null and status != ''">
			AND u.status = #{status}
		</if>
		<if test="phonenumber != null and phonenumber != ''">
			AND u.phonenumber like concat('%', #{phonenumber}, '%')
		</if>
		<if test="params.beginTime != null and params.beginTime != ''"><!-- 开始时间检索 -->
			AND date_format(u.create_time,'%y%m%d') &gt;= date_format(#{params.beginTime},'%y%m%d')
		</if>
		<if test="params.endTime != null and params.endTime != ''"><!-- 结束时间检索 -->
			AND date_format(u.create_time,'%y%m%d') &lt;= date_format(#{params.endTime},'%y%m%d')
		</if>
		<if test="deptId != null and deptId != 0">
			AND (u.dept_id = #{deptId} OR u.dept_id IN ( SELECT t.dept_id FROM sys_dept t WHERE find_in_set(#{deptId}, ancestors) ))
		</if>
		<!-- 数据范围过滤 -->
		${params.dataScope}
	</select>

重点：

<!-- 数据范围过滤 -->
   ${params.dataScope}

2.5 注意

SysUser extends BaseEntity

BaseEntity：

package com.ruoyi.common.core.domain;

import java.io.Serializable;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonInclude;

/**
 * Entity基类
 * 
 * @author ruoyi
 */
public class BaseEntity implements Serializable
{
    private static final long serialVersionUID = 1L;

    /** 搜索值 */
    @JsonIgnore
    private String searchValue;

    /** 创建者 */
    private String createBy;

    /** 创建时间 */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date createTime;

    /** 更新者 */
    private String updateBy;

    /** 更新时间 */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date updateTime;

    /** 备注 */
    private String remark;

    /** 请求参数 */
    @JsonInclude(JsonInclude.Include.NON_EMPTY)
    private Map<String, Object> params;

    public String getSearchValue()
    {
        return searchValue;
    }

    public void setSearchValue(String searchValue)
    {
        this.searchValue = searchValue;
    }

    public String getCreateBy()
    {
        return createBy;
    }

    public void setCreateBy(String createBy)
    {
        this.createBy = createBy;
    }

    public Date getCreateTime()
    {
        return createTime;
    }

    public void setCreateTime(Date createTime)
    {
        this.createTime = createTime;
    }

    public String getUpdateBy()
    {
        return updateBy;
    }

    public void setUpdateBy(String updateBy)
    {
        this.updateBy = updateBy;
    }

    public Date getUpdateTime()
    {
        return updateTime;
    }

    public void setUpdateTime(Date updateTime)
    {
        this.updateTime = updateTime;
    }

    public String getRemark()
    {
        return remark;
    }

    public void setRemark(String remark)
    {
        this.remark = remark;
    }

    public Map<String, Object> getParams()
    {
        if (params == null)
        {
            params = new HashMap<>();
        }
        return params;
    }

    public void setParams(Map<String, Object> params)
    {
        this.params = params;
    }
}

params这个很关键，不能缺失。

桂花白米糕
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
若依开源框架中数据权限的使用及配置
乘风偷月的博客
06-25 2万+
对于数据隔离问题，也就是不同角色的用户拥有的数据权限问题，虽然文档也有描述，也有一个现成的例子，但是没有结果业务功能，看得有点不太好理解，我这里直接举例业务功能的例子，帮助朋友们根据自己业务去做调整，完成数据权限的使用，能够满足业主的需求...
基于若依框架的数据权限。
热门推荐
莫听雨的博客
11-21 1万+
数据权限 数据权限和菜单权限不一样 菜单权限： 根据不同的性质的用户，显示不同的菜单。 数据权限： 设置权限，不同的用户只能访问本用户的数据，或者本部门的数据。当然对于特殊的领导可以跨部门访问数据。这些都是可以设置权限。 此代码的数据权限是基于若依框架，基于部门权限的简单数据权限设置。 实现功能 本系统针对多个幼儿园，不同的幼儿园园长，只能增删查改属于本幼儿园的儿童信息。但是所有的儿童信息都储存在同一个表中。此时就需要对不同的幼儿园园长设置数据权限。 实现步骤 在设置儿童信息表时，添加一个字段
若依框架数据权限源码解析
世界在我口袋的博客
12-17 1864
结合注解标注的方法来看,下面注解标记的方法,只有一个SysUser类型的参数。一个车间[部门]的负责人[角色]只能查看自己车间的设备数据。生成代码(这步就不展示了可以参考我先前的文章)添加注解,并改造xml文件。
若依框架 - 数据权限配置及使用
JavaSE_991226的博客
08-31 997
注意: 实体类需要继承 “BaseEntity” 类, 要不然没有params参数。1、仅本人数据权限，说明自己看自己的。一般情况下这种最底层的操作人员；进入该模块的Mapper.xml中，增加若依框架的。3、管理人员，那么可以看到本部门及以下的数据；2、部门经理，则只能看本部门人员的数据；
若依框架 使用数据权限功能
编程圈子-谢厂节的博客
10-20 2396
低代码开发框架若依，使用数据权限功能。
若依框架使用数据权限
小草的博客
07-10 9709
1.若依架构自带的数据权限为以下几种： 2.再功能模块给用户角色配置对应的数据权限如何让它生效 1）查看自己若依架构的 com.ruoyi.framework.aspectj. DataScopeAspect类 /** * 数据过滤处理 * * @author ruoyi */ @Aspect @Component public class DataScopeAspect { /** * 全部数据权限 */ public static fin.
若依框架 --- 使用数据权限功能
02-21 946
若依框架使用数据权限功能
权限管理之数据权限（若依框架）
狼魂之力
03-21 2075
从该属性中可以获取到需要拼接的sql。需要拼接的sql是在切面类中前置方法中存入的。在service层，Aop处理将sql片段，加入到bean属性map中，key是dataScope，value是sql片段。数据权限说明：不同的用户查看到的数据不一样。比如，部门经理可以查看属于该部门的所有数据，该部门普通员工只能查看属于自己的数据。用户发起请求，后台获取用户的角色，从角色中读取data_scope字段。核心逻辑是sql的拼接，使用的是Aop技术实现。注解类中的字段是用来拼接sql时，获取表的别名。
若依框架中权限管理的后端实现
weixin_51643592的博客
06-25 3742
若依框架中权限管理的后端实现
若依角色与权限字符串
世界在我口袋的博客
12-07 3432
基于权限字段串和基于角色的访问控制是两种不同的权限管理模型，它们各自有其优点和应用场景。若依框架采用了基于角色（Role-Based Access Control, RBAC）的权限控制模型。这种模型将权限与角色相关联，而不是直接与用户关联，从而提高了灵活性和可扩展性。在若依框架中，用户通过被赋予不同的角色来获得相应的权限。开发者可以创建多个角色，并为每个角色分配不同的权限。然后将这些角色分配给用户，以实现对用户权限的管理。此外，若依框架还提供了数据权限控制、按钮级权限控制等功能，以适应复杂的业务需求。
若依微服务框架111-125视频章节
07-11
├── 111 数据权限相关使用 ├── 112 数据权限代码详解 ├── 113 数据权限业务实现 ├── 114 应用容器介绍 ├── 115 应用容器架构概念 ├── 116 应用容器镜像命令 ├── 117 应用容器容器命令 ├── ...
若依框架分布式事务配置和项目启动手册
04-11
《若依框架分布式事务配置与...通过阅读《分布式事务 _ RuoYi.pdf》、《后台手册 _ RuoYi.pdf》等文档，以及实践《环境部署 _ RuoYi.pdf》中的步骤，开发者能够更深入地理解若依框架的分布式事务管理和项目启动过程。
离线版若依框架的说明文档
05-09
3. **数据权限控制**：若依提供了细粒度的数据权限控制，可以对不同角色进行不同级别的数据操作限制。 4. **代码生成器**：内置代码生成器可以自动生成CRUD操作的Java代码和前端页面，大大减少了开发工作量。 5. *...
若依框架集成达梦数据库完整源码
11-16
本文将详细介绍如何在若依框架中集成达梦数据库，并探讨相关技术细节。 **1. 若依框架介绍** 若依框架的核心特性包括： - **模块化设计**：若依采用模块化结构，可以灵活地增删功能，如权限管理、字典管理、工作...
若依-mybatisplus框架
03-04
3. **权限控制**：若依框架内置了完善的权限控制机制，支持RBAC（Role-Based Access Control）角色权限控制，能够根据用户角色动态生成菜单和操作按钮，确保系统安全。 4. **快速开发**：若依提供了一系列的生成...
12. Hibernate 模板设计模式
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1153
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
redis+spring面试题
github_36510643的博客
07-21 415
redis+spring面试题
Java-Lambda
lizhiwei21的博客
07-21 453
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Java内存模型
weixin_44267758的博客
07-19 796
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
若依框架数据权限如何进行分配
05-12
在依框架中，数据权限可以通过角色、用户、组织机构等方式进行分配。具体步骤如下： 1. 定义数据权限规则：在依框架后台管理系统中，可以定义数据权限规则，如“只能查看自己的数据”、“只能查看本部门的数据”等。 2. 分配数据权限：可以通过角色、用户、组织机构等方式将数据权限规则分配给相应的用户或角色。例如，将“只能查看本部门的数据”规则分配给某个部门的所有成员或某个角色。 3. 数据权限控制：当用户访问相关数据时，依框架会根据用户的身份和所属角色等信息，自动判断用户是否具有相应的数据权限，并进行相应的数据过滤操作。这样可以保证用户仅能访问其具有数据权限的数据，从而保护敏感数据的安全性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值