控制权限系列之（2）手把手教你使用基于角色的权限控制

前一篇已经分析了多种权限模型控制权限系列之（1）模型分析梳理，其中比较常用的是基于角色的权限控制。

基于角色的权限控制的表设计：

用户表
角色表
菜单表用户--角色关系表
角色--菜单关系表

权限标识格式：

格式：xxx:xxx:xxx（模块:资源:操作）

权限架构的分层结构：

应用层 (@RequirePermission注解)↓
权限验证层 (PermissionValidator)↓
权限上下文层 (PermissionContext - ThreadLocal)↓
权限提供层 (PermissionProvider - 数据库/缓存)↓
权限存储层 (PermissionStorage - Redis/Memory)

权限架构接口：

权限提供者接口 (PermissionProvider)

从数据源获取用户权限数据

public interface PermissionProvider {
    // 获取用户的所有权限标识
    Set<String> getUserPermissions(Object userId);
    
    // 获取用户角色列表
    Set<String> getUserRoles(Object userId);
    
    // 检查用户是否为超级管理员
    boolean isSuperAdmin(Object userId);
    
    // 刷新用户权限缓存
    void refreshUserPermissions(Object userId);
}

• userId 使用 Object 类型，支持 String、Long 等不同ID类型
• 支持超级管理员逻辑（拥有所有权限）
• 提供刷新接口，支持权限变更后更新缓存

权限存储接口 (PermissionStorage)

权限数据的存储和读取（Token、Redis、Memory等）

public interface PermissionStorage {
    // 存储用户权限信息
    void storeUserInfo(String token, UserInfo userInfo);
    
    // 获取用户权限信息
    UserInfo getUserInfo(String token);
    
    // 删除用户权限信息
    void removeUserInfo(String token);
    
    // 刷新用户权限信息
    void refreshUserInfo(String token, UserInfo userInfo);
}

• 基于Token存储，支持分布式场景
• 支持多种存储实现（Redis、Memory、数据库等）
• 提供刷新接口，支持权限实时更新

权限匹配器接口 (PermissionMatcher)

权限匹配策略（精确匹配、通配符匹配等）

public interface PermissionMatcher {
    // 匹配权限
    boolean match(String requiredPermission, Set<String> userPermissions);
    
    // 批量匹配（全部满足）
    boolean matchAll(Set<String> requiredPermissions, Set<String> userPermissions);
    
    // 批量匹配（任意一个满足）
    boolean matchAny(Set<String> requiredPermissions, Set<String> userPermissions);
}

• 支持多种匹配策略（精确、通配符、正则等）
• 支持批量匹配（AND/OR逻辑）
• 可扩展自定义匹配规则

用户信息

public class UserInfo {
    private Object userId;                    // 用户ID
    private String username;                  // 用户名
    private Set<String> permissions;          // 权限集合
    private Set<String> roles;                // 角色集合
    private boolean superAdmin;               // 是否超级管理员
    private Map<String, Object> attributes;   // 扩展属性
}

• 使用 Object 类型支持不同ID类型
• 提供扩展属性，支持业务字段存储
• 轻量级设计，便于序列化和传输

权限上下文 (PermissionContext)

基于ThreadLocal的权限上下文管理

public class PermissionContext {
    private static final ThreadLocal<UserInfo> USER_INFO_HOLDER = new TransmittableThreadLocal<>();
    
    public static void set(UserInfo userInfo);
    public static UserInfo get();
    public static void clear();
    
    public static boolean hasPermission(String permission);
    public static Set<String> getPermissions();
}

• 使用 TransmittableThreadLocal 支持线程池传递
• 提供便捷方法，简化权限判断
• 请求结束后自动清理，避免内存泄漏

权限验证器接口 (PermissionValidator)

权限验证逻辑

public interface PermissionValidator {
    // 验证单个权限
    boolean hasPermission(String permission);
    
    // 验证所有权限（AND）
    boolean hasAllPermissions(Set<String> permissions);
    
    // 验证任意权限（OR）
    boolean hasAnyPermission(Set<String> permissions);
    
    // 验证角色
    boolean hasRole(String role);
    
    // 获取当前用户上下文
    UserContext getCurrentUser();
}

• 提供多种验证方式（单个、全部、任意）
• 支持角色验证
• 统一权限验证入口

实现策略

数据库权限获取

1. 通过JdbcTemplate执行SQL查询
2. SQL可配置化（支持不同数据库表结构）
3. 支持超级管理员特殊处理
4. 支持权限缓存

@Component
public class DatabasePermissionProvider implements PermissionProvider {
    
    @Override
    public Set<String> getUserPermissions(Object userId) {
        // 1. 检查是否为超级管理员
        if (isSuperAdmin(userId)) {
            return getAllPermissions(); // 返回所有权限
        }
        
        // 2. 查询用户权限（通过用户-角色-菜单关联）
        List<String> permsList =userService.getPermissions();19         
        // 3. 返回权限集合
        return permsList;
    }
}

抽象权限提供者 (AbstractPermissionProvider)

• 提供模板方法，定义权限获取流程
• 子类只需实现具体查询逻辑
• 统一处理超级管理员逻辑

public abstract class AbstractPermissionProvider implements PermissionProvider {
    
    @Override
    public Set<String> getUserPermissions(Object userId) {
        // 方法：统一处理超管
        if (isSuperAdmin(userId)) {
            return getAllPermissions();
        }
        return doGetUserPermissions(userId);
    }
    
    // 子类实现：获取所有权限
    protected abstract Set<String> getAllPermissions();
    
    // 子类实现：查询用户权限
    protected abstract Set<String> doGetUserPermissions(Object userId);
}

Redis存储 (RedisPermissionStorage)

1. 使用Redis存储用户信息（JSON序列化）
2. 支持过期时间配置
3. 支持Key前缀配置
4. 异常处理和日志记录

public class RedisPermissionStorage implements PermissionStorage {
    
    @Override
    public void storeUserInfo(String token, UserInfo userInfo) { 7         redisTemplate.opsForValue().set(key, value, expireSeconds, TimeUnit.SECONDS);
    }
    
    @Override
    public UserInfo getUserInfo(String token) {14         return value;
    }
}

通配符匹配器 (WildcardPermissionMatcher)

• 支持 * 和 ? 通配符
• 例如：sys:user:* 匹配 sys:user:save、sys:user:update 等
• 使用Spring的 PatternMatchUtils.simpleMatch()

权限过滤器实现

1. 请求头提取Token
2. 从Storage获取用户信息（如不存在，从Provider加载）
3. 设置到PermissionContext
4. 请求结束后清理上下文

过滤器流程：

请求到达↓
检查排除路径（登录、公开接口等）↓
提取Token↓
从Storage获取用户信息↓（如果不存在）
从Provider加载用户信息 → 存储到Storage↓
设置到PermissionContext↓
继续请求处理↓
清理PermissionContext

权限注解 (@RequirePermission)

• 支持单个权限、多个权限（AND/OR）
• 支持角色验证
• 支持自定义错误消息

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface RequirePermission {String value() default "";           // 单个权限String[] all() default {};            // 全部权限（AND）String[] any() default {};            // 任意权限（OR）String role() default "";              // 单个角色String message() default "权限不足";   // 错误消息
}

AOP切面实现

1. 拦截 @RequirePermission 注解的方法
2. 从PermissionContext获取用户信息
3. 调用PermissionValidator验证权限
4. 验证失败抛出异常

@Aspect
public class PermissionAspect {
    
    @Before("@annotation(RequirePermission)")
    public void checkPermission(JoinPoint joinPoint) {
        RequirePermission annotation = getAnnotation(joinPoint);
        
        // 验证权限
        if (!permissionValidator.hasPermission(annotation.value())) {
            throw new PermissionDeniedException(annotation.message());
        }
    }
}

与SpringBoot项目集成

配置类设计：

• 自动配置各个组件
• 支持条件装配（@ConditionalOnMissingBean）
• 提供默认实现

@Configuration
@EnableConfigurationProperties(PermissionProperties.class)
public class PermissionAutoConfiguration {
    
    @Bean
    @ConditionalOnMissingBean
    public PermissionMatcher permissionMatcher() {
        return new WildcardPermissionMatcher(); 
    }
    
    @Bean
    @ConditionalOnMissingBean
    public PermissionValidator permissionValidator(PermissionMatcher matcher) {
        return new DefaultPermissionValidator(matcher);
    }
    
    @Bean
    @ConditionalOnMissingBean
    public PermissionFilter permissionFilter(...) {
        return new PermissionFilter(...);
    }
}

使用示例：

@RestController
@RequestMapping("/api/user")
public class UserController {
    
    // 单个权限验证
    @GetMapping("/list")
    @RequirePermission("sys:user:list")
    public ResponseEntity<List<User>> list() {
        return ResponseEntity.ok(userService.list());
    }
    
    // 多个权限（全部满足）
    @PutMapping("/{id}")
    @RequirePermission(all = {"sys:user:update", "sys:user:edit"})
    public ResponseEntity<Void> update(@PathVariable Long id, @RequestBody User user) {
        userService.update(id, user);
        return ResponseEntity.ok().build();
    }
    
    // 多个权限（任意一个）
    @DeleteMapping("/{id}")
    @RequirePermission(any = {"sys:user:delete", "sys:user:remove"})
    public ResponseEntity<Void> delete(@PathVariable Long id) {
        userService.delete(id);
        return ResponseEntity.ok().build();
    }
    
    // 角色验证
    @GetMapping("/admin")
    @RequirePermission(role = "ADMIN")
    public ResponseEntity<String> adminOnly() {
        return ResponseEntity.ok("Admin only");
    }
}

代码逻辑使用：

@Service
public class UserService {
    
    @Autowired
    private PermissionValidator permissionValidator;
    
    public void deleteUser(Long userId) {
        
        if (!permissionValidator.hasPermission("sys:user:delete")) {
            throw new PermissionDeniedException("无删除权限");
        }
        
        userRepository.delete(userId);
    }
    
    public UserContext getCurrentUser() {
        return permissionValidator.getCurrentUser();
    }
19 }

 

总结：

1. 接口抽象：所有核心功能都通过接口定义，便于扩展
2. 分层设计：Provider → Storage → Matcher → Validator，职责清晰
3. 上下文管理：使用ThreadLocal，支持异步场景
4. 配置化：SQL、路径等可配置，适应不同项目
5. 默认实现：提供常用实现，开箱即用

按照以上设计思路，可以逐步实现一个通用、灵活、易用的权限控制框架。