首页 > 资讯 > 后端开发 > Python >Springboot利用Redis实现接口幂等性拦截

611

分享到

Springboot利用Redis实现接口幂等性拦截

2024-04-02 19:04:59 611人浏览独家记忆

Python 官方文档：入门教程 => 点击学习

摘要

目录前言正文实战开始核心三件套工具类三件套Redis配置类前言近期一个老项目出现了接口幂等性校验问题，前端加了按钮置灰，依然被人拉着接口参数一顿输出，还是重复调用了接口，小陈及

前言

近期一个老项目出现了接口幂等性校验问题，前端加了按钮置灰，

依然被人拉着接口参数一顿输出，还是重复调用了接口，小陈及时赶到现场，通过复制粘贴，完成了后端接口幂等性调用校验。

以前写过一篇关于接口简单限流防止重复调用的，但是跟该篇还是不一样的，该篇的角度是接口和参数整体一致才当做重复。

简单限流：SpringBoot使用redis实现接口api限流的实例

该篇内容：

实现接口调用的幂等性校验

方案：自定义注解+redis+拦截器+MD5 实现

草图，意会（用户标识不是必要，看业务场景是针对个人还是只针对接口&参数）：

话不多说，开始实战。

PS：前排提醒，如果你还不知道怎么springboot整合redis，可以先去看下redis使用系列的一、二。

SpringBoot中对应2.0.x版本的Redis配置详解

SpringBoot整合Redis之编写RedisConfig

正文

自定义注解怎么玩的：

①标记哪个接口需要进行幂等性拦截

②每个接口可以要求幂等性范围时间不一样，举例：可以2秒内，可以3秒内，时间自己传

③ 一旦触发了，提示语可以不同，举例：VIP的接口，普通用户的接口，提示语不一样（开玩笑）

效果：

实战开始

核心三件套

注解、拦截器、拦截器配置

① RepeatDaMie.java

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface RepeatDaMie {
 
    
    public int second() default 1;
 
    
    public String describe() default "重复提交了,兄弟";
    
}

②ApiRepeatInterceptor.java

import com.example.repeatdemo.annotation.RepeatDaMie;
import com.example.repeatdemo.util.ContextUtil;
import com.example.repeatdemo.util.Md5Encrypt;
import com.example.repeatdemo.util.RedisUtils;
import com.example.repeatdemo.wrapper.CustomhttpservletRequestWrapper;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.WEB.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
 
import javax.servlet.Http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Objects;
 

@Component
public class ApiRepeatInterceptor implements HandlerInterceptor {
 
    private final Logger log = LoggerFactory.getLogger(this.getClass());
 
    private static final String POST="POST";
    private static final String GET="GET";
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        try {
            if (handler instanceof HandlerMethod) {
                HandlerMethod handlerMethod = (HandlerMethod) handler;
                // 获取RepeatDaMie注解
                RepeatDaMie repeatDaMie = handlerMethod.getMethodAnnotation(RepeatDaMie.class);
                if (null==repeatDaMie) {
                    return true;
                }
                //限制的时间范围
                int seconds = repeatDaMie.second();
                //这个用户唯一标识，可以自己细微调整，是userId还是token还是sessionId还是不需要
                String userUniqueKey = request.getHeader("userUniqueKey");
                String method = request.getMethod();
                String apiParams = "";
                if (GET.equals(method)){
                    log.info("GET请求来了");
                    apiParams = new ObjectMapper().writeValueAsString(request.getParameterMap());
                }else if (POST.equals(method)){
                    log.info("POST请求来了");
                    CustomHttpServletRequestWrapper wrapper = (CustomHttpServletRequestWrapper) request;
                    apiParams = wrapper.getBody();
                }
               log.info("当前参数是：{}",apiParams);
                // 存储key
                String keyRepeatDaMie = Md5Encrypt.md5(userUniqueKey+request.getServletPath()+apiParams) ;
                RedisUtils redisUtils = ContextUtil.getBean(RedisUtils.class);
                if (Objects.nonNull(redisUtils.get(keyRepeatDaMie))){
                   log.info("重复请求了，重复请求了，拦截了");
                   returnData(response,repeatDaMie.describe());
                   return false;
               }else {
                    redisUtils.setWithTime(keyRepeatDaMie, true,seconds);
               }
 
            }
            return true;
        } catch (Exception e) {
            log.warn("请求过于频繁请稍后再试");
            e.printStackTrace();
        }
        return true;
    }
 
    public void returnData(HttpServletResponse response,String msg) throws IOException {
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/JSON; charset=utf-8");
        ObjectMapper objectMapper = new ObjectMapper();
        //这里传提示语可以改成自己项目的返回数据封装的类
        response.getWriter().println(objectMapper.writeValueAsString(msg));
        return;
    }
 
}

③ WebConfig.java

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorReGIStry;
import org.springframework.web.servlet.config.annotation.WebmvcConfigurer;
 

@Configuration
public class WebConfig implements WebMvcConfigurer {
 
    
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new ApiRepeatInterceptor()).addPathPatterns("
@Component
public final class ContextUtil implements ApplicationContextAware {
    protected static ApplicationContext applicationContext ;
    @Override
    public void setApplicationContext(ApplicationContext arg0) throws BeansException {
        if (applicationContext == null) {
            applicationContext = arg0;
        }
    }
    public static Object getBean(String name) {
        //name表示其他要注入的注解name名
        return applicationContext.getBean(name);
    }
    
    public static <T> T getBean(Class<T> clazz) {
        return applicationContext.getBean(clazz);
    }
}

②Md5Encrypt.java

import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlGorithmException;
 

public class Md5Encrypt {
 
    private static final char[] DIgitS = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a',
            'b', 'c', 'd', 'e', 'f'};
 
    
    public static String md5(String text) {
        MessageDigest msgDigest = null;
 
        try {
            msgDigest = MessageDigest.getInstance("MD5");
        } catch (NoSuchAlgorithmException e) {
            throw new IllegalStateException("System doesn't support MD5 algorithm.");
        }
 
        try {
            // 注意该接口是按照指定编码形式签名
            msgDigest.update(text.getBytes("UTF-8"));
 
        } catch (UnsupportedEncodingException e) {
 
            throw new IllegalStateException("System doesn't support your  EncodingException.");
 
        }
 
        byte[] bytes = msgDigest.digest();
 
        String md5Str = new String(encodeHex(bytes));
 
        return md5Str;
    }
 
    private static char[] encodeHex(byte[] data) {
 
        int l = data.length;
 
        char[] out = new char[l << 1];
        // two characters fORM the hex value.
        for (int i = 0, j = 0; i < l; i++) {
            out[j++] = DIGITS[(0xF0 & data[i]) >>> 4];
            out[j++] = DIGITS[0x0F & data[i]];
        }
 
        return out;
    }
}

③RedisUtils.java

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Component;
import java.io.Serializable;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
 
 
@Component
public class RedisUtils {
 
    @Autowired
    private RedisTemplate redisTemplate;
 
    
 
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
 
    }
 
 
 
    
 
    public boolean setWithTime(final String key, Object value,int seconds) {
        boolean result = false;
        try {
 
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value,seconds, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
 
    }
 
 
 
    
 
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }
 
    
 
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0)
            redisTemplate.delete(keys);
    }
 
    
 
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }
 
 
    
 
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }
 
 
    
 
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }
 
 
    
 
    public void hmSet(String key, Object hashKey, Object value) {
 
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
 
        hash.put(key, hashKey, value);
 
    }
 
 
    
 
    public Object hmGet(String key, Object hashKey) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        return hash.get(key, hashKey);
 
    }
 
 
    
 
    public void lPush(String k, Object v) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        list.rightPush(k, v);
    }
 
 
    
 
    public List<Object> lRange(String k, long l, long l1) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        return list.range(k, l, l1);
    }
 
 
    
 
    public void add(String key, Object value) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        set.add(key, value);
    }
 
 
    
 
    public Set<Object> setMembers(String key) {
 
        SetOperations<String, Object> set = redisTemplate.opsForSet();
 
        return set.members(key);
 
    }
 
 
    
 
    public void zAdd(String key, Object value, double scoure) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.add(key, value, scoure);
    }
 
 
    
 
    public Set<Object> rangeByScore(String key, double scoure, double scoure1) {
 
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
 
        return zset.rangeByScore(key, scoure, scoure1);
 
    }
 
 
    
 
    public Set<Integer> sGet(String key) {
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
 
 
    
 
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
 
}

REDIS配置类

RedisConfig.java

import com.fasterxml.jackson.annotation.jsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import static org.springframework.data.redis.cache.RedisCacheConfiguration.defaultCacheConfig;
 

@Configuration
@EnableCaching
public class RedisConfig {
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        RedisCacheConfiguration cacheConfiguration =
                defaultCacheConfig()
                        .disableCachingNullValues()
                        .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new Jackson2JsonRedisSerializer(Object.class)));
        return RedisCacheManager.builder(connectionFactory).cacheDefaults(cacheConfiguration).build();
    }
 
 
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        //序列化设置 ，这样为了存储操作对象时正常显示的数据，也能正常存储和获取
        redisTemplate.seTKEySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        return redisTemplate;
    }
    @Bean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
        stringRedisTemplate.setConnectionFactory(factory);
        return stringRedisTemplate;
    }
 
}

最后写测试接口，看看效果（一个POST，一个GET）：

故意把时间放大，1000秒内重复调用，符合我们拦截规则的都会被拦截。

TestController.java

import com.example.repeatdemo.dto.PayOrderApply;
import com.example.repeatdemo.annotation.RepeatDaMie;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.*;
 

@RestController
public class TestController {
    private final Logger log = LoggerFactory.getLogger(this.getClass());
 
    @RepeatDaMie(second = 1000,describe = "尊敬的客户,您慢点")
    @PostMapping(value = "/doPost")
    @ResponseBody
    public void test(@RequestBody PayOrderApply payOrderApply) {
        log.info("Controller POST请求:"+payOrderApply.toString());
    }
 
    @RepeatDaMie(second = 1000,describe = "大哥,你冷静点")
    @GetMapping(value = "/doGet")
    @ResponseBody
    public void doGet( PayOrderApply payOrderApply) {
        log.info("Controller GET请求:"+payOrderApply.toString());
    }
 
}

PayOrderApply.java


public class PayOrderApply {
 
    private String sn;
    private Long amount;
    private String proCode;
 
    public String getSn() {
        return sn;
    }
 
    public void setSn(String sn) {
        this.sn = sn;
    }
 
    public Long getAmount() {
        return amount;
    }
 
    public void setAmount(Long amount) {
        this.amount = amount;
    }
 
    public String getProCode() {
        return proCode;
    }
 
    public void setProCode(String proCode) {
        this.proCode = proCode;
    }
 
    @Override
    public String toString() {
        return "PayOrderApply{" +
                "sn='" + sn + '\'' +
                ", amount=" + amount +
                ", proCode='" + proCode + '\'' +
                '}';
    }
}

redis生成了值：

到此这篇关于Springboot利用Redis实现接口幂等性拦截的文章就介绍到这了,更多相关Springboot接口幂等性拦截内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: Springboot利用Redis实现接口幂等性拦截

本文链接: https://www.lsjlt.com/news/152437.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

Springboot利用Redis实现接口幂等性拦截

目录前言正文实战开始核心三件套工具类三件套REDIS配置类前言近期一个老项目出现了接口幂等性校验问题，前端加了按钮置灰，依然被人拉着接口参数一顿输出，还是重复调用了接口，小陈及...

99+

2024-04-02
Springboot怎么利用Redis实现接口幂等性拦截

今天小编给大家分享一下Springboot怎么利用Redis实现接口幂等性拦截的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以分享这篇文章给大家参考一下，希望大家阅读完这篇文章后有所收获，下面我们一起来了解一下吧。...

99+

2023-07-02
SpringBoot结合Redis实现接口幂等性的示例代码

目录介绍实现过程引入 maven 依赖spring 配置文件写入引入 Redis自定义注解token 的创建和实现拦截器的配置测试用例介绍幂等性的概念是，任意多次执行所产生的影响都...

99+

2024-04-02
使用SpringBoot实现接口幂等性的方法有哪些

使用SpringBoot实现接口幂等性的方法有哪些？针对这个问题，这篇文章详细介绍了相对应的分析和解答，希望可以帮助更多想解决这个问题的小伙伴找到更简单易行的方法。一、什么是幂等性幂等是一个数学与计算机学概念，在数学中某一元运算为幂等时，其...

99+

2023-06-07
SpringBoot实现接口等幂次校验的示例代码

目录主流的实现方案如下：第一步：书写redis工具类第二步、书写token工具类第三步：定义注解，使用在方法上，当控制层的方法上被注释时，表示该请求为等幂性请求第四步：拦截器配置。选...

99+

2024-04-02
Redis处理接口幂等性的方案有哪些

这篇文章主要介绍“Redis处理接口幂等性的方案有哪些”，在日常操作中，相信很多人在Redis处理接口幂等性的方案有哪些问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”Redi...

99+

2024-04-02
SpringBoot处理接口幂等性的两种方法详解

目录1. 接口幂等性实现方案梳理1.1 基于 Token1.2 基于请求参数校验2. 基于请求参数的校验在上周发布的 TienChin 项目视频中，我和大家一共梳理了六种幂等性解决方...

99+

2024-04-02
如何使用SpringBoot拦截器实现登录拦截

小编给大家分享一下如何使用SpringBoot拦截器实现登录拦截，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！可以对URL路径进行拦截，可以用于权限验证、解决乱码...

99+

2023-06-29
Spring Boot怎么实现接口自动幂等

今天小编给大家分享一下Spring Boot怎么实现接口自动幂等的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以分享这篇文章给大家参考一下，希望大家阅读完这篇文章后有所收获，下面我...

99+

2024-04-02
SpringBoot中利用AOP和拦截器实现自定义注解

目录前言Spring实现自定义注解1.引入相关依赖2.相关类Java实现自定义注解通过Cglib实现通过JDk动态代理实现Cglib和JDK动态代理的区别写在最后前言最近遇到了这样...

99+

2024-04-02
利用Mybatis Plus实现一个SQL拦截器

目录起源实现拦截器接口InnerInterceptor修改sql常用的工具类起源最近公司要做多租户，Mybatis-Plus的多租户插件很好用，但是有一个场景是：字典表或者某些数据...

99+

2023-05-19

Mybatis Plus实现SQL拦截器 Mybatis Plus SQL拦截 Mybatis Plus SQL
SpringBoot中怎么利用AOP和拦截器实现自定义注解

本篇内容主要讲解“SpringBoot中怎么利用AOP和拦截器实现自定义注解”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“SpringBoot中怎么利用AOP和拦截器实现自定义注解”吧!Spri...

99+

2023-07-02
如何使用SpringBoot + Redis实现接口限流

本篇内容介绍了“如何使用SpringBoot + Redis实现接口限流”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！配...

99+

2023-06-30
Spring Boot怎么利用拦截器加缓存完成接口防刷

小编给大家分享一下Spring Boot怎么利用拦截器加缓存完成接口防刷，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！为什么需要接口防刷为了减缓服务器压...

99+

2023-06-29
SpringBoot利用@Retryable注解实现接口重试

目录前言1.@Retryable是什么2.使用步骤（1） POM依赖（2）启用@Retryable（3）在方法上添加@Retryable（4）@Recover（5）注意事项3.总结前...

99+

2024-04-02
springboot怎么利用aop实现接口异步

小编给大家分享一下springboot怎么利用aop实现接口异步，希望大家阅读完这篇文章之后都有所收获，下面让我们一起去探讨吧！一、前言在项目中发现有接口（excel导入数据）处理数据需要耗时比较长的时间，是因为数据量比较大，同时数据的校验...

99+

2023-06-22
Springboot使用redis实现接口Api限流的实例

前言该篇介绍的内容如题，就是利用redis实现接口的限流（某时间范围内最大的访问次数）。正文惯例，先看下我们的实战目录结构：首...

99+

2024-04-02
教你用Springboot实现拦截器获取header内容

分析既然需要动态获取那么只有两种方式：要么每次下游请求过来时从请求头中获取，要么定义统一的拦截器自动获取。实现那么我们就先来实现一下吧。第一种比较简单，直接使用springb...

99+

2024-04-02
spring中的拦截器怎么利用注解实现

本篇文章给大家分享的是有关spring中的拦截器怎么利用注解实现，小编觉得挺实用的，因此分享给大家学习，希望大家阅读完这篇文章后可以有所收获，话不多说，跟着小编一起来看看吧。类似用户权限的需求，有些操作需要登录，有些操作不需要，可以使用过滤...

99+

2023-05-31

spring
使用SpringBoot + Redis 实现接口限流的方式

目录配置限流注解定制 RedisTemplateLua 脚本注解解析接口测试全局异常处理Redis 除了做缓存，还能干很多很多事情：分布式锁、限流、处理请求接口幂等性。。。太多太多了...

99+

2024-04-02