Java轻松实现权限认证管理

我们在实际开发中经常会进行权限认证管理，给不同的人加上对应的角色和权限，对于不同的登录用户要求根据他们所扮演的的角色和拥有的权限去访问指定的接口，那具体该怎么实现呢

我这边参考了各个框架的实现逻辑，发现还是蛮简单的，今天就实现一个简易的权限验证管理系统

首先需要角色和权限表

角色表：字段为用户唯一标识（user_id），该用户所扮演的角色（role_name）

权限表：字段为用户所含有的角色（user_roles）,该角色所拥有的权限（permission）

数据库脚本

-- 创建Roles表
CREATE TABLE Roles (
    id INT AUTO_INCREMENT PRIMARY KEY,
    user_id INT NOT NULL,
    role_name VARCHAR(255) NOT NULL
);

-- 创建Permissions表
CREATE TABLE Permissions (
    id INT AUTO_INCREMENT PRIMARY KEY,
    user_roles VARCHAR(255) NOT NULL,
    permission VARCHAR(255) NOT NULL
);

接下来该敲代码了，依旧是熟悉的套路，依赖配置写代码

核心逻辑如下

根据jwt登录得到redis的用户key获取用户信息，比如id，根据id拿到角色和权限
在每一个接口写一个aop切面，在切面中判断该登录用户是否含有对应接口所需要的角色和权限

登录jwt认证和拦截参考我的另一篇博客：JWT生成ToKen进行验证-CSDN博客 

1.使用aop切面先加上依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

2. 接下来创建权限注解（注解大致就是一个类，包含一些属性，主要还是切面的逻辑）

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DbmAuthority {
    String value(); // 权限字符串，格式为"功能:角色:权限"
}

3.创建一个简单的用户权限类，如下

@Data
public class User {
    private String id; //用户ID
    private List<String> roles; //角色
    private List<String> permissions; //权限
}

4.模拟从数据库根据登录用户id查询该角色的角色和权限

public interface UserRepository {
    User getUserById(String userId);
}

实现这个接口

public class UserRepositoryimpl implements UserRepository{

    @Resource
    private RolesMapper rolesMapper;
 
    @Resource
    private Permissions permissionsMapper;

    @Override
    public User getUserById(String userId) {
        //根据id获取该用户扮演的角色
        List<String> roles = rolesMapper.selectAll(userId);
        //根据id获取该用户拥有的权限 
        List<String> permissions = new ArrayList<>();  
         roles.stream().forEach(a->{
         List<String> permission =permissionsMapper.selectAll(a);   
         permission.stream().forEach(a->{
         permissions.add(a);
         });
        });       
        User user= new User(userId,roles,permissions);
        return user;
    }
}

用户的角色和权限一般都是一起查出来，参考sql如下

SELECT R.id AS id, 
       GROUP_CONCAT(R.role_name) AS role_list,
       GROUP_CONCAT(P.permission) AS permission_list
FROM Roles R
LEFT JOIN Permissions P ON R.role_name = P.user_roles
WHERE R.id = 1; -- 你的特定id
GROUP BY R.id;

5.在注解实现aop逻辑，本质和上面说的一样，很简单

@Aspect
@Component
public class DbmAuthorityAspect {

    @Resource
    private UserRepositoryimpl userRepositoryimpl;

    @Resource
    private RedisUtils redisutils;

    @Pointcut("@annotation(com.dabaimao.DbmAuthority)")
    public void authorityCheckPointcut(JoinPoint joinPoint) {
    }

    @Before("@annotation(com.dabaimao.DbmAuthority)")
    public void checkDbmAuthority(JoinPoint joinPoint) {
      try {
        // 获取当前用户的ID（从Redis中获取）
        String userId = getUserIdFromRedis(); 

        // 根据用户ID查询用户信息
        User user = userRepositoryimpl.getUserById(userId);
        
        // 获取注解类对象
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method method = methodSignature.getMethod();
        DbmAuthority annotation = method.getAnnotation(DbmAuthority.class);

        // 检查用户是否具有所需的角色和权限
        if (userHasRequiredAuthority(user, annotation.value())) {
            // 用户具有权限，允许访问
        } else {
            throw new SecurityException("权限不够，拒绝访问");
        }
       } catch (Exception ex) {
           throw new RuntimeException("权限处理异常");
       }
    }

    private boolean userHasRequiredAuthority(User user, String requiredAuthority) {
        // 实际权限检查逻辑，需要根据用户的角色和权限信息以及 requiredAuthority 判断
        // 这里只是一个示例，实际逻辑可能更复杂
        return user.getRoles().contains(requiredAuthority) || user.getPermissions().contains(requiredAuthority);
    }

    private String getUserIdFromRedis() {
        // 实际从Redis中获取用户ID的逻辑
        // redisutils.getkey...
        return "user123"; // 示例
    }
}

最后在需要加权限访问的接口加上这个注解，写上访问这个接口所需要的角色和权限就行了

@RestController
public class MyController {
 
    @DbmAuthority("功能:角色:权限") //访问这个功能登录用户所需要的角色和权限
    @GetMapping("/protectedEndpoint")
    public ResponseEntity<String> protectedEndpoint() {
        // 执行需要权限验证的操作
        return ResponseEntity.ok("访问成功");
    }
}

这样一个简单的权限认证就实现了