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

    前言

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

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

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

    简单限流：  （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;
    5.  
    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 {
    14.  
    15.     /**
    16.      * 时间ms限制
    17.      */
    18.     public int second() default 1;
    19.  
    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;
    12.  
    13. import javax.servlet.http.HttpServletRequest;
    14. import javax.servlet.http.HttpServletResponse;
    15. import java.io.IOException;
    16. import java.util.Objects;
    17.  
    18. /**
    19.  * @Author: JCccc
    20.  * @Date: 2022-6-15 9:11
    21.  * @Description: 接口幂等性校验拦截器
    22.  */
    23. @Component
    24. public class ApiRepeatInterceptor implements HandlerInterceptor {
    25.  
    26.     private final Logger log = LoggerFactory.getLogger(this.getClass());
    27.  
    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.                }
    65.  
    66.             }
    67.             return true;
    68.         } catch (Exception e) {
    69.             log.warn("请求过于频繁请稍后再试");
    70.             e.printStackTrace();
    71.         }
    72.         return true;
    73.     }
    74.  
    75.     public void returnData(HttpServletResponse response,String msg) throws IOException {
    76.         response.setCharacterEncoding("UTF-8");
    77.         response.setContentType("application/json; charset=utf-8");
    78.         ObjectMapper objectMapper = new ObjectMapper();
    79.         //这里传提示语可以改成自己项目的返回数据封装的类
    80.         response.getWriter().println(objectMapper.writeValueAsString(msg));
    81.         return;
    82.     }
    83.  
    84. }

    ③ 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;
    4.  
    5. /**
    6.  * @Author: JCccc
    7.  * @Date: 2022-6-15 9:24
    8.  * @Description:
    9.  */
    10. @Configuration
    11. public class WebConfig implements WebMvcConfigurer {
    12.  
    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;
    4.  
    5. /**
    6.  * @Author: JCccc
    7.  * @CreateTime: 2018-10-30
    8.  * @Description:
    9.  */
    10. public class Md5Encrypt {
    11.  
    12.     private static final char[] DIGITS = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a',
    13.             'b', 'c', 'd', 'e', 'f'};
    14.  
    15.     /**
    16.      * 对字符串进行MD5加密
    17.      *
    18.      * @param text 明文
    19.      * @return 密文
    20.      */
    21.     public static String md5(String text) {
    22.         MessageDigest msgDigest = null;
    23.  
    24.         try {
    25.             msgDigest = MessageDigest.getInstance("MD5");
    26.         } catch (NoSuchAlgorithmException e) {
    27.             throw new IllegalStateException("System doesn't support MD5 algorithm.");
    28.         }
    29.  
    30.         try {
    31.             // 注意该接口是按照指定编码形式签名
    32.             msgDigest.update(text.getBytes("UTF-8"));
    33.  
    34.         } catch (UnsupportedEncodingException e) {
    35.  
    36.             throw new IllegalStateException("System doesn't support your  EncodingException.");
    37.  
    38.         }
    39.  
    40.         byte[] bytes = msgDigest.digest();
    41.  
    42.         String md5Str = new String(encodeHex(bytes));
    43.  
    44.         return md5Str;
    45.     }
    46.  
    47.     private static char[] encodeHex(byte[] data) {
    48.  
    49.         int l = data.length;
    50.  
    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.         }
    57.  
    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;
    8.  
    9.  
    10. @Component
    11. public class RedisUtils {
    12.  
    13.     @Autowired
    14.     private RedisTemplate redisTemplate;
    15.  
    16.     /**
    17.      * 写入String型 [ 键，值]
    18.      *
    19.      * @param key
    20.      * @param value
    21.      * @return
    22.      */
    23.  
    24.     public boolean set(final String key, Object value) {
    25.         boolean result = false;
    26.         try {
    27.             ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
    28.             operations.set(key, value);
    29.             result = true;
    30.         } catch (Exception e) {
    31.             e.printStackTrace();
    32.         }
    33.         return result;
    34.  
    35.     }
    36.  
    37.  
    38.  
    39.     /**
    40.      * 写入String型,顺便带有过期时间 [ 键，值]
    41.      *
    42.      * @param key
    43.      * @param value
    44.      * @return
    45.      */
    46.  
    47.     public boolean setWithTime(final String key, Object value,int seconds) {
    48.         boolean result = false;
    49.         try {
    50.  
    51.             ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
    52.             operations.set(key, value,seconds, TimeUnit.SECONDS);
    53.             result = true;
    54.         } catch (Exception e) {
    55.             e.printStackTrace();
    56.         }
    57.         return result;
    58.  
    59.     }
    60.  
    61.  
    62.  
    63.     /**
    64.      * 批量删除对应的value
    65.      *
    66.      * @param keys
    67.      */
    68.  
    69.     public void remove(final String... keys) {
    70.         for (String key : keys) {
    71.             remove(key);
    72.         }
    73.     }
    74.  
    75.     /**
    76.      * 批量删除key
    77.      *
    78.      * @param pattern
    79.      */
    80.  
    81.     public void removePattern(final String pattern) {
    82.         Set<Serializable> keys = redisTemplate.keys(pattern);
    83.         if (keys.size() > 0)
    84.             redisTemplate.delete(keys);
    85.     }
    86.  
    87.     /**
    88.      * 删除对应的value
    89.      *
    90.      * @param key
    91.      */
    92.  
    93.     public void remove(final String key) {
    94.         if (exists(key)) {
    95.             redisTemplate.delete(key);
    96.         }
    97.     }
    98.  
    99.  
    100.     /**
    101.      * 判断缓存中是否有对应的value
    102.      *
    103.      * @param key
    104.      * @return
    105.      */
    106.  
    107.     public boolean exists(final String key) {
    108.         return redisTemplate.hasKey(key);
    109.     }
    110.  
    111.  
    112.     /**
    113.      * 读取缓存
    114.      *
    115.      * @param key
    116.      * @return
    117.      */
    118.  
    119.     public Object get(final String key) {
    120.         Object result = null;
    121.         ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
    122.         result = operations.get(key);
    123.         return result;
    124.     }
    125.  
    126.  
    127.     /**
    128.      * 哈希 添加
    129.      * hash 一个键值(key->value)对集合
    130.      *
    131.      * @param key
    132.      * @param hashKey
    133.      * @param value
    134.      */
    135.  
    136.     public void hmSet(String key, Object hashKey, Object value) {
    137.  
    138.         HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
    139.  
    140.         hash.put(key, hashKey, value);
    141.  
    142.     }
    143.  
    144.  
    145.     /**
    146.      * Hash获取数据
    147.      *
    148.      * @param key
    149.      * @param hashKey
    150.      * @return
    151.      */
    152.  
    153.     public Object hmGet(String key, Object hashKey) {
    154.         HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
    155.         return hash.get(key, hashKey);
    156.  
    157.     }
    158.  
    159.  
    160.     /**
    161.      * 列表添加
    162.      * list:lpush key value1
    163.      *
    164.      * @param k
    165.      * @param v
    166.      */
    167.  
    168.     public void lPush(String k, Object v) {
    169.         ListOperations<String, Object> list = redisTemplate.opsForList();
    170.         list.rightPush(k, v);
    171.     }
    172.  
    173.  
    174.     /**
    175.      * 列表List获取
    176.      * lrange： key 0 10 (读取的个数 从0开始 读取到下标为10 的数据)
    177.      *
    178.      * @param k
    179.      * @param l
    180.      * @param l1
    181.      * @return
    182.      */
    183.  
    184.     public List<Object> lRange(String k, long l, long l1) {
    185.         ListOperations<String, Object> list = redisTemplate.opsForList();
    186.         return list.range(k, l, l1);
    187.     }
    188.  
    189.  
    190.     /**
    191.      * Set集合添加
    192.      *
    193.      * @param key
    194.      * @param value
    195.      */
    196.  
    197.     public void add(String key, Object value) {
    198.         SetOperations<String, Object> set = redisTemplate.opsForSet();
    199.         set.add(key, value);
    200.     }
    201.  
    202.  
    203.     /**
    204.      * Set 集合获取
    205.      *
    206.      * @param key
    207.      * @return
    208.      */
    209.  
    210.     public Set<Object> setMembers(String key) {
    211.  
    212.         SetOperations<String, Object> set = redisTemplate.opsForSet();
    213.  
    214.         return set.members(key);
    215.  
    216.     }
    217.  
    218.  
    219.     /**
    220.      * Sorted set :有序集合添加
    221.      *
    222.      * @param key
    223.      * @param value
    224.      * @param scoure
    225.      */
    226.  
    227.     public void zAdd(String key, Object value, double scoure) {
    228.         ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
    229.         zset.add(key, value, scoure);
    230.     }
    231.  
    232.  
    233.     /**
    234.      * Sorted set:有序集合获取
    235.      *
    236.      * @param key
    237.      * @param scoure
    238.      * @param scoure1
    239.      * @return
    240.      */
    241.  
    242.     public Set<Object> rangeByScore(String key, double scoure, double scoure1) {
    243.  
    244.         ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
    245.  
    246.         return zset.rangeByScore(key, scoure, scoure1);
    247.  
    248.     }
    249.  
    250.  
    251.     /**
    252.      * 根据key获取Set中的所有值
    253.      *
    254.      * @param key 键
    255.      * @return
    256.      */
    257.  
    258.     public Set<Integer> sGet(String key) {
    259.         try {
    260.             return redisTemplate.opsForSet().members(key);
    261.         } catch (Exception e) {
    262.             e.printStackTrace();
    263.             return null;
    264.         }
    265.     }
    266.  
    267.  
    268.     /**
    269.      * 根据value从一个set中查询,是否存在
    270.      *
    271.      * @param key   键
    272.      * @param value 值
    273.      * @return true 存在 false不存在
    274.      */
    275.  
    276.     public boolean sHasKey(String key, Object value) {
    277.         try {
    278.             return redisTemplate.opsForSet().isMember(key, value);
    279.         } catch (Exception e) {
    280.             e.printStackTrace();
    281.             return false;
    282.         }
    283.     }
    284.  
    285. }

    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;
    17.  
    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.     }
    34.  
    35.  
    36.     @Bean
    37.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
    38.         RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
    39.         redisTemplate.setConnectionFactory(factory);
    40.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
    41.         ObjectMapper om = new ObjectMapper();
    42.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    43.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    44.         jackson2JsonRedisSerializer.setObjectMapper(om);
    45.         //序列化设置 ，这样为了存储操作对象时正常显示的数据，也能正常存储和获取
    46.         redisTemplate.setKeySerializer(new StringRedisSerializer());
    47.         redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
    48.         redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    49.         redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
    50.         return redisTemplate;
    51.     }
    52.     @Bean
    53.     public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
    54.         StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
    55.         stringRedisTemplate.setConnectionFactory(factory);
    56.         return stringRedisTemplate;
    57.     }
    58.  
    59. }

    最后写测试接口，看看效果（一个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.*;
    6.  
    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());
    15.  
    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.     }
    22.  
    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.     }
    29.  
    30. }

    PayOrderApply.java

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

     redis生成了值：

     

    好了，该篇就到这吧、

  • 相关阅读:
    MySQL - order by排序查询 （查询操作 四）
    python第五次作业
    yarn的安装与配置（Windows/macOS）
    【PAT甲级】1058 A+B in Hogwarts
    [鹏程杯2023]复现
    -级数求和-
    「C#」异步编程玩法笔记-async、await
    Linux编程知识之GLIB的GOption接口函数
    Web&Http&Servlet&Request&Response（完整知识点汇总）
    WAN-LAN以及一些计算机网络概念
  • 原文地址：https://blog.csdn.net/qq_35387940/article/details/125426400