1.什麼是幂等

在我們程式設計中常見幂等
1)select查詢天然幂等  
2)delete删除也是幂等,删除同一個多次效果一樣 
3)update直接更新某個值的,幂等 
4)update更新累加操作的,非幂等 
5)insert非幂等操作,每次新增一條
複制代碼

2.産生原因

由于重複點選或者網絡重發  eg:  
1)點選送出按鈕兩次;
2)點選重新整理按鈕;
3)使用浏覽器後退按鈕重複之前的操作，導緻重複送出表單;
4)使用浏覽器曆史記錄重複送出表單;
5)浏覽器重複的HTTP請;
6)nginx重發等情況;
7)分布式RPC的try重發等;

3.解決方案

1)前端js送出禁止按鈕可以用一些js元件

2)使用Post/Redirect/Get模式

在送出後執行頁面重定向，這就是所謂的
Post-Redirect-Get (PRG)模式。簡言之，
當使用者送出了表單後，你去執行一個用戶端的重定向，
轉到送出成功資訊頁面。這能避免使用者按F5導緻的
重複送出，而其也不會出現浏覽器表單重複送出的警告，
也能消除按浏覽器前進和後退按導緻的同樣問題。

3)在session中存放一個特殊标志

在伺服器端，生成一個唯一的辨別符，将它存入session，
同時将它寫入表單的隐藏字段中，然後将表單頁面發給浏覽器，
使用者錄入資訊後點選送出，在伺服器端，擷取表單中隐藏字段
的值，與session中的唯一辨別符比較，相等說明是首次送出，
就處理本次請求，然後将session中的唯一辨別符移除；不相等
說明是重複送出，就不再處理。
複制代碼

4)其他借助使用header頭設定緩存控制頭Cache-control等方式

比較複雜  不适合移動端APP的應用 這裡不詳解

5)借助資料庫

insert使用唯一索引 update使用 樂觀鎖 version版本法
這種在大資料量和高并發下效率依賴資料庫硬體能力,可針對非核心業務

6)借助悲觀鎖

使用select ... for update  ,這種和 synchronized 
鎖住先查再insert or update一樣,但要避免死鎖,效率也較差 
針對單體 請求并發不大 可以推薦使用

7)借助本地鎖(本文重點)

原理:使用了 ConcurrentHashMap 并發容器 putIfAbsent 方法,
和 ScheduledThreadPoolExecutor 定時任務,也可以使用guava cache
的機制, gauva中有配有緩存的有效時間 也是可以的key的生成 
Content-MD5 Content-MD5 是指 Body 的 MD5 值，
隻有當 Body 非Form表單時才計算MD5，計算方式直接将參數和參數名稱統一加密MD5
MD5在一定範圍類認為是唯一的 近似唯一  當然在低并發的情況下足夠了 
當然本地鎖隻适用于單機部署的應用.
複制代碼

①配置注解

import java.lang.annotation.*;

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

    /**
     * 延時時間 在延時多久後可以再次送出
     *
     * @return Time unit is one second
     */
    int delaySeconds() default 20;
}

②執行個體化鎖

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.digest.DigestUtils;

import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author lijing
 * 重複送出鎖
 */
@Slf4j
public final class ResubmitLock {

    private static final ConcurrentHashMap<String, Object> LOCK_CACHE = new ConcurrentHashMap<>(200);
    private static final ScheduledThreadPoolExecutor EXECUTOR = new ScheduledThreadPoolExecutor(5, new ThreadPoolExecutor.DiscardPolicy());

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

    private ResubmitLock() {
    }

    /**
     * 靜态内部類 單例模式
     *
     * @return
     */
    private static class SingletonInstance {
        private static final ResubmitLock INSTANCE = new ResubmitLock();
    }

    public static ResubmitLock getInstance() {
        return SingletonInstance.INSTANCE;
    }

    public static String handleKey(String param) {
        return DigestUtils.md5Hex(param == null ? "" : param);
    }

    /**
     * 加鎖 putIfAbsent 是原子操作保證線程安全
     *
     * @param key   對應的key
     * @param value
     * @return
     */
    public boolean lock(final String key, Object value) {
        return Objects.isNull(LOCK_CACHE.putIfAbsent(key, value));
    }

    /**
     * 延時釋放鎖 用以控制短時間内的重複送出
     *
     * @param lock         是否需要解鎖
     * @param key          對應的key
     * @param delaySeconds 延時時間
     */
    public void unLock(final boolean lock, final String key, final int delaySeconds) {
        if (lock) {
            EXECUTOR.schedule(() -> {
                LOCK_CACHE.remove(key);
            }, delaySeconds, TimeUnit.SECONDS);
        }
    }
}

③AOP 切面

import com.alibaba.fastjson.JSONObject;
import com.cn.xxx.common.annotation.Resubmit;
import com.cn.xxx.common.annotation.impl.ResubmitLock;
import com.cn.xxx.common.dto.RequestDTO;
import com.cn.xxx.common.dto.ResponseDTO;
import com.cn.xxx.common.enums.ResponseCode;
import lombok.extern.log4j.Log4j;
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.stereotype.Component;

import java.lang.reflect.Method;

/**
 * @ClassName RequestDataAspect
 * @Description 資料重複送出校驗
 * @Author lijing
 * @Date 2019/05/16 17:05
 **/
@Log4j
@Aspect
@Component
public class ResubmitDataAspect {

    private final static String DATA = "data";
    private final static Object PRESENT = new Object();

    @Around("@annotation(com.cn.xxx.common.annotation.Resubmit)")
    public Object handleResubmit(ProceedingJoinPoint joinPoint) throws Throwable {
        Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
        //擷取注解資訊
        Resubmit annotation = method.getAnnotation(Resubmit.class);
        int delaySeconds = annotation.delaySeconds();
        Object[] pointArgs = joinPoint.getArgs();
        String key = "";
        //擷取第一個參數
        Object firstParam = pointArgs[0];
        if (firstParam instanceof RequestDTO) {
            //解析參數
            JSONObject requestDTO = JSONObject.parseObject(firstParam.toString());
            JSONObject data = JSONObject.parseObject(requestDTO.getString(DATA));
            if (data != null) {
                StringBuffer sb = new StringBuffer();
                data.forEach((k, v) -> {
                    sb.append(v);
                });
                //生成加密參數 使用了content_MD5的加密方式
                key = ResubmitLock.handleKey(sb.toString());
            }
        }
        //執行鎖
        boolean lock = false;
        try {
            //設定解鎖key
            lock = ResubmitLock.getInstance().lock(key, PRESENT);
            if (lock) {
                //放行
                return joinPoint.proceed();
            } else {
                //響應重複送出異常
                return new ResponseDTO<>(ResponseCode.REPEAT_SUBMIT_OPERATION_EXCEPTION);
            }
        } finally {
            //設定解鎖key和解鎖時間
            ResubmitLock.getInstance().unLock(lock, key, delaySeconds);
        }
    }
}

④注解使用案例

@ApiOperation(value = "儲存我的文章接口", notes = "儲存我的文章接口")
    @PostMapping("/posts/save")
    @Resubmit(delaySeconds = 10)
    public ResponseDTO<BaseResponseDataDTO> saveBbsPosts(@RequestBody @Validated RequestDTO<BbsPostsRequestDTO> requestDto) {
        return bbsPostsBizService.saveBbsPosts(requestDto);
    }

以上就是本地鎖的方式進行的幂等送出使用了Content-MD5 進行加密隻要參數不變,參數加密密值不變,key存在就阻止送出

當然也可以使用一些其他簽名校驗在某一次送出時先生成固定簽名送出到後端根據後端解析統一的簽名作為每次送出的驗證token 去緩存中處理即可.

8)借助分布式redis鎖（參考其他）

在 pom.xml 中添加上 starter-web、starter-aop、starter-data-redis 的依賴即可

<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>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
</dependencies>

屬性配置在 application.properites 資源檔案中添加 redis 相關的配置項

spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=123456

主要實作方式: 熟悉 Redis 的朋友都知道它是線程安全的，我們利用它的特性可以很輕松的實作一個分布式鎖，如 opsForValue().setIfAbsent(key,value)它的作用就是如果緩存中沒有目前 Key 則進行緩存同時傳回 true 反之亦然；當緩存後給 key 在設定個過期時間，防止因為系統崩潰而導緻鎖遲遲不釋放形成死鎖；那麼我們是不是可以這樣認為當傳回 true 我們認為它擷取到鎖了，在鎖未釋放的時候我們進行異常的抛出…

package com.battcn.interceptor;

import com.battcn.annotation.CacheLock;
import com.battcn.utils.RedisLockHelper;
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.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.StringUtils;

import java.lang.reflect.Method;
import java.util.UUID;

/**
 * redis 方案
 *
 * @author Levin
 * @since 2018/6/12 0012
 */
@Aspect
@Configuration
public class LockMethodInterceptor {

    @Autowired
    public LockMethodInterceptor(RedisLockHelper redisLockHelper, CacheKeyGenerator cacheKeyGenerator) {
        this.redisLockHelper = redisLockHelper;
        this.cacheKeyGenerator = cacheKeyGenerator;
    }

    private final RedisLockHelper redisLockHelper;
    private final CacheKeyGenerator cacheKeyGenerator;

    @Around("execution(public * *(..)) && @annotation(com.battcn.annotation.CacheLock)")
    public Object interceptor(ProceedingJoinPoint pjp) {
        MethodSignature signature = (MethodSignature) pjp.getSignature();
        Method method = signature.getMethod();
        CacheLock lock = method.getAnnotation(CacheLock.class);
        if (StringUtils.isEmpty(lock.prefix())) {
            throw new RuntimeException("lock key don't null...");
        }
        final String lockKey = cacheKeyGenerator.getLockKey(pjp);
        String value = UUID.randomUUID().toString();
        try {
            // 假設上鎖成功，但是設定過期時間失效，以後拿到的都是 false
            final boolean success = redisLockHelper.lock(lockKey, value, lock.expire(), lock.timeUnit());
            if (!success) {
                throw new RuntimeException("重複送出");
            }
            try {
                return pjp.proceed();
            } catch (Throwable throwable) {
                throw new RuntimeException("系統異常");
            }
        } finally {
            // TODO 如果示範的話需要注釋該代碼;實際應該放開
            redisLockHelper.unlock(lockKey, value);
        }
    }
}

RedisLockHelper 通過封裝成 API 方式調用，靈活度更加高

package com.battcn.utils;

import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisStringCommands;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.types.Expiration;
import org.springframework.util.StringUtils;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.regex.Pattern;

/**
 * 需要定義成 Bean
 *
 * @author Levin
 * @since 2018/6/15 0015
 */
@Configuration
@AutoConfigureAfter(RedisAutoConfiguration.class)
public class RedisLockHelper {

    private static final String DELIMITER = "|";

    /**
     * 如果要求比較高可以通過注入的方式配置設定
     */
    private static final ScheduledExecutorService EXECUTOR_SERVICE = Executors.newScheduledThreadPool(10);

    private final StringRedisTemplate stringRedisTemplate;

    public RedisLockHelper(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    /**
     * 擷取鎖（存在死鎖風險）
     *
     * @param lockKey lockKey
     * @param value   value
     * @param time    逾時時間
     * @param unit    過期機關
     * @return true or false
     */
    public boolean tryLock(final String lockKey, final String value, final long time, final TimeUnit unit) {
        return stringRedisTemplate.execute((RedisCallback<Boolean>) connection -> connection.set(lockKey.getBytes(), value.getBytes(), Expiration.from(time, unit), RedisStringCommands.SetOption.SET_IF_ABSENT));
    }

    /**
     * 擷取鎖
     *
     * @param lockKey lockKey
     * @param uuid    UUID
     * @param timeout 逾時時間
     * @param unit    過期機關
     * @return true or false
     */
    public boolean lock(String lockKey, final String uuid, long timeout, final TimeUnit unit) {
        final long milliseconds = Expiration.from(timeout, unit).getExpirationTimeInMilliseconds();
        boolean success = stringRedisTemplate.opsForValue().setIfAbsent(lockKey, (System.currentTimeMillis() + milliseconds) + DELIMITER + uuid);
        if (success) {
            stringRedisTemplate.expire(lockKey, timeout, TimeUnit.SECONDS);
        } else {
            String oldVal = stringRedisTemplate.opsForValue().getAndSet(lockKey, (System.currentTimeMillis() + milliseconds) + DELIMITER + uuid);
            final String[] oldValues = oldVal.split(Pattern.quote(DELIMITER));
            if (Long.parseLong(oldValues[0]) + 1 <= System.currentTimeMillis()) {
                return true;
            }
        }
        return success;
    }

    /**
     * @see <a href="http://redis.io/commands/set">Redis Documentation: SET</a>
     */
    public void unlock(String lockKey, String value) {
        unlock(lockKey, value, 0, TimeUnit.MILLISECONDS);
    }

    /**
     * 延遲unlock
     *
     * @param lockKey   key
     * @param uuid      client(最好是唯一鍵的)
     * @param delayTime 延遲時間
     * @param unit      時間機關
     */
    public void unlock(final String lockKey, final String uuid, long delayTime, TimeUnit unit) {
        if (StringUtils.isEmpty(lockKey)) {
            return;
        }
        if (delayTime <= 0) {
            doUnlock(lockKey, uuid);
        } else {
            EXECUTOR_SERVICE.schedule(() -> doUnlock(lockKey, uuid), delayTime, unit);
        }
    }

    /**
     * @param lockKey key
     * @param uuid    client(最好是唯一鍵的)
     */
    private void doUnlock(final String lockKey, final String uuid) {
        String val = stringRedisTemplate.opsForValue().get(lockKey);
        final String[] values = val.split(Pattern.quote(DELIMITER));
        if (values.length <= 0) {
            return;
        }
        if (uuid.equals(values[1])) {
            stringRedisTemplate.delete(lockKey);
        }
    }

}

Java 的知識面非常廣，面試問的涉及也非常廣泛，重點包括：Java 基礎、Java 并發，JVM、MySQL、資料結構、算法、Spring、微服務、MQ 等等，涉及的知識點何其龐大，是以我們在複習的時候也往往無從下手，今天小編給大家帶來一套 Java 面試題，題庫非常全面，包括 Java 基礎、Java 集合、JVM、Java 并發、Spring全家桶、Redis、MySQL、Dubbo、Netty、MQ 等等，包含 Java 後端知識點 2000 +

資料擷取方式：關注工種号：“程式員白楠楠”擷取上述資料

8 種方案解決重複送出問題！你選擇哪一種呀？1.什麼是幂等2.産生原因3.解決方案①配置注解②執行個體化鎖③AOP 切面④注解使用案例

1.什麼是幂等

2.産生原因

3.解決方案

①配置注解

②執行個體化鎖

③AOP 切面

④注解使用案例

繼續閱讀

/\B(?=(?:\d{3})+$)/g 一條令人費解的正規表達式

neo4j之cypher使用文檔

适用于JavaScript的ECMAScript 2020規範向前發展

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

JS生成uuid的四種方法

mysql使用source指令導入.sql檔案

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

layui多任務上傳添加進度條

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method