基于Interceptor+JWT+Redis的后端API权限验证小实现

最新推荐文章于 2023-12-07 14:17:57 发布
最新推荐文章于 2023-12-07 14:17:57 发布
阅读量289 收藏
点赞数
文章标签： java Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BASK2312/article/details/128683023
版权

1. 描述

1.1 实现思路

  • 总体流程如下:

  • 登录逻辑如下:

  • 请求权限认证如下

1.2 用户访问API划分

  • 如下图所示

2. 环境搭建

2.1 数据库

  • 基于RBAC模型建立的，比较简单

  • 在这里要特别描述下权限表的各个字段含义：

  • 比如做SaaS如果还要细分的话，权限表实际上还可以拆，这里只是一个权限认证的小Demo，就简单化了

  • 本Demo中权限表中的具体数据如下图所示（特别注意每行记录中的api_identify值，代表某个接口的唯一标识符，后面在Controller中会有对应标明"）

2.2 项目

  • 由于总体上比较简单，这里只描述一些重要的点，其余的自行查看发布到GitHub的项目

  1. 登录接口

@RestController@RequestMapping("/login")publicclassLoginController {
    @Resource
    private UserService userService;
​
    @Resource
    private JwtUtils jwtUtils;
​
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
​
    @Value("${redis.user.prefix}")
    private String redisKeyPrefix;
​
    @Value("${jwt.config.ttl}")
    privateLong time = 1800L;
​
    @PostMapping
    public Result login(String username,  String password) throws CommonException {
        if(StringUtils.isEmpty(username) || StringUtils.isEmpty(password)){
            throw new CommonException(ResultCode.REQUEST_PARARMETER_MISS);
        }
        User user = userService.findByUsername(username);
        if(user == null){
            // 不存在此用户,登录失败
            return new Result(ResultCode.USERNAME_PASSWORD_ERROR);
        }else{
            // 比对密码
            if(password.equals(user.getPassword())){
                // 登录成功,存储当前用户到Redis里(设置存活时间) 签发token
                redisTemplate.opsForValue().set(redisKeyPrefix + user.getId(), user, time, TimeUnit.SECONDS);
                String token = jwtUtils.createJwt(user.getId(), user.getUsername(), null);
                return Result.SUCCESS(token);
            }else{
                // 密码错误
                return new Result(ResultCode.USERNAME_PASSWORD_ERROR);
            }
        }
    }
}
复制代码

  • 这里的登录逻辑是按照上述的逻辑图来实现的

  • 特别注意用户信息存放到Redis中的key，是通过配置的前缀 + 用户id拼接成的

  • 有效时间也是通过配置来设置的，否则有个默认时间

  1. 两个Controller（注意每个接口上的请求映射注解name属性上，都标明了此接口对应的唯一标识符）

  1. 统一状态码封装

publicenumResultCode {
​
​
    SUCCESS(true, 10000, "操作成功！"),
    //---系统错误返回码-----
    FAIL(false, 10001, "操作失败"),
    UNAUTHENTICATED(false, 10002, "您还未登录"),
    TOKEN_LOSE_EFFICACY(false, 10003, "登录凭证已失效!"),
    UNAUTHORISE(false, 10004, "权限不足"),
​
    /**
     * 登录失败异常
     */
    USERNAME_PASSWORD_ERROR(false, 20001, "用户名或者密码错误"),
​
    REQUEST_PARARMETER_MISS(false, 30000, "请求参数缺失"),
    /**
     * 请求类型不支持
     */
    REQUEST_METHOD_NOT_SUPPORT(false, 40000, "不支持的请求类型"),
    SERVER_ERROR(false, 99999, "抱歉，系统繁忙，请稍后重试！");
    //---其他操作返回码----
​
​
    //操作是否成功
    boolean success;
    //操作代码
    int code;
    //提示信息
    String message;
​
    ResultCode(boolean success, int code, String message) {
        this.success = success;
        this.code = code;
        this.message = message;
    }
​
    publicbooleansuccess(){
        return success;
    }
​
    publicintcode(){
        return code;
    }
​
    publicStringmessage(){
        return message;
    }
}
复制代码

  1. 自定义异常

  1. 异常统一处理

​
/**
 * @author: Zero
 * @time: 2022/12/28
 * @description: 统一异常处理
 */@RestControllerAdvice
public class BaseExceptionHandler {
​
    /**
     * 通用自定义异常捕获(登录状态/权限验证)
     *
     * @return
     */
    @ExceptionHandler(value = CommonException.class)
    public Result commonException(CommonException exception) {
        if (exception.getMessage() != null && exception.getMessage().equals(ResultCode.REQUEST_PARARMETER_MISS.message())) {
            // 请求参数缺失
            return new Result(ResultCode.REQUEST_PARARMETER_MISS);
        }
        if (exception.getMessage() != null && exception.getMessage().equals(ResultCode.UNAUTHENTICATED.message())) {
            // 未登录/token非法
            return new Result(ResultCode.UNAUTHENTICATED);
        }
        if (exception.getMessage() != null && exception.getMessage().equals(ResultCode.TOKEN_LOSE_EFFICACY.message())) {
            // 登录凭证token已经失效
            return new Result(ResultCode.TOKEN_LOSE_EFFICACY);
        }
        if (exception.getMessage() != null && exception.getMessage().equals(ResultCode.UNAUTHORISE.message())) {
            // 访问权限不足
            return new Result(ResultCode.UNAUTHORISE);
        }
        if (exception.getMessage() != null && exception.getMessage().equals(ResultCode.REQUEST_METHOD_NOT_SUPPORT.message())) {
            // 不支持的请求方法类型
            return new Result(ResultCode.REQUEST_METHOD_NOT_SUPPORT);
        }
        if (exception.getMessage() != null) {
            // 给定异常信息
            return new Result(10001, exception.getMessage(), false);
        }
        // 请求失败
        return new Result(ResultCode.FAIL);
    }
​
​
    /**
     * 服务器异常统一返回
     *
     * @return
     */
    @ExceptionHandler(value = Exception.class)
    public Result error() {
        return new Result(ResultCode.SERVER_ERROR);
    }
}
复制代码

  1. 拦截器实现

/**
 * @author: Zero
 * @time: 2022/12/28
 * @description:
 */publicclassRequestInterceptorimplementsHandlerInterceptor {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
​
    @Resource
    private JwtUtils jwtUtils;
​
​
    @Value("${redis.user.prefix}")
    private String redisKeyPrefix;
​
    @Override
    publicbooleanpreHandle(HttpServletRequest request, HttpServletResponse response, Object handler)throws Exception {
        // 1. 获取token
        Stringauthorization= request.getHeader("Authorization");
        // 2. 验证token  (不为null 且 开头为"Bearer ",签发的时候是以"Bearer "开头,后面再接token实际值-业界统一这样做,也不知道为啥)
        if (!StringUtils.isEmpty(authorization) && authorization.startsWith("Bearer ")) {
            Stringtoken= authorization.replace("Bearer ", "");
            Claimsclaims=null;
            try {
                claims = jwtUtils.parseJwt(token);
            } catch (ExpiredJwtException e) {
                e.printStackTrace();
                thrownewCommonException(ResultCode.TOKEN_LOSE_EFFICACY); // token失效
            } catch (UnsupportedJwtException e) {
                e.printStackTrace();
                thrownewCommonException("不支持的token");
            } catch (MalformedJwtException e) {
                e.printStackTrace();
                thrownewCommonException("token解析失败");
            } catch (SignatureException e) {
                e.printStackTrace();
                thrownewCommonException("token签名验证失败");
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
                thrownewCommonException("token非法参数");
            }
            if (claims != null) {
                // 已登录
                // 从Redis中获取用户,从而获取权限信息
                Useruser= (User) redisTemplate.opsForValue().get(redisKeyPrefix + claims.getId());
                List<Permission> permissions = null;
                if (user != null) {
                    permissions = user.getPermissions();
                } else {
                    // Redis出问题,导致保存的已经登录的用户信息没了(注意不是登录时间失效了)
                    thrownewCommonException(ResultCode.SERVER_ERROR);
                }
                // 通过注解反射获取每个API接口的唯一标识符
                //  --在这里的是唯一标识符是在Controller的方法上的@RequestMapping的name属性标明的，数据库的API也有
                //  --可以自己自定义注解接口来实现（这样获取时比较容易），使用Restful风格时推荐使用,
                //  -- 使用了Restful风格但是没有统一使用@RequestMapping的话那就根据请求类型来获取注解
                HandlerMethodh= (HandlerMethod) handler;
                //  获取接口上的@RequestMapping注解
                Objectannotation=null;
                // 获取请求类型
                Stringmethod= request.getMethod().toUpperCase();
                Stringname=null;    // 表示目标接口处的唯一标识符
                booleanpass=false; // 表示最终是否有权限访问此接口
                switch (method) {
                    case"GET":
                        annotation = h.getMethodAnnotation(GetMapping.class);
                        name = ((GetMapping) annotation).name();
                        break;
                    case"POST":
                        annotation = h.getMethodAnnotation(PostMapping.class);
                        name = ((PostMapping) annotation).name();
                        break;
                    case"DELETE":
                        annotation = h.getMethodAnnotation(DeleteMapping.class);
                        name = ((DeleteMapping) annotation).name();
                        break;
                    case"PUT":
                        annotation = h.getMethodAnnotation(PutMapping.class);
                        name = ((PutMapping) annotation).name();
                        break;
                    default:
                        thrownewCommonException(ResultCode.REQUEST_METHOD_NOT_SUPPORT);
                }
                if (permissions != null && !StringUtils.isEmpty(name)) { //如需权限限定时使用开放此句即可
                    for (Permission permission : permissions) {
                        if (permission.getApiIdentify() != null && permission.getApiIdentify().equals(name)) {
                            // 具有访问权限
                            pass = true;
                            break;
                        }
                    }
                }
                if (pass) { //
                    // 表示具有访问权限
                    returntrue;
                } else {
                    // 无访问权限
                    thrownewCommonException(ResultCode.UNAUTHORISE);
                }
​
            }
        }
        // 未登录/token格式不对
        thrownewCommonException(ResultCode.UNAUTHENTICATED);
    }
​
}
​
复制代码

  1. 配置文件

3. 实践测试

3.1 Admin

  • 登录张三用户

  • 带着token访问OneController的各个接口

  • Get

  • Post

  • Put

  • Delete

  • 带着token访问TwoController的各个接口

  • Get

  • Post

  • Put

  • Delete

  • 可以看到张三这个Admin用户正如我们所愿，可以访问到OneController和TwoController中的接口

3.2 Common

  • 登录李四用户

  • 带着token访问OneController的各个接口

  • Get

  • Post

  • Put

  • Delete

  • 带着token访问OneController的各个接口

  • Get

  • Post

  • Put

  • Delete

  • 可以看到李四这个Common用户，按照我们之前的规划，只能访问OneController的接口，访问不到TwoController的接口

3.3 Another

  1. 对于其他情况，比如说token过期，未登录，还是说token非法等情况

  1. 在拦截器中均有对应的情况解决

  1. 也就是直接抛出对应的装载了自定义状态码的异常

  1. 然后统一解决异常处理

  1. 在这里就不再一一演示了

4. 总结

  1. 总的来说,逻辑上是没啥问题的

  1. 基本上能够实现登录验权的基本功能

  1. 只要写Controller接口时，在请求映射注解上通过name属性标明此接口的唯一标识符（因为现在大多数使用的是Restful风格，这里推荐通过自定义注解上的属性来标识每个接口的唯一标识符，这样在Interceptor中便于获取每个接口的唯一标识符，不用再枚举使用的是哪个映射注解）

  1. 然后再到权限表中插入此接口信息，最后在角色-权限表中设置不同角色对应的权限映射关系即可

  1. 但也带来很多问题

  1. 得手动插入接口信息入表，得手动设置角色-权限表中的映射关系，很麻烦

最好是当接口写的差不多后，再统一弄这个，会节省很多时间，但是还是很麻烦,或者看 能不能自己写个工具类出来，自动完成这一工作，目前这个正在考虑怎么写ing

  1. token本身可能带来的问题

比如说
token发布后，比如说设置了有效时间为半个钟，那么这半个钟内此token都有效，无法主动注销此token（玩点极端的，可以重启Redis服务器，付出让所有在线用户掉线一次的代价销毁此token的作用，然后赶紧跑路）
还是假设token发布，其有效时间为半个钟，原本此用户是无法A接口的，在这半个钟内，超级管理员设置了此用户可以访问A接口，但是用户对应权限信息只是实时更新到了数据库中，而Redis中还是存的是老旧的用户信息，也就代表着使用刚刚发布的token来访问时，从Redis中获取到的用户信息，是不具有访问A接口的权限的，很矛盾。（让用户退出重新登录即可）

  1. 总而言之：仅供参考

作者：之诺

原文链接：https://juejin.cn/post/7187228194406137914

职场面试官
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
前后端分离的项目，采用ssm后端接口权限校验
qq_38089964的博客
11-28 3270
前后端分离的项目中，服务端对于每个请求都是一模一样的，对于每个用户的请求识别就需要用到一个统一的方式（jwt），然后在访问每个接口的时候先对这个jwt进行识别，查出这个用户的权限级别，检查是否拥有访问这个接口的权限，如果没有，那么将直接返回一个错误信息，表示权限不足，反之放过，继续往下执行。 jwt就是一个包含用户信息的加密字符串：参考：JWT的生成及验证过程 因为对于每个接口都需要进行权...
后端接口权限验证
热门推荐
bleuesprit的专栏
01-08 1万+
接口验证有两种,一种是基于人的验证,比如需要调用者提供人员信息.第二种则是基于接口本身.接口本身的验证是因为很多调用者并不是一个人,可能仅仅是一个定时启动的脚本,无法采用用户名密码的形式来进行验证. 接口本身的验证基本方法就是在调用的时候在请求后方添加一个密钥,作为验证身份的令牌. # 基于简单密码 双方约定密码,密码正确验证通过 # 参数签名方式 步骤通常如下：
springboot整合shiro+jwt+redis实现权限校验，项目实战，有开源项目
Think_and_work的博客
02-13 3433
本文介绍了springboot整合shiro实现基本权限管理功能，是一个权限管理的实战项目，又开源项目地址，希望能够帮助到你
后端如何实现URL权限的校验
qq_46130027的博客
12-01 189
实现核心是基于Spring Security提供的@PreAuthorize注解，这个注解可以添加在方法上，基于表达式判断，是否有权限。权限表达式有两种，一种是基于角色标识的校验，一种是基于权限标识的校验。第三段逻辑则会遍历每一个权限，判断这个权限对应的菜单，最终在这个用户上有没有角色去满足。有的时候不是校验是否有权限，而是判断是否有某个角色，则可以使用hasRole这个方法。接着判断是否是超级管理员，如果是，也是return true。首先是判断权限是否为空，为空则说明已经有权限，返回true。
权限校验—接口检验
一起加油吧~
08-08 3158
获取传入用户的信息判断用户信息的权限信息集合中是否含有定义的权限/*** @Description: 自定义权限实现*//** 所有权限标识 *//*** 验证用户是否具备某权限* @param permission 权限字符串* @return 用户是否具备某权限*///判断是否传入权限字符//获取用户信息//判断是否有用户信息，或者用户信息中是否包含权限集合//将权限设置到请求头中//判断是否包含权限/*** 判断是否包含权限。
spring+springmvc+Interceptor+jwt+redis实现sso单点登录
02-26
### 使用Spring + SpringMVC + Interceptor + JWT + Redis 实现SSO单点登录 #### 一、背景介绍 在当前互联网技术飞速发展的背景下，越来越多的企业选择采用微服务架构来构建自己的应用系统。分布式环境下，如何...
spring+springmvc+Interceptor+jwt+redis实现sso单点登录.zip
07-17
本项目利用Spring、SpringMVC、Interceptor拦截器、JWT（JSON Web Token）以及Redis来实现SSO系统。下面将详细解释这些关键组件及其在SSO中的作用。 1. **Spring框架**： Spring是Java企业级应用开发的基石，提供...
springboot + jwt + websocket + 拦截
09-02
6. **权限控制**：通过Interceptor，我们可以检查JWT中的权限信息，控制用户对WebSocket端点的访问权限，实现细粒度的访问控制。 这样的架构可以提供一个高效、安全的实时交互系统，适用于需要实时数据同步和认证...
Springboot+redis+Interceptor+自定义annotation实现接口自动幂等
08-25
【接口幂等性概念】 接口幂等性是软件设计中的一个重要原则，它指的是一个接口被多...Spring Boot结合Redis和自定义Interceptor，能够有效地确保接口幂等性，防止重复处理和数据不一致，从而提高系统的稳定性和可靠性。
【SpringBoot系列】最详细demo--集成JWT实现接口权限认证
wufaqidong1的博客
07-15 3356
为了实现我自己能够手动抛出异常，我自己写了一个123456789}}}
django 后端用户权限和验证方式补充
lvbu89757的博客
07-02 497
这里写一些补充关于之前的Authenticate方法 全局IsAuthenticate设置是在setting文件中添加，比如下面 REST_FRAMEWORK={ ........ # 'DEFAULT_PERMISSION_CLASSES': ( # 'rest_framework.permissions.IsAuthenticated', # ) } 这里面...
interceptor方式拦截请求进行权限验证和签名验证
Zhtt的博客
10-13 1417
外部应用调用我方接口时通常需要做安全校验，这里记录一种验签方式，基于interceptor实现。 先看看接口的定义： @ApiOperation(value = "同步第三方商品数据") @PostMapping(value = "/sync") @ExternalAPI(sourceSystem = SourceSystemEnum.SUNAC) public ResponseHeaderVO<ThirdpartResponseSkuMappingVO> sync
后端认证鉴权
胡汉三
07-07 696
之前我们把redis缓存工具模块做好了、下面结合RBAC权限模型，我们来进行用户的认证鉴权设计。关于RBAC权限模型在之前的文章跟网上都有很多很详细的描述，这里就简单说一下、就是通过用户关联角色（多对多）、角色关联权限（多对多）、并且大部分系统还在角色与角色之间做了上下级关系。用来控制下级角色不能拥有上级角色没有的权限。有些系统还是组合权限的形式、给机构（部门）也跟角色挂钩。具体的根据业务需求来做就好了、反正最后我们的目的就是通过URL跟用户的token来校验当前用户是否拥有该URL的权限。
Shiro+JWT+Redis做认证，关于token有效期内续期方案
lucay1992的博客
02-09 1821
最近做的项目Springboot+vue前后端分离 还是选用了扩展功能很强大的shiro作为安全框架 并且弃用了shiro的session管理，使用JWT(JSON Web Token)取而代之 现在已经实现登录认证 有个问题是，用户在token有效时间内的正常操作(请求header中携带token的请求)如何刷新token最好？ 在网上查了查，我总结出两个方案： 1.第一种方案，单token反复刷新 简单来说就是用户每次访问后台服务，验证老token通过时，会进行jwt续期(重新颁发toke
以RuoYi为例自定义接口并设置权限验证
最新发布
weixin_64890968的博客
12-07 1839
本博客主要回答了ruoyi 系统里面后端这么多接口，不登录能访问吗？登录了就都能访问吗？ 自定义的接口，如何能保证其安全性？
Web API接口鉴权方式
人间世
02-28 5966
介绍web API接口的鉴权方式
Interceptor实现的权限管理
突破吧！次元壁
07-29 390
这几天老板突发奇想要我在app上搞个权限检验，“哎呀，这个很简单的，你从数据库里把权限找出来，然后放到手机里，用的时候比对一下就可以了”。 这也太完蛋了，直接把权限暴露出去不说，这代码写的一点设计感都没有，真就开发一时爽，维护火葬场。 所以在一上午面向百度编程之后，尝试了一下传说中的aop编程。在后端项目中，利用Interceptor在调用方法执行前进行拦截，根据调用方法上的注解验证当前session用户的权限。 首先是实现检验用户持有权限完整代码不敢放，怕查水表，只能写个伪的 boolean check
【java】基于JWT的token身份认证方案
九师兄
02-13 1381
1.概述 转载：基于JWT的token身份认证方案 2.使用JSON Web Token的好处 2.1 性能问题 验证信息可以由前端保存，后端不需要为保存token消耗内存。JWT方式将用户状态分散到了客户端中，相比于Session，可以明显减轻服务端的内存压力。 Session方式存储用户id的最大弊病在于Session是存储在服务器端的，所以需要占用大量服务器内存，对于较大型应用而言可能还要保存许多的状态，一般还需借助nosql和缓存机制来实现Session存储，如果是分布式应用还需Session共享.
springboot axios多文件上传 数据分组校验 拦截器Interceptor jwt登录
weixin_43292547的博客
09-24 350
【代码】springboot axios多文件上传 数据分组校验 拦截器Interceptor jwt登录。
SpringAOP与Interceptor：权限控制实现解析
Spring AOP主要通过动态代理机制实现，包括JDK动态代理和CGLIB动态代理，而Interceptor则是Spring MVC中的拦截器，用于处理请求前后的逻辑，如权限验证。" 在软件开发中，面向切面编程（AOP）是一种重要的设计模式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值