（Redis使用系列） Springboot 使用redis实现接口幂等性拦截 十一

转x33g5p2x  于2022-06-27 转载在 Redis  
字(13.8k)|赞(0)|评价(0)|浏览(492)

前言

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

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

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

简单限流：  （Redis使用系列） Springboot 使用redis实现接口Api限流 十

该篇内容：

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

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

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

话不多说，开始实战。

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

（Redis使用系列） SpringBoot 中对应2.0.x版本的Redis配置 一

（Redis使用系列） SpringBoot中Redis的RedisConfig 二

正文

自定义注解 怎么玩的 ：      

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

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

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

效果：

实战开始：

核心三件套

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

① RepeatDaMie.java

  1. import java.lang.annotation.ElementType;
  2. import java.lang.annotation.Retention;
  3. import java.lang.annotation.RetentionPolicy;
  4. import java.lang.annotation.Target;
  6. /**
  7.  * @Author: JCccc
  8.  * @Date: 2022-6-13 9:04
  9.  * @Description:  自定义注解,防止重复提交
  10.  */
  11. @Target({ElementType.METHOD})
  12. @Retention(RetentionPolicy.RUNTIME)
  13. public @interface RepeatDaMie {
  15.     /**
  16.      * 时间ms限制
  17.      */
  18.     public int second() default 1;
  20.     /**
  21.      * 提示消息
  22.      */
  23.     public String describe() default "重复提交了,兄弟";
  24.     
  25. }

②ApiRepeatInterceptor.java

  1. import com.example.repeatdemo.annotation.RepeatDaMie;
  2. import com.example.repeatdemo.util.ContextUtil;
  3. import com.example.repeatdemo.util.Md5Encrypt;
  4. import com.example.repeatdemo.util.RedisUtils;
  5. import com.example.repeatdemo.wrapper.CustomHttpServletRequestWrapper;
  6. import com.fasterxml.jackson.databind.ObjectMapper;
  7. import org.slf4j.Logger;
  8. import org.slf4j.LoggerFactory;
  9. import org.springframework.stereotype.Component;
  10. import org.springframework.web.method.HandlerMethod;
  11. import org.springframework.web.servlet.HandlerInterceptor;
  13. import javax.servlet.http.HttpServletRequest;
  14. import javax.servlet.http.HttpServletResponse;
  15. import java.io.IOException;
  16. import java.util.Objects;
  18. /**
  19.  * @Author: JCccc
  20.  * @Date: 2022-6-15 9:11
  21.  * @Description: 接口幂等性校验拦截器
  22.  */
  23. @Component
  24. public class ApiRepeatInterceptor implements HandlerInterceptor {
  26.     private final Logger log = LoggerFactory.getLogger(this.getClass());
  28.     private static final String POST="POST";
  29.     private static final String GET="GET";
  30.     @Override
  31.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  32.         try {
  33.             if (handler instanceof HandlerMethod) {
  34.                 HandlerMethod handlerMethod = (HandlerMethod) handler;
  35.                 // 获取RepeatDaMie注解
  36.                 RepeatDaMie repeatDaMie = handlerMethod.getMethodAnnotation(RepeatDaMie.class);
  37.                 if (null==repeatDaMie) {
  38.                     return true;
  39.                 }
  40.                 //限制的时间范围
  41.                 int seconds = repeatDaMie.second();
  42.                 //这个用户唯一标识，可以自己细微调整，是userId还是token还是sessionId还是不需要
  43.                 String userUniqueKey = request.getHeader("userUniqueKey");
  44.                 String method = request.getMethod();
  45.                 String apiParams = "";
  46.                 if (GET.equals(method)){
  47.                     log.info("GET请求来了");
  48.                     apiParams = new ObjectMapper().writeValueAsString(request.getParameterMap());
  49.                 }else if (POST.equals(method)){
  50.                     log.info("POST请求来了");
  51.                     CustomHttpServletRequestWrapper wrapper = (CustomHttpServletRequestWrapper) request;
  52.                     apiParams = wrapper.getBody();
  53.                 }
  54.                log.info("当前参数是：{}",apiParams);
  55.                 // 存储key
  56.                 String keyRepeatDaMie = Md5Encrypt.md5(userUniqueKey+request.getServletPath()+apiParams) ;
  57.                 RedisUtils redisUtils = ContextUtil.getBean(RedisUtils.class);
  58.                 if (Objects.nonNull(redisUtils.get(keyRepeatDaMie))){
  59.                    log.info("重复请求了，重复请求了，拦截了");
  60.                    returnData(response,repeatDaMie.describe());
  61.                    return false;
  62.                }else {
  63.                     redisUtils.setWithTime(keyRepeatDaMie, true,seconds);
  64.                }
  66.             }
  67.             return true;
  68.         } catch (Exception e) {
  69.             log.warn("请求出现异常,errorMsg={}",e.getMessage());
  70.             returnData(response,"请求出现异常");
  71.             return false;
  72.         }
  73.         return true;
  74.     }
  76.     public void returnData(HttpServletResponse response,String msg) throws IOException {
  77.         response.setCharacterEncoding("UTF-8");
  78.         response.setContentType("application/json; charset=utf-8");
  79.         ObjectMapper objectMapper = new ObjectMapper();
  80.         //这里传提示语可以改成自己项目的返回数据封装的类
  81.         response.getWriter().println(objectMapper.writeValueAsString(msg));
  82.         return;
  83.     }
  85. }

③ WebConfig.java

  1. import org.springframework.context.annotation.Configuration;
  2. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
  3. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  5. /**
  6.  * @Author: JCccc
  7.  * @Date: 2022-6-15 9:24
  8.  * @Description:
  9.  */
  10. @Configuration
  11. public class WebConfig implements WebMvcConfigurer {
  13.     
  14.     @Override
  15.     public void addInterceptors(InterceptorRegistry registry) {
  16.         registry.addInterceptor(new ApiRepeatInterceptor()).addPathPatterns("/**");
  17.     }
  18. }

工具类三件套

①ContextUtil.java

  1. import org.springframework.beans.BeansException;
  2. import org.springframework.context.ApplicationContext;
  3. import org.springframework.context.ApplicationContextAware;
  4. import org.springframework.stereotype.Component;
  5. /**
  6.  * @Author: JCccc
  7.  * @Date: 2022-6-15 9:24
  8.  * @Description:
  9.  */
  10. @Component
  11. public final class ContextUtil implements ApplicationContextAware {
  12.     protected static ApplicationContext applicationContext ;
  13.     @Override
  14.     public void setApplicationContext(ApplicationContext arg0) throws BeansException {
  15.         if (applicationContext == null) {
  16.             applicationContext = arg0;
  17.         }
  18.     }
  19.     public static Object getBean(String name) {
  20.         //name表示其他要注入的注解name名
  21.         return applicationContext.getBean(name);
  22.     }
  23.     /**
  24.      * 拿到ApplicationContext对象实例后就可以手动获取Bean的注入实例对象
  25.      */
  26.     public static <T> T getBean(Class<T> clazz) {
  27.         return applicationContext.getBean(clazz);
  28.     }
  29. }

②Md5Encrypt.java

  1. import java.io.UnsupportedEncodingException;
  2. import java.security.MessageDigest;
  3. import java.security.NoSuchAlgorithmException;
  5. /**
  6.  * @Author: JCccc
  7.  * @CreateTime: 2018-10-30
  8.  * @Description:
  9.  */
  10. public class Md5Encrypt {
  12.     private static final char[] DIGITS = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a',
  13.             'b', 'c', 'd', 'e', 'f'};
  15.     /**
  16.      * 对字符串进行MD5加密
  17.      *
  18.      * @param text 明文
  19.      * @return 密文
  20.      */
  21.     public static String md5(String text) {
  22.         MessageDigest msgDigest = null;
  24.         try {
  25.             msgDigest = MessageDigest.getInstance("MD5");
  26.         } catch (NoSuchAlgorithmException e) {
  27.             throw new IllegalStateException("System doesn't support MD5 algorithm.");
  28.         }
  30.         try {
  31.             // 注意该接口是按照指定编码形式签名
  32.             msgDigest.update(text.getBytes("UTF-8"));
  34.         } catch (UnsupportedEncodingException e) {
  36.             throw new IllegalStateException("System doesn't support your  EncodingException.");
  38.         }
  40.         byte[] bytes = msgDigest.digest();
  42.         String md5Str = new String(encodeHex(bytes));
  44.         return md5Str;
  45.     }
  47.     private static char[] encodeHex(byte[] data) {
  49.         int l = data.length;
  51.         char[] out = new char[l << 1];
  52.         // two characters form the hex value.
  53.         for (int i = 0, j = 0; i < l; i++) {
  54.             out[j++] = DIGITS[(0xF0 & data[i]) >>> 4];
  55.             out[j++] = DIGITS[0x0F & data[i]];
  56.         }
  58.         return out;
  59.     }
  60. }

③RedisUtils.java

  1. import org.springframework.beans.factory.annotation.Autowired;
  2. import org.springframework.data.redis.core.*;
  3. import org.springframework.stereotype.Component;
  4. import java.io.Serializable;
  5. import java.util.List;
  6. import java.util.Set;
  7. import java.util.concurrent.TimeUnit;
  9. @Component
  10. public class RedisUtils {
  12.     @Autowired
  13.     private RedisTemplate redisTemplate;
  15.     /**
  16.      * 写入String型 [ 键，值]
  17.      *
  18.      * @param key
  19.      * @param value
  20.      * @return
  21.      */
  23.     public boolean set(final String key, Object value) {
  24.         boolean result = false;
  25.         try {
  26.             ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  27.             operations.set(key, value);
  28.             result = true;
  29.         } catch (Exception e) {
  30.             e.printStackTrace();
  31.         }
  32.         return result;
  34.     }
  37.     /**
  38.      * 写入String型,顺便带有过期时间 [ 键，值]
  39.      *
  40.      * @param key
  41.      * @param value
  42.      * @return
  43.      */
  45.     public boolean setWithTime(final String key, Object value,int seconds) {
  46.         boolean result = false;
  47.         try {
  49.             ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  50.             operations.set(key, value,seconds, TimeUnit.SECONDS);
  51.             result = true;
  52.         } catch (Exception e) {
  53.             e.printStackTrace();
  54.         }
  55.         return result;
  57.     }
  60.     /**
  61.      * 批量删除对应的value
  62.      *
  63.      * @param keys
  64.      */
  66.     public void remove(final String... keys) {
  67.         for (String key : keys) {
  68.             remove(key);
  69.         }
  70.     }
  72.     /**
  73.      * 批量删除key
  74.      *
  75.      * @param pattern
  76.      */
  78.     public void removePattern(final String pattern) {
  79.         Set<Serializable> keys = redisTemplate.keys(pattern);
  80.         if (keys.size() > 0)
  81.             redisTemplate.delete(keys);
  82.     }
  84.     /**
  85.      * 删除对应的value
  86.      *
  87.      * @param key
  88.      */
  90.     public void remove(final String key) {
  91.         if (exists(key)) {
  92.             redisTemplate.delete(key);
  93.         }
  94.     }
  96.     /**
  97.      * 判断缓存中是否有对应的value
  98.      *
  99.      * @param key
  100.      * @return
  101.      */
  103.     public boolean exists(final String key) {
  104.         return redisTemplate.hasKey(key);
  105.     }
  107.     /**
  108.      * 读取缓存
  109.      *
  110.      * @param key
  111.      * @return
  112.      */
  114.     public Object get(final String key) {
  115.         Object result = null;
  116.         ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
  117.         result = operations.get(key);
  118.         return result;
  119.     }
  121.     /**
  122.      * 哈希 添加
  123.      * hash 一个键值(key->value)对集合
  124.      *
  125.      * @param key
  126.      * @param hashKey
  127.      * @param value
  128.      */
  130.     public void hmSet(String key, Object hashKey, Object value) {
  132.         HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
  134.         hash.put(key, hashKey, value);
  136.     }
  138.     /**
  139.      * Hash获取数据
  140.      *
  141.      * @param key
  142.      * @param hashKey
  143.      * @return
  144.      */
  146.     public Object hmGet(String key, Object hashKey) {
  147.         HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
  148.         return hash.get(key, hashKey);
  150.     }
  152.     /**
  153.      * 列表添加
  154.      * list:lpush key value1
  155.      *
  156.      * @param k
  157.      * @param v
  158.      */
  160.     public void lPush(String k, Object v) {
  161.         ListOperations<String, Object> list = redisTemplate.opsForList();
  162.         list.rightPush(k, v);
  163.     }
  165.     /**
  166.      * 列表List获取
  167.      * lrange： key 0 10 (读取的个数 从0开始 读取到下标为10 的数据)
  168.      *
  169.      * @param k
  170.      * @param l
  171.      * @param l1
  172.      * @return
  173.      */
  175.     public List<Object> lRange(String k, long l, long l1) {
  176.         ListOperations<String, Object> list = redisTemplate.opsForList();
  177.         return list.range(k, l, l1);
  178.     }
  180.     /**
  181.      * Set集合添加
  182.      *
  183.      * @param key
  184.      * @param value
  185.      */
  187.     public void add(String key, Object value) {
  188.         SetOperations<String, Object> set = redisTemplate.opsForSet();
  189.         set.add(key, value);
  190.     }
  192.     /**
  193.      * Set 集合获取
  194.      *
  195.      * @param key
  196.      * @return
  197.      */
  199.     public Set<Object> setMembers(String key) {
  201.         SetOperations<String, Object> set = redisTemplate.opsForSet();
  203.         return set.members(key);
  205.     }
  207.     /**
  208.      * Sorted set :有序集合添加
  209.      *
  210.      * @param key
  211.      * @param value
  212.      * @param scoure
  213.      */
  215.     public void zAdd(String key, Object value, double scoure) {
  216.         ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
  217.         zset.add(key, value, scoure);
  218.     }
  220.     /**
  221.      * Sorted set:有序集合获取
  222.      *
  223.      * @param key
  224.      * @param scoure
  225.      * @param scoure1
  226.      * @return
  227.      */
  229.     public Set<Object> rangeByScore(String key, double scoure, double scoure1) {
  231.         ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
  233.         return zset.rangeByScore(key, scoure, scoure1);
  235.     }
  237.     /**
  238.      * 根据key获取Set中的所有值
  239.      *
  240.      * @param key 键
  241.      * @return
  242.      */
  244.     public Set<Integer> sGet(String key) {
  245.         try {
  246.             return redisTemplate.opsForSet().members(key);
  247.         } catch (Exception e) {
  248.             e.printStackTrace();
  249.             return null;
  250.         }
  251.     }
  253.     /**
  254.      * 根据value从一个set中查询,是否存在
  255.      *
  256.      * @param key   键
  257.      * @param value 值
  258.      * @return true 存在 false不存在
  259.      */
  261.     public boolean sHasKey(String key, Object value) {
  262.         try {
  263.             return redisTemplate.opsForSet().isMember(key, value);
  264.         } catch (Exception e) {
  265.             e.printStackTrace();
  266.             return false;
  267.         }
  268.     }
  270. }

REDIS配置类

RedisConfig.java

  1. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  2. import com.fasterxml.jackson.annotation.PropertyAccessor;
  3. import com.fasterxml.jackson.databind.ObjectMapper;
  4. import org.springframework.cache.CacheManager;
  5. import org.springframework.cache.annotation.EnableCaching;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  8. import org.springframework.data.redis.cache.RedisCacheConfiguration;
  9. import org.springframework.data.redis.cache.RedisCacheManager;
  10. import org.springframework.data.redis.connection.RedisConnectionFactory;
  11. import org.springframework.data.redis.core.RedisTemplate;
  12. import org.springframework.data.redis.core.StringRedisTemplate;
  13. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  14. import org.springframework.data.redis.serializer.RedisSerializationContext;
  15. import org.springframework.data.redis.serializer.StringRedisSerializer;
  16. import static org.springframework.data.redis.cache.RedisCacheConfiguration.defaultCacheConfig;
  18. /**
  19.  * @Author: JCccc
  20.  * @CreateTime: 2018-09-11
  21.  * @Description:
  22.  */
  23. @Configuration
  24. @EnableCaching
  25. public class RedisConfig {
  26.     @Bean
  27.     public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
  28.         RedisCacheConfiguration cacheConfiguration =
  29.                 defaultCacheConfig()
  30.                         .disableCachingNullValues()
  31.                         .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new Jackson2JsonRedisSerializer(Object.class)));
  32.         return RedisCacheManager.builder(connectionFactory).cacheDefaults(cacheConfiguration).build();
  33.     }
  35.     @Bean
  36.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
  37.         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
  38.         redisTemplate.setConnectionFactory(factory);
  39.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  40.         ObjectMapper om = new ObjectMapper();
  41.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  42.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  43.         jackson2JsonRedisSerializer.setObjectMapper(om);
  44.         //序列化设置 ，这样为了存储操作对象时正常显示的数据，也能正常存储和获取
  45.         redisTemplate.setKeySerializer(new StringRedisSerializer());
  46.         redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
  47.         redisTemplate.setHashKeySerializer(new StringRedisSerializer());
  48.         redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
  49.         return redisTemplate;
  50.     }
  51.     @Bean
  52.     public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
  53.         StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
  54.         stringRedisTemplate.setConnectionFactory(factory);
  55.         return stringRedisTemplate;
  56.     }
  58. }

处理流数据三件套

【文章】流数据只能读一次的三件套，以后直接复制粘贴使用

最后写测试接口，看看效果（一个POST，一个GET）：
故意把时间放大，1000秒内重复调用，符合我们拦截规则的都会被拦截。

TestController.java

  1. import com.example.repeatdemo.dto.PayOrderApply;
  2. import com.example.repeatdemo.annotation.RepeatDaMie;
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5. import org.springframework.web.bind.annotation.*;
  7. /**
  8.  * @Author: JCccc
  9.  * @Date: 2022-6-05 9:44
  10.  * @Description:
  11.  */
  12. @RestController
  13. public class TestController {
  14.     private final Logger log = LoggerFactory.getLogger(this.getClass());
  16.     @RepeatDaMie(second = 1000,describe = "尊敬的客户,您慢点")
  17.     @PostMapping(value = "/doPost")
  18.     @ResponseBody
  19.     public void test(@RequestBody PayOrderApply payOrderApply) {
  20.         log.info("Controller POST请求:"+payOrderApply.toString());
  21.     }
  23.     @RepeatDaMie(second = 1000,describe = "大哥,你冷静点")
  24.     @GetMapping(value = "/doGet")
  25.     @ResponseBody
  26.     public void doGet( PayOrderApply payOrderApply) {
  27.         log.info("Controller GET请求:"+payOrderApply.toString());
  28.     }
  30. }

PayOrderApply.java

  1. /**
  2.  * @Author: JCccc
  3.  * @Date: 2022-6-12 9:46
  4.  * @Description:
  5.  */
  6. public class PayOrderApply {
  8.     private String sn;
  9.     private Long amount;
  10.     private String proCode;
  12.     public String getSn() {
  13.         return sn;
  14.     }
  16.     public void setSn(String sn) {
  17.         this.sn = sn;
  18.     }
  20.     public Long getAmount() {
  21.         return amount;
  22.     }
  24.     public void setAmount(Long amount) {
  25.         this.amount = amount;
  26.     }
  28.     public String getProCode() {
  29.         return proCode;
  30.     }
  32.     public void setProCode(String proCode) {
  33.         this.proCode = proCode;
  34.     }
  36.     @Override
  37.     public String toString() {
  38.         return "PayOrderApply{" +
  39.                 "sn='" + sn + '\'' +
  40.                 ", amount=" + amount +
  41.                 ", proCode='" + proCode + '\'' +
  42.                 '}';
  43.     }
  44. }

redis生成了值：

好了，该篇就到这吧、

CSDN 社区图书馆，开张营业！

深读计划，写书评领图书福利~

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/qq_35387940/article/details/125426400

内容来源于网络，如有侵权，请联系作者删除！

Javaredis

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com