SpringBoot 2.X 整合redisson 创建分布式锁

引入Maven依赖

 <!-- https://mvnrepository.com/artifact/org.redisson/redisson -->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.13.2</version>
        </dependency>

---

增加application.yaml配置

spring:
    redis:
      database: 1
      host: localhost
      port: 6709
      password:*****

---

增加redis配置文件

 import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @program: devicedataporocessor
 * @description: redis设置
 * @author: linwl
 * @create: 2020-07-01 11:05
 */
@Configuration
@Slf4j
public class RedisConfig {

  @Value("${spring.redis.host}")
  private String host;

  @Value("${spring.redis.port}")
  private String port;

  @Value("${spring.redis.password}")
  private String password;

  @Value("${spring.redis.database}")
  private int database;

  @Bean
  public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
    RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
    redisTemplate.setConnectionFactory(connectionFactory);

    // 使用Jackson2JsonRedisSerialize替换默认序列化
    Jackson2JsonRedisSerializer jackson2JsonRedisSerializer =
        new Jackson2JsonRedisSerializer(Object.class);

    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    //    objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

    jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

    // 设置key和value的序列化规则
    redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    // value hashmap序列化
    redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
    // key haspmap序列化
    redisTemplate.setHashKeySerializer(new StringRedisSerializer());
    redisTemplate.afterPropertiesSet();

    return redisTemplate;
  }

  @Bean
  public RedissonClient getRedisson() {
    Config config = new Config();
    String url = "redis://" + host + ":" + port;
    config.useSingleServer().setAddress(url).setPassword(password).setDatabase(database);
    // 添加主从配置
    //
    // config.useMasterSlaveServers().setMasterAddress("").setPassword("").addSlaveAddress(new
    // String[]{"",""});
    return Redisson.create(config);
  }
}

---

创建DistributedRedisLock类来方便使用分布式锁

 mport lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

/**
 * @program: devicedataporocessor
 * @description: 分布式锁工具类
 * @author: linwl
 * @create: 2020-07-16 16:55
 */
@Slf4j
@Component
public class DistributedRedisLock {

  @Autowired private RedissonClient redissonClient;

  /**
   * 获取分布式锁
   *
   * @param lockName
   * @return
   */
  public Boolean lock(String lockName) {
    try {
      if (redissonClient == null) {
        log.info("DistributedRedisLock redissonClient is null");
        return false;
      }

      RLock lock = redissonClient.getLock(lockName);
      // 锁10秒后自动释放，防止死锁
      lock.lock(10, TimeUnit.SECONDS);

      log.info(
          "Thread [{}] DistributedRedisLock lock [{}] success",
          Thread.currentThread().getName(),
          lockName);
      // 加锁成功
      return true;
    } catch (Exception e) {
      log.error("DistributedRedisLock lock [{}] Exception:", lockName, e);
      return false;
    }
  }

  /**
   * 释放分布式锁
   *
   * @param lockName
   * @return
   */
  public Boolean unlock(String lockName) {
    try {
      if (redissonClient == null) {
        log.info("DistributedRedisLock redissonClient is null");
        return false;
      }

      RLock lock = redissonClient.getLock(lockName);
      lock.unlock();
      log.info(
          "Thread [{}] DistributedRedisLock unlock [{}] success",
          Thread.currentThread().getName(),
          lockName);
      // 释放锁成功
      return true;
    } catch (Exception e) {
      log.error("DistributedRedisLock unlock [{}] Exception:", lockName, e);
      return false;
    }
  }
}

---

使用方法

 @Autowired private DistributedRedisLock redisLock;
 if(redisLock.lock(lockName))
 {
 try{
  //TODO:编写你的业务
 }
 finally{
  redisLock.unlock(lockName);
  }
 }