Springboot权限管理

已于 2023-09-05 09:57:02 修改
阅读量1.7k 收藏 17
点赞数 1
文章标签： java 开发语言 spring boot spring
于 2023-09-05 09:46:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55895202/article/details/132684682
版权

一、前言

最近在整合完单点登录后，又来了一个新活，好在这个任务已经比较成熟，实现的方式也比较多，也有比较成熟的框架已经实现了它，它就是权限管理。

二、实现过程

实现权限管理的方式有很多，我提出我通过查阅资料学习所知道的，如果有更多欢迎分享：

  1. 拦截器做鉴权
  2. AOP做鉴权
  3. shiro框架
  4. springsecurity框架

其中，1、2点都是基于在类或方法上加上一个自定义注解实现的，在通知或拦截器中通过获取类或方法上的注解的value值，来比较判断用户的权限，再决定是否放行执行我们的核心业务。

考虑到公司架构和其他原因，我使用到的是使用AOP进行鉴权认证。

实现过程如下：

2.1数据库设计   

2.1.1RBAC权限模型

RBAC是基于角色的访问控制，是用户通过角色与权限进行关联，为什么不直接给用户分配权限呢？简单来说，一个用户拥有多个角色，每个角色拥有若干权限。这样就构成了“用户-角色-权限”的授权模型。在这个模型中，用户与角色、角色与权限之间是多对多的关系。

根据角色授权的思想，我们需要设计五张表

​ 用户表（user）

​ 角色表（role）

​ 权限表（permission）

这三个表之间都是多对多的关系，所以衍生出两个关联表如下

 用户角色表（user_role）

​ 角色资源表（role_permission)

2.2.选择方案

2.2.1基于AOP的实现

1.定义注解

@Retention(value = RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD,ElementType.TYPE})
@Inherited
@Documented
public @interface PreAuthorize {
    String value();
}

注解的value值代表的是方法所需的条件或权限

2.AuthorizeAspect切面定义


@Aspect
@Component
public class AuthorizeAspect {

    @Autowired
    private ZsjScadaUserService userService;

    @Autowired
    private ZsjScadaUserRoleService userRoleService;

    @Autowired
    private ZsjScadaRolePermissionService rolePermissionService;

    @Autowired
    private ZsjScadaPermissionService permissionService;

    //定义切点
    @Pointcut("@annotation(com.metastar.vip.scada.service.annotation.PreAuthorize)")
    public void logPointCut(){

    }
    //鉴权通知
    //环绕通知选择原因：取消方法执行：在环绕通知中，我们可以选择不执行目标方法（JointPoint），从而取消方法的执行。这在鉴权过程中非常有用，如果用户没有相应的权限，我们可以直接返回错误信息，而不必执行目标方法。
    @Around("logPointCut()")
    public Object authAround(ProceedingJoinPoint joinPoint) throws Throwable{

        // TODO: 2023/8/31 获取目标方法中的HttpRequest -> 获取请求头携带的Cookie
        Object[] args = joinPoint.getArgs();
        String name = joinPoint.getSignature().getName();
        HttpServletRequest request = (HttpServletRequest) args[0];
        Object proceed = null;
        HttpSession session = request.getSession(false);
        if (session == null){
      
            return proceed = Result.fail("请先登录");
        }
//         TODO: 2023/8/31  根据cookie获取当前会话信息 -> 获取当前登录用户
        Assertion assertion = (Assertion) session.getAttribute("_const_cas_assertion_");
        Map<String, Object> attributes = assertion.getPrincipal().getAttributes();
        String user = attributes.get("USER").toString();
        JSONObject userJsonObject = JSON.parseObject(user);
        String userId = userJsonObject.getString("userId");
//         TODO: 2023/8/31 根据用户ID查询该用户角色
        QueryWrapper<UserDO> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("id",userId).eq("in_use",1);
        UserDO userDO = userService.getOne(queryWrapper);
        if (user == null){
            throw new RuntimeException("该用户不存在");
        }
//         TODO: 2023/8/31 根据该角色去查询所拥有的权限
        QueryWrapper<UserRoleDO> userRoleDOQueryWrapper = new QueryWrapper<>();
        userRoleDOQueryWrapper.eq("user_id",userDO.getId());
        UserRoleDO one = userRoleService.getOne(userRoleDOQueryWrapper);
        Long roleId = one.getRoleId();
        QueryWrapper<RolePermissionDO> rolePermissionDOQueryWrapper = new QueryWrapper<>();
        rolePermissionDOQueryWrapper.eq("role_id",roleId);
        List<Long> permissionIds = rolePermissionService.list(rolePermissionDOQueryWrapper).stream().map(RolePermissionDO::getPermissionId).collect(Collectors.toList());
//         TODO: 2023/8/31 查看该权限所能访问的资源uri
//         TODO: 2023/8/31 查看当前目标类+方法的URI是否存在与当前用户权限所对应的资源uri列表中
//         TODO: 2023/8/31 存在->继续指定控制器中的方法 不存在->返回错误信息
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Object target = joinPoint.getTarget();
        //获取注解标注的类（鉴权以类为单位）
//        PreAuthorize annotation1 = target.getClass().getAnnotation(PreAuthorize.class);
//        String value = annotation1.value();
        //获取注解标注的方法(鉴权以方法为单位)
        Method method = target.getClass().getMethod(methodSignature.getName(), methodSignature.getParameterTypes());
        //通过方法获取注解
        PreAuthorize annotation = method.getAnnotation(PreAuthorize.class);
        //获取注解中的值
        String permissionValue = annotation.value();
        Integer count = 0;
        for (Long permissionId : permissionIds) {

            String permissionName = permissionService.getById(permissionId).getPermissionName();
            if (permissionName.equals(permissionValue)){
                //该角色含有该权限 访问方法
                proceed = joinPoint.proceed(args);
                break;
            }
            count++;
        }
        if (count == permissionIds.size()){
            //没有该权限 抛出异常
            return proceed = Result.fail("权限不足，无法访问");
    
        }
        return proceed;
    }

}

3.测试

@RestController
@RequestMapping("/auth")
public class authTestController {

    @PostMapping("/test1")
    @PreAuthorize(value = "用户模块")
    public Result Test1(HttpServletRequest request,String userName){

        return Result.ok(userName);
    }
}

Postman访问该url后，拦截后执行环绕通知进行鉴权，通过后访问该控制器中的Test1方法响应结果。

2.2.2基于拦截器的实现

1.同样是定义自定义注解

@Target({ElementType.TYPE, ElementType.METHOD}) //注解的作用域，即此注解应该被用在什么地方
@Retention(RetentionPolicy.RUNTIME)  //注解的生命周期，即注解在什么范围内有效
@Inherited  //标识注解，允许子类继承
@Documented //标识注解，生成javadoc文档时，会包含此注解
public @interface RoleNum {
//    int value(); //default 1;
    String value();
}

2.定义拦截器

@Component
public class LoginInterceptor implements HandlerInterceptor {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 目标方法执行之前(Controller方法调用之前)
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        // TODO: 2023/7/21 获取前端Authorization的token值 访问redis
        // TODO: 2023/7/21 命中 放行 刷新redis中token的TTL
        // TODO: 2023/7/21 未命中（过期） 重新向登录页面 拦截
        // TODO: 2023/7/24 在验证到相应登陆的Token后 需要查看当前用户Role值 检验是否有该路径的访问权限
        String token = request.getHeader("Authorization");
        Long size = stringRedisTemplate.opsForHash().size(RedisConstant.LOGIN_INFO + token);
        if (size == 0){
            //重定向到登录页面
//            response.sendRedirect("/login");
            //拦截
            response.getWriter().write("{\"code\":-1,\"msg\":\"please login first\",\"data\":null}");
            return false;
        }else {
            String role = (String) stringRedisTemplate.opsForHash().get(RedisConstant.LOGIN_INFO + token, "role");
            if (hasPermission(handler,role)) {
                //权限足够
                //放行 并 刷新 用户信息token TTL
                stringRedisTemplate.expire(RedisConstant.LOGIN_INFO + token,RedisConstant.LOGIN_TTL, TimeUnit.MINUTES);
                return true;
            } else {
                //权限不足
                response.getWriter().write("{\"code\":-1,\"msg\":\"privilege is not enough\",\"data\":null}");
                //放行 并 刷新 用户信息token TTL
                stringRedisTemplate.expire(RedisConstant.LOGIN_INFO + token,RedisConstant.LOGIN_TTL, TimeUnit.MINUTES);
                return false;
            }
        }
    }

    /**
     * 验证权限是否足够
     * @param handler
     * @param role
     * @return
     */
    private boolean hasPermission(Object handler, String role) {

        if (handler instanceof HandlerMethod){
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            //获取方法上的注解
            RoleNum roleNum = handlerMethod.getMethod().getAnnotation(RoleNum.class);
            //如果方法上的注解为空 则获取类的注解
            if (roleNum == null){
                roleNum = handlerMethod.getMethod().getDeclaringClass().getAnnotation(RoleNum.class);
            }
            //如果标记了注解，则判断权限
            if (roleNum != null){
                if (roleNum.value().equals("2")){  //该通用身份即可访问
//                    System.err.println("权限足够，正在访问");
                    return true;
                }
                if (roleNum.value().equals("1")) {  //Normal  0
                    if (role.equals("1")){
                        return true;
                    }else if (role.equals("0")){
                        return true;
                    }
                }
                if (roleNum.value().equals("0")){
                    if (role.equals("0")){
                        return true;
                    }else {
                        return false;
                    }
                }
            }
        }

        return false;
    }

注意：上述用户的角色权限信息是存储在Redis中的。

三、最后

现在鉴权模块已经非常成熟，以上仅为个人心得和实践，还有很多改进的地方欢迎评论，后续还会补充通过Shiro框架实现的鉴权这一模块。

玩煤球的咕咕猪
关注
  • 1
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
基于springboot的RBAC权限管理演示系统
01-17
这是一个RBAC权限管理系统，即基于角色的用户权限控制，，使用springboot框架开发，UI使用的是layui。。 演示地址：http://116.196.66.248:8090/page/index 欢迎大家下载。。。。另外，建议使用IDEA导入项目。。
SpringBoot权限管理系统
08-03
用Springboot框架开发的权限管理系统后台
SpringBoot整合SpringScurity权限控制（菜单权限，按钮权限）以及加上SSH实现安全传输
最新发布
qq_63946922的博客
05-10 1260
如果你在设计一个需要存储用户密码的系统，强烈建议使用 bcrypt、PBKDF2 或 Argon2 而不是 MD5。这些现代算法提供了更高级别的安全保障，可以帮助你的系统抵御当前的威胁，如暴力破解和彩虹表攻击。选择正确的密码存储策略是保护用户数据安全的关键一步。
springboot权限管理系统源码.zip
05-28
springboot权限管理系统源码 主要功能： * 系统用户,角色,权限增删改查,权限分配，权限配色<br/> * 文件上传可自由选择本地存储,七牛云存储,阿里云存储 * 系统字典<br/> * 配置网站基本信息，包括博客数据限制<br/> * 查看系统关键操作的日志(可在系统后台自动定制需要监控的模板)<br/> * 在线新增数据库并直接生成 前，后台基本源码，放到源码相应目录中重启tomcat可直接使用，预览<br/> * 系统定时任务的新增改查 立即启动 暂停 恢复<br/> 技术框架： * 核心框架：`SpringBoot` * 安全框架：`Apache Shiro 1.3.2` * 缓存框架：`Redis 4.0` * 搜索框架：`Lucene 7.1` * 任务调度：`quartz 2.3` * 持久层框架：`MyBatis 3`
springboot springsecurity动态权限控制
09-18
springboot springsecurity动态权限控制，实现数据库动态管理菜单权限
企业员工角色权限管理平台（SpringBoot2.0+Mybatis+Shiro+Vue）
08-07
课程简介：历经半个多月的时间，Debug亲自撸的 “企业员工角色权限管理平台” 终于完成了。正如字面意思，本课程讲解的是一个真正意义上的、企业级的项目实战，主要介绍了企业级应用系统中后端应用权限的管理，其中主要涵盖了六大核心业务模块、十几张数据库表。 其中的核心业务模块主要包括用户模块、部门模块、岗位模块、角色模块、菜单模块和系统日志模块；与此同时，Debug还亲自撸了额外的附属模块，包括字典管理模块、商品分类模块以及考勤管理模块等等，主要是为了更好地巩固相应的技术栈以及企业应用系统业务模块的开发流程！ 核心技术栈列表： 值得介绍的是，本课程在技术栈层面涵盖了前端和后端的大部分常用技术，包括Spring Boot、Spring MVC、Mybatis、Mybatis-Plus、Shiro(身份认证与资源授权跟会话等等)、Spring AOP、防止XSS攻击、防止SQL注入攻击、过滤器Filter、验证码Kaptcha、热部署插件Devtools、POI、Vue、LayUI、ElementUI、JQuery、HTML、Bootstrap、Freemarker、一键打包部署运行工具Wagon等等，如下图所示： 课程内容与收益： 总的来说，本课程是一门具有很强实践性质的“项目实战”课程，即“企业应用员工角色权限管理平台”，主要介绍了当前企业级应用系统中员工、部门、岗位、角色、权限、菜单以及其他实体模块的管理；其中，还重点讲解了如何基于Shiro的资源授权实现员工-角色-操作权限、员工-角色-数据权限的管理；在课程的最后，还介绍了如何实现一键打包上传部署运行项目等等。如下图所示为本权限管理平台的数据库设计图： 以下为项目整体的运行效果截图： 值得一提的是，在本课程中，Debug也向各位小伙伴介绍了如何在企业级应用系统业务模块的开发中，前端到后端再到数据库，最后再到服务器的上线部署运行等流程，如下图所示：
spring boot 权限管理的几种方式
orton777的博客
05-27 4807
spring boot 权限
springboot 实现权限管理（一）
iijik55的博客
08-02 4899
若token失效则返回失效，token未失效进行权限查看（token及权限信息等常用个人信息采用Redis进行缓存），有权限放行，无权限拦截；（2）用户访问登录URL，则无需拦截，判断用户、密码，进行缓存个人信息（查询关系数据库的用户角色、权限信息后进行缓存），并返回token给用户作为下次登录凭证；（2）分类资源（对应相应的权限），一般可以有数据权限、操作权限、访问权限等，表现为对URL（URI）的访问控制；在关系数据库中，由于原子性（第一规范），因此需要两张关联表进行管理用户和角色，角色和权限。...
springboot权限系统
ABC_efg123456的博客
03-02 2894
springboot权限管理系统详细思路
【SpringBoot】RBAC权限控制
m0_62645012的博客
02-04 2331
通常情况下，一个系统，除了登陆也就是认证之外，还应该有一个重要的功能，就是鉴权，使用rbac可以很好的解决上述的问题。认证(authentication)-规定了谁能够登陆鉴权(authorization)-规定了谁能访问那些接口，浏览那些页面，使用哪些功能，RBAC（Role-Based Access Control ）基于角色的访问控制。不同人，有不同的权限，老师有判卷权限，学生有答题的权限...RBAC语言中的角色通常是指一组具有某些特征的人，例如:部门 /地点/资历/工作职责等。
springboot库存管理系统
10-02
基于springboot+mybatis搭建的库存管理系统，功能包括： 供销管理：客户管理、供应商管理、商品管理。 进退货管理：商品进货、商品退货查询。 销售管理：商品销售、销售退货查询。 系统管理：部门管理、菜单管理、...
基于springBoot的权限管理系统
01-07
mysiteforme权限管理系统是学习springBoot时基于springBoot开发的一套轻量级的系统脚手架，可以以此形成一套属于自己的系统后台 ，自动生成前后台基本代码；使用Spring Boot、Shiro、MyBatis、Layui等框架，包含：...
springboot图书管理系统
07-09
此外，权限管理和用户认证也是图书管理系统不可或缺的部分。Spring Security可以提供强大的安全控制，包括角色分配、登录验证、访问控制等。通过XML配置或Java配置，我们可以定制化的定义安全策略，确保系统操作的...
SpringBoot的安全与权限管理
禅与计算机程序设计艺术
01-25 609
1.背景介绍 1. 背景介绍 Spring Boot是一个用于构建新Spring应用的优秀框架。它简化了配置，使得开发人员可以快速搭建Spring应用。然而，在实际应用中，安全和权限管理是非常重要的。因此，本文将深入探讨Spring Boot的安全与权限管理，并提供实用的最佳实践。 2. 核心概念与联系 在Spring Boot应用中，安全与权限管理主要依赖于Spring Security...
springboot实现权限管理（shiro）
qq_44156131的博客
12-13 935
总结一下学习springboot权限管理的经验 1、创建数据库 5张表 user表：用户表 role表：角色表 permission表：功能表 role_permission:角色功能表（外键关联） user_role:角色用户表（外键关联） /* Navicat MySQL Data Transfer Source Server : 10.2.10.201111 Source ...
【SpringBoot整合系列】SpringBoot整合Shiro——权限控制
低调做人，低调编码，神码都是浮云
04-12 1083
SpringBoot整合Shiro权限控制
【业务功能篇57】Springboot + Spring Security 权限管理 【上篇】
studyday1的博客
07-28 4209
1) Spring Security 是 Spring 家族中的一个安全管理框架，可以轻松地与 Spring 应用程序集成, 它提供了一系列的安全服务和工具，用于保护企业应用程序的安全性。Spring Security 提供了许多功能，包括身份验证（Authentication）、授权（Authorization）、访问控制、密码管理、单点登录（Single Sign-On）、攻击防范（如跨站点脚本攻击、SQL注入攻击）等。2) 认证和授权也是SpringSecurity作为安全框架的核心功能。
SpringBoot项目使用切面编程实现数据权限管理
weixin_44792849的博客
03-26 2325
springboot项目使用切面编程实现数据权限管理
springboot 权限管理
03-31
Spring Boot 提供了多种权限管理方式，如使用 Spring Security 或自定义实现。下面简单介绍两种实现方式： 1. 使用 Spring Security Spring Security 是 Spring 生态中用于安全认证和授权的框架，可以非常方便地实现基于角色或权限的访问控制。在 Spring Boot 中集成 Spring Security 非常简单，只需要添加依赖和配置文件即可。 首先，在 `pom.xml` 中添加 Spring Security 的依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> ``` 然后，在 `application.properties` 文件中配置用户名和密码： ``` spring.security.user.name=admin spring.security.user.password=123456 ``` 最后，在 Spring Boot 应用程序的启动类上添加 `@EnableWebSecurity` 注解，启用 Spring Security： ```java @SpringBootApplication @EnableWebSecurity public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } ``` 现在，你可以使用 `@PreAuthorize` 或 `@Secured` 注解来限制方法的访问： ```java @RestController public class UserController { @GetMapping("/users") @PreAuthorize("hasRole('ADMIN')") public List<User> getUsers() { // ... } @PostMapping("/users") @PreAuthorize("hasAuthority('CREATE_USER')") public void createUser(@RequestBody User user) { // ... } } ``` 在上面的例子中，`@PreAuthorize` 注解会检查用户是否具有指定的角色或权限。如果用户没有权限，访问将被拒绝。 2. 自定义实现 如果你不想使用 Spring Security，或者需要更细粒度的控制，可以自定义权限管理实现。下面是一个简单的例子： 首先，定义一个 `Permission` 类表示权限： ```java public enum Permission { READ_USER, CREATE_USER, UPDATE_USER, DELETE_USER } ``` 然后，定义一个 `User` 类表示用户信息： ```java public class User { private String username; private String password; private List<Permission> permissions; // getter and setter } ``` 接着，在 `UserController` 中添加一个 `checkPermission` 方法来检查用户是否具有指定的权限： ```java @RestController public class UserController { @Autowired private UserService userService; @GetMapping("/users") public List<User> getUsers() { checkPermission(Permission.READ_USER); return userService.getUsers(); } @PostMapping("/users") public void createUser(@RequestBody User user) { checkPermission(Permission.CREATE_USER); userService.createUser(user); } private void checkPermission(Permission permission) { User user = getCurrentUser(); if (user == null || !user.getPermissions().contains(permission)) { throw new RuntimeException("Access denied"); } } private User getCurrentUser() { // 获取当前用户信息 // ... } } ``` 在上面的例子中，`checkPermission` 方法会检查当前用户是否具有指定的权限。如果用户没有权限，访问将被拒绝。 最后，在 `UserService` 中添加一个 `getCurrentUser` 方法来获取当前用户信息： ```java @Service public class UserService { public User getCurrentUser() { // 获取当前用户信息 // ... } } ``` 在实际应用中，你可能需要更复杂的权限管理逻辑，如基于角色的访问控制、动态授权等。这些都可以通过自定义实现来实现。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值