春眠不觉晓，接口幂等知多少~

最新推荐文章于 2023-10-15 17:05:41 发布
最新推荐文章于 2023-10-15 17:05:41 发布
阅读量338 收藏 3
点赞数
分类专栏： Java并发编程 java 文章标签： java redis spring 幂等性 接口幂等控制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JinglongSource/article/details/105604709
版权

文章目录

1. 写在前面的话

在实际开发中，不知道大家有没有遇到过 “ 测试人员 ” 疯狂点击提交按钮，结果产生脏数据的问题？最终导致一条数据会产生多条记录，这篇博客主要核心是为了解决这一类事情（BUG）提供一个简单的方案。
--------- 甚至我前端使用 disabled 或者 loading 都没有完全能阻止这类BUG，只能说有效减少部分，所以我就在想如何搞一个简单办法，最好是能通用的方案呢？

2. 了解一个概念：幂等

任意多次执行所产生的影响均与一次执行的影响相同。

简单理解就是：只做一次（可以做多次，但是效果都是第一次的效果）

3. 实际场景有哪些？

  • 订单接口，不能多次创建订单
  • 支付接口，重复支付同一笔订单只能扣一次钱
  • 支付宝回调接口，可能会多次回调，必须处理重复回调
  • 普通表单提交接口，因为网络超时等原因多次点击提交，只能成功一次等等

4. 解决方案汇总

  • 唯一索引 – 防止新增脏数据（如果数据精准性要求高，建议使用）
  • token机制 – 防止页面重复提交
  • 悲观锁 – 获取数据的时候加锁(锁表或锁行)
  • 乐观锁 – 基于版本号version实现, 在更新数据那一刻校验数据
  • 分布式锁 – redis(jedis、redisson)或zookeeper实现
  • 状态机 – 状态变更, 更新数据时判断状态
  • …

5. 实现简单幂等方案

为什么叫做简单幂等？因为这里的实现方案并不是完全幂等的实现，只是并发幂等实现，如果需要完全幂等，还需要在具体service操作一些校验， 这里其实方案有点类似 “token机制” 和 “分布式锁”。

主要用到哪些知识点？

  1. 注解的使用
  2. 切面（AOP）增强（前置和后置）
  3. redis的使用（基于RedisTemplate）

6. 问题源码

@RequestMapping("/simple-idempotent")
public String simpleIdempotent(String params) throws InterruptedException {
    // 先从数据库里边查询是否存在该记录
    Object object = this.getOne(params);
    if(object == null) {
        log.info("{}", "请求成功, 正在操作业务");
        // 请求成功, 自增
        atomicInteger.incrementAndGet();
        // 模拟处理业务耗时3秒
        Thread.sleep(3000);
        // 保存入库
        this.save(params);
        return "handle success";
    } else {
        log.info("{}", "数据已经存在, 不执行任何操作");
        return "数据已经存在, 不执行任何操作";
    }
}

问题描述：
这里存在的问题主要是当有多个线程同时进入 Object object = this.getOne(params); 这行代码的时候， 都是返回null， 因此都会一直往下执行， 最终导致新增多个记录

7. 解决思路

知道问题出现的原因，那就有解决的思路了，这里主要解决，如果同一个的参数同时(只要这个参数还没处理完成之前进入的)进入这个 simpleIdempotent 方法，那就抛出异常，或者等待，从而实现 Object object = this.getOne(params); 的 “准确性”。

8. 源码实现

  • SimpleIdempotent (注解类)
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @description 简单幂等
 * @date 2020-04-18 21:14:11
 * @author houyu for.houyu@foxmail.com
 */
@Retention(RetentionPolicy.RUNTIME)
@Target( {ElementType.METHOD})
@Documented
public @interface SimpleIdempotent {

}
  • SimpleIdempotentAspect (切面类)
import cn.shaines.fastboot.common.core.extra.BusinessException;
import cn.shaines.fastboot.common.core.extra.Constant;
import cn.shaines.fastboot.common.utils.CoreUtil;
import cn.shaines.fastboot.common.utils.JSONUtil;
import cn.shaines.fastboot.common.utils.SpringContextUtil;
import cn.shaines.fastboot.common.utils.validator.AssertUtils;
import java.nio.charset.Charset;
import java.time.Duration;
import javax.servlet.http.HttpServletRequest;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

/**
 * @description 简单幂等切面
 * @date 2020-04-18 21:14:11
 * @author houyu for.houyu@foxmail.com
 */
@Slf4j
@Aspect
@Component
public class SimpleIdempotentAspect {

    private static final String keyPrefix = Constant.appName + ":idempotent:simple:";
    @Autowired
    private RedisTemplate redisTemplate;

    @Pointcut("@annotation(cn.shaines.fastboot.common.core.idempotent.SimpleIdempotent)")
    public void requiresIdempotent() {}

    @Before("requiresIdempotent()")
    public void doBefore(JoinPoint point) {
        // MethodSignature methodSignature = (MethodSignature) point.getSignature();
        // Method method = methodSignature.getMethod();
        // SimpleIdempotent annotation = method.getAnnotation(SimpleIdempotent.class);
        Object[] args = point.getArgs();
        AssertUtils.check(args == null || args.length == 0, "参数为空");
        String jsonString = JSONUtil.toJSONString(args);
        String hash = CoreUtil.md5(jsonString.getBytes(Charset.defaultCharset()));
        this.check(hash);
    }

    private void check(String hash) {
        String key = keyPrefix + hash;
        // 设置初始值, 也可以不设置, 但是建议设置
        // (这里设置10秒钟, 也就是说这个请求10秒钟之内如果没有完成, 相同参数的请求也会进来)
        Boolean ifAbsent = redisTemplate.opsForValue().setIfAbsent(key, 0, Duration.ofSeconds(10));
        if(ifAbsent == null || !ifAbsent) {
            throw new BusinessException("重复提交");
        }
        // 自增1
        Long increment = redisTemplate.opsForValue().increment(key);
        if(increment == null || increment.intValue() != 1) {
            // 基于redis线程安全的自增, 保证准确性
            throw new BusinessException("重复提交");
        }
        HttpServletRequest request = SpringContextUtil.getHttpServletRequest();
        if(request != null) {
            // 基于请求存储一下这个key, 请求完之后删除这个key, 那么相同的参数其他就会可以进来了
            request.setAttribute(keyPrefix, key);
        }
    }

    @After("requiresIdempotent()")
    public void doAfter(JoinPoint point) {
        HttpServletRequest request = SpringContextUtil.getHttpServletRequest();
        if(request != null) {
            String key = (String) request.getAttribute(keyPrefix);
            if(StringUtils.isBlank(key)) {
                return;
            }
            // 删除key
            redisTemplate.delete(key);
        }
    }
}

9. 简单使用: 添加@SimpleIdempotent

@SimpleIdempotent // 添加简单幂等注解
@RequestMapping("/simple-idempotent")
public String simpleIdempotent(String params) throws InterruptedException {
    // 先从数据库里边查询是否存在该记录
    Object object = this.getOne(params);
    if(object == null) {
        log.info("{}", "请求成功, 正在操作业务");
        // 请求成功, 自增
        atomicInteger.incrementAndGet();
        // 模拟处理业务耗时3秒(3秒内 相同的params都会返回重复提交提示)
        Thread.sleep(3000);
        // 保存入库
        this.save(params);
        return "handle success";
    } else {
        log.info("{}", "数据已经存在, 不执行任何操作");
        return "数据已经存在, 不执行任何操作";
    }
}

10. 测试

这里测试可以使用压测工具 jmeter 或者 postman 什么的一类工具都可以， 我这里图方便就直接使用代码测试了~~

public static void main(String[] args) {
    CountDownLatch runLatch = new CountDownLatch(1);
    String url = "http://localhost:10002/test/simple-idempotent?params=xxx";
    for(int i = 0; i < 20; i++) {
        new Thread(() -> {
            try {
                runLatch.await();
            } catch(InterruptedException e) {
                e.printStackTrace();
            }
            // HttpClient 是我的一个工具类, 不必纠结
            Response<String> response = HttpClient.buildHttpClient().buildRequest(url).execute(BodyHandlers.ofString());
            System.out.println("==>>>" + response.getBody());
        }).start();
    }
    try {
        // 这里简单等待一下创建线程, 当然也可以使用 CountDownLatch 来进行精准等待
        Thread.sleep(2000);
    } catch(InterruptedException e) {
        e.printStackTrace();
    }
    // 开始执行请求
    runLatch.countDown();
}

测试结果

==>>>{"code":40000,"msg":"重复提交","data":null,"extra":{}}
==>>>{"code":40000,"msg":"重复提交","data":null,"extra":{}}
==>>>{"code":40000,"msg":"重复提交","data":null,"extra":{}}
==>>>{"code":40000,"msg":"重复提交","data":null,"extra":{}}
==>>>{"code":40000,"msg":"重复提交","data":null,"extra":{}}
==>>>{"code":40000,"msg":"重复提交","data":null,"extra":{}}
==>>>{"code":40000,"msg":"重复提交","data":null,"extra":{}}
==>>>{"code":40000,"msg":"重复提交","data":null,"extra":{}}
==>>>{"code":40000,"msg":"重复提交","data":null,"extra":{}}
==>>>{"code":40000,"msg":"重复提交","data":null,"extra":{}}
==>>>{"code":40000,"msg":"重复提交","data":null,"extra":{}}
==>>>{"code":40000,"msg":"重复提交","data":null,"extra":{}}
==>>>{"code":40000,"msg":"重复提交","data":null,"extra":{}}
==>>>{"code":40000,"msg":"重复提交","data":null,"extra":{}}
==>>>{"code":40000,"msg":"重复提交","data":null,"extra":{}}
==>>>{"code":40000,"msg":"重复提交","data":null,"extra":{}}
==>>>{"code":40000,"msg":"重复提交","data":null,"extra":{}}
==>>>{"code":40000,"msg":"重复提交","data":null,"extra":{}}
==>>>{"code":40000,"msg":"重复提交","data":null,"extra":{}}
==>>>handle success

可以看出来，20个并发请求， 19个被拦截掉，只有一个进入controller， 因为进入controller需要3秒执行业务，因此最后才打印出来

11. 写在最后的话

  • 这里只是控制并发时的幂等，我叫它简单幂等（相同参数进入接口，只有一个在处理，其他的被拦截掉），因此并不是完全的控制了幂等，如果需要完全幂等，建议1. 数据库建立唯一约束 2. Service判断记录是否存在
  • 这里实现的是使用接口的所有参数进行hash，因此范围可能有些广，可以结合自己自身业务灵活调整
  • 往后再也不怕测试拼手速啦 [奸笑], 只需要在接口添加一个注解 @SimpleIdempotent 就完事啦，甚至前端都可以不用加 loading disabled （为了友好体验的话还是加上吧）
  • 深知并发水深，不敢说这里实现的代码不会出现其他并发问题， 如果有大佬发现问题，欢迎找我啪啪打脸…
  • emial: for.houyu@foxmail.com
IT加载中
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
春眠不觉晓，SQL 知多少？
12-14
文章目录SQL 的诞生SQL 标准化SQL:2019SQL:2016SQL:2011SQL:2008SQL:2006SQL:2003SQL:1999SQL-92语言特性语句分类SQL 实现NewSQL SQL 的诞生 一九七九年，那是一个夏天。 有一位来自 IBM 圣约瑟研究实验室的高级研究...
幂等专项测试分享
weixin_43146803的博客
05-30 2127
幂等性测试分享什么是幂等？幂等性测试为什么需要幂等？幂等性多数场景运用在支付、订单、和分布式事务处理等幂等的类型插入幂等一般插入幂等多用于生成流水号没做幂等做了幂等校验幂等字段的设计更新幂等为何会有更新不幂等会带来的问题更新丢失更新丢失场景脏读场景脏读幻读和不可重复读总结Thanks Thanks Thanks 什么是幂等？ f(x)=f(f(x))f(x)=f(f(x))f(x)=f(f(x)) 幂等性测试 同一个请求被执行一次与被执行多次的效果是一样的，服务器的状态也是一样的 为什么需要幂等？
常见幂等测试方法
laihuahua66的博客
01-31 1506
幂等测试、软件测试、自动化测试、验收测试
阿里面试官：如何测试接口幂等性？
自动化测试技术栈
10-08 1509
什么是接口幂等性？
【测试知识点学习笔记】接口测试中的幂等性测试与高并发测试与断点
m0_72775367的博客
04-10 494
接口测试的一些笔记
接口幂等测试
weixin_43500974的博客
03-03 392
接口测试幂等
Strom流处理的基础知识总结
04-19
Strom的基础概念，包括核心概念释义，如拓扑等；一些常用API方法和参数详解；大方面的工作流程；
Java多线程小结
10-26
Java中多线程的学习的自我小结，有多线程的意思，多线程常见的控制方法等内容
kafka基础知识总结
04-19
kafka的概念和一些基础的机制，如基础概念，分组策略，数据的完全生产，负载均衡等
接口幂等性校验，太优雅了(经典)
最新发布
gb4215287的博客
10-15 368
接口幂等性校验，太优雅了
简单谈一谈幂等测试
梦里有阳光
02-16 2201
幂等是一个抽象的概念，在编程中一个幂等操作的特点是其任意多次执行所产生的影响均与一次执行的影响相同，即多次调用方法或者接口不会改变业务状态，可以保证重复调用的结果和单次调用的结果一致。幂等测试，则主要是为了验证同一个请求被执行一次与被执行多次的效果是否是一样的。
软件测试系列：接口幂等测试
weixin_43936332的博客
04-01 407
前端重复提交表单： 在填写一些表格时候，用户填写完成提交，很多时候会因网络波动没有及时对用户做出提交成功响应，致使用户认为没有成功提交，然后一直点提交按钮，这时就会发生重复提交表单请求。接口超时重复提交： 很多时候 HTTP 客户端工具都默认开启超时重试的机制，尤其是第三方调用接口时候，为了防止网络波动超时等造成的请求失败，都会添加重试机制，导致一个请求提交多次。(注意可能返回结果不一样，删除的数据不存在，返回0，删除的数据多条，返回结果多个，在不考虑返回结果的情况下，删除操作也是具有幂等性的）
接口测试的幂等性测试【杭州多测师_王sir】【杭州多测师】
多测师_王sir的博客
11-16 870
一)什么是接口幂等概念：接口幂等性就是用户对于同一个接口发起的一次请求或者多次请求的结果是一致的，不会因为多次请求而产生不同的结果。案例用户购买商品后需要进行支付，支付扣款成功，但是返回结果的时侯报网络异常，此时钱已经扣了，用户不知道并再次点击支付按钮，此时会进行第二次扣款，返回结果成功，用户查询余额发现扣了两次款，多扣钱了，流水记录也生成了两条，这其实就没有保证接口的幂等性。二)增删改查涉及的...
接口幂等性测试
be yourself 的博客
10-13 1627
所谓幂等:多次调用方法或者接口不会改变业务状态，可以保证重复调用的结果和单次调用的结果一致。
JAVA 二维数组的应用----打印唐诗（横版，竖版 春晓）
qq_47018979的博客
04-18 5720
JAVA 用二维数组打印唐诗 你好WO SHI 七七卡卡 ^ _ ^ 二维数组的应用----打印唐诗（横版，竖版 春晓） 我们上次讨论了如何用javascrip创建二维数组，这次我们用java 二维数组解决一个小问题打印唐诗（横版，竖版 春晓） 在做之前，我们先看看打印后的效果： 横版 0.0我们先定义一个二维数组 横版 竖版 春眠不觉晓， ...
二维数组与多维数组以及练习题
weixin_30548917的博客
10-15 164
二维数组 int[,]array=new int[3,2]{ {1，2}, {3，4}, {5，6}}; 3表示有三个一维数组。2表示每一个一维数组有两个元素 如果把一维数组看作是一个点，那么二维数组就是一个面 多维数组， 多维数组就是[,,],的形式 。如果把二维数...
学习笔记_二维数组的使用场景
进击的字母K
03-21 1793
实例一 P89 二维数组的使用场景 2020-03-20 22:04:07 创建Poetry类,声明一个字符型二维数组,将古诗《春晓》的内容赋值于二维数组,然后分别用横版和竖版的方式输出. public class Dcc_Poetry { public static void main(String[] args) { // 创建二维数组,数组长度(行)为4 char arr[][...
java行列互调输出春眠不觉晓的古诗
06-02
好的，以下是一个示例代码，可以将《春眠不觉晓》这首古诗按照行列互调的方式输出： ```java public class PoemTranspose { public static void main(String[] args) { String[][] poem = { {"春眠不觉晓", "处处闻啼鸟", "夜来风雨声", "花落知多少"}, }; // 获取行列数 int rows = poem.length; int cols = poem[0].length; // 创建新的二维数组 String[][] transposed = new String[cols][rows]; // 行列互调 for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { transposed[j][i] = poem[i][j]; } } // 输出互调后的古诗 for (int i = 0; i < cols; i++) { for (int j = 0; j < rows; j++) { System.out.print(transposed[i][j]); if (j < rows - 1) { System.out.print("，"); } } System.out.println(); } } } ``` 输出结果为： ``` 春眠不觉晓，处处闻啼鸟，夜来风雨声，花落知多少 ``` 希望能够帮到您！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值