数据权限过滤注解

已于 2022-10-03 22:51:40 修改
阅读量785 收藏 2
点赞数 2
分类专栏： spring boot 文章标签： mybatis java spring boot
于 2022-10-02 22:02:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_46159525/article/details/127146823
版权

文章目录

根据权限去定义能看到那些数据，自定义注解和切面，动态修改 sql 进行数据查询。


🍉 环境搭建

新建项目并添加依赖：

<!--        aop -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
<!--        mybatis-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.2</version>
        </dependency>
<!--        mybatis-plus 生成工具 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.5.2</version>
        </dependency>
<!--spring security-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
<!--        freemaker -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-freemarker</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.4</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

application.properties 配置：

# 应用名称
spring.application.name=data_scope
# 应用服务 WEB 访问端口
server.port=8080
#下面这些内容是为了让MyBatis映射
#指定Mybatis的Mapper文件
mybatis.mapper-locations=classpath:mappers/*xml
#指定Mybatis的实体目录
#mybatis.type-aliases-package=org.javaboy.ds.mybatis.entity
# 数据库驱动：
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# 数据源名称
#spring.datasource.name=defaultDataSource
# 数据库连接地址
spring.datasource.url=jdbc:mysql://192.168.10.10:3306/ry-vue?serverTimezone=Asia/Shanghai&useSSL=false
# 数据库用户名&密码：
spring.datasource.username=root
spring.datasource.password=root

配置 mybatis-plus 代码生成器：

在这里插入图片描述

@SpringBootTest
class DataScopeApplicationTests {

    @Test
    void contextLoads() {

        FastAutoGenerator.create("jdbc:mysql://192.168.10.10:3306/ry-vue?serverTimezone=Asia/Shanghai&useSSL=false", "root", "root")
                .globalConfig(builder -> {
                    builder.author("javaboy") // 设置作者
                            .fileOverride() // 覆盖已生成文件
                            .outputDir("D:\\workspace\\ruoyi_test\\data_scope\\src\\main\\java"); // 指定输出目录
                })
                .packageConfig(builder -> {
                    builder.parent("org.javaboy.ds") // 设置父包名
//                            .moduleName("system") // 设置父包模块名
                            .pathInfo(Collections.singletonMap(OutputFile.xml, "D:\\workspace\\ruoyi_test\\data_scope\\src\\main\\resources\\mapper")); // 设置mapperXml生成路径
                })
                .strategyConfig(builder -> {
                    builder.addInclude("sys_dept","sys_role","sys_user") // 设置需要生成的表名
                            .addTablePrefix("sys_"); // 设置过滤表前缀
                })
                .templateEngine(new FreemarkerTemplateEngine()) // 使用Freemarker引擎模板，默认的是Velocity引擎模板
                .execute();
    }

}

user 用户：

@TableName("sys_user")
public class User extends BaseEntity implements Serializable, UserDetails {

    private static final long serialVersionUID = 1L;

    /**
     * 用户ID
     */
    @TableId(value = "user_id", type = IdType.AUTO)
    private Long userId;

    /**
     * 部门ID
     */
    private Long deptId;

    /**
     * 用户账号
     */
    private String userName;

    /**
     * 用户昵称
     */
    private String nickName;

    /**
     * 用户类型（00系统用户）
     */
    private String userType;

    /**
     * 用户邮箱
     */
    private String email;

    /**
     * 手机号码
     */
    private String phonenumber;

    /**
     * 用户性别（0男 1女 2未知）
     */
    private String sex;

    /**
     * 头像地址
     */
    private String avatar;

    /**
     * 密码
     */
    private String password;

    /**
     * 帐号状态（0正常 1停用）
     */
    private String status;

    /**
     * 删除标志（0代表存在 2代表删除）
     */
    private String delFlag;

    /**
     * 最后登录IP
     */
    private String loginIp;

    /**
     * 最后登录时间
     */
    private LocalDateTime loginDate;

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

    /**
     * 创建时间
     */
    private LocalDateTime createTime;

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

    /**
     * 更新时间
     */
    private LocalDateTime updateTime;

    /**
     * 备注
     */
    private String remark;

    @TableField(exist = false)
    public List<Role> roles;

    public static long getSerialVersionUID() {
        return serialVersionUID;
    }

    public List<Role> getRoles() {
        return roles;
    }

    public void setRoles(List<Role> roles) {
        this.roles = roles;
    }

    public Long getUserId() {
        return userId;
    }

    public void setUserId(Long userId) {
        this.userId = userId;
    }

    public Long getDeptId() {
        return deptId;
    }

    public void setDeptId(Long deptId) {
        this.deptId = deptId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getNickName() {
        return nickName;
    }

    public void setNickName(String nickName) {
        this.nickName = nickName;
    }

    public String getUserType() {
        return userType;
    }

    public void setUserType(String userType) {
        this.userType = userType;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getPhonenumber() {
        return phonenumber;
    }

    public void setPhonenumber(String phonenumber) {
        this.phonenumber = phonenumber;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getAvatar() {
        return avatar;
    }

    public void setAvatar(String avatar) {
        this.avatar = avatar;
    }

    @Override
    // 忽略生成 json
    @JsonIgnore
    public Collection<? extends GrantedAuthority> getAuthorities() {

        List<SimpleGrantedAuthority> collect = roles.stream().map(r -> new SimpleGrantedAuthority(r.getRoleKey())).collect(Collectors.toList());
        return collect ;
    }

    @Override
    public String getPassword() {
        return password;
    }

    @Override
    public String getUsername() {
        return userName;
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    public String getDelFlag() {
        return delFlag;
    }

    public void setDelFlag(String delFlag) {
        this.delFlag = delFlag;
    }

    public String getLoginIp() {
        return loginIp;
    }

    public void setLoginIp(String loginIp) {
        this.loginIp = loginIp;
    }

    public LocalDateTime getLoginDate() {
        return loginDate;
    }

    public void setLoginDate(LocalDateTime loginDate) {
        this.loginDate = loginDate;
    }

    public String getCreateBy() {
        return createBy;
    }

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

    public LocalDateTime getCreateTime() {
        return createTime;
    }

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

    public String getUpdateBy() {
        return updateBy;
    }

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

    public LocalDateTime getUpdateTime() {
        return updateTime;
    }

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

    public String getRemark() {
        return remark;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", deptId=" + deptId +
                ", userName=" + userName +
                ", nickName=" + nickName +
                ", userType=" + userType +
                ", email=" + email +
                ", phonenumber=" + phonenumber +
                ", sex=" + sex +
                ", avatar=" + avatar +
                ", password=" + password +
                ", status=" + status +
                ", delFlag=" + delFlag +
                ", loginIp=" + loginIp +
                ", loginDate=" + loginDate +
                ", createBy=" + createBy +
                ", createTime=" + createTime +
                ", updateBy=" + updateBy +
                ", updateTime=" + updateTime +
                ", remark=" + remark +
                "}";
    }
}

role 角色：

@TableName("sys_dept")
public class Dept extends BaseEntity implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 部门id
     */
    @TableId(value = "dept_id", type = IdType.AUTO)
    private Long deptId;

    /**
     * 父部门id
     */
    private Long parentId;

    /**
     * 祖级列表
     */
    private String ancestors;

    /**
     * 部门名称
     */
    private String deptName;

    /**
     * 显示顺序
     */
    private Integer orderNum;

    /**
     * 负责人
     */
    private String leader;

    /**
     * 联系电话
     */
    private String phone;

    /**
     * 邮箱
     */
    private String email;

    /**
     * 部门状态（0正常 1停用）
     */
    private String status;

    /**
     * 删除标志（0代表存在 2代表删除）
     */
    private String delFlag;

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

    /**
     * 创建时间
     */
    private LocalDateTime createTime;

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

    /**
     * 更新时间
     */
    private LocalDateTime updateTime;
    // 省略 get/set/toString 方法
}

dept 部门：

@TableName("sys_dept")
public class Dept extends BaseEntity implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 部门id
     */
    @TableId(value = "dept_id", type = IdType.AUTO)
    private Long deptId;

    /**
     * 父部门id
     */
    private Long parentId;

    /**
     * 祖级列表
     */
    private String ancestors;

    /**
     * 部门名称
     */
    private String deptName;

    /**
     * 显示顺序
     */
    private Integer orderNum;

    /**
     * 负责人
     */
    private String leader;

    /**
     * 联系电话
     */
    private String phone;

    /**
     * 邮箱
     */
    private String email;

    /**
     * 部门状态（0正常 1停用）
     */
    private String status;

    /**
     * 删除标志（0代表存在 2代表删除）
     */
    private String delFlag;

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

    /**
     * 创建时间
     */
    private LocalDateTime createTime;

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

    /**
     * 更新时间
     */
    private LocalDateTime updateTime;
 // 省略 get/set/toString 方法
}

重写 UserService 方法：

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService, UserDetailsService {

    @Override
    public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {
        LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(User::getUserName,s);
        User user = this.baseMapper.selectOne(wrapper);
        if (ObjectUtils.isEmpty(user)){
            throw new UsernameNotFoundException("用户不存在!");
        }
        return user;
    }
}

配置 spring security：

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired
    private UserServiceImpl userService;

    @Bean
    PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userService);
    }
}

在这里插入图片描述

🍉 功能实现

创建一个 BaseEtity 的基类，所有的 model 继承该基类。需要追加的 sql 存放在 params 参数中。

/**
 * @author: yueLQ
 * @date: 2022-09-27 20:23
 *
 * 需要追加的 sql 放到 params 中去
 */
public class BaseEntity {

    @TableField(exist = false)
    private Map<String,String> params = new HashMap<>();

    public Map<String, String> getParams() {
        return params;
    }

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

定义 @dataScope 注解，在需要进行权限的地方标注：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface DataScope {

    /**
     *  部门
     * @return
     */
    String deptAlias() default  "";

    /**
     *  用户
     * @return
     */
    String userAlias() default  "";
}

创建切面，进行业务上的权限处理，本质上是进行 sql 拼接，对数据进行处理：

@Component
@Aspect
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";
    // params 中传递的参数
    public static final String DATA_SCOPE = "data_scope";

    @Before("@annotation(dataScope)")
    public void doBefore(JoinPoint point, DataScope dataScope) {
        // 清除 params 中的数据，防止接口调用时候传入参数
        clearDataScope(point);
        // 获取当前登录用户信息
        User user = (User) SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        if (user.getUserId() == 1L) {
            // 说明是超级管理员，不用进行权限过过滤
            return;
        }
        // 进行现有 sql 进行追加
        StringBuilder sql = new StringBuilder();
        // 获取角色
//        select * from  sys_dept d where d.del_flag='0'
//        and  dept_id in (select rd.dept_id from  sys_role_dept rd where
//                rd.role_id=2	 )
        List<Role> roles = user.getRoles();
        for (Role role : roles) {
            // 获取角色的数据权限
            String scope = role.getDataScope();
            switch (scope){
                case DATA_SCOPE_ALL:
                    // 如果用户能查所有数据，这里不需要做什么
                    return;
                case DATA_SCOPE_CUSTOM:
                    // 自定义数据权限，那么就根据用户角色，去查找到部门 id
                    sql.append(String
                            .format("OR %s.dept_id in(select rd.dept_id from sys_role_dept rd where rd.role_id=%d)"
                            ,dataScope.deptAlias(),role.getRoleId()));
                    break;
                case DATA_SCOPE_DEPT:
                    sql.append(String.format("OR %s.dept_id=%d",dataScope.deptAlias(),user.getDeptId()));
                    break;
                case DATA_SCOPE_DEPT_AND_CHILD:
                    sql.append(String.format("OR %s.dept_id in (select dept_id from sys_dept WHERE dept_id=%d or FIND_IN_SET(%d,`ancestors`))"
                            ,dataScope.deptAlias()
                            ,user.getDeptId(),user.getDeptId()));
                    break;
                case DATA_SCOPE_SELF:
                    String userAlias = dataScope.userAlias();
                     if ("".equals(userAlias)){
                         // 数据权限仅限于本人
                         sql.append("OR 1=0");
                     }else {
                         sql.append(String.format("OR %s.user_id=%d",dataScope.userAlias(),user.getUserId()));
                     }
                    break;
                default:
                    break;
            }
        }
        // and (xxx or xxx or xxx)
        Object arg = point.getArgs()[0];
        if (arg!=null&&arg instanceof  BaseEntity){
            BaseEntity entity = (BaseEntity) arg;
            entity.getParams().put(DATA_SCOPE,"AND ("+sql.substring(3)+")");
        }
    }

    /**
     * 如果 params 中已经有参数了，则删除掉，防止 sql 注入
     *
     * @param point
     */
    private void clearDataScope(JoinPoint point) {
        Object arg = point.getArgs()[0];
        if (arg != null && arg instanceof BaseEntity) {
            BaseEntity baseEntity = (BaseEntity) arg;
            baseEntity.getParams().put(DATA_SCOPE, "");
        }
    }
}

在这里插入图片描述

🍉 部门权限

controller、service,mapper…

// controller
@RestController
@RequestMapping("/dept")
public class DeptController {

    @Autowired
    IDeptService deptService;

    @DataScope(deptAlias = "d")
    @GetMapping("/")
    public List<Dept> getAllDepts(Dept dept){
        return deptService.getAllDepts(dept);
    }
}
// serviceImpl
public interface IDeptService extends IService<Dept> {

    List<Dept> getAllDepts(Dept dept);
}

// service
@Service
public class DeptServiceImpl extends ServiceImpl<DeptMapper, Dept> implements IDeptService {

    @Autowired
    private DeptMapper deptMapper;

    @Override
    public List<Dept> getAllDepts(Dept dept) {
        return deptMapper.getAllDepts(dept);
    }
}
// mapper
public interface DeptMapper extends BaseMapper<Dept> {
    List<Dept> getAllDepts(Dept dept);
}

mapper 的 xml 文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.javaboy.ds.mapper.DeptMapper">

    <select id="getAllDepts" resultType="org.javaboy.ds.entity.Dept">
          select * from  sys_dept d where d.del_flag='0'
          ${params.data_scope}
    </select>
</mapper>

在这里插入图片描述

🍉 角色权限

controller、service,mapper…

// controller
@RestController
@RequestMapping("/role")
public class RoleController {

    @Autowired
    IRoleService iRoleService;

    @GetMapping("/")
    @DataScope(deptAlias = "d",userAlias = "u")
    public List<Role> getAllRoles(Role role){
        return iRoleService.getAllRoles(role);
    }
}
// serviceImpl
public interface IRoleService extends IService<Role> {

    List<Role> getAllRoles(Role role);
}
// service
@Service
public class RoleServiceImpl extends ServiceImpl<RoleMapper, Role> implements IRoleService {

    @Autowired
    private  RoleMapper roleMapper;

    @Override
    public List<Role> getAllRoles(Role role) {
        return roleMapper.getAllRoles(role);
    }
}
// mapper
public interface RoleMapper extends BaseMapper<Role> {

    List<Role> getAllRoles(Role role);
}

mapper 的 xml 文件：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.javaboy.ds.mapper.RoleMapper">

    <select id="getAllRoles" resultType="org.javaboy.ds.entity.Role">
     select r.* 
     from sys_role r 
     left join sys_user_role ur on r.role_id=ur.role_id 
     left join sys_user u on ur.user_id=u.user_id 
     left join sys_dept d on u.dept_id=d.dept_id where r.del_flag='0'
        ${params.data_scope}
    </select>
</mapper>
【D3S】数据权限 - 基于Mybatis的数据权限拦截器实现
罗小爬的技术宝书
07-02 1977
目录一、背景二、动机三、实现思路3.1 权限类型、操作类型3.2 统一用户及数据权限集合模型3.3 定义数据权限拦截注解3.4 提取配置属性3.5 数据权限拦截器实现四、集成方式五、关于D3S 一、背景 最近一直在做RBAC相关的架构设计与实现，传统的RBAC的权限控制只是控制到REST接口（url）、具体方法（权限码）等，而通常实际业务场景还需要对数据权限进行控制，例如： 用户仅允许查询自己的用户信息，不允许查询其他人的用户信息 用户仅被允许查询 同部门 或 同部门及子部门 的用户信息 用户仅允许查询指
Mybatis拦截器之数据权限过滤与分页集成
weixin_35383324的博客
01-31 1098
需求场景 最近项目有个数据权限的业务需求，要求大致为每个单位只能查看本级单位及下属单位的数据，例如：一个集团军下属十二个旅，那么军级用户可以看到所有数据，而每个旅则只能看到本旅部的数据，以此类推； 解决方案之改SQL 原sql SELECT a.id AS "id", a.NAME AS "name", a.sex_cd AS "sexCd", a.org_id AS "...
数据权限控制
03-09
支持各种数字信息的权限控制，主导思路采用的是自定义方言，完成对sql语句的控制，达到对数据安全的控制
注解实现数据权限过滤
weixin_50117915的博客
12-02 671
一般一些后台管理系统都会有租户或者组织架构的概念，由于租户或者组织都是属于某一群体的，因此他们的数据应该是隔离的。
基于Mybatis拦截器实现数据权限过滤
qq_43613885的博客
07-22 790
intercept方法这个方法是核心，当拦截到调用时会执行。Invocation 对象包含了被拦截方法的所有信息，包括方法本身、参数、目标对象等。在这个方法中，你可以做任何预处理或后处理逻辑，然后通过调用 invocation.proceed() 来继续执行原方法，或者直接返回自定义的结果。plugin方法这个方法用于决定是否对某个对象应用拦截器。如果返回 target，则表示不进行拦截；
mybatis拦截器数据权限过滤
java_xiaoba1的博客
03-06 2540
mybatis拦截器数据权限过滤
springboot权限控制_Spring Security 中的四种权限控制方式
weixin_39632397的博客
11-21 1354
Spring Security 中对于权限控制默认已经提供了很多了，但是，一个优秀的框架必须具备良好的扩展性，恰好，Spring Security 的扩展性就非常棒，我们既可以使用 Spring Security 提供的方式做授权，也可以自定义授权逻辑。一句话，你想怎么玩都可以！今天松哥来和大家介绍一下 Spring Security 中四种常见的权限控制方式。表达式控制 URL 路径权限表达式控...
java 利用注解，实现接口级别的请求限制和数据过滤
axiao321123的博客
09-11 817
由于接到项目需求，需求对项目接口进行的调用，进行请求限制和数据过滤本教程，我将向你介绍利用Java，利用注解，根据权限，实现接口级别的查询限制和数据过滤。
一个通用的数据权限的过滤方法，简单，高效，好用，支持的数据权限范围：仅本人、本组织、本组织及子组织、所有数据
最新发布
横竖撇折点
04-28 614
它的主要功能是根据当前登录用户的数据权限范围（如仅查看本人数据、本组织数据或子组织数据等），动态修改查询 SQL 的条件。SelectInterceptor 是一个功能强大的 MyBatis 拦截器，能够根据用户的数据权限范围动态修改查询条件，实现细粒度的数据权限控制。如果查询的是业务表，结合用户表和组织表，限制业务表的创建者 ID 在指定组织范围内。查询业务表时，结合用户表和组织表，限制业务表的创建者 ID 在指定组织范围内。查询参数的基类，包含默认查询条件、组织路径、忽略数据权限标志等属性。
7、数据权限注解
qq_47142993的博客
05-31 790
数据权限，一个注解搞定！ 注意点 占位符 sql.append(String.format(" OR %s.dept_id in(select rd.dept_id from sys_role_dept rd where rd.role_id=%d)", dataScope.deptAlias(), role.getRoleId())); mysql中的函数 mysql中find_in_set()函数的使用 https://www.cnblogs.com/xiaoxi/p/5889486.html 搭建项
Springboot管理系统数据权限过滤（三）——0业务入侵实现部门数据权限过滤
朗朗的博客
12-19 2231
上一章，讲解了SQL拦截器的，做了一个简单的SQL改造。本章要实现：以下简单用一个图说明了整个处理过程，红色框住的部分，就是本章要实现的内容：DataScope.java DataScope对象里面设置了用于数据权限规则数组。在SQL拦截器中将从这些数据权限规则中获取条件表达式。 DataPermissionRule.java 这里定义了一个权限解析接口，如此即可以扩展很多不同类型的权限，如：对部门过滤，本章我们仅实现对部门权限过滤。（若要实现对如预算科目、项目等过滤，可实现该接口，另外还得单独实现对这些数
java mybatis 过滤数据
weixin_42555971的博客
09-30 1478
过滤返回值
数据权限范围过滤的设计（通过注解形式实现数据权限过滤）
qq_61223023的博客
10-17 1267
创建拦截器类：创建一个类，实现 DataPermissionHandler 接口。在类中，重写 getSqlSegment方法，编写自定义的逻辑@Data@Aspect@Slf4j@Component/*** 通过ThreadLocal记录权限相关的属性值*//*** 清空当前线程上次保存的权限信息*/// 获得注解= null) {// 获取当前的用户及相关属性，需提前获取和保存数据权限对应的部门ID集合return;/*** 是否存在注解，如果存在就获取。
spring boot 使用 aop技术 实现数据权限过滤
weixin_41765715的博客
04-07 1220
spring boot使用aop技术实现数据权限过滤的功能
Springboot管理系统数据权限过滤（四）——mybatis数据权限插件
朗朗的博客
01-02 1849
Springboot管理系统数据权限过滤（三）——0业务入侵实现部门数据权限过滤数据权限实现的思路和代码实现已经了解。本节在此基础上实现支持mybatis框架的通用数据过滤插件。 实现目标：上一章示例，使用的是mytatisplus数据持久框架，使用是的mybatisplus拦截器，本章是基于mybatis持久化框，所以仅拦截器实现上有一点点差异，但我们也是可以引入mybatisplus的依赖包，但仅使用它的对SQL的处理上，这样可以省很多事。除了这一点，其他的代码都可以沿用上一章的内容。该项目初衷
Mybatis-Plus通过注解形式实现数据权限过滤
热门推荐
u011584350的博客
07-21 1万+
背景 本文借鉴若依快速开发框架的数据权限思路，通过注解形式实现数据权限过滤，优点是灵活方便。 代码 创建注解类 @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface DataScope { /** * 部门表的别名 */ public String deptAlias() default ""; /** * 部门字段名
MyBatis Plus 拦截器实现数据权限控制(完整版)
progammer10086的博客
06-09 7461
新增针对不需要做数据权限控制的注解
Mybatis -过滤查询
m0_63600788的博客
07-09 1556
属性是字符串类型，用户查询的时候，可能没传此参数或者传的是空字符串，所以我们需要在拼接条件之前进行判断，若用户查询传的是非空且有内容的的字符串时，才按照此条件过滤查询商品信息。根据前面我们对多条件过滤查询的分析得知，用户过滤查询时，请求时会传递可能会传递多个过滤条件的参数来查询对应的数据，又因为这些参数需要在后台多个层次之间进行传递（例如：在商品列表中，用户可以根据自己的需要，按照商品的名称和价格范围对商品进行查询。，这样既可以封装分页查询的参数，又可以封装过滤查询的参数，且减少代码重复。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

光头小小强007

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值