/**
 * 冪等處理
 */
Rsp idempotent（Request req）{
  
    try {
        insert(req);
    } catch (DuplicateKeyException e) {
        //攔截是重復請求，直接返回成功
        log.info("主鍵沖突，是重復請求，直接返回成功，流水號：{}",bizSeq);
        return rsp;
    }

    //正常處理請求
    dealRequest(req);

    return rsp;
}

select order_id，version from order where order_id='666'；

update order set version = version +1，status='P' where order_id='666' and version =1

begin;  # 1.開始事務
select * from order where order_id='666' for update # 查詢訂單，判斷狀態(tài),鎖住這條記錄
if（status !=處理中）{
   //非處理中狀態(tài)，直接返回；
   return ;
}
## 處理業(yè)務邏輯
update order set status='完成' where order_id='666' # 更新完成
commit; # 5.提交事務

update transfor_flow set status = 2 where biz_seq='666' and status = 1;

Rsp idempotentTransfer（Request req）{
    String bizSeq = req.getBizSeq();
    int rows= "update transfr_flow set status=2 where biz_seq=#{bizSeq} and status=1;"
    if(rows==1){
        log.info(“更新成功,可以處理該請求”);
        //其他業(yè)務邏輯處理
        return rsp;
    } else if(rows == 0) {
        log.info(“更新不成功，不處理該請求”);
        //不處理，直接返回
        return rsp;
    }

    log.warn("數(shù)據(jù)異常")
    return rsp：
}

import java.lang.annotation.*;

/**
 * 冪等性校驗注解
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface NotRepeat {

}

import com.demo.util.RedisUtils;
import lombok.extern.slf4j.Slf4j;
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.stereotype.Component;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.concurrent.TimeUnit;

/**
 * 重復點擊校驗
 */
@Slf4j
@Aspect
@Component
public class IdempotentAOP {
    
    /** Redis前綴 */
    private String API_IDEMPOTENT_CHECK = "API_IDEMPOTENT_CHECK:";

    @Resource
    private HttpServletRequest request;
    @Resource
    private RedisUtils redisUtils;

    /**
     * 定義切面
     */
    @Pointcut("@annotation(com.demo.annotation.NotRepeat)")
    public void notRepeat() {
    }

    /**
     * 在接口原有的方法執(zhí)行前，將會首先執(zhí)行此處的代碼
     */
    @Before("notRepeat()")
    public void doBefore(JoinPoint joinPoint) {
        String uri = request.getRequestURI();

        // 登錄后才做校驗
        UserInfo loginUser = AuthUtil.getLoginUser();
        if (loginUser != null) {
            assert uri != null;
            String key = loginUser.getAccount() + "_" + uri;
            log.info(">>>>>>>>>> 【IDEMPOTENT】開始冪等性校驗，加鎖，account: {}，uri: {}", loginUser.getAccount(), uri);

            // 加分布式鎖
            boolean lockSuccess = redisUtils.setIfAbsent(API_IDEMPOTENT_CHECK + key, "1", 30, TimeUnit.MINUTES);
            log.info(">>>>>>>>>> 【IDEMPOTENT】分布式鎖是否加鎖成功:{}", lockSuccess);
            if (!lockSuccess) {
                if (uri.contains("contract/saveDraftContract")) {
                    log.error(">>>>>>>>>> 【IDEMPOTENT】文件保存中，請稍后");
                    throw new IllegalArgumentException("文件保存中，請稍后");

                } else if (uri.contains("contract/saveContract")) {
                    log.error(">>>>>>>>>> 【IDEMPOTENT】文件發(fā)起中，請稍后");
                    throw new IllegalArgumentException("文件發(fā)起中，請稍后");
                }
            }
        }
    }

    /**
     * 在接口原有的方法執(zhí)行后，都會執(zhí)行此處的代碼（final）
     */
    @After("notRepeat()")
    public void doAfter(JoinPoint joinPoint) {
        // 釋放鎖
        String uri = request.getRequestURI();
        assert uri != null;
        UserInfo loginUser = SysUserUtil.getloginUser();
        if (loginUser != null) {
            String key = loginUser.getAccount() + "_" + uri;
            log.info(">>>>>>>>>> 【IDEMPOTENT】冪等性校驗結束，釋放鎖，account: {}，uri: {}", loginUser.getAccount(), uri);
            redisUtils.del(API_IDEMPOTENT_CHECK + key);
        }
    }
}

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.concurrent.TimeUnit;


/**
 * redis工具類
 */
@Slf4j
@Component
public class RedisUtils {

    /**
     * 默認RedisObjectSerializer序列化
     */
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 加分布式鎖
     */
    public boolean setIfAbsent(String key, String value, long timeout, TimeUnit unit) {
        return redisTemplate.opsForValue().setIfAbsent(key, value, timeout, unit);
    }

    /**
     * 釋放鎖
     */
    public void del(String... keys) {
        if (keys != null && keys.length > 0) {
            //將參數(shù)key轉為集合
            redisTemplate.delete(Arrays.asList(keys));
        }
    }
}

import com.demo.annotation.NotRepeat;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Arrays;
import java.util.List;

/**
 * 冪等性校驗測試類
 */
@RequestMapping("/order")
@RestController
public class OrderController {

    @NotRepeat
    @GetMapping("/orderList")
    public List<String> orderList() {
        // 查詢列表
        return Arrays.asList("Order_A", "Order_B", "Order_C");
        // throw new RuntimeException("參數(shù)錯誤");
    }
}