一、什么是幂等性
接口幂等性就是用户对于同一操作发起的一次请求或者多次请求的结果是一致的，不会因为多次点击而产生了副作用；比如说支付场景，用户购买了商品支付扣款成功，但是返回结果的时候网络异常，此时钱已经扣了，用户再次点击按钮，此时会进行第二次扣款，返回结果成功，用户查询余额返发现多扣钱了，流水记录也变成了两条,这就没有保证接口的幂等性。
二、哪些情况需要防止
用户多次点击按钮
用户页面回退再次提交
微服务互相调用，由于网络问题，导致请求失败。feign 触发重试机制
其他业务情况
三、什么情况下需要幂等
以 SQL 为例，有些操作是天然幂等的。
SELECT * FROM table WHER id=?，无论执行多少次都不会改变状态，是天然的幂等。UPDATE tab1 SET col1=1 WHERE col2=2，无论执行成功多少次状态都是一致的，也是幂等操作。
delete from user where userid=1，多次操作，结果一样，具备幂等性
insert into user(userid,name) values(1,‘a’) 如 userid 为唯一主键，即重复操作上面的业务，只会插入一条用户数据，具备幂等性。
UPDATE tab1 SET col1=col1+1 WHERE col2=2，每次执行的结果都会发生变化，不是幂等的。
insert into user(userid,name) values(1,‘a’) 如 userid 不是主键，可以重复，那上面业务多次操作，数据都会新增多条，不具备幂等性。
四、幂等解决方案
1、token 机制
1、服务端提供了发送 token 的接口。我们在分析业务的时候，哪些业务是存在幂等问题的，就必须在执行业务前，先去获取 token，服务器会把 token 保存到 redis 中。
2、然后调用业务接口请求时，把 token 携带过去，一般放在请求头部。3、服务器判断 token 是否存在 redis 中，存在表示第一次请求，然后删除 token,继续执行业务。4、如果判断 token 不存在 redis 中，就表示是重复操作，直接返回重复标记给 client，这样就保证了业务代码，不被重复执行。
危险性：1、先删除 token 还是后删除 token；
- 先删除可能导致，业务确实没有执行，重试还带上之前 token，由于防重设计导致，请求还是不能执行。
- 后删除可能导致，业务处理成功，但是服务闪断，出现超时，没有删除 token，别人继续重试，导致业务被执行两边
- 我们最好设计为先删除 token，如果业务调用失败，就重新获取 token 再次请求。
2、Token 获取、比较和删除必须是原子性
- redis.get(token) 、token.equals、redis.del(token)如果这两个操作不是原子，可能导致，高并发下，都 get 到同样的数据，判断都成功，继续业务并发执行
- 可以在 redis 使用 lua 脚本完成这个操作
if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end
2、各种锁机制
1、数据库悲观锁
select * from xxxx where id = 1 for update;悲观锁使用时一般伴随事务一起使用，数据锁定时间可能会很长，需要根据实际情况选用。另外要注意的是，id 字段一定是主键或者唯一索引，不然可能造成锁表的结果，处理起来会非常麻烦。
2、数据库乐观锁
这种方法适合在更新的场景中，update t_goods set count = count -1 , version = version + 1 where good_id=2 and version = 1根据 version 版本，也就是在操作库存前先获取当前商品的 version 版本号，然后操作的时候带上此 version 号。我们梳理下，我们第一次操作库存时，得到 version 为 1，调用库存服务version 变成了 2；但返回给订单服务出现了问题，订单服务又一次发起调用库存服务，当订单服务传如的 version 还是 1，再执行上面的 sql 语句时，就不会执行；因为 version 已经变为 2 了，where 条件就不成立。这样就保证了不管调用几次，只会真正的处理一次。乐观锁主要使用于处理读多写少的问题
3、业务层分布式锁
如果多个机器可能在同一时间同时处理相同的数据，比如多台机器定时任务都拿到了相同数据处理，我们就可以加分布式锁，锁定此数据，处理完成后释放锁。获取到锁的必须先判断这个数据是否被处理过。
3、各种唯一约束
1、数据库唯一约束
插入数据，应该按照唯一索引进行插入，比如订单号，相同的订单就不可能有两条记录插入。我们在数据库层面防止重复。这个机制是利用了数据库的主键唯一约束的特性，解决了在 insert 场景时幂等问题。但主键的要求不是自增的主键，这样就需要业务生成全局唯一的主键。如果是分库分表场景下，路由规则要保证相同请求下，落地在同一个数据库和同一表中，要不然数据库主键约束就不起效果了，因为是不同的数据库和表主键不相关。
2、redis set 防重
很多数据需要处理，只能被处理一次，比如我们可以计算数据的 MD5 将其放入 redis 的 set，每次处理数据，先看这个 MD5 是否已经存在，存在就不处理。
4、防重表
使用订单号 orderNo 做为去重表的唯一索引，把唯一索引插入去重表，再进行业务操作，且他们在同一个事务中。这个保证了重复请求时，因为去重表有唯一约束，导致请求失败，避免了幂等问题。这里要注意的是，去重表和业务表应该在同一库中，这样就保证了在同一个事务，即使业务操作失败了，也会把去重表的数据回滚。这个很好的保证了数据一致性。
之前说的 redis 防重也算
5、全局请求唯一 id
调用接口时，生成一个唯一 id，redis 将数据保存到集合中（去重），存在即处理过。可以使用 nginx 设置每一个请求的唯一 id；proxy_set_header X-Request-Id $request_id;
案例
本案例以商城下单为例，采用token机制。通过模拟用户点击结算去订单结算页，多次点击付款按钮，避免重复下单。
流程图如下：
具体实现
1、创建一个订单需要用的数据
@Data
public class OrderConfirmVo {
/** 会员收获地址列表 **/
List<MemberAddressVo> memberAddressVos;
/** 所有选中的购物项 **/
List<OrderItemVo> items;
/** 发票记录 **/
/** 优惠券（会员积分） **/
private Integer integration;
/** 防止重复提交的令牌 **/
private String orderToken;
Map<Long,Boolean> stocks;
/** 订单总额 **/
BigDecimal total;
/** 应付价格 **/
BigDecimal payPrice;
}
2、提交订单的时候创建防重令牌
public OrderConfirmVo confirOrder() throws ExecutionException, InterruptedException {
OrderConfirmVo confirmVo=new OrderConfirmVo();
MemberRespVo memberRespVo = LoginUserInterceptor.loginUser.get();
//获取父线程的请求数据，在异步任务执行之前，先共享数据
RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
CompletableFuture<Void> getAddressFuture = CompletableFuture.runAsync(() -> {
//在主线程中拿到原来的数据，在父线程里面共享RequestContextHolder
//只有共享，拦截其中才会有数据
RequestContextHolder.setRequestAttributes(requestAttributes);
//1、远程查询所有的收货地址列表
List<MemberAddressVo> addressVos = memberFeignService.getAddress(memberRespVo.getId());
confirmVo.setMemberAddressVos(addressVos);
}, executor);
CompletableFuture<Void> getCartfFurue = CompletableFuture.runAsync(() -> {
//在主线程中拿到原来的数据，在父线程里面共享RequestContextHolder
//只有共享，拦截其中才会有数据
RequestContextHolder.setRequestAttributes(requestAttributes);
//2、远程查询购物车中所有选中的购物项
List<OrderItemVo> currentUserCartItem = cartFeignService.getCurrentUserCartItem();
confirmVo.setItems(currentUserCartItem);
}, executor).thenRunAsync(()->{
//3、商品是否有库存
List<OrderItemVo> items = confirmVo.getItems();
//批量查询每个商品的信息
List<Long> collect = items.stream().map(item -> item.getSkuId()).collect(Collectors.toList());
R r = wareFeignService.getSkuHasStock(collect);
List<SkuHasStockVo> hasStockVo = r.getData(new TypeReference<List<SkuHasStockVo>>() {
});
if (hasStockVo!=null){
Map<Long, Boolean> stockMap = hasStockVo.stream().collect(Collectors.toMap(SkuHasStockVo::getSkuId, SkuHasStockVo::getHasStock));
confirmVo.setStocks(stockMap);
log.info("stockMap:{}", stockMap);
}
},executor);
//3、查询用户积分
Integer integration = memberRespVo.getIntegration();
confirmVo.setIntegration(integration);
//4、其余数据自动计算
// 5、防重令牌
CompletableFuture.allOf(getAddressFuture,getCartfFurue).get();
String token= UUID.randomUUID().toString().replace("-","");
redisTemplate.opsForValue().set(OrderConstant.USER_ORDER_TOKEN_PREFIX+memberRespVo.getId(),token,30, TimeUnit.SECONDS);
confirmVo.setOrderToken(token);
return confirmVo;
}
这个时候前端可以拿到我们返回的反重令牌了。
下一步就是需要点击提交订单，进入结算界面。
具体的流程如下：
1、先创建一个提交订单的封装类
@Data
public class OrderSubmitVo {
/** 收获地址的id **/
private Long addrId;
/** 支付方式 **/
private Integer payType;
//无需提交要购买的商品，去购物车再获取一遍
//优惠、发票
/** 防重令牌 **/
private String orderToken;
/** 应付价格 **/
private BigDecimal payPrice;
/** 订单备注 **/
private String remarks;
//用户相关的信息，直接去session中取出即可
}
2、具体的实现类，演示作用。具体的逻辑比这个复杂。
@Transactional
@Override
public SubmitOrderResponseVo submitOrder(OrderSubmitVo vo) {
//先将参数放到共享变量中，方便之后方法使用该参数
confirmVoThreadLocal.set(vo);
SubmitOrderResponseVo responseVo = new SubmitOrderResponseVo();
MemberRespVo memberRespVo = LoginUserInterceptor.loginUser.get();
//不适用原子性验证令牌
/**
* 不使用原子性验证令牌
* 1、用户带着两个订单，提交速度非常快，两个订单的令牌都是123，去redis里面查查到的也是123两个对比都通过，然后来删除令牌，那么就会出现用户重复提交的问题，
* 2、第一次差的快，第二次查的慢，只要没删就会出现这些问题
* 3、因此令牌的[验证和删除必须保证原子性]
*/
// String orderToken = vo.getOrderToken();
// String redisToken = redisTemplate.opsForValue().get(OrderConstant.USER_ORDER_TOKEN_PREFIX + memberRespVo.getId());
// if (orderToken!=null&&orderToken.equals(redisToken)){
//
// }else {
//
// }
//验证令牌【令牌的对比和删除必须保证原子性】
//因此使用redis中脚本进行验证并删除令牌
// 0【删除失败/验证失败】 1【删除成功】
String script="if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
/**
* redis lur脚本命令解析
* if redis.call('get',KEYS[1]) == ARV1 then return redis.call('del',KEYS1]) else return 0 end
* 1、redis调用get方法来获取一个key的值，如果这个get出来的值等于我们传过来的值
* 2、然后就执行删除，根据这个key进行删除，删除成功返回1，验证失败返回0
* 3、删除否则就是0
* 总结: 相同的进行删除，不相同的返回0
* 脚本大致意思
*/
//拿到令牌
String orderToken = vo.getOrderToken();
/**
* public <T> T execute(RedisScript<T> script // redis的脚本，
* List<K> keys // 对应的key 参数中使用了Array.asList 将参数转成list集合
* object... args) { // 要删除的值
*/
Long result = redisTemplate.execute(new DefaultRedisScript<Long>(script, Long.class), Arrays.asList(OrderConstant.USER_ORDER_TOKEN_PREFIX + memberRespVo.getId()), orderToken);
if (result==0L){
responseVo.setCode(1);
return responseVo;
}else {
//原子验证成功
//下单，创建订单、验证令牌、验证价格、验证库存
//1、创建订单，订单项信息
OrderCreateTo order=createOrder();
//2、应付总额
BigDecimal payAmount = order.getOrder().getPayAmount();
//应付价格
BigDecimal payPrice = vo.getPayPrice();
/**
* 电商项目对应的金额精确到小数点后两位
* 订单创建好的应付总额和购物车中计算好的应付价格求出绝对值
*/
if (Math.abs(payAmount.subtract(payPrice).doubleValue())<0.01){
//金额对比成功，保存订单
saveOrder(order);
//锁定库存
WareSkuLockVo wareSkuLockVo = new WareSkuLockVo();
//准备好商品项
List<OrderItemVo> collect = order.getOrderItems().stream().map(orderItemEntity -> {
OrderItemVo orderItemVo = new OrderItemVo();
//商品购买数量
orderItemVo.setCount(orderItemEntity.getSkuQuantity());
//skuid用来查询商品信息
orderItemVo.setSkuId(orderItemEntity.getSkuId());
//商品标题
orderItemVo.setTitle(orderItemEntity.getSkuName());
return orderItemVo;
}).collect(Collectors.toList());
//订单号
wareSkuLockVo.setOrderSn(order.getOrder().getOrderSn());
//商品项
wareSkuLockVo.setLocks(collect);
//远程调用库存服务锁定库存
//TODO 库存成功了，但是网络原因超时了，订单回滚，库存不滚
//为了保证高并发，库存服务自己回滚，可以发消息给库存服务；
//库存服务本身也可以使用自动解锁模式
R r=wareFeignService.orderLockStock(wareSkuLockVo);
if (r.getCode()==0){
//将订单对象放到返回vo中
responseVo.setCode(0);
responseVo.setOrder(order.getOrder());
//TODO
// int i=10/0;
//订单创建完成，发送消息
rabbitTemplate.convertAndSend("order-event-exchange","order.create.order",order.getOrder());
return responseVo;
}else {
responseVo.setCode(3);
String msg = (String) r.get("msg");
throw new NoStockException(msg);
}
}else{
responseVo.setCode(2);
return responseVo;
}
}
}
如果是分布式环境下，可以采用Redisson分布式锁的方式判断是否重复提交
// 使用Redisson分布式锁的方式判断是否重复提交
RLock lock = redissonClient.getLock(lockKey);
boolean isLocked = false;
try {
//尝试抢占锁
isLocked = lock.tryLock();
//没有拿到锁说明已经有了请求了
if (!isLocked) {
throw new BizException(ResponseCodeEnum.BIZ_CHECK_FAIL, "您的操作太快了,请稍后重试");
}
//拿到锁后设置过期时间
lock.lock(requestLock.expire(), requestLock.timeUnit());
try {
return joinPoint.proceed();
} catch (Throwable throwable) {
throw new BizException(ResponseCodeEnum.BIZ_CHECK_FAIL, "系统异常");
}
} catch (Exception e) {
throw new BizException(ResponseCodeEnum.BIZ_CHECK_FAIL, "您的操作太快了,请稍后重试");
} finally {
//释放锁
if (isLocked && lock.isHeldByCurrentThread()) {
lock.unlock();
}
}
Redisson的核心思路就是抢锁，当一次请求抢到锁之后，对锁加一个过期时间，在这个时间段内重复的请求是无法获得这个锁，也不难理解。
总结
幂等性有多种实现方法，可以通过token机制、各种锁机制、唯一性约束、防重表、全局请求唯一id等方法来实现。
不同的场景遇到的问题可能不一样，具体问题具体分析。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
