概念：

一次和多次请求某一个资源，对资源本身所产生的的影响均与一次执行的影响相同; 需要考虑到幂等的场景就是新增和更新，对于查询，删除的操作执行一次和执行多次不影响最终结果集所以Select, delete 天生就是幂等的

常见解决方案

1:分布式锁保证幂等

1.1 场景：秒杀，抢票

在秒杀情况下同一个用户只能抢购一件商品，在买票的情况下同一个用户，同一个班次的火车票也能买一张；如果此时用户是写的脚本程序或者网络抖动发生重试，执行了多次request 则会导致一个用户抢购多个商品或者出票重复

1.2 解决方案：redis 锁

用户ID + 火车班次号 生成一个唯一key 存储到redis中使用setnx / rédission 保证某一段时间内的数据唯一性

1.3 DEMO 代码

redis设置全局锁代码

 public ResponseCode setLockAndExecute(String key, String value, long timeOut, TimeUnit time, Supplier<ResponseCode> execute) {
   boolean lock = false;
   try {
     lock = stringRedisTemplate.opsForValue().setIfAbsent(key, value, timeOut, time);
     if (lock) {
       log.info(“重复请求：{}”, key);
       return execute.get();
     }
     //加锁失败
     log.info("重复请求：{}", key);
     return ResponseCode.REPEAT_ERROR;
   } catch (Exception ex) {
     log.error("Redis加锁异常", ex);
     return ResponseCode.UNKNOWN_ERROR;
   } finally {
     if (lock) {
       log.info("任务执行完成：删除锁：{}",key);
       this.del(key);
     }
   }
}

需要做幂等的业务方法

return setLockAndExecute(userId+productId, 1, 1, TimeUnit.HOURS, () -> {
   User user = userService.getUserById(userId);
   if (ObjectUtils.isEmpty(user)) {
     log.info(“不存在该用户：{}”, userid);
     return ResponseCode.USER_NOT_FIND;
   }
   Product product = productService.getProductById(productId);
   if (ObjectUtils.isEmpty(product)) {
       log.info(“不存在该商品：{}”, productid);
       return ResponseCode.PRODUCT_NOT_FIND;
   }
   String orderId = orderService.insertNewOrder(user, product);
   if (StringUtils.hasLength(orderId)) {
       log.info(“订单生成成功：{}”, orderId);
       return ResponseCode.SUCCESS;
   }
   log.info("订单生成失败);
   return ResponseCode.FAIL;
});

2:token保证幂等

2.1 场景：用户注册，创建子部门

当有创建新数据的时候因为都是新数据没有ID，当用户点击多次提交会导致创建重复数据到DB中

2.2 解决方案：在正式请求前做一次获取令牌的预请求

当点击新增，或者注册的时候先请求一次后端接口后端接口生成一个token保存到redis中(setnx)同时返回给前端请求，等前端填写完注册信息并提交保存的时候携带上上次返回的token, 后端收到请求后获取token并且判断redis中是否存在,如果存在从redis中删除然后保存数据库，如果不存在返回错误信息给前端

2.3 DEMO 代码：

创建注册用户的幂等拦截注解，以后对于需要幂等的方法只需要在方法上添加该注解即可

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RegisterRestriction {
    boolean value() default true;
}

在注册用户的controller 上添加幂等判断注解

@PostMapping(“/register")
@RegisterRestriction
public ResponseData registerUser(@RequestHeader(value = "Authorization") String token, HttpServletResponse response) {
    return userService.registerUser(token, response);
}

生成正式请求的令牌代码

Public ResponseCode generateUniqueKey(String userId) {
   User user = userService.getUserById(userId);
   if (ObjectUtils.isEmpty(user)) {
     log.info(“不存在该用户：{}”, userid);
     return ResponseCode.USER_NOT_FIND;
   }
  //生成唯一key 给response
  String uniqueKey = String.*format*("%s%s", Instant.*now*().toEpochMilli(), userId);
  stringRedisTemplate.opsForValue().set(uniqueKey, uniqueKey, 5 * 60, TimeUnit.SECONDS);
  response.setHeader(CommonConst.*REGISTER_REQUEST_ID*, uniqueKey);
  // 成功更新，返回
  return ResponseCode.SUCCESS;
}

幂等拦截器代码

@Slf4j
public class RegisterInterceptor implements HandlerInterceptor {

    @Autowired
    private RedisUtils redisUtils;

    private boolean checkRequestId(HttpServletRequest request, HttpServletResponse response) throws InterceptorException {
        String requestId = request.getHeader("X-Request-Id");
        if (!StringUtils.hasLength(requestId)) {
            log.info("header中未获取到预先生成的注册令牌，请求非法");
            throw new InterceptorException(40012, "header中未获取到预先生成的注册令牌，请求非法");
        }
        //判断redis中是否存在requestId, 如果存在 -> return true
        //如果不存在(可能是前端造的假ID-> return false)
        if (redisUtils.exists(requestId)) {
            //删除
            if (redisUtils.del(requestId)) {
                return true;
            }

            log.info("请勿重复请求");
            throw new InterceptorException(ResponseCode.REPEAT_ERROR);
        }

        log.info("redis 中未获取到预先生成的注册令牌，请求非法");
        throw new InterceptorException(ResponseCode.REPEAT_ERROR);
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (handler instanceof HandlerMethod) {
            HandlerMethod handlerMethod = (HandlerMethod)handler;
            Method method = handlerMethod.getMethod();
            if (!ObjectUtils.isEmpty(method) && method.isAnnotationPresent(RegisterRestriction.class)) {
                if (method.getAnnotation(RegisterRestriction.class).value()) {
                    return checkRequestId(request, response);
                }
            }
        }

        return true;
    }
}

3:mysql unique key 保证幂等

3.1 解决方案：

通过对mysql 表创建唯一key来达到幂等性，比如用户注册手机号设置唯一key 当发生重复请求后mysql判重拒绝写入db,
创建子部门，可以创建parent_id + 部门名称做唯一key 来保证幂等性

3.3 DEMO 代码：

ALTER TABLE tb_department ADD CONSTRAINT department_info_UN UNIQUE KEY (parent_id,department_name);

4:乐观锁保证幂等

4.1 场景：

当涉及到自增，自减更新的时候需要考虑幂等性问题，因为普通的更新就是给字段赋值执行一次和执行多次效果都是一样的，比如：更新用户名称，更新数据状态
Update user set name= ‘张三’ where id = ‘zhangsan’
Update user set status=‘1’ where id = ‘zhansan’

4.2 解决方案：乐观锁

对于自增自减类的update,比如：update goods set count=count -1 where id = ‘123’ 就需要做幂等处理因为执行多次就会自减多次，使用乐观锁，给表中新增一个version字段，每次读取的时候将version字段读取，更新的时候再判断version字段是否是自己持有的值同时将version +1

Update goods set count=count -1 , version=version +1 where id = ‘123’ and version = ‘1’