分布式锁实例教程之防止重复提交

/**
 * 用户注册请求
 * @param userDto
 * @param bindingResult
 * @return
 */
@RequestMapping(value=prefix+"/db/register",method = RequestMethod.POST,consumes = MediaType.APPLICATION_JSON_UTF8_VALUE)
public BaseResponse register(@RequestBody @Validated UserDto userDto, BindingResult bindingResult){
    BaseResponse response=new BaseResponse(StatusCode.Success);
    try {
        log.debug("注册信息： {} ",userDto);
        //注册之前，我们先判断是否已经注册了。（正常逻辑）
        User user=userService.selectByUserName(userDto.getUserName());
        if (user!=null){
            return new BaseResponse(StatusCode.UserNameExist);
        }
        userService.register(userDto);
    }catch (Exception e){
        e.printStackTrace();
        response=new BaseResponse(StatusCode.Fail);
    }
    return response;
}

/**
 * 用户注册——最普通的操作，没有任何加锁，没有任何防止重复提交
 *
 * @param userDto
 * @return
 * @throws Exception
 */
public int register(UserDto userDto) throws Exception {
    int result = 0;
    User user = new User();
    BeanUtils.copyProperties(userDto, user);
    result = userMapper.insertSelective(user);
    return result;
}

/**
 * 用户注册，基于redisson的分布式锁
 *
 * @param userDto
 * @return
 */
public int registerLockRedisson(UserDto userDto) {
    int result = 0;
    RLock rLock = redissonLockComponent.acquireLock(userDto.getUserName());
    try {
        if (rLock != null) {
            User user = new User();
            BeanUtils.copyProperties(userDto, user);
            user.setCreateTime(new Date());
            userMapper.insertSelective(user);
        }
    } catch (Exception e) {
        log.error("获取redisson分布式锁异常");
    } finally {
        if (rLock != null) {
            redissonLockComponent.releaseLock(rLock);
        }
    }
    return result;
}

/**
 * 用户注册，redisson分布式锁，redis防止重复提交
 *
 * @param userDto
 * @return
 */
public int registerLockAvoidDupPost(UserDto userDto) {
    int result = 0;
    RLock rLock = redissonLockComponent.acquireLock(userDto.getUserName());
    try {
        //redis中根据用户名存储作为key值
        String key = lockKeyPrefix+userDto.getUserName();
        if (!stringRedisTemplate.hasKey(key)) {//如果不存在key则进入注册阶段
            stringRedisTemplate.opsForValue().set(key,UUID.randomUUID().toString(),10L,TimeUnit.SECONDS);
            User user = new User();
            BeanUtils.copyProperties(userDto, user);
            user.setCreateTime(new Date());
            userMapper.insertSelective(user);
            log.info("{},注册成功",userDto.getUserName());
        }else{//如果存在，则提示不可重复提交
            log.error("10秒内，请勿重复提交注册信息");
        }
    } catch (Exception e) {
        log.error("获取redisson分布式锁异常");
    } finally {
        if (rLock != null) {
            redissonLockComponent.releaseLock(rLock);
        }
    }
    return result;
}

/**
 * 用户注册，redisson分布式锁，redis防止重复提交
 *
 * @param userDto
 * @return
 */
public int registerLockAvoidDupPost(UserDto userDto) {
    int result = 0;

    InterProcessMutex mutex=new InterProcessMutex(client,zkPrefix+userDto.getUserName()+"-lock");
    try {
        if (mutex.acquire(10L, TimeUnit.SECONDS)){

            final String realKey=zkRedisKeyPrefix+userDto.getUserName();
            if (!stringRedisTemplate.hasKey(realKey)){
                stringRedisTemplate.opsForValue().set(realKey, UUID.randomUUID().toString());

                User user=new User();
                BeanUtils.copyProperties(userDto,user);
                user.setCreateTime(new Date());
                userMapper.insertSelective(user);
				log.info("{},注册成功",userDto.getUserName());
            }else{
                log.error("10秒内，请勿重复提交注册信息");
            }

        }else{
            throw new RuntimeException("获取zk分布式锁失败!");
        }
    }catch (Exception e){
        e.printStackTrace();
        throw e;
    }finally {
        mutex.release();
    }
    return result;
}