当前位置：首页 > ai >正文

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

ai 2025/5/8 8:51:21

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

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

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

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

1.数据权限实现步骤

1.1插件原理

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

数据权限插件 | MyBatis-Plus (baomidou.com)

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：一个字符串，表示你正在调用的查询方法@Overridepublic 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*/@Beanpublic DataPermissionRuleFactory dataPermissionRuleFactory(List<DataPermissionRule> rules) {return new DataPermissionRuleFactoryImpl(rules);}/*** 处理数据权限规则的核心处理器* @param interceptor* @param ruleFactory* @return*/@Beanpublic 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*/@Beanpublic 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*/@Beanpublic 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 {@Beanpublic DeptDataPermissionRuleCustomizer sysDeptDataPermissionRuleCustomizer() {return rule -> {// deptrule.addDeptColumn(AdminUserDO.class);rule.addDeptColumn(DeptDO.class, "id");// userrule.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：一个字符串，表示你正在调用的查询方法@Overridepublic 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;@Overridepublic 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<>();@Overridepublic Set<String> getTableNames() {return TABLE_NAMES;}@Overridepublic 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。

查看全文

http://www.xdnf.cn/news/4477.html