技術文章 » 如何防止使用者重複提交訂單？（下）

如何防止使用者重複提交訂單？（下）

2022-11-23 15:01:34

一、摘要

在上一篇文章中，我們詳細的介紹了隨著下單流量逐漸上升，為了降低資料庫的存取壓力，通過請求唯一ID+redis分散式鎖來防止介面重複提交，流程圖如下！

每次提交的時候，需要先呼叫後端服務獲取請求唯一ID，然後才能提交。

對於這樣的流程，不少的同學可能會感覺到非常雞肋，尤其是單元測試，需要每次先獲取submitToken值，然後才能提交！

能不能不用這麼麻煩，直接伺服器端通過一些規則組合，生成本次請求唯一ID呢？

答案是可以的！

今天我們就一起來看看，如何通過伺服器端來完成請求唯一 ID 的生成？

二、方案實踐

我們先來看一張圖，這張圖就是本次方案的核心流程圖。

實現的邏輯，流程如下：

  • 1.使用者點選提交按鈕，伺服器端接受到請求後，通過規則計算出本次請求唯一ID值
  • 2.使用redis的分散式鎖服務，對請求 ID 在限定的時間內嘗試進行加鎖，如果加鎖成功，繼續後續流程；如果加鎖失敗，說明服務正在處理，請勿重複提交
  • 3.最後一步，如果加鎖成功後，需要將鎖手動釋放掉，以免再次請求時，提示同樣的資訊

引入快取服務後，防止重複提交的大體思路如上，實踐程式碼如下！

2.1、引入 redis 元件

本次 demo 專案是基於SpringBoot版本進行構建，新增相關的redis依賴環境如下：

<!-- 引入springboot -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.0.RELEASE</version>
</parent>

......

<!-- Redis相關依賴包，採用jedis作為使用者端 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <exclusions>
        <exclusion>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </exclusion>
        <exclusion>
            <artifactId>lettuce-core</artifactId>
            <groupId>io.lettuce</groupId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

2.2、新增 redis 環境設定

在全域性設定application.properties檔案中，新增redis相關服務設定如下

# 專案名
spring.application.name=springboot-example-submit

# Redis資料庫索引（預設為0）
spring.redis.database=1
# Redis伺服器地址
spring.redis.host=127.0.0.1
# Redis伺服器連線埠
spring.redis.port=6379
# Redis伺服器連線密碼（預設為空）
spring.redis.password=
# Redis伺服器連線超時設定
spring.redis.timeout=1000

# 連線池設定
spring.redis.jedis.pool.max-active=8
spring.redis.jedis.pool.max-wait=1000
spring.redis.jedis.pool.max-idle=8
spring.redis.jedis.pool.min-idle=0
spring.redis.jedis.pool.time-between-eviction-runs=100

2.3、編寫服務驗證邏輯，通過 aop 代理方式實現

首先建立一個@SubmitLimit註解，通過這個註解來進行方法代理攔截！

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
@Documented
public @interface SubmitLimit {

    /**
     * 指定時間內不可重複提交（僅相對上一次發起請求時間差）,單位毫秒
     * @return
     */
    int waitTime() default 1000;

    /**
     * 指定請求頭部key，可以組合生成簽名
     * @return
     */
    String[] customerHeaders() default {};


    /**
     * 自定義重複提交提示語
     * @return
     */
    String customerTipMsg() default "";
}

編寫方法代理服務，增加防止重複提交的驗證，實現了邏輯如下！

@Order(1)
@Aspect
@Component
public class SubmitLimitAspect {

    private static final Logger LOGGER = LoggerFactory.getLogger(SubmitLimitAspect.class);

    /**
     * redis分割符
     */
    private static final String REDIS_SEPARATOR = ":";

    /**
     * 預設鎖對應的值
     */
    private static final String DEFAULT_LOCK_VALUE = "DEFAULT_SUBMIT_LOCK_VALUE";

    /**
     * 預設重複提交提示語
     */
    private static final String DEFAULT_TIP_MSG = "服務正在處理，請勿重複提交！";


    @Value("${spring.application.name}")
    private String applicationName;

    @Autowired
    private RedisLockService redisLockService;


    /**
     * 方法呼叫環繞攔截
     */
    @Around(value = "@annotation(com.example.submittoken.config.annotation.SubmitLimit)")
    public Object doAround(ProceedingJoinPoint joinPoint){
        HttpServletRequest request = getHttpServletRequest();
        if(Objects.isNull(request)){
            return ResResult.getSysError("請求引數不能為空！");
        }
        //獲取註解設定的引數
        SubmitLimit submitLimit = getSubmitLimit(joinPoint);
        //組合生成key，通過key實現加鎖和解鎖
        String lockKey = buildSubmitLimitKey(joinPoint, request, submitLimit.customerHeaders());
        //嘗試在指定的時間內加鎖
        boolean lock = redisLockService.tryLock(lockKey, DEFAULT_LOCK_VALUE, Duration.ofMillis(submitLimit.waitTime()));
        if(!lock){
            String tipMsg = StringUtils.isEmpty(submitLimit.customerTipMsg()) ? DEFAULT_TIP_MSG : submitLimit.customerTipMsg();
            return ResResult.getSysError(tipMsg);
        }
        try {
            //繼續執行後續流程
            return execute(joinPoint);
        } finally {
            //執行完畢之後，手動將鎖釋放
            redisLockService.releaseLock(lockKey, DEFAULT_LOCK_VALUE);
        }
    }

    /**
     * 執行任務
     * @param joinPoint
     * @return
     */
    private Object execute(ProceedingJoinPoint joinPoint){
        try {
            return joinPoint.proceed();
        } catch (CommonException e) {
            return ResResult.getSysError(e.getMessage());
        } catch (Throwable e) {
            LOGGER.error("業務處理髮生異常，錯誤資訊：",e);
            return ResResult.getSysError(ResResultEnum.DEFAULT_ERROR_MESSAGE);
        }
    }


    /**
     * 獲取請求物件
     * @return
     */
    private HttpServletRequest getHttpServletRequest(){
        RequestAttributes ra = RequestContextHolder.getRequestAttributes();
        ServletRequestAttributes sra = (ServletRequestAttributes)ra;
        HttpServletRequest request = sra.getRequest();
        return request;
    }

    /**
     * 獲取註解值
     * @param joinPoint
     * @return
     */
    private SubmitLimit getSubmitLimit(JoinPoint joinPoint){
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Method method = methodSignature.getMethod();
        SubmitLimit submitLimit = method.getAnnotation(SubmitLimit.class);
        return submitLimit;
    }

    /**
     * 組合生成lockKey
     * 生成規則：專案名+介面名+方法名+請求引數簽名（對請求頭部引數+請求body引數，取SHA1值）
     * @param joinPoint
     * @param request
     * @param customerHeaders
     * @return
     */
    private String buildSubmitLimitKey(JoinPoint joinPoint, HttpServletRequest request, String[] customerHeaders){
        //請求引數=請求頭部+請求body
        String requestHeader = getRequestHeader(request, customerHeaders);
        String requestBody = getRequestBody(joinPoint.getArgs());
        String requestParamSign = DigestUtils.sha1Hex(requestHeader + requestBody);
        String submitLimitKey = new StringBuilder()
                .append(applicationName)
                .append(REDIS_SEPARATOR)
                .append(joinPoint.getSignature().getDeclaringType().getSimpleName())
                .append(REDIS_SEPARATOR)
                .append(joinPoint.getSignature().getName())
                .append(REDIS_SEPARATOR)
                .append(requestParamSign)
                .toString();
        return submitLimitKey;
    }


    /**
     * 獲取指定請求頭部引數
     * @param request
     * @param customerHeaders
     * @return
     */
    private String getRequestHeader(HttpServletRequest request, String[] customerHeaders){
        if (Objects.isNull(customerHeaders)) {
            return "";
        }
        StringBuilder sb = new StringBuilder();
        for (String headerKey : customerHeaders) {
            sb.append(request.getHeader(headerKey));
        }
        return sb.toString();
    }


    /**
     * 獲取請求body引數
     * @param args
     * @return
     */
    private String getRequestBody(Object[] args){
        if (Objects.isNull(args)) {
            return "";
        }
        StringBuilder sb = new StringBuilder();
        for (Object arg : args) {
            if (arg instanceof HttpServletRequest
                    || arg instanceof HttpServletResponse
                    || arg instanceof MultipartFile
                    || arg instanceof BindResult
                    || arg instanceof MultipartFile[]
                    || arg instanceof ModelMap
                    || arg instanceof Model
                    || arg instanceof ExtendedServletRequestDataBinder
                    || arg instanceof byte[]) {
                continue;
            }
            sb.append(JacksonUtils.toJson(arg));
        }
        return sb.toString();
    }
}

部分校驗邏輯用到了redis分散式鎖，具體實現邏輯如下：

/**
 * redis分散式鎖服務類
 * 採用LUA指令碼實現，保證加鎖、解鎖操作原子性
 *
 */
@Component
public class RedisLockService {

    /**
     * 分散式鎖過期時間，單位秒
     */
    private static final Long DEFAULT_LOCK_EXPIRE_TIME = 60L;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 嘗試在指定時間內加鎖
     * @param key
     * @param value
     * @param timeout 鎖等待時間
     * @return
     */
    public boolean tryLock(String key,String value, Duration timeout){
        long waitMills = timeout.toMillis();
        long currentTimeMillis = System.currentTimeMillis();
        do {
            boolean lock = lock(key, value, DEFAULT_LOCK_EXPIRE_TIME);
            if (lock) {
                return true;
            }
            try {
                Thread.sleep(1L);
            } catch (InterruptedException e) {
                Thread.interrupted();
            }
        } while (System.currentTimeMillis() < currentTimeMillis + waitMills);
        return false;
    }

    /**
     * 直接加鎖
     * @param key
     * @param value
     * @param expire
     * @return
     */
    public boolean lock(String key,String value, Long expire){
        String luaScript = "if redis.call('setnx', KEYS[1], ARGV[1]) == 1 then return redis.call('expire', KEYS[1], ARGV[2]) else return 0 end";
        RedisScript<Long> redisScript = new DefaultRedisScript<>(luaScript, Long.class);
        Long result = stringRedisTemplate.execute(redisScript, Collections.singletonList(key), value, String.valueOf(expire));
        return result.equals(Long.valueOf(1));
    }


    /**
     * 釋放鎖
     * @param key
     * @param value
     * @return
     */
    public boolean releaseLock(String key,String value){
        String luaScript = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        RedisScript<Long> redisScript = new DefaultRedisScript<>(luaScript, Long.class);
        Long result = stringRedisTemplate.execute(redisScript, Collections.singletonList(key),value);
        return result.equals(Long.valueOf(1));
    }
}

部分程式碼使用到了序列化相關類JacksonUtils，原始碼如下：

public class JacksonUtils {

    private static final Logger LOGGER = LoggerFactory.getLogger(JacksonUtils.class);


    private static final ObjectMapper objectMapper = new ObjectMapper();

    static {
        // 物件的所有欄位全部列入
        objectMapper.setSerializationInclusion(JsonInclude.Include.ALWAYS);
        // 忽略未知的欄位
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        // 讀取不認識的列舉時，當null值處理
        objectMapper.configure(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL, true);
//        序列化忽略未知屬性
        objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
        //忽略欄位大小寫
        objectMapper.configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, true);

        objectMapper.configure(JsonParser.Feature.AUTO_CLOSE_SOURCE, true);
        SimpleModule module = new SimpleModule();
        module.addSerializer(Long.class, ToStringSerializer.instance);
        module.addSerializer(Long.TYPE, ToStringSerializer.instance);
        objectMapper.registerModule(module);
    }

    public static String toJson(Object object) {
        if (object == null) {
            return null;
        }
        try {
            return objectMapper.writeValueAsString(object);
        } catch (Exception e) {
            LOGGER.error("序列化失敗",e);
        }
        return null;
    }

    public static <T> T fromJson(String json, Class<T> classOfT) {
        if (json == null) {
            return null;
        }
        try {
            return objectMapper.readValue(json, classOfT);
        } catch (Exception e) {
            LOGGER.error("反序列化失敗",e);
        }
        return null;
    }

    public static <T> T fromJson(String json, Type typeOfT) {
        if (json == null) {
            return null;
        }
        try {
            return objectMapper.readValue(json, objectMapper.constructType(typeOfT));
        } catch (Exception e) {
            LOGGER.error("反序列化失敗",e);
        }
        return null;
    }
}

2.4、在相關的業務介面上，增加SubmitLimit註解即可

@RestController
@RequestMapping("order")
public class OrderController {

    @Autowired
    private OrderService orderService;

    /**
     * 下單，指定請求頭部參與請求唯一值計算
     * @param request
     * @return
     */
    @SubmitLimit(customerHeaders = {"appId", "token"}, customerTipMsg = "正在加緊為您處理，請勿重複下單！")
    @PostMapping(value = "confirm")
    public ResResult confirmOrder(@RequestBody OrderConfirmRequest request){
        //呼叫訂單下單相關邏輯
        orderService.confirm(request);
        return ResResult.getSuccess();
    }
}

其中最關鍵的一個步就是將唯一請求 ID 的生成，放在伺服器端通過組合來實現，在保證防止介面重複提交的效果同時，也可以顯著的降低介面測試複雜度！

三、小結

本次方案相比於上一個方案，最大的改進點在於：將介面請求唯一 ID 的生成邏輯，放在伺服器端通過規則組合來實現，不需要前端提交介面的時候強制帶上這個引數，在滿足防止介面重複提交的要求同時，又能減少前端和測試提交介面的複雜度！

需要特別注意的是：使用redis的分散式鎖，推薦單機環境，如果redis是叢集環境，可能會導致鎖短暫無效！