問題を再送信するためのソリューションの8種類

著者：ジンチェンの同級生

リンク：juejin.im/post/5d31928c51882564c966a71c

1.冪等とは何ですか

私たちのプログラミングでの一般的な電源など

• 選択クエリ自然冪等

• 削除冪等を削除し、何回も同じ効果を削除

• 更新直接更新値、パワー、等

• 更新更新蓄積操作、非冪等

• 非冪等の操作を挿入し、毎回新しいです

2.原因

繰り返しクリックやネットワークの再送信などのため：

• 送信ボタンを2度クリックします。

• [更新]ボタンをクリックします。

• 重複したフォーム送信で、その結果、操作の前に繰り返して戻ってブラウザのボタンを使用します。

• 歴史の繰り返しは、フォームを送信し、ブラウザを使用してください。

• お使いのブラウザのHTTPを繰り返してください。

• nginxの再送信、等。

• 分散型RPCのようなの再送を試みます。

3.ソリューション

1）いくつかのJSを使用することができ、遠位JS阻害ボタンアセンブリを提出

 

2）ポスト/リダイレクト/取得モード

ポストリダイレクト - ゲット（PRG）モードと呼ばれる、送信後のリダイレクトページを実行します。ユーザーがフォームを送信する際要するに、あなたは成功したページを送信するためにクライアントをリダイレクト実行するために行きます。これは、結果を再送信F5を押すようにユーザーを避けることができ、それが提出され、ブラウザのフォームを繰り返さないことを警告しながら、前後に起因する同じブラウザで問題を解消することができます。

3）セッションでの特別なロゴに保存されています

サーバー側では、一意の識別子を生成し、それはそれは隠されたフィールドの形式で書かれている間に、セッションを保存して、ブラウザにページを形成し、ユーザーが入力した情報を提出クリックし、サーバー側で、フォームを取得セッションの一意の識別子と比較して非表示フィールドの値は、この要求の処理には、提出された最初のノートに等しく、その後、セッションはユニークな識別子削除され、繰り返し命令が等しくない提出し、処理はもはやありません。

4）等キャッシュ制御ヘッダーキャッシュ制御を設定された第1のヘッダを使用する他の手段を

ここでは説明できないAPPのより複雑な動きには適していません

5）データベースを介して

楽観的ロックバージョンのバージョンを使用して一意のインデックス更新方法を挿入

非中核事業のための大きなデータ量と高い同時低い効率でこの依存関係データベース・ハードウェアの能力、

6）悲観的ロックと

SELECT ... FOR UPDATEを使用し、ロックをチェックして、同じことを再挿入または更新する同期が、デッドロックを避けるためになる、効率が悪く、

我々は、単一のための同時要求を使用することをお勧めすることはできません

7）ローカル・ロックでは（この記事では）に焦点を当てて

原理：

キャッシュ有効時間鍵生成とがgauvaも可能であり、ConcurrentHashMapの同時容器はputIfAbsentメソッドを使用し、タイミングタスクのScheduledThreadPoolExecutor、グアバキャッシュ機構で使用することができます 

Content-MD5 

コンテンツ-MD5 MD5値は、ユニティ・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は、一定のパラメータを暗号化して使用し提出し、暗号化パラメータの値が変化し、キーが存在提出防止ローカルパワーロックのようなものです

もちろん、あなたは氏が固定・ツー・バックキャッシュバックエンド処理に提出署名を提出する時にいくつかの他の署名の検証を使用することができ、認証トークンとして均一な署名各提出に応じて解決することができます。

他8）分散錠のRedisの手段によって（参照）

 

：また、この参照してください分散ロックのRedisに基づく分析と実践を

スターター・ウェブ、スタータAOP、スターターデータRedisの依存関係の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>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（キー、値）キャッシュは現在、主に行われていない場合、その役割は、ありますキャッシュながら、真その逆を返します。

私たちは、我々はそれがロックに入ったと思うときに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);
        }
    }

}

Redisの参照を提出しました

https://blog.battcn.com/2018/06/13/springboot/v2-cache-redislock/

読書推奨（読むためにジャンプします）

1.  SpringBootコンテンツアグリゲータ

2.  顔の質問コンテンツアグリゲータ

3.  設計パターンコンテンツアグリゲータ

4.  MyBatisのコンテンツアグリゲータ

マルチスレッド・コンテンツアグリゲータ