若依框架的简单学习

若依框架其实算是低代码开发框架，如果只是做一些简单的增删查改需求，那么基本上不需要写代码，复杂一点的需求也可以生成增删改查后进行简单的修改就可以了。今天再这里简单的学习一下下。

一、下载安装

1、下载源码

我这里做的是前后端分离的版本，去到官网
https://doc.ruoyi.vip/ruoyi-vue/
https://gitee.com/y_project/RuoYi-Vue
用git或者直接下载代码，这个就是后端代码。

里面有个前端，但是我们前端不用这个，因为这个是vue2版本的，我们从gitee的remark可以看到vue3版本的地址。

https://github.com/yangzongzhuan/RuoYi-Vue3

2、后台启动

我们需要redis和mysql，这里准备好后就修改相应的配置启动。对于mysql我们需要先建库

create database ry_vue;

然后执行sql下面的两个文件。配置修改地方如下

然后启动ruoyi-admin即可，后台启动后，端口是8080，所有接口都是

http://localhost:8080

3、前端启动

前端下载完后，执行

npm install
npm run dev

就可以用了，如果依赖下载慢可能要切换镜像https://registry.npmmirror.com。

4、访问测试

前后端启动后就可以访问了，用户密码admin/admin123

二、低代码开发

假设我们有个读物的维护功能，要有增删改导出等功能，那么怎么快速搞定呢？这里就要借助低代码开发了。假设有这样一张表.

1、建表

CREATE TABLE `reading` (
    `id` BIGINT(20) NOT NULL COMMENT '主键ID,雪花算法生成',
    `chinese_name` VARCHAR(255) NULL DEFAULT NULL COMMENT '中文名称' COLLATE 'utf8mb4_unicode_ci',
    `english_name` VARCHAR(255) NULL DEFAULT NULL COMMENT '英文名称' COLLATE 'utf8mb4_unicode_ci',
    `image_url` VARCHAR(255) NULL DEFAULT NULL COMMENT '书本图片' COLLATE 'utf8mb4_unicode_ci',
    `author_name` VARCHAR(100) NULL DEFAULT NULL COMMENT '作者名称' COLLATE 'utf8mb4_unicode_ci',
    `auth_desc` VARCHAR(1024) NULL DEFAULT NULL COMMENT '作者简介' COLLATE 'utf8mb4_unicode_ci',
    `content_desc` VARCHAR(1024) NULL DEFAULT NULL COMMENT '内容简介' COLLATE 'utf8mb4_unicode_ci',
    `status` CHAR(1) NULL DEFAULT NULL COMMENT '状态：0已下架，1已上架，2查看广告' COLLATE 'utf8mb4_unicode_ci',
    `create_datetime` VARCHAR(32) NULL DEFAULT NULL COMMENT '创建时间' COLLATE 'utf8mb4_unicode_ci',
    `sort` BIGINT(20) NULL DEFAULT NULL COMMENT '排序',
    `type` CHAR(1) NULL DEFAULT '0' COMMENT '类型，0是默认，1是首页推荐，2精品，3-最新更新' COLLATE 'utf8mb4_unicode_ci',
    `reading_status` CHAR(1) NULL DEFAULT '0' COMMENT '类型，0是更新中，1是已完本' COLLATE 'utf8mb4_unicode_ci',
    `reading_type` CHAR(1) NULL DEFAULT '0' COMMENT '类型，0拓展阅读，1小学初中，2高中大学' COLLATE 'utf8mb4_unicode_ci',
    PRIMARY KEY (`id`) USING BTREE
)
COLLATE='utf8mb4_unicode_ci'
ENGINE=InnoDB
;

2、通过导入功能导入表

3、编辑表

这里主要的是字段信息
【插入】值得是新增功能要维护的字段
【编辑】表示更新的时候要维护的字段
【列表】表示列表要展示的字段
【查询】表示要作为查询条件的字段

这里生成后后续我们只需要对代码进行小修改就好了，比如ID，我们会改下代码按我们自己的规范来生成比如

    public int insertReading(Reading reading)
    {
        reading.setId(System.currentTimeMillis());
        reading.setCreateDatetime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        return readingMapper.insertReading(reading);
    }

还有下拉框的类型，这里我们是从字典那里配置好

4、生成代码

生成完后是个压缩包，里面有后端的代码和前端的代码，以及相关的sql文件。我们只需要执行完sql将对应的代码黏贴到对应的目录重启就可以了。

启动就可以看到。

当然导出也是OK的，不过上面的截图我是调整过后的代码。

三、权限管理逻辑

在角色管理里面有个数据权限，发现权限功能很强大，那若依是怎么做到的呢？通过调试可以发现打印的ssql后面拼上了

and (dept_id =103)

然后去看代码Mapper的代码

多了

${params.dataScope}

这个肯定是后面拼上的，虽然开起来有注入的问题，但是应该都有解决。我们去看service

    @Override
    @DataScope(deptAlias = "d")
    public List<SysDept> selectDeptList(SysDept dept)
    {
        return deptMapper.selectDeptList(dept);
    }

发现有@DataScope注解。那这个注解什么时候用呢？是Mybatis的拦截器还是AOP呢，应该不会是Mybatis拦截器，如果是的话就不应该有${params.dataScope}这个代码。所以我们去找AOP

最后发现果然是AOP

这里做了两步，第一步是清除dataScode，估计是防止sql注入

 /**
     * 拼接权限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, "");
        }
    }

这里我们的参数都继承了BaseEntity，因为只有这个父类才params

然后就获取当前登录信息，毕竟要从当前登录信息里面去获取用户的角色权限，哪些角色的数据权限是怎样的，最后要获取用户所有的权限集合。

    protected void handleDataScope(final JoinPoint joinPoint, DataScope controllerDataScope)
    {
        // 获取当前的用户
        LoginUser loginUser = SecurityUtils.getLoginUser();
        if (StringUtils.isNotNull(loginUser))
        {
            SysUser currentUser = loginUser.getUser();
            // 如果是超级管理员，则不过滤数据
            if (StringUtils.isNotNull(currentUser) && !currentUser.isAdmin())
            {
                String permission = StringUtils.defaultIfEmpty(controllerDataScope.permission(), PermissionContextHolder.getContext());
                dataScopeFilter(joinPoint, currentUser, controllerDataScope.deptAlias(), controllerDataScope.userAlias(), permission);
            }
        }
    }

当然这里怎么获取用户登录信息，我们可以在controller或者springboot的拦截器过滤器将用户的信息token放入当前线程中，后续Mybatis的拦截器就可以获取了，这里不展开。

然后就各种根据用户选择的角色权限拼凑不同的sql

全部代码

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

DataScopeAspect

package com.ruoyi.framework.aspectj;
import java.util.ArrayList;
import java.util.List;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
import com.ruoyi.common.annotation.DataScope;
import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.core.domain.BaseEntity;
import com.ruoyi.common.core.domain.entity.SysRole;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.core.text.Convert;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.framework.security.context.PermissionContextHolder;
/**
 * 数据过滤处理
 *
 * @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";
    @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)
    {
        // 获取当前的用户
        LoginUser loginUser = SecurityUtils.getLoginUser();
        if (StringUtils.isNotNull(loginUser))
        {
            SysUser currentUser = loginUser.getUser();
            // 如果是超级管理员，则不过滤数据
            if (StringUtils.isNotNull(currentUser) && !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, SysUser user, String deptAlias, String userAlias, String permission)
    {
        StringBuilder sqlString = new StringBuilder();
        List<String> conditions = new ArrayList<String>();
        List<String> scopeCustomIds = new ArrayList<String>();
        user.getRoles().forEach(role -> {
            if (DATA_SCOPE_CUSTOM.equals(role.getDataScope()) && StringUtils.equals(role.getStatus(), UserConstants.ROLE_NORMAL) && StringUtils.containsAny(role.getPermissions(), Convert.toStrArray(permission)))
            {
                scopeCustomIds.add(Convert.toStr(role.getRoleId()));
            }
        });
        for (SysRole role : user.getRoles())
        {
            String dataScope = role.getDataScope();
            if (conditions.contains(dataScope) || StringUtils.equals(role.getStatus(), UserConstants.ROLE_DISABLE))
            {
                continue;
            }
            if (!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))
            {
                if (scopeCustomIds.size() > 1)
                {
                    // 多个自定数据权限使用in查询，避免多次拼接。
                    sqlString.append(StringUtils.format(" OR {}.dept_id IN ( SELECT dept_id FROM sys_role_dept WHERE role_id in ({}) ) ", deptAlias, String.join(",", scopeCustomIds)));
                }
                else
                {
                    sqlString.append(StringUtils.format(" OR {}.dept_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 {}.dept_id = {} ", deptAlias, user.getDeptId()));
            }
            else if (DATA_SCOPE_DEPT_AND_CHILD.equals(dataScope))
            {
                sqlString.append(StringUtils.format(" OR {}.dept_id IN ( SELECT dept_id FROM sys_dept WHERE dept_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, "");
        }
    }
}

四、总结

上面只是初步了解，还是很强大的。