基于Redis分布式鎖Redisson及SpringBoot集成Redisson

更新時間：2022年09月23日 10:06:00 作者：_燈火闌珊處

這篇文章主要介紹了基于Redis分布式鎖Redisson及SpringBoot集成Redisson，文章圍繞主題展開詳細的內容介紹，具有一定的參考價值，需要的小小伙伴可以參考一下

- 分布式鎖需要具備的條件和剛需

獨占性：OnlyOne，任何時刻只能有且僅有一個線程持有
高可用：若redis集群環(huán)境下，不能因為某一個節(jié)點掛了而出現(xiàn)獲取鎖和釋放鎖失敗的情況
防死鎖：杜絕死鎖，必須有超時控制機制或者撤銷操作，有個兜底終止跳出方案
不亂搶：防止張冠李戴，不能私下unlock別人的鎖，只能自己加鎖自己釋放
重入性：同一個節(jié)點的同一個線程如果獲得鎖之后，它也可以再次獲取這個鎖

- Redisson使用

引入 redisson 依賴：

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.16.2</version>
</dependency>

添加 redisson 配置：

import org.redisson.Redisson;
import org.redisson.config.Config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.io.Serializable;

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Serializable> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
        RedisTemplate<String, Serializable> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(lettuceConnectionFactory);
        // 設置key序列號方式string
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        // 設置value的序列化方式json
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
    @Bean
    public Redisson redisson() {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://192.168.10.233:6379").setDatabase(0);
        return (Redisson) Redisson.create(config);
    }

}

接口測試：

import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Autowired
    private Redisson redisson;

    private static final String KEY = "spike";

    @GetMapping("/buy")
    public String bugGood() {
        RLock redissonLock = redisson.getLock(KEY);
        redissonLock.lock();
        try {
            String result = stringRedisTemplate.opsForValue().get("goods:001");
            int goodNumber = result == null ? 0 : Integer.parseInt(result);
            if (goodNumber > 0) {
                int realNum = goodNumber - 1;
                stringRedisTemplate.opsForValue().set("goods:001", realNum + "");
                return "秒殺成功，剩余庫存：" + realNum;
            }
            return "商品已售罄！";
        } finally {
            redissonLock.unlock();
        }
    }

}

多節(jié)點的情況下，代碼相同，要保證 lock 的 key 一樣

- SpringBoot集成Redisson

引入 redis 和 redisson starter：

<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/org.redisson/redisson -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
</dependency>

redis 配置：

spring:
  redis:
    # 地址
    host: 192.168.20.26
    # 端口，默認為6379
    port: 6379
    password: 123456
    # 連接超時時間
    timeout: 30s
    database: 0
    lettuce:
      pool:
        # 連接池中的最小空閑連接
        min-idle: 0
        # 連接池中的最大空閑連接
        max-idle: 8
        # 連接池的最大數(shù)據(jù)庫連接數(shù)
        max-active: 8
        # #連接池最大阻塞等待時間（使用負值表示沒有限制）
        max-wait: -1ms

redisson配置：

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.config.SingleServerConfig;
import org.redisson.config.TransportMode;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * redisson配置
 */
@Configuration
public class RedissonConfig {

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

    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.setTransportMode(TransportMode.NIO);
        // 單體配置，如果是SSL連接，使用 rediss://
        SingleServerConfig singleServerConfig = config.useSingleServer();
        singleServerConfig.setAddress("redis://" + host + ":" + port);
        singleServerConfig.setPassword(password);
        return Redisson.create(config);
    }
}

使用：

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;
public class TestController {

    @Resource
    private RedissonClient redissonClient;

    public void doAction1() {
        String lockKey = "lockKey";
        RLock lock = redissonClient.getLock(lockKey);
        // 加鎖，無參數(shù)
        lock.lock();
        // 鎖有效時間，時間單位
        // lock.lock(5, TimeUnit.SECONDS);
        try {
            // do something
        } finally {
            // 解鎖
            lock.unlock();
        }
    }
    public void doAction2() throws InterruptedException {
        String lockKey = "lockKey";
        RLock lock = redissonClient.getLock(lockKey);
        // 1. 無參數(shù)，直接上鎖
        // lock.tryLock();
        // 2. 等待時間，時間單位
        // lock.tryLock(3, TimeUnit.SECONDS);
        // 3. 等待時間，鎖有效時間，時間單位
        // lock.tryLock(3, 5, TimeUnit.SECONDS);
        try {
            // 常規(guī)寫法
            if (lock.tryLock(3, 5, TimeUnit.SECONDS)) {
                // do something
            } else {
                // 沒有獲取到鎖
            }
        } finally {
            // 解鎖
            lock.unlock();
        }
    }

}

到此這篇關于基于Redis分布式鎖Redisson及SpringBoot集成Redisson的文章就介紹到這了,更多相關Redis分布式鎖內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: