使用拦截器+Redis实现接口幂思路详解

更新时间：2023年08月19日 14:57:38 作者：逛窑子的李靖

这篇文章主要介绍了使用拦截器+Redis实现接口幂等,接口幂等有很多种实现方式，拦截器/AOP+Redis，拦截器/AOP+本地缓存等等，本文讲解一下通过拦截器+Redis实现幂等的方式，需要的朋友可以参考下

使用拦截器+Redis实现接口幂等

1.思路分析

接口幂等有很多种实现方式，拦截器/AOP+Redis，拦截器/AOP+本地缓存等等，本文讲解一下通过拦截器+Redis实现幂等的方式。

其原理就是在拦截器中拦截请求，然后根据一个标识符去redis中查询是否已经存在，如果存在，则说明当前请求正在处理，抛出异常告诉前端请勿重复请求。

标识符：一般可以使用token+methodType+uri作为标识符，具体业务具体分析。

2.具体实现

2.1 创建redis工具类

import com.yunling.sys.config.exception.ParamValidateException;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;
import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;
/**
 * Redis工具类
 *
 * @author 谭永强
 * @date 2023-08-15
 */
@Component
public class RedisUtils {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    /**
     * 写入缓存
     *
     * @param key   建
     * @param value 值
     * @return 成功/失败
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<String, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 写入缓存设置时效时间
     *
     * @param key   键
     * @param value 值
     * @return 成功/失败
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<String, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
    /**
     * 判断缓存中是否有对应的value
     *
     * @param key 键
     * @return 成功/失败
     */
    public boolean exists(final String key) {
        return Boolean.TRUE.equals(redisTemplate.hasKey(key));
    }
    /**
     * 读取缓存
     *
     * @param key 键
     * @return 成功/失败
     */
    public Object get(final String key) {
        return redisTemplate.opsForValue().get(key);
    }
    /**
     * 删除对应的value
     *
     * @param key 键
     * @return 成功/失败
     */
    public boolean remove(final String key) {
        if (exists(key)) {
            return Boolean.TRUE.equals(redisTemplate.delete(key));
        }
        return false;
    }
    /**
     * 递增
     *
     * @param key   键
     * @param delta 要增加几(大于0)
     * @return 结果
     */
    public Long incr(String key, long delta) {
        if (ObjectUtils.isEmpty(key)) {
            throw new ParamValidateException("key值不能为空");
        }
        if (delta < 0) {
            throw new ParamValidateException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }
    /**
     * 递减
     *
     * @param key   键
     * @param delta 要减少几(小于0)
     * @return 结果
     */
    public Long decr(String key, long delta) {
        if (ObjectUtils.isEmpty(key)) {
            throw new ParamValidateException("key值不能为空");
        }
        if (delta < 0) {
            throw new ParamValidateException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }
}

2.2 自定义幂等注解

自定义幂等注解，将seconds设置为该注解的属性，在拦截器中判断方法上是否有该注解，如果有该注解，则说明当前方法需要做幂等校验。

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 * 自动幂等
 * 该注解加在需要幂等的方法上，即可自动上线方法的幂等。
 *
 * @author 谭永强
 * @date 2023-08-15
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface AutoIdempotent {
    /**
     * 限定时间(秒)
     * 限制多少秒内，每个用户只能请求一次该接口。
     */
    long seconds() default 1;
}

2.3 自定义幂等拦截器

定义幂等接口用于拦截处理请求。

import com.alibaba.fastjson.JSON;
import com.alibaba.nacos.common.utils.MD5Utils;
import com.yunling.sys.annotate.AutoIdempotent;
import com.yunling.sys.common.RedisUtils;
import com.yunling.sys.common.ResultData;
import com.yunling.sys.common.ReturnCode;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import javax.annotation.Resource;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Objects;
/**
 * 自动幂等拦截器
 *
 * @author 谭永强
 * @date 2023-08-15
 */
@Component
public class AutoIdempotentInterceptor extends HandlerInterceptorAdapter {
    @Resource
    private RedisUtils redisUtils;
    /**
     * @param request  请求
     * @param response 响应
     * @param handler  处理
     * @return 结果
     * @throws Exception 异常
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //判断请求是否为方法的请求
        if (!(handler instanceof HandlerMethod)) {
            return true;
        }
        HandlerMethod method = (HandlerMethod) handler;
        //获取方法中是否有幂等性注解
        AutoIdempotent anno = method.getMethodAnnotation(AutoIdempotent.class);
        //若注解为空则直接返回
        if (Objects.isNull(anno)) {
            return true;
        }
        //限定时间
        long seconds = anno.seconds();
        //token
        String token = request.getHeader(HttpHeaders.AUTHORIZATION);
        if (Objects.isNull(token)) {
            ResultData<String> resultData = ResultData.fail(ReturnCode.ACCESS_DENIED.getCode(), "token不能为空");
            write(response, JSON.toJSONString(resultData));
            return false;
        }
        //此处转MD5的原因就是token长度太长了，转成md5短一些，此操作并不是必须的
        String md5 = MD5Utils.md5Hex(token, StandardCharsets.UTF_8.toString());
        //使用token+method+uri作为key值，此处需要通过key值确定请求的唯一性，也可以使用其他的组合，只要保证唯一性即可
        String key = md5 + ":" + request.getMethod() + ":" + request.getRequestURI();
        Object requestCountObj = redisUtils.get(key);
        if (!ObjectUtils.isEmpty(requestCountObj)) {
            //不为空，说明不是第一次请求，直接报错
            ResultData<String> resultData = ResultData.fail(ReturnCode.RC206.getCode(), "请求已提交，请勿重复请求");
            write(response, JSON.toJSONString(resultData));
            return false;
        }
        //若为空则为第一次请求
        return redisUtils.set(key, 1, seconds);
    }
    /**
     * 返回结果到前端
     *
     * @param response 响应
     * @param body     结果
     * @throws IOException 异常
     */
    private void write(HttpServletResponse response, String body) throws IOException {
        response.setContentType(MediaType.APPLICATION_JSON_VALUE);
        ServletOutputStream os = response.getOutputStream();
        os.write(body.getBytes());
        os.flush();
        os.close();
    }
}

2.4 注入拦截器到容器

将拦截器注册到容器中。

package com.yunling.sys.config;
import com.yunling.sys.config.interceptor.AutoIdempotentInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import javax.annotation.Resource;
/**
 * 将拦截器注入到容器中
 *
 * @author 谭永强
 * @date 2023-08-15
 */
@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Resource
    private AutoIdempotentInterceptor autoIdempotentInterceptor;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(autoIdempotentInterceptor);
    }
}

3.测试

@RestController
@RequestMapping("user")
public class SysUserController {
    /**
     * 用户新增
     *
     * @param user 用户信息
     */
    @AutoIdempotent(seconds = 60)
    @PostMapping("add")
    public void add(@RequestBody SysUser user) {
       //业务代码.....
    }
}

请求该接口，如果在60s内再次请求，就会返回重复请求的结果。seconds具体值设置多少由该接口的实际响应时间为标准，默认值为1秒。

在这里插入图片描述

到此这篇关于使用拦截器+Redis实现接口幂思路详解的文章就介绍到这了,更多相关Redis接口幂内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

基于Redis实现订阅发布功能
本文介绍了在SpringBoot项目中使用Redis实现异步解耦的方法,无需引入MQ中间件,首先引入Redis依赖并配置Redis,随后创建Redis配置类来配置Redis连接工厂和监听器,接着创建消息订阅者和发布者,通过RedisTemplate发送消息,最后强调了可以设置多个消息适配器来监听多个channel
2026-05-05
redis主从复制的原理及实现
Redis主从复制是一种数据同步机制,它通过将一个Redis实例的数据复制到其他Redis,本文主要介绍了redis主从复制的原理及实现,具有一定的参考价值,感兴趣的可以了解一下
2023-08-08
redis过期回调坑的解决
Redis提供了一种过期回调的机制,可以在某个键过期时触发一个回调函数,然而,在实际使用中,我们往往会遇到一些灾难性的问题,其中一个就是在使用过期回调的时候,我们可能会遭遇到无法预料的错误,本文就详细的介绍一下
2023-09-09
Redis的Sentinel解决方案介绍与运行机制
这篇文章主要介绍了Redis的Sentinel解决方案介绍与运行机制, Sentinel 是一款面向分布式服务架构的轻量级流量控制组件，主要以流量为切入点，从流量控制、熔断降级、系统自适应保护等多个维度来保障服务的稳定性,需要的朋友可以参考下
2023-07-07
使用Redis实现会话管理的示例代码
文章介绍了如何使用Redis实现会话管理,包括会话的创建、读取、更新和删除操作,通过设置会话超时时间并重置,可以确保会话在用户持续活动期间不会过期,此外,展示了使用Redis的Hashes存储更多信息,并使用Redis集群提高系统的可用性和扩展性,感兴趣的朋友跟随小编一起看看吧
2025-12-12
redis使用skiplist跳表的原因解析
经常会有人问这个问题，redis中为什么要使用跳表?这个问题，redis作者已经给出过明确答案,今天通过本文再给大家讲解下这个问题，对redis skiplist跳表知识感兴趣的朋友一起看看吧
2022-10-10
深入剖析 Redis 的三种集群方式以及实战配置
本文深入解析Redis三种集群部署方式,文章包含完整的配置示例和操作指南,为Redis集群部署提供实用参考,感兴趣的朋友跟随小编一起看看吧
2026-03-03
Redis实现集群搭建+集群读写的示例
本文介绍了Redis集群的搭建和读写操作,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
2025-02-02
Redis批量查询的四种方式详解
在高并发场景下,巧妙地利用缓存批量查询技巧能够显著提高系统性能,熟练掌握细粒度的缓存使用是每位架构师必备的技能,因此,在本文中,我们将深入探讨 Redis 中批量查询的一些技巧,希望能够给你带来一些启发,需要的朋友可以参考下
2025-10-10
Redis有序集合类型的操作_动力节点Java学院整理
今天通过本文给大家说一下Redis中最后一个数据类型 “有序集合类型”，需要的的朋友参考下吧
2017-08-08