Springboot2本地鎖實踐

　　在平時開發中，如果網速比較慢的情況下，用戶提交表單后，發現服務器半天都沒有響應，那么用戶可能會以為是自己沒有提交表單，就會再點擊提交按鈕重復提交表單，我們在開發中必須防止表單重復提交….

下面我們利用自定義注解、Spring Aop、Guava Cache 實現表單防重復提交

一、導入依賴

 創建springboot項目，在pom.xml文件中加入以下內容

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>21.0</version>
    </dependency>
</dependencies>

 二、Lock注解

創建一個 LocalLock 注解，就一個 key 可以了

package com.carry.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 鎖的注解
 *
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface LocalLock {

    String key() default "";
}

 三、Lock攔截器（AOP）

首先通過 CacheBuilder.newBuilder() 構建出緩存對象，設置好過期時間；其目的就是為了防止因程序崩潰鎖得不到釋放，然后在具體的 interceptor() 方法上采用的是 Around（環繞增強） ，所有帶 LocalLock 注解的都將被切面處理

具體代碼

package com.carry.interceptor;

import java.lang.reflect.Method;
import java.util.concurrent.TimeUnit;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.StringUtils;
import com.carry.annotation.LocalLock;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;

@Aspect
@Configuration
public class LockMethodInterceptor {

    private static final Cache<String, Object> CACHES = CacheBuilder.newBuilder()
            // 最大緩存 100 個
            .maximumSize(100)
            // 設置寫緩存后 5 秒鍾過期
            .expireAfterWrite(5, TimeUnit.SECONDS).build();

    @Around("execution(public * *(..)) && @annotation(com.carry.annotation.LocalLock)")
    public Object interceptor(ProceedingJoinPoint pjp) {
        MethodSignature signature = (MethodSignature) pjp.getSignature();
        Method method = signature.getMethod();
        LocalLock localLock = method.getAnnotation(LocalLock.class);
        String key = getKey(localLock.key(), pjp.getArgs());
        if (!StringUtils.isEmpty(key)) {
            if (CACHES.getIfPresent(key) != null) {
                throw new RuntimeException("請勿重復請求");
            }
            // 如果是第一次請求,就將 key 當前對象壓入緩存中
            CACHES.put(key, key);
        }
        try {
            return pjp.proceed();
        } catch (Throwable throwable) {
            throw new RuntimeException("服務器異常");
        } finally {
            // TODO
        }
    }

    /**
     * key 的生成策略,如果想靈活可以寫成接口與實現類的方式
     *
     * @param keyExpress
     *            表達式
     * @param args
     *            參數
     * @return 生成的key
     */
    private String getKey(String keyExpress, Object[] args) {
        for (int i = 0; i < args.length; i++) {
            keyExpress = keyExpress.replace("arg[" + i + "]", args[i].toString());
        }
        return keyExpress;
    }
}

四、控制層

在接口方法上添加 @LocalLock(key = "book:arg[0]")；意味着會將 arg[0] 替換成第一個參數的值，生成后的新 key 將被緩存起來

具體代碼

package com.carry.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.carry.annotation.LocalLock;

@RestController
@RequestMapping("/test")
public class LocalLockController {

    @LocalLock(key = "key:arg[0]")
    @GetMapping
    public String query(@RequestParam String token) {
        return "success - " + token;
    }
}

五、測試

啟動項目，在postman中輸入url：localhost:8080/test?token=1

第一次請求結果：

第二次請求結果：