SpringBoot整合Redis正确的实现分布式锁的示例代码

 <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
 </dependency>

spring.redis.host=xxx
spring.redis.port=6379
spring.redis.database=0
spring.redis.password=xxx
spring.redis.timeout=10000

# 设置jedis连接池
spring.redis.jedis.pool.max-active=50
spring.redis.jedis.pool.min-idle=20

/**
 * @author Chkl
 * @create 2020/6/7
 * @since 1.0.0
 */
@Component
public class RedisConfig {
  /**
   * 改造RedisTemplate，重写序列化规则，避免存入序列化内容看不懂
   * @param connectionFactory
   * @return
   */
  @Bean
  public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
    RedisTemplate redisTemplate = new RedisTemplate();
    redisTemplate.setConnectionFactory(connectionFactory);
    // 设置key和value的序列化规则
    redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer(Object.class));
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    return redisTemplate;
  }
}

@Component
public class RedisLock {

  @Autowired
  private StringRedisTemplate redisTemplate;

  private long timeout = 3000;

  /**
   * 上锁
   * @param key 锁标识
   * @param value 线程标识
   * @return 上锁状态
   */
  public boolean lock(String key, String value) {
    long start = System.currentTimeMillis();
    while (true) {
      //检测是否超时
      if (System.currentTimeMillis() - start > timeout) {
        return false;
      }
      //执行set命令
      Boolean absent = redisTemplate.opsForValue().setIfAbsent(key, value, timeout, TimeUnit.MILLISECONDS);//1
      //是否成功获取锁
      if (absent) {
        return true;
      }
      return false;
    }
  }
}

Boolean absent = redisTemplate.opsForValue().setIfAbsent(key, value, timeout, TimeUnit.MILLISECONDS);

@Component
public class RedisLock {
  @Autowired
  private StringRedisTemplate redisTemplate;

  @Autowired
  private DefaultRedisScript<Long> redisScript;

  private static final Long RELEASE_SUCCESS = 1L;


  /**
   * 解锁
   * @param key 锁标识
   * @param value 线程标识
   * @return 解锁状态
   */
  public boolean unlock(String key, String value) {
    //使用Lua脚本：先判断是否是自己设置的锁，再执行删除
    Long result = redisTemplate.execute(redisScript, Arrays.asList(key,value));
    //返回最终结果
    return RELEASE_SUCCESS.equals(result);
  }


  /**
   * @return lua脚本
   */
  @Bean
  public DefaultRedisScript<Long> defaultRedisScript() {
    DefaultRedisScript<Long> defaultRedisScript = new DefaultRedisScript<>();
    defaultRedisScript.setResultType(Long.class);
    defaultRedisScript.setScriptText("if redis.call('get', KEYS[1]) == KEYS[2] then return redis.call('del', KEYS[1]) else return 0 end");
    return defaultRedisScript;
  }
}

	/**
   * 保存文件分块编号到redis
   * @param chunkNumber 分块号
   * @param identifier 文件唯一编号
   * @return 文件分块的大小
   */
  @Override
  public Integer saveChunk(Integer chunkNumber, String identifier) {
  	//从Redis获取已经存在的分块编号集合
    Set<Integer> oldChunkNumber = (Set<Integer>) JSON.parseObject(redisOperator.get("chunkNumberList_"+identifier),Set.class);
    //如果不存在分块集合，创建一个集合
    if (Objects.isNull(oldChunkNumber)) {
      Set<Integer> newChunkNumber = new HashSet<>();
      newChunkNumber.add(chunkNumber);
      redisOperator.set("chunkNumberList_"+identifier, JSON.toJSONString(newChunkNumber),36000);
      return newChunkNumber.size();
     //如果分块集合已经存在了，就添加一个编号
    } else {
      oldChunkNumber.add(chunkNumber);
      redisOperator.set("chunkNumberList_"+identifier, JSON.toJSONString(oldChunkNumber),36000);
      return oldChunkNumber.size();
    }
  }

/**
   * 保存文件分块编号到redis
   * @param chunkNumber 分块号
   * @param identifier 文件唯一编号
   * @return 文件分块的大小
   */
  @Override
  public Integer saveChunk(Integer chunkNumber, String identifier) {
  	//通过UUID生成一个请求线程识别标志作为锁的value
    String threadUUID = CoreUtil.getUUID();
    //上锁，以共享资源标识:文件唯一编号,作为key，以线程标识UUID作为value
    redisLock.lock(identifier,threadUUID);
    //从Redis获取已经存在的分块编号集合
    Set<Integer> oldChunkNumber = (Set<Integer>) JSON.parseObject(redisOperator.get("chunkNumberList_"+identifier),Set.class);
    //如果不存在分块集合，创建一个集合
    if (Objects.isNull(oldChunkNumber)) {
      Set<Integer> newChunkNumber = new HashSet<>();
      newChunkNumber.add(chunkNumber);
      redisOperator.set("chunkNumberList_"+identifier, JSON.toJSONString(newChunkNumber),36000);
      //解锁
      redisLock.unlock(identifier,threadUUID);
      return newChunkNumber.size();
     //如果分块集合已经存在了，就添加一个编号
    } else {
      oldChunkNumber.add(chunkNumber);
      redisOperator.set("chunkNumberList_"+identifier, JSON.toJSONString(oldChunkNumber),36000);
      //解锁
      redisLock.unlock(identifier,threadUUID);
      return oldChunkNumber.size();
    }
  }