devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringBoot中接口幂等性实现方案-自定义注解+Redis+拦截器实现防止订单重复提交_接口幂等性,防止重复提交

作者：IT小白 | 2024-04-28 22:52:33

赞

踩

接口幂等性,防止重复提交

场景

SpringBoot+Redis+自定义注解实现接口防刷(限制不同接口单位时间内最大请求次数)：

SpringBoot+Redis+自定义注解实现接口防刷(限制不同接口单位时间内最大请求次数)_redis防刷_霸道流氓气质的博客-CSDN博客

以下接口幂等性的实现方式与上面博客类似，可参考。

接口幂等性

什么是幂等性？

幂等是一个数学与计算机学概念，在数学中某一元运算为幂等时，其作用在任一元素两次后

会和其作用一次的结果相同。在计算机中编程中，一个幂等操作的特点是其任意多次执行所

产生的影响均与一次执行的影响相同。幂等函数或幂等方法是指可以使用相同参数重复执行，

并能获得相同结果的函数。这些函数不会影响系统状态，也不用担心重复执行会对系统造成改变。

什么是接口幂等性？

在HTTP/1.1中，对幂等性进行了定义。它描述了一次和多次请求某一个资源对于资源本身应该具有

同样的结果（网络超时等问题除外），即第一次请求的时候对资源产生了副作用，但是以后的多次请求

都不会再对资源产生副作用。这里的副作用是不会对结果产生破坏或者产生不可预料的结果。

也就是说，其任意多次执行对资源本身所产生的影响均与一次执行的影响相同。

为什么需要实现幂等性？

在接口调用时一般情况下都能正常返回信息不会重复提交，不过在遇见以下情况时可以就会出现问题，

如：

前端重复提交表单：

在填写一些表格时候，用户填写完成提交，很多时候会因网络波动没有及时对用户做出提交成功响应，

致使用户认为没有成功提交，然后一直点提交按钮，这时就会发生重复提交表单请求。

用户恶意进行刷单：

例如在实现用户投票这种功能时，如果用户针对一个用户进行重复提交投票，这样会导致接口接收到

用户重复提交的投票信息，这样会使投票结果与事实严重不符。

接口超时重复提交：

很多时候 HTTP 客户端工具都默认开启超时重试的机制，尤其是第三方调用接口时候，为了防止网络

波动超时等造成的请求失败，都会添加重试机制，导致一个请求提交多次。

消息进行重复消费：

当使用 MQ 消息中间件时候，如果发生消息中间件出现错误未及时提交消费信息，导致发生重复消费。

使用幂等性最大的优势在于使接口保证任何幂等性操作，免去因重试等造成系统产生的未知的问题。

实现接口幂等性的方案有很多，下面记录一种自定义注解加拦截器和redis的实现方式模拟防止订单重复提交。

注：

博客：
霸道流氓气质_C#,架构之路,SpringBoot-CSDN博客

实现

1、新建SpringBoot项目并添加必要的依赖

  1.     <dependencies>
  2.         <dependency>
  3.             <groupId>org.springframework.boot</groupId>
  4.             <artifactId>spring-boot-starter-web</artifactId>
  5.         </dependency>
  6.  
  7.         <dependency>
  8.             <groupId>com.mysql</groupId>
  9.             <artifactId>mysql-connector-j</artifactId>
  10.             <scope>runtime</scope>
  11.         </dependency>
  12.         <dependency>
  13.             <groupId>org.projectlombok</groupId>
  14.             <artifactId>lombok</artifactId>
  15.             <optional>true</optional>
  16.         </dependency>
  17.         <dependency>
  18.             <groupId>org.springframework.boot</groupId>
  19.             <artifactId>spring-boot-starter-test</artifactId>
  20.             <scope>test</scope>
  21.         </dependency>
  22.         <!--MySQL驱动-->
  23.         <dependency>
  24.             <groupId>mysql</groupId>
  25.             <artifactId>mysql-connector-java</artifactId>
  26.         </dependency>
  27.         <!--MyBatis整合SpringBoot框架的起步依赖-->
  28.         <dependency>
  29.             <groupId>org.mybatis.spring.boot</groupId>
  30.             <artifactId>mybatis-spring-boot-starter</artifactId>
  31.             <version>2.2.1</version>
  32.         </dependency>
  33.         <!-- redis 缓存操作 -->
  34.         <dependency>
  35.             <groupId>org.springframework.boot</groupId>
  36.             <artifactId>spring-boot-starter-data-redis</artifactId>
  37.         </dependency>
  38.         <!-- 阿里JSON解析器 -->
  39.         <dependency>
  40.             <groupId>com.alibaba</groupId>
  41.             <artifactId>fastjson</artifactId>
  42.             <version>1.2.75</version>
  43.         </dependency>
  44.     </dependencies>

2、修改配置文件yml添加相关配置

  1. # 开发环境配置
  2. server:
  3.   # 服务器的HTTP端口，默认为8080
  4.   port: 996
  5.   servlet:
  6.     # 应用的访问路径
  7.     context-path: /
  8.   tomcat:
  9.     # tomcat的URI编码
  10.     uri-encoding: UTF-8
  11.     # tomcat最大线程数，默认为200
  12.     max-threads: 800
  13.     # Tomcat启动初始化的线程数，默认值25
  14.     min-spare-threads: 30
  15.  
  16. # 数据源
  17. spring:
  18.   application:
  19.     name: badao-tcp-demo
  20.   datasource:
  21.    url:jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
  22.     username: root
  23.     password: 123456
  24.     driver-class-name: com.mysql.cj.jdbc.Driver
  25.     dbcp2:
  26.       min-idle: 5                                # 数据库连接池的最小维持连接数
  27.       initial-size: 5                            # 初始化连接数
  28.       max-total: 5                               # 最大连接数
  29.       max-wait-millis: 150                       # 等待连接获取的最大超时时间
  30.  
  31.   # redis 配置
  32.   redis:
  33.     # 地址
  34.     #本地测试用
  35.     host: 127.0.0.1
  36.     port: 6379
  37.     password: 123456
  38.     # 连接超时时间
  39.     timeout: 10s
  40.     lettuce:
  41.       pool:
  42.         # 连接池中的最小空闲连接
  43.         min-idle: 0
  44.         # 连接池中的最大空闲连接
  45.         max-idle: 8
  46.         # 连接池的最大数据库连接数
  47.         max-active: 8
  48.         # #连接池最大阻塞等待时间（使用负值表示没有限制）
  49.         max-wait: -1ms
  50.  
  51. # mybatis配置
  52. mybatis:
  53.   mapper-locations: classpath:mapper/*.xml    # mapper映射文件位置
  54.   type-aliases-package: com.badao.demo.entity    # 实体类所在的位置
  55.   configuration:
  56.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl   #用于控制台打印sql语句


3、新建Redis的两个配置类

RedisConfig:

  1. import org.springframework.cache.annotation.CachingConfigurerSupport;
  2. import org.springframework.cache.annotation.EnableCaching;
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.context.annotation.Primary;
  6. import org.springframework.data.redis.connection.RedisConnectionFactory;
  7. import org.springframework.data.redis.core.RedisTemplate;
  8. import org.springframework.data.redis.serializer.StringRedisSerializer;
  9. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  10. import com.fasterxml.jackson.annotation.JsonTypeInfo;
  11. import com.fasterxml.jackson.annotation.PropertyAccessor;
  12. import com.fasterxml.jackson.databind.ObjectMapper;
  13. import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
  14.  
  15. /**
  16.  * redis配置
  17.  *
  18.  */
  19. @Configuration
  20. @EnableCaching
  21. public class RedisConfig extends CachingConfigurerSupport
  22. {
  23.     @Bean
  24.     @SuppressWarnings(value = { "unchecked", "rawtypes" })
  25.     @Primary
  26.     public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory)
  27.     {
  28.         RedisTemplate<Object, Object> template = new RedisTemplate<>();
  29.         template.setConnectionFactory(connectionFactory);
  30.  
  31.         FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);
  32.  
  33.         ObjectMapper mapper = new ObjectMapper();
  34.         mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  35.         mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
  36.         serializer.setObjectMapper(mapper);
  37.  
  38.         template.setValueSerializer(serializer);
  39.         // 使用StringRedisSerializer来序列化和反序列化redis的key值
  40.         template.setKeySerializer(new StringRedisSerializer());
  41.         template.afterPropertiesSet();
  42.         return template;
  43.     }
  44. }

FastJson2JsonRedisSerializer:

  1. import com.alibaba.fastjson.JSON;
  2. import com.alibaba.fastjson.parser.ParserConfig;
  3. import com.alibaba.fastjson.serializer.SerializerFeature;
  4. import com.fasterxml.jackson.databind.JavaType;
  5. import com.fasterxml.jackson.databind.ObjectMapper;
  6. import com.fasterxml.jackson.databind.type.TypeFactory;
  7. import org.springframework.data.redis.serializer.RedisSerializer;
  8. import org.springframework.data.redis.serializer.SerializationException;
  9. import org.springframework.util.Assert;
  10.  
  11. import java.nio.charset.Charset;
  12.  
  13. /**
  14.  * Redis使用FastJson序列化
  15.  *
  16.  */
  17. public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T>
  18. {
  19.     @SuppressWarnings("unused")
  20.     private ObjectMapper objectMapper = new ObjectMapper();
  21.  
  22.     public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
  23.  
  24.     private Class<T> clazz;
  25.  
  26.     static
  27.     {
  28.         ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
  29.     }
  30.  
  31.     public FastJson2JsonRedisSerializer(Class<T> clazz)
  32.     {
  33.         super();
  34.         this.clazz = clazz;
  35.     }
  36.  
  37.     @Override
  38.     public byte[] serialize(T t) throws SerializationException
  39.     {
  40.         if (t == null)
  41.         {
  42.             return new byte[0];
  43.         }
  44.         return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
  45.     }
  46.  
  47.     @Override
  48.     public T deserialize(byte[] bytes) throws SerializationException
  49.     {
  50.         if (bytes == null || bytes.length <= 0)
  51.         {
  52.             return null;
  53.         }
  54.         String str = new String(bytes, DEFAULT_CHARSET);
  55.  
  56.         return JSON.parseObject(str, clazz);
  57.     }
  58.  
  59.     public void setObjectMapper(ObjectMapper objectMapper)
  60.     {
  61.         Assert.notNull(objectMapper, "'objectMapper' must not be null");
  62.         this.objectMapper = objectMapper;
  63.     }
  64.  
  65.     protected JavaType getJavaType(Class<?> clazz)
  66.     {
  67.         return TypeFactory.defaultInstance().constructType(clazz);
  68.     }
  69. }

4、新建Redis工具类

  1. import org.springframework.beans.factory.annotation.Autowired;
  2. import org.springframework.data.redis.core.*;
  3. import org.springframework.stereotype.Component;
  4. import java.util.*;
  5. import java.util.concurrent.TimeUnit;
  6.  
  7. /**
  8.  * spring redis 工具类
  9.  *
  10.  **/
  11. @SuppressWarnings(value = { "unchecked", "rawtypes" })
  12. @Component
  13. public class RedisCache
  14. {
  15.     @Autowired
  16.     public RedisTemplate redisTemplate;
  17.  
  18.     @Autowired
  19.     public StringRedisTemplate stringRedisTemplate;
  20.  
  21.     /**
  22.      * 缓存基本的对象，Integer、String、实体类等
  23.      *
  24.      * @param key 缓存的键值
  25.      * @param value 缓存的值
  26.      * @return 缓存的对象
  27.      */
  28.     public <T> ValueOperations<String, T> setCacheObject(String key, T value)
  29.     {
  30.         ValueOperations<String, T> operation = redisTemplate.opsForValue();
  31.         operation.set(key, value);
  32.         return operation;
  33.     }
  34.  
  35.     /**
  36.      * 缓存基本的对象，Integer、String、实体类等
  37.      *
  38.      * @param key 缓存的键值
  39.      * @param value 缓存的值
  40.      * @param timeout 时间
  41.      * @param timeUnit 时间颗粒度
  42.      * @return 缓存的对象
  43.      */
  44.     public <T> ValueOperations<String, T> setCacheObject(String key, T value, Integer timeout, TimeUnit timeUnit)
  45.     {
  46.         ValueOperations<String, T> operation = redisTemplate.opsForValue();
  47.         operation.set(key, value, timeout, timeUnit);
  48.         return operation;
  49.     }
  50.  
  51.     /**
  52.      * 获得缓存的基本对象。
  53.      *
  54.      * @param key 缓存键值
  55.      * @return 缓存键值对应的数据
  56.      */
  57.     public <T> T getCacheObject(String key)
  58.     {
  59.         ValueOperations<String, T> operation = redisTemplate.opsForValue();
  60.         return operation.get(key);
  61.     }
  62.  
  63.     /**
  64.      * 删除单个对象
  65.      *
  66.      * @param key
  67.      */
  68.     public void deleteObject(String key)
  69.     {
  70.         redisTemplate.delete(key);
  71.     }
  72.  
  73.     /**
  74.      * 删除集合对象
  75.      *
  76.      * @param collection
  77.      */
  78.     public void deleteObject(Collection collection)
  79.     {
  80.         redisTemplate.delete(collection);
  81.     }
  82.  
  83.     /**
  84.      * 缓存List数据
  85.      *
  86.      * @param key 缓存的键值
  87.      * @param dataList 待缓存的List数据
  88.      * @return 缓存的对象
  89.      */
  90.     public <T> ListOperations<String, T> setCacheList(String key, List<T> dataList)
  91.     {
  92.         ListOperations listOperation = redisTemplate.opsForList();
  93.         if (null != dataList)
  94.         {
  95.             int size = dataList.size();
  96.             for (int i = 0; i < size; i++)
  97.             {
  98.                 listOperation.leftPush(key, dataList.get(i));
  99.             }
  100.         }
  101.         return listOperation;
  102.     }
  103.  
  104.     /**
  105.      * 获得缓存的list对象
  106.      *
  107.      * @param key 缓存的键值
  108.      * @return 缓存键值对应的数据
  109.      */
  110.     public <T> List<T> getCacheList(String key)
  111.     {
  112.         List<T> dataList = new ArrayList<T>();
  113.         ListOperations<String, T> listOperation = redisTemplate.opsForList();
  114.         Long size = listOperation.size(key);
  115.  
  116.         for (int i = 0; i < size; i++)
  117.         {
  118.             dataList.add(listOperation.index(key, i));
  119.         }
  120.         return dataList;
  121.     }
  122.  
  123.     /**
  124.      * 缓存Set
  125.      *
  126.      * @param key 缓存键值
  127.      * @param dataSet 缓存的数据
  128.      * @return 缓存数据的对象
  129.      */
  130.     public <T> BoundSetOperations<String, T> setCacheSet(String key, Set<T> dataSet)
  131.     {
  132.         BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
  133.         Iterator<T> it = dataSet.iterator();
  134.         while (it.hasNext())
  135.         {
  136.             setOperation.add(it.next());
  137.         }
  138.         return setOperation;
  139.     }
  140.  
  141.     /**
  142.      * 获得缓存的set
  143.      *
  144.      * @param key
  145.      * @return
  146.      */
  147.     public <T> Set<T> getCacheSet(String key)
  148.     {
  149.         Set<T> dataSet = new HashSet<T>();
  150.         BoundSetOperations<String, T> operation = redisTemplate.boundSetOps(key);
  151.         dataSet = operation.members();
  152.         return dataSet;
  153.     }
  154.  
  155.     /**
  156.      * 缓存Map
  157.      *
  158.      * @param key
  159.      * @param dataMap
  160.      * @return
  161.      */
  162.     public <T> HashOperations<String, String, T> setCacheMap(String key, Map<String, T> dataMap)
  163.     {
  164.         HashOperations hashOperations = redisTemplate.opsForHash();
  165.         if (null != dataMap)
  166.         {
  167.             for (Map.Entry<String, T> entry : dataMap.entrySet())
  168.             {
  169.                 hashOperations.put(key, entry.getKey(), entry.getValue());
  170.             }
  171.         }
  172.         return hashOperations;
  173.     }
  174.  
  175.     /**
  176.      * 获得缓存的Map
  177.      *
  178.      * @param key
  179.      * @return
  180.      */
  181.     public <T> Map<String, T> getCacheMap(String key)
  182.     {
  183.         Map<String, T> map = redisTemplate.opsForHash().entries(key);
  184.         return map;
  185.     }
  186.  
  187.     /**
  188.      * 获得缓存的基本对象列表
  189.      *
  190.      * @param pattern 字符串前缀
  191.      * @return 对象列表
  192.      */
  193.     public Collection<String> keys(String pattern)
  194.     {
  195.         return redisTemplate.keys(pattern);
  196.     }
  197.  
  198.     /**
  199.      * 如果redis中不存在则存储进redis
  200.      * @return
  201.      */
  202.     public Boolean setIfAbsent(Object key,Object value,long timeout){
  203.         return redisTemplate.opsForValue().setIfAbsent(key, value,timeout, TimeUnit.SECONDS);
  204.     }
  205. }

5、新建自定义注解类Idempotent

  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. @Target(ElementType.METHOD)
  7. @Retention(RetentionPolicy.RUNTIME)
  8. public @interface Idempotent {
  9.  
  10.     /**
  11.      * 用于拼接幂等性判断的key的入参字段
  12.      * @return
  13.      */
  14.     String[] fields();
  15.     /**
  16.      * 用于接口幂等性校验的Redis中Key的过期时间，单位秒
  17.      * @return
  18.      */
  19.     long timeout() default 10l;
  20. }

6、创建自定义拦截器IdempotentInterceptor

  1. import com.badao.demo.annotation.Idempotent;
  2. import com.badao.demo.utils.RedisCache;
  3. import org.springframework.stereotype.Component;
  4. import org.springframework.web.method.HandlerMethod;
  5. import org.springframework.web.servlet.HandlerInterceptor;
  6. import javax.annotation.Resource;
  7. import javax.servlet.http.HttpServletRequest;
  8. import javax.servlet.http.HttpServletResponse;
  9. import java.io.OutputStream;
  10.  
  11. @Component
  12. public class IdempotentInterceptor implements HandlerInterceptor {
  13.  
  14.     @Resource
  15.     private RedisCache redisCache;
  16.  
  17.     @Override
  18.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  19.         Idempotent idempotent = ((HandlerMethod)handler).getMethodAnnotation(Idempotent.class);
  20.         if(idempotent == null){
  21.             return true;
  22.         }
  23.         String idempotentKey = this.idempotentKey(idempotent,request);
  24.         Boolean success = redisCache.setIfAbsent(idempotentKey,1, idempotent.timeout());
  25.         if(Boolean.FALSE.equals(success)){
  26.             render(response,"请勿重复请求");
  27.             return false;
  28.         }
  29.         return true;
  30.     }
  31.  
  32.     private String idempotentKey(Idempotent idempotent,HttpServletRequest request){
  33.         String[] fields = idempotent.fields();
  34.         StringBuilder idempotentKey = new StringBuilder();
  35.         for (String field : fields) {
  36.             String parameter = request.getParameter(field);
  37.             idempotentKey.append(parameter);
  38.         }
  39.         return idempotentKey.toString();
  40.     }
  41.  
  42.     /**
  43.      * 接口渲染
  44.      * @param response
  45.      * @throws Exception
  46.      */
  47.     private void render(HttpServletResponse response,String message)throws Exception {
  48.         response.setContentType("application/json;charset=UTF-8");
  49.         OutputStream out = response.getOutputStream();
  50.         out.write(message.getBytes("UTF-8"));
  51.         out.flush();
  52.         out.close();
  53.     }
  54. }

7、配置拦截器IdempotentInterceptor注册到SpringMVC的拦截器链中

  1. import org.springframework.context.annotation.Configuration;
  2. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
  3. import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
  4. import javax.annotation.Resource;
  5.  
  6. /**
  7.  * 配置拦截器IdempotentInterceptor注册到SpringMVC的拦截器链中
  8.  */
  9. @Configuration
  10. public class WebConfig extends WebMvcConfigurationSupport {
  11.  
  12.     @Resource
  13.     private IdempotentInterceptor idempotentInterceptor;
  14.  
  15.     @Override
  16.     protected void addInterceptors(InterceptorRegistry registry) {
  17.         registry.addInterceptor(idempotentInterceptor);
  18.     }
  19. }

8、创建测试接口并添加自定义注解

  1. import com.badao.demo.annotation.Idempotent;
  2. import org.springframework.web.bind.annotation.GetMapping;
  3. import org.springframework.web.bind.annotation.RequestParam;
  4. import org.springframework.web.bind.annotation.RestController;
  5.  
  6. @RestController
  7. public class TestController {
  8.  
  9.     @Idempotent(fields = {"orderId"},timeout = 10)
  10.     @GetMapping("/test")
  11.     public String test(@RequestParam("orderId") String orderId, String remark){
  12.         return "success";
  13.     }
  14. }

这里指定orderId为订单唯一ID参数，并设置在10秒内如果此字段相同的请求会被拦截

9、创建测试方法

  1. import org.junit.jupiter.api.Test;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.boot.test.context.SpringBootTest;
  4. import org.springframework.http.MediaType;
  5. import org.springframework.test.web.servlet.MockMvc;
  6. import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
  7. import org.springframework.test.web.servlet.setup.MockMvcBuilders;
  8. import org.springframework.web.context.WebApplicationContext;
  9.  
  10. @SpringBootTest
  11. class IdempotenceTest {
  12.  
  13.     @Autowired
  14.     private WebApplicationContext webApplicationContext;
  15.  
  16.     @Test
  17.     void test1() throws Exception {
  18.         //初始化MockMvc
  19.         MockMvc mockMvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
  20.         //循环调用5次进行测试
  21.         for (int i = 1; i <= 5; i++) {
  22.             System.out.println("第"+i+"次调用接口");
  23.             //调用接口
  24.             String result = mockMvc.perform(MockMvcRequestBuilders.get("/test")
  25.                     .accept(MediaType.TEXT_HTML)
  26.                     .param("orderId","001")
  27.                     .param("remark","badao"))
  28.                     .andReturn()
  29.                     .getResponse()
  30.                     .getContentAsString();
  31.             System.out.println(result);
  32.         }
  33.     }
  34. }

测试结果

使用postman等接口测试工具复测验证

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/504690
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号