美文网首页
防重复提交设计方案

防重复提交设计方案

作者: 那年的纸飞机 | 来源:发表于2019-01-30 11:07 被阅读0次

场景描述

大型互联网项目中,由于业务特点(例如秒杀)同一时间很多的人在使用,用户连续快速点击,而且前端没有针对性处理,导致连续发送两次请求,此时如果不做好控制,那么系统将会产生很多的数据重复的问题。

解决方案

解决思路:相同的请求在同一时间只能被处理一次。

分布式锁

1.服务器A接收到请求之后,获取锁,获取成功

2.服务器A进行业务处理,订单提交成功

3.服务器B接收到相同的请求,获取锁,失败,因为锁被服务器A获取了,并且未释放

4.服务器A处理完成,释放锁 实现采用redis

流程图
20190128151646582.png

代码设计

防重复提交注解类

/**
 * 避免重复提交注解
 * @Author huanglian
 * @Date 2019-01-24-下午4:56
 */
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface AvoidRepeatableCommit {
    long acquireTimeout() default 1000;

    long lockTimeout() default 2000;
}

防重复提交切面类

/**
 * 避免重复提交切面
 *
 * @Author huanglian
 * @Date 2019-01-24-下午5:09
 */
@Component
@Aspect
public class AvoidRepeatableCommitAspect {
    private static final Logger logger = LoggerFactory.getLogger(AvoidRepeatableCommitAspect.class);

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    private AvoidRepeatableCommitLock avoidRepeatableCommitLock;

    @PostConstruct
    private void init() {
        avoidRepeatableCommitLock = new AvoidRepeatableCommitLock(stringRedisTemplate);
    }

    @Autowired
    private HttpServletRequest request;

    @Around("execution(public * com.app.sns.controller..*.*(..))")
    public Object process(ProceedingJoinPoint joinPoint) throws Throwable {
        Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
        AvoidRepeatableCommit avoidRepeatableCommitAnnotation = method.getAnnotation(AvoidRepeatableCommit.class);
        //如果注解为空,则不需要校验重复提交
        if (avoidRepeatableCommitAnnotation == null) {
            return joinPoint.proceed();
        }
        //按key从小到大,对参数进行排序,目的是确保统一请求的内容加密结果一致
        Map<String, String[]> requestParams = request.getParameterMap();
        String body = requestParams.get("body")[0];
        //按key从小到大,对参数body进行排序
        TreeMap treeMap = JSONObject.parseObject(body, TreeMap.class);
        body = JSONObject.toJSONString(treeMap);
        requestParams.put("body", new String[]{body});

        String lockName = MapUtil.getRedisKeyByParam(requestParams);
        logger.info("lockName ->" + lockName);
        long start = System.currentTimeMillis();
        //获取锁
        String identifier = avoidRepeatableCommitLock.acquireLock(lockName);
        //锁标识为空,则表示锁已存在,当前请求是重复提交
        if (identifier == null) {
            IBaseResp resp = new IBaseResp();
            return BaseRespUtils.buildFailed(resp, ErrorType.FAILED.getErrorCode(), "您操作太频繁啦");
        }
        logger.info("acquireLock time -> " + (System.currentTimeMillis() - start));
        try {
            return joinPoint.proceed();
        } finally {
            //释放锁
            boolean flag = avoidRepeatableCommitLock.releaseLock(lockName, identifier);
            logger.info("releaseLock flag ->" + flag);
        }
    }
}

防重复提交锁类

/**
 * Redis防重复提交锁
 *
 * @Author huanglian
 * @Date 2019-01-24-上午9:50
 */
public class AvoidRepeatableCommitLock {
    private static Logger logger = LoggerFactory.getLogger(AvoidRepeatableCommitLock.class);

    private final long lockTimeout = 3000;

    private StringRedisTemplate redisTemplate;

    public AvoidRepeatableCommitLock(StringRedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    public String acquireLock(final String lockName) {
        return acquireLock(lockName, lockTimeout);
    }

    public String acquireLock(final String lockName, final long lockTimeout) {
        //保证释放锁的时候是同一个持有锁的人
        final String identifier = UUID.randomUUID().toString();
        final int lockExpire = (int) (lockTimeout / 1000);
        final String lockKey = "lock:" + lockName;
        final String lua = "if redis.call(\"setnx\",KEYS[1], ARGV[1])==1 then " +
                "redis.call(\"expire\",KEYS[1], ARGV[2]) " +
                "return 1 " +
                "else return 0 end";

        Long rs = redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                Object nativeConnection = redisConnection.getNativeConnection();
                Long result = 0L;
                List<String> keys = new ArrayList<>();
                keys.add(lockKey);
                List<String> values = new ArrayList<>();
                values.add(identifier);
                values.add(lockExpire + "");
                // 集群模式
                if (nativeConnection instanceof JedisCluster) {
                    result = (Long) ((JedisCluster) nativeConnection).eval(lua, keys, values);
                }
                // 单机模式
                if (nativeConnection instanceof Jedis) {
                    result = (Long) ((Jedis) nativeConnection).eval(lua, keys, values);
                }
                return result;
            }
        });
        return rs == 1 ? identifier : null;
    }

    public boolean releaseLock(final String lockName, final String identifier) {
        logger.info(lockName + "开始释放锁:" + identifier);
        final String lockKey = "lock:" + lockName;
        final String lua = "if redis.call(\"get\",KEYS[1])==ARGV[1] then " +
                "return redis.call(\"del\",KEYS[1]) " +
                "else return 0 end";

        Long rs = redisTemplate.execute(new RedisCallback<Long>() {
            @Override
            public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                Object nativeConnection = redisConnection.getNativeConnection();
                Long result = 0L;
                List<String> keys = new ArrayList<>();
                keys.add(lockKey);
                List<String> values = new ArrayList<>();
                values.add(identifier);
                // 集群模式
                if (nativeConnection instanceof JedisCluster) {
                    result = (Long) ((JedisCluster) nativeConnection).eval(lua, keys, values);
                }
                // 单机模式
                if (nativeConnection instanceof Jedis) {
                    result = (Long) ((Jedis) nativeConnection).eval(lua, keys, values);
                }
                return result;
            }
        });
        return rs.intValue() > 0;
    }

}

Controller类

/**
 * @Author huanglian
 * @Date 2019-01-24-上午11:38
 */
@Controller
@RequestMapping(value = "/lock/")
public class LockController {

    @AvoidRepeatableCommit
    @RequestMapping(value = "/test", method = RequestMethod.POST)
    @ResponseBody
    public IBaseResp lock() throws InterruptedException {
        Thread.sleep(1000);
        return BaseRespUtils.buildSuccess(new IBaseResp());
    }
}

相关文章

  • 防重复提交设计方案

    场景描述 大型互联网项目中,由于业务特点(例如秒杀)同一时间很多的人在使用,用户连续快速点击,而且前端没有针对性处...

  • SpringMVC后台token防重复提交解决方案

    SpringMVC后台token防重复提交解决方案 本文介绍如何使用token来防止前端重复提交的问题。 目录 1...

  • web 防重复提交实现

    通过注解方式,在aop中判断是否重复提交。整个流程如下。 注解 AOP 内处理业务 这样如果是2秒内 同一个 ur...

  • SpringBoot项目防重复提交

    前言 表单提交是web项目的基础功能,用户点击提交/保存按钮后,即会将提交的数据保存到服务端,使服务端对应的数据发...

  • Spring MVC表单防重复提交

    ​ 利用Spring MVC的过滤器及token传递验证来实现表单防重复提交。 创建注解 @Target(Elem...

  • Spring MVC表单防重复提交

    利用Spring MVC的过滤器及token传递验证来实现表单防重复提交。 创建注解 @Target(Elemen...

  • 通过Redis 实现防重复提交

    简介 同一条数据被用户点击了多次,导致数据冗余,需要防止弱网络等环境下的重复点击,通过在指定的接口处添加注解,实现...

  • 防止表单重复提交(一)

    声明:此文章写于17年7月,并不够详细和完善,最新应用代码见文章 防表单重复提交(二) 一、表单重复提交的三种情形...

  • 2021-03-30_Redission之接口防重复提交

    20210330_Redission之接口防重复提交 1概述 本节主要是基于redis + lua+token机制...

  • 防抖、节流

    防抖:连续重复发生的动作 提交最后一次 提交第一次 节流: 一定时间内执行一次

网友评论

      本文标题:防重复提交设计方案

      本文链接:https://www.haomeiwen.com/subject/hmvqsqtx.html