java每日精进 5.07【框架之数据权限】-EW帮帮网

数据权限，实现指定用户可以操作指定范围的数据。

数据权限不支持指定用户只能查看数据的某些字段；

权限可以分成三类：功能权限、数据权限、字段权限。

目前可以使用数据脱敏实现一定程度的字段权限控制；

1.数据权限实现步骤

1.1插件原理

DataPermissionInterceptor 的工作原理与租户插件类似，它会在 SQL 执行前拦截 SQL 语句，并根据用户权限动态添加权限相关的 SQL 片段。这样，只有用户有权限访问的数据才会被查询出来。

1.2SQL片段组装的核心逻辑代码

JSQLParser 是一个开源的 SQL 解析库，可方便地解析和修改 SQL 语句。它是插件实现权限逻辑的关键工具，MyBatis-Plus 的数据权限依托于 JSQLParser 的解析能力。

以下示例展示如何使用 JSQLParser 来修改 SQL：

// 示例 SQL
String sql = "SELECT * FROM user WHERE status = 'active'";
Expression expression;

try {
    expression = CCJSqlParserUtil.parseCondExpression("status = 'inactive'");
    PlainSelect select = (PlainSelect) ((Select) CCJSqlParserUtil.parse(sql)).getSelectBody();
    select.setWhere(expression);

    System.out.println(select); // 输出：SELECT * FROM user WHERE status = 'inactive'
} catch (JSQLParserException e) {
    e.printStackTrace();
}

自定义 MultiDataPermissionHandler，实现特定业务逻辑:

/**
 * 基于 {@link DataPermissionRule} 的数据权限处理器
 *
 * 它的底层，是基于 MyBatis Plus 的 <a href="https://baomidou.com/plugins/data-permission/">数据权限插件</a>
 * 核心原理：它会在 SQL 执行前拦截 SQL 语句，并根据用户权限动态添加权限相关的 SQL 片段。这样，只有用户有权限访问的数据才会被查询出来
 */
@RequiredArgsConstructor
public class DataPermissionRuleHandler implements MultiDataPermissionHandler {

    //ruleFactory 是一个“规则工厂”，它是一个工具，专门用来提供“权限规则”。
    private final DataPermissionRuleFactory ruleFactory;

    //Table table：表示你要查的表;
    //Expression where：表示你原来的查询条件（比如 WHERE id = 1）
    //String mappedStatementId：一个字符串，表示你正在调用的查询方法
    @Override
    public Expression getSqlSegment(Table table, Expression where, String mappedStatementId) {
        // 获得 Mapper 对应的数据权限的规则
        List<DataPermissionRule> rules = ruleFactory.getDataPermissionRule(mappedStatementId);
        if (CollUtil.isEmpty(rules)) {
            return null;
        }
        // 生成条件,allExpression，用来存放最终的权限条件
        Expression allExpression = null;
        for (DataPermissionRule rule : rules) {
            // 判断表名是否匹配,规则是否管理当前的表
            String tableName = MyBatisUtils.getTableName(table);
            if (!rule.getTableNames().contains(tableName)) {
                continue;
            }
            // 单条规则的条件，对于这个表（tableName），它的限制条件是什么
            Expression oneExpress = rule.getExpression(tableName, table.getAlias());
            if (oneExpress == null) {
                continue;
            }
            // 拼接到 allExpression 中
            allExpression = allExpression == null ? oneExpress
                    : new AndExpression(allExpression, oneExpress);
        }
        return allExpression;
    }
}

整体流程（用图书馆的例子）

你想借书（查数据库），比如查 SELECT * FROM user。
图书管理员（DataPermissionRuleHandler）先拦住你，问：“你用的是哪个借书方法？”（mappedStatementId）。
管理员去问规则工厂（ruleFactory）：“这个借书方法有哪些权限规则？”（rules）。
如果没有规则，管理员说：“随便借！”（返回 null）。
如果有规则（比如“只能借 dept_id = 1 的书”），管理员检查你借的书是不是这个部门的（tableName）。
如果是，管理员生成一个限制条件（u.dept_id = 1），并把所有条件用 AND 连起来。
最后，管理员把限制条件加到你的借书请求里（SELECT * FROM user WHERE dept_id = 1），确保你只能借到有权限的书。

2.整体代码实现流程

2.1Spring 应用启动：

Spring 容器启动时，处理 @AutoConfiguration 和 @Configuration 类。
YudaoDataPermissionAutoConfiguration 创建核心 Bean：
- DataPermissionRuleFactory：管理所有 DataPermissionRule 实例。
- DataPermissionRuleHandler：通过 DataPermissionInterceptor 集成到 MyBatis Plus 拦截器链。
- DataPermissionAnnotationAdvisor：支持基于注解的权限控制。
YudaoDeptDataPermissionAutoConfiguration（在满足条件时）创建 DeptDataPermissionRule Bean，并通过 DeptDataPermissionRuleCustomizer 配置部门相关规则。
具体每个模块的规则就像DataPermissionConfiguration 定义 DeptDataPermissionRuleCustomizer，为 DeptDataPermissionRule 配置特定表和字段（如 AdminUserDO、DeptDO）。

/**
 * 数据权限的自动配置类
 * DataPermissionRuleFactory：管理所有 DataPermissionRule 实例。
 * DataPermissionRuleHandler：通过 DataPermissionInterceptor 集成到 MyBatis Plus 拦截器链
 * DataPermissionAnnotationAdvisor：支持基于注解的权限控制
 */
@AutoConfiguration
public class YudaoDataPermissionAutoConfiguration {

    /**
     * 创建数据权限规则的工厂，管理所有数据权限规则的集合
     * @param rules
     * @return
     */
    @Bean
    public DataPermissionRuleFactory dataPermissionRuleFactory(List<DataPermissionRule> rules) {
        return new DataPermissionRuleFactoryImpl(rules);
    }

    /**
     * 处理数据权限规则的核心处理器
     * @param interceptor
     * @param ruleFactory
     * @return
     */
    @Bean
    public DataPermissionRuleHandler dataPermissionRuleHandler(MybatisPlusInterceptor interceptor,
                                                               DataPermissionRuleFactory ruleFactory) {
        // 创建 DataPermissionInterceptor 拦截器
        DataPermissionRuleHandler handler = new DataPermissionRuleHandler(ruleFactory);
        DataPermissionInterceptor inner = new DataPermissionInterceptor(handler);
        // 添加到 interceptor 中
        // 需要加在首个，主要是为了在分页插件前面。这个是 MyBatis Plus 的规定
        MyBatisUtils.addInterceptor(interceptor, inner, 0);
        return handler;
    }

    /**
     * 提供基于注解的数据权限控制
     * @return
     */
    @Bean
    public DataPermissionAnnotationAdvisor dataPermissionAnnotationAdvisor() {
        return new DataPermissionAnnotationAdvisor();
    }

}

/**
 * 基于部门的数据权限 AutoConfiguration
 * YudaoDeptDataPermissionAutoConfiguration（在满足条件时）创建 DeptDataPermissionRule Bean，
 * 并通过 DeptDataPermissionRuleCustomizer 配置部门相关规则。
 */
@AutoConfiguration
@ConditionalOnClass(LoginUser.class)
@ConditionalOnBean(value = {PermissionApi.class, DeptDataPermissionRuleCustomizer.class})
public class YudaoDeptDataPermissionAutoConfiguration {

    /**
     * 创建一个 DeptDataPermissionRule 对象，并将 permissionApi 作为参数传递给其构造函数。
     * 遍历 customizers 列表，调用每个 DeptDataPermissionRuleCustomizer 的 customize 方法
     * 对 rule 对象进行自定义配置。
     * 返回配置好的 DeptDataPermissionRule 对象。
     * @param permissionApi
     * @param customizers
     * @return
     */
    @Bean
    public DeptDataPermissionRule deptDataPermissionRule(PermissionApi permissionApi,
                                                         List<DeptDataPermissionRuleCustomizer> customizers) {
        // 创建 DeptDataPermissionRule 对象
        DeptDataPermissionRule rule = new DeptDataPermissionRule(permissionApi);
        // 补全表配置
        customizers.forEach(customizer -> customizer.customize(rule));
        return rule;
    }

}

/**
 * system 模块的数据权限 Configuration
 */
@Configuration(proxyBeanMethods = false)
public class DataPermissionConfiguration {

    @Bean
    public DeptDataPermissionRuleCustomizer sysDeptDataPermissionRuleCustomizer() {
        return rule -> {
            // dept
            rule.addDeptColumn(AdminUserDO.class);
            rule.addDeptColumn(DeptDO.class, "id");
            // user
            rule.addUserColumn(AdminUserDO.class, "id");
        };
    }

}

2.2发起 MyBatis Plus 查询：
- 通过 MyBatis Mapper 方法（如 selectList）发起数据库查询。
- 生成查询的 mappedStatementId，例如 com.example.UserMapper.selectList。

2.3MyBatis Plus 拦截器链处理：

MyBatis Plus 通过拦截器链处理查询。
DataPermissionInterceptor（在 YudaoDataPermissionAutoConfiguration 中添加到 MybatisPlusInterceptor）在链的早期（位置 0，优先于分页插件）被调用。
DataPermissionInterceptor 委托给 DataPermissionRuleHandler 的 getSqlSegment 方法。

/**
 * 基于 {@link DataPermissionRule} 的数据权限处理器
 *
 * 它的底层，是基于 MyBatis Plus 的 <a href="https://baomidou.com/plugins/data-permission/">数据权限插件</a>
 * 核心原理：它会在 SQL 执行前拦截 SQL 语句，并根据用户权限动态添加权限相关的 SQL 片段。这样，只有用户有权限访问的数据才会被查询出来
 */
@RequiredArgsConstructor
public class DataPermissionRuleHandler implements MultiDataPermissionHandler {

    //ruleFactory 是一个“规则工厂”，它是一个工具，专门用来提供“权限规则”。
    private final DataPermissionRuleFactory ruleFactory;

    //Table table：表示你要查的表;
    //Expression where：表示你原来的查询条件（比如 WHERE id = 1）
    //String mappedStatementId：一个字符串，表示你正在调用的查询方法
    @Override
    public Expression getSqlSegment(Table table, Expression where, String mappedStatementId) {
        // 获得 Mapper 对应的数据权限的规则
        List<DataPermissionRule> rules = ruleFactory.getDataPermissionRule(mappedStatementId);
        if (CollUtil.isEmpty(rules)) {
            return null;
        }
        // 生成条件,allExpression，用来存放最终的权限条件
        Expression allExpression = null;
        for (DataPermissionRule rule : rules) {
            // 判断表名是否匹配,规则是否管理当前的表
            String tableName = MyBatisUtils.getTableName(table);
            if (!rule.getTableNames().contains(tableName)) {
                continue;
            }
            // 单条规则的条件，对于这个表（tableName），它的限制条件是什么
            Expression oneExpress = rule.getExpression(tableName, table.getAlias());
            if (oneExpress == null) {
                continue;
            }
            // 拼接到 allExpression 中
            allExpression = allExpression == null ? oneExpress
                    : new AndExpression(allExpression, oneExpress);
        }
        return allExpression;
    }
}

2.4DataPermissionRuleHandler 处理：

DataPermissionRuleHandler 从 DataPermissionRuleFactory 获取适用于当前查询的 DataPermissionRule 列表（通过 getDataPermissionRule(mappedStatementId)）。
DataPermissionRuleFactoryImpl 根据 DataPermissionContextHolder 过滤规则：
- 无上下文：返回所有规则。
- 有上下文：根据 enable()、includeRules 或 excludeRules 过滤。
对每个适用规则（如 DeptDataPermissionRule），检查是否适用于查询的表（tableName）。
如果适用，调用规则的 getExpression 方法生成 SQL 条件（Expression）。

/**
 * 默认的 DataPermissionRuleFactoryImpl 实现类
 * 支持通过 {@link DataPermissionContextHolder} 过滤数据权限
 */
@RequiredArgsConstructor
public class DataPermissionRuleFactoryImpl implements DataPermissionRuleFactory {

    /**
     * 数据权限规则数组
     */
    private final List<DataPermissionRule> rules;

    @Override
    public List<DataPermissionRule> getDataPermissionRules() {
        return rules;
    }

    @Override // mappedStatementId 参数，暂时没有用。以后，可以基于 mappedStatementId + DataPermission 进行缓存
    public List<DataPermissionRule> getDataPermissionRule(String mappedStatementId) {
        // 1. 无数据权限
        if (CollUtil.isEmpty(rules)) {
            return Collections.emptyList();
        }
        // 2. 未配置，则默认开启
        DataPermission dataPermission = DataPermissionContextHolder.get();
        if (dataPermission == null) {
            return rules;
        }
        // 3. 已配置，但禁用
        if (!dataPermission.enable()) {
            return Collections.emptyList();
        }

        // 4. 已配置，只选择部分规则
        if (ArrayUtil.isNotEmpty(dataPermission.includeRules())) {
            return rules.stream().filter(rule -> ArrayUtil.contains(dataPermission.includeRules(), rule.getClass()))
                    .collect(Collectors.toList()); // 一般规则不会太多，所以不采用 HashSet 查询
        }
        // 5. 已配置，只排除部分规则
        if (ArrayUtil.isNotEmpty(dataPermission.excludeRules())) {
            return rules.stream().filter(rule -> !ArrayUtil.contains(dataPermission.excludeRules(), rule.getClass()))
                    .collect(Collectors.toList()); // 一般规则不会太多，所以不采用 HashSet 查询
        }
        // 6. 已配置，全部规则
        return rules;
    }

}

2.5DeptDataPermissionRule 处理：

DeptDataPermissionRule 检查是否存在登录用户（LoginUser）并验证用户是否为管理员（UserTypeEnum.ADMIN）。
从用户上下文或通过 PermissionApi.getDeptDataPermission 获取部门数据权限（DeptDataPermissionRespDTO）。
根据权限设置（all、deptIds、self）构建 SQL 条件：
- buildDeptExpression：若 deptIds 不为空且表配置了 dept_id 字段，生成 WHERE dept_id IN (...)。
- buildUserExpression：若 self 为 true 且表配置了 user_id 字段，生成 WHERE user_id = ?。
- 使用 OR 组合条件或返回单一条件。
将生成的 Expression 转换为 SQL 片段（如 dept_id IN (1, 2) OR user_id = 100）。

/**
 * 基于部门的 {@link DataPermissionRule} 数据权限规则实现
 *
 * 注意，使用 DeptDataPermissionRule 时，需要保证表中有 dept_id 部门编号的字段，可自定义。
 *
 * 实际业务场景下，会存在一个经典的问题？当用户修改部门时，冗余的 dept_id 是否需要修改？
 * 1. 一般情况下，dept_id 不进行修改，则会导致用户看不到之前的数据。【moyun-server 采用该方案】
 * 2. 部分情况下，希望该用户还是能看到之前的数据，则有两种方式解决：【需要你改造该 DeptDataPermissionRule 的实现代码】
 *  1）编写洗数据的脚本，将 dept_id 修改成新部门的编号；【建议】
 *      最终过滤条件是 WHERE dept_id = ?
 *  2）洗数据的话，可能涉及的数据量较大，也可以采用 user_id 进行过滤的方式，此时需要获取到 dept_id 对应的所有 user_id 用户编号；
 *      最终过滤条件是 WHERE user_id IN (?, ?, ? ...)
 *  3）想要保证原 dept_id 和 user_id 都可以看的到，此时使用 dept_id 和 user_id 一起过滤；
 *      最终过滤条件是 WHERE dept_id = ? OR user_id IN (?, ?, ? ...)
 */
@AllArgsConstructor
@Slf4j
public class DeptDataPermissionRule implements DataPermissionRule {

    /**
     * LoginUser 的 Context 缓存 Key
     */
    protected static final String CONTEXT_KEY = DeptDataPermissionRule.class.getSimpleName();

    private static final String DEPT_COLUMN_NAME = "dept_id";
    private static final String USER_COLUMN_NAME = "user_id";

    static final Expression EXPRESSION_NULL = new NullValue();

    private final PermissionApi permissionApi;

    /**
     * 基于部门的表字段配置
     * 一般情况下，每个表的部门编号字段是 dept_id，通过该配置自定义
     *
     * key：表名
     * value：字段名
     */
    private final Map<String, String> deptColumns = new HashMap<>();
    /**
     * 基于用户的表字段配置
     * 一般情况下，每个表的部门编号字段是 dept_id，通过该配置自定义。
     *
     * key：表名
     * value：字段名
     */
    private final Map<String, String> userColumns = new HashMap<>();
    /**
     * 所有表名，是 {@link #deptColumns} 和 {@link #userColumns} 的合集
     */
    private final Set<String> TABLE_NAMES = new HashSet<>();

    @Override
    public Set<String> getTableNames() {
        return TABLE_NAMES;
    }

    @Override
    public Expression getExpression(String tableName, Alias tableAlias) {
        // 只有有登陆用户的情况下，才进行数据权限的处理
        LoginUser loginUser = SecurityFrameworkUtils.getLoginUser();
        if (loginUser == null) {
            return null;
        }
        // 只有管理员类型的用户，才进行数据权限的处理
        if (ObjectUtil.notEqual(loginUser.getUserType(), UserTypeEnum.ADMIN.getValue())) {
            return null;
        }

        // 获得数据权限
        DeptDataPermissionRespDTO deptDataPermission = loginUser.getContext(CONTEXT_KEY, DeptDataPermissionRespDTO.class);
        // 从上下文中拿不到，则调用逻辑进行获取
        if (deptDataPermission == null) {
            deptDataPermission = permissionApi.getDeptDataPermission(loginUser.getId());
            if (deptDataPermission == null) {
                log.error("[getExpression][LoginUser({}) 获取数据权限为 null]", JsonUtils.toJsonString(loginUser));
                throw new NullPointerException(String.format("LoginUser(%d) Table(%s/%s) 未返回数据权限",
                        loginUser.getId(), tableName, tableAlias.getName()));
            }
            // 添加到上下文中，避免重复计算
            loginUser.setContext(CONTEXT_KEY, deptDataPermission);
        }

        // 情况一，如果是 ALL 可查看全部，则无需拼接条件
        if (deptDataPermission.getAll()) {
            return null;
        }

        // 情况二，即不能查看部门，又不能查看自己，则说明 100% 无权限
        if (CollUtil.isEmpty(deptDataPermission.getDeptIds())
            && Boolean.FALSE.equals(deptDataPermission.getSelf())) {
            return new EqualsTo(null, null); // WHERE null = null，可以保证返回的数据为空
        }

        // 情况三，拼接 Dept 和 User 的条件，最后组合
        Expression deptExpression = buildDeptExpression(tableName,tableAlias, deptDataPermission.getDeptIds());
        Expression userExpression = buildUserExpression(tableName, tableAlias, deptDataPermission.getSelf(), loginUser.getId());
        if (deptExpression == null && userExpression == null) {
            // TODO 芋艿：获得不到条件的时候，暂时不抛出异常，而是不返回数据
            log.warn("[getExpression][LoginUser({}) Table({}/{}) DeptDataPermission({}) 构建的条件为空]",
                    JsonUtils.toJsonString(loginUser), tableName, tableAlias, JsonUtils.toJsonString(deptDataPermission));
//            throw new NullPointerException(String.format("LoginUser(%d) Table(%s/%s) 构建的条件为空",
//                    loginUser.getId(), tableName, tableAlias.getName()));
            return EXPRESSION_NULL;
        }
        if (deptExpression == null) {
            return userExpression;
        }
        if (userExpression == null) {
            return deptExpression;
        }
        // 目前，如果有指定部门 + 可查看自己，采用 OR 条件。即，WHERE (dept_id IN ? OR user_id = ?)
        return new ParenthesedExpressionList(new OrExpression(deptExpression, userExpression));
    }

    private Expression buildDeptExpression(String tableName, Alias tableAlias, Set<Long> deptIds) {
        // 如果不存在配置，则无需作为条件
        String columnName = deptColumns.get(tableName);
        if (StrUtil.isEmpty(columnName)) {
            return null;
        }
        // 如果为空，则无条件
        if (CollUtil.isEmpty(deptIds)) {
            return null;
        }
        // 拼接条件
        return new InExpression(MyBatisUtils.buildColumn(tableName, tableAlias, columnName),
                // Parenthesis 的目的，是提供 (1,2,3) 的 () 左右括号
                new ParenthesedExpressionList(new ExpressionList<LongValue>(CollectionUtils.convertList(deptIds, LongValue::new))));
    }

    private Expression buildUserExpression(String tableName, Alias tableAlias, Boolean self, Long userId) {
        // 如果不查看自己，则无需作为条件
        if (Boolean.FALSE.equals(self)) {
            return null;
        }
        String columnName = userColumns.get(tableName);
        if (StrUtil.isEmpty(columnName)) {
            return null;
        }
        // 拼接条件
        return new EqualsTo(MyBatisUtils.buildColumn(tableName, tableAlias, columnName), new LongValue(userId));
    }

    // ==================== 添加配置 ====================

    public void addDeptColumn(Class<? extends BaseDO> entityClass) {
        addDeptColumn(entityClass, DEPT_COLUMN_NAME);
    }

    public void addDeptColumn(Class<? extends BaseDO> entityClass, String columnName) {
        String tableName = TableInfoHelper.getTableInfo(entityClass).getTableName();
       addDeptColumn(tableName, columnName);
    }

    public void addDeptColumn(String tableName, String columnName) {
        deptColumns.put(tableName, columnName);
        TABLE_NAMES.add(tableName);
    }

    public void addUserColumn(Class<? extends BaseDO> entityClass) {
        addUserColumn(entityClass, USER_COLUMN_NAME);
    }

    public void addUserColumn(Class<? extends BaseDO> entityClass, String columnName) {
        String tableName = TableInfoHelper.getTableInfo(entityClass).getTableName();
        addUserColumn(tableName, columnName);
    }

    public void addUserColumn(String tableName, String columnName) {
        userColumns.put(tableName, columnName);
        TABLE_NAMES.add(tableName);
    }

}

2.6SQL 修改与执行：
- DataPermissionInterceptor 将 SQL 片段追加到原始查询的 WHERE 子句。
- MyBatis Plus 继续通过其他拦截器（如分页）处理修改后的 SQL。
- 最终 SQL 执行，数据库返回仅限于用户有权限的数据。
2.7示例场景

假设用户（ID: 100，管理员类型）查询用户列表（AdminUserDO），配置如下：

查询通过 UserMapper.selectList(new QueryWrapper<>()) 执行。

用户权限：deptIds = [1, 2]，self = true。

AdminUserDO 在 DataPermissionConfiguration 中配置了 dept_id 和 user_id 字段。
分步执行：

1. 查询发起：
Mapper 方法：com.example.UserMapper.selectList。
原始 SQL：SELECT * FROM admin_user。
2. 拦截器调用：
DataPermissionInterceptor 拦截查询，调用 DataPermissionRuleHandler.getSqlSegment。
3.规则获取：
DataPermissionRuleHandler 调用 DataPermissionRuleFactoryImpl.getDataPermissionRule("com.example.UserMapper.selectList")。
返回 [DeptDataPermissionRule]（假设无上下文过滤）。
4. 表匹配：
表名：admin_user。
DeptDataPermissionRule.getTableNames() 包含 admin_user，规则适用。
5. 条件生成：
调用 DeptDataPermissionRule.getExpression("admin_user", alias)。
用户已登录（ID: 100，管理员）。
获取 DeptDataPermissionRespDTO：{ all: false, deptIds: [1, 2], self: true }。
buildDeptExpression：deptColumns 映射 admin_user 到 dept_id，生成 dept_id IN (1, 2)。
buildUserExpression：userColumns 映射 admin_user 到 user_id，self = true，生成 user_id = 100。
组合：(dept_id IN (1, 2) OR user_id = 100)。
6. SQL 修改：
修改后 SQL：SELECT * FROM admin_user WHERE (dept_id IN (1, 2) OR user_id = 100)。
7. 执行：
数据库执行修改后的 SQL，仅返回部门 1 或 2 的用户，或 user_id = 100 的用户。

每个类功能详解

以下是每个类的功能描述以及它们之间的联系。

3.解释类

3.1类详解

YudaoDataPermissionAutoConfiguration：
- 目的：配置数据权限核心组件。
- 功能：
  - 创建 DataPermissionRuleFactory，管理所有 DataPermissionRule。
  - 创建 DataPermissionRuleHandler，通过 DataPermissionInterceptor 集成到 MyBatis Plus。
  - 提供 DataPermissionAnnotationAdvisor，支持注解驱动的权限控制。
- 关键 Bean：
  - dataPermissionRuleFactory：返回 DataPermissionRuleFactoryImpl。
  - dataPermissionRuleHandler：配置 MyBatis Plus 拦截器链。
  - dataPermissionAnnotationAdvisor：启用注解权限。
YudaoDeptDataPermissionAutoConfiguration：
- 目的：配置基于部门的数据权限。
- 功能：
  - 在 LoginUser、PermissionApi 和 DeptDataPermissionRuleCustomizer 存在时激活。
  - 创建 DeptDataPermissionRule，通过 DeptDataPermissionRuleCustomizer 进行定制。
- 关键 Bean：
  - deptDataPermissionRule：初始化并配置部门规则。
DataPermissionRuleHandler：
- 目的：应用数据权限规则的核心处理器。
- 功能：
  - 从 DataPermissionRuleFactory 获取适用规则。
  - 遍历规则，检查表适用性，生成 SQL 条件。
  - 使用 AND 组合多条规则的条件。
- 关键方法：
  - getSqlSegment：为给定表和查询生成 SQL 片段。
DataPermissionRuleFactoryImpl：
- 目的：管理和过滤数据权限规则。
- 功能：
  - 存储 DataPermissionRule 列表。
  - 根据 DataPermissionContextHolder 过滤规则（enable、includeRules、excludeRules）。
- 关键方法：
  - getDataPermissionRules：返回所有规则。
  - getDataPermissionRule：为特定查询过滤规则。
DeptDataPermissionRule：
- 目的：实现基于部门的数据权限逻辑。
- 功能：
  - 配置表的 dept_id 和 user_id 字段。
  - 根据用户权限（deptIds、self）生成 SQL 条件。
  - 支持动态字段映射（deptColumns、userColumns）。
- 关键方法：
  - getTableNames：返回受控表。
  - getExpression：为表构建 SQL 条件。
  - buildDeptExpression / buildUserExpression：生成部门/用户条件。
  - 配置方法（如 addDeptColumn、addUserColumn）。
DeptDataPermissionRuleCustomizer：
- 目的：为 DeptDataPermissionRule 提供定制接口。
- 功能：
  - 允许外部配置表-字段映射。
  - 在 DataPermissionConfiguration 中实现，为特定表（如 AdminUserDO）设置规则。
DataPermissionConfiguration：
- 目的：为系统模块提供特定配置。
- 功能：
  - 定义 DeptDataPermissionRuleCustomizer，为 DeptDataPermissionRule 配置 AdminUserDO 和 DeptDO 的字段映射。

3.2类之间的关系

YudaoDataPermissionAutoConfiguration 是入口，搭建核心框架，创建 DataPermissionRuleFactory、DataPermissionRuleHandler 和注解支持。
YudaoDeptDataPermissionAutoConfiguration 扩展框架，添加部门特定规则，依赖 DataPermissionRuleFactory 注册 DeptDataPermissionRule。
DataPermissionRuleHandler 是运行时处理器，连接 DataPermissionRuleFactory（提供规则）和 MyBatis Plus（通过 DataPermissionInterceptor）。
DataPermissionRuleFactoryImpl 作为规则仓库，管理包括 DeptDataPermissionRule 在内的规则，支持动态过滤。
DeptDataPermissionRule 是具体规则实现，由 DeptDataPermissionRuleCustomizer 配置，被 DataPermissionRuleHandler 使用。
DeptDataPermissionRuleCustomizer（通过 DataPermissionConfiguration）为 DeptDataPermissionRule 提供表特定配置。
PermissionApi 和 LoginUser 是外部依赖，提供用户权限数据和上下文。

3.3类形成分层架构：

配置层：YudaoDataPermissionAutoConfiguration、YudaoDeptDataPermissionAutoConfiguration、DataPermissionConfiguration。
核心逻辑层：DataPermissionRuleHandler、DataPermissionRuleFactoryImpl。
规则层：DeptDataPermissionRule。
定制层：DeptDataPermissionRuleCustomizer。

java每日精进 5.07【框架之数据权限】

1.数据权限实现步骤

1.1插件原理

1.2SQL片段组装的核心逻辑代码

整体流程（用图书馆的例子）

2.整体代码实现流程

2.1Spring 应用启动：

2.2发起 MyBatis Plus 查询：

2.3MyBatis Plus 拦截器链处理：

2.4DataPermissionRuleHandler 处理：

2.5DeptDataPermissionRule 处理：

2.6SQL 修改与执行：

2.7示例场景

3.解释类

3.1类详解

3.2类之间的关系

3.3类形成分层架构：

网站公告

今日签到

热门文章

最新发布