Spring Boot集成Redisson详细介绍_redisson springboot

Redisson是一个用于Java的分布式和高可用的Java对象的框架，它基于Redis实现。在Spring Boot应用程序中集成Redisson可以帮助我们更轻松地实现分布式锁、分布式对象、分布式集合等功能。本文将介绍如何在Spring Boot项目中集成Redisson，并展示一些基本用法。

添加依赖

在Spring Boot项目中，打开pom.xml文件并添加以下Redisson的Maven依赖：

<!-- redisson -->
<dependency>
  <groupId>org.redisson</groupId>
  <artifactId>redisson</artifactId>
  <version>3.25.2</version>
</dependency>
1
2
3
4
5
6

添加配置文件

在application.yml文件中添加Redisson的配置信息：

spring:
  redisson:
    #  单机模式
    host: 192.168.10.106
    port: 6379
    # 哨兵模式
    sentinel:
      master: mymaster
      nodes: 192.168.10.106:6209,192.168.10.106:6219,192.168.10.106:6229
    # 集群模式
    cluster: 192.168.10.106:6109,192.168.10.106:6119,192.168.10.106:6129
    # 密码
    password: xj2022
1
2
3
4
5
6
7
8
9
10
11
12
13

注意： 我们如果只有一个redis客户端的话我们在此处只需要配置一种模式，别的配置信息留空即可，我们会通过配置类优先找 哨兵配置，没有的话再找cluster集群配置，没有的话再找单机配置。

添加配置类

在代码中添加配置类RedissonConfig：

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.client.codec.StringCodec;
import org.redisson.config.Config;
import org.redisson.config.ReadMode;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration
@Slf4j
public class RedissonConfig {


    @Value("${spring.redisson.sentinel.nodes}")
    private  String sentinel;
    @Value("${spring.redisson.sentinel.master}")
    private String masterName;

    @Value("${spring.redisson.cluster}")
    private  String cluster;

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

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

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




    private int timeout = 2000;
    private int scanInterval = 60000;
    private static String ADDRESS_PREFIX = "redis://";

    /**
     * 单机模式
     */
    @Bean
    public RedissonClient initBean() {
        // 哨兵模式
        if (StringUtils.isNotBlank(sentinel)) {
            log.info("redis is sentinel mode");
            return redissonSentinel();
        }
        // 集群模式
        if (StringUtils.isNotBlank(cluster)) {
            log.info("redis is cluster mode");
            return redissonCluster();
        }
        // 单机模式
        if (StringUtils.isNotBlank(host)) {
            log.info("redis is single mode");
            return redissonSingle();
        }

        log.error("redisson config can not support this redis mode");
        return null;
    }

    /**
     * 单机模式
     */
    private RedissonClient redissonSingle() {
        Config config = new Config();
        String address = ADDRESS_PREFIX+host+":"+port;
        //设置
        config.setCodec(new StringCodec())
                //这是用的集群server
                .useSingleServer()
                .setAddress(address)
                .setTimeout(timeout)
                .setPassword(password);
        return Redisson.create(config);
    }


    /**
     * 哨兵模式
     */
    private RedissonClient redissonSentinel() {

        String[] nodes = sentinel.split(",");
        //redisson版本是3.5，集群的ip前面要加上“redis://”，不然会报错，3.2版本可不加
        for(int i=0;i<nodes.length;i++){
            nodes[i] = ADDRESS_PREFIX+nodes[i];
        }
        Config config = new Config();
        //设置
        config.setCodec(new StringCodec())
                .useSentinelServers()
                .setMasterName(masterName)
                .setPassword(password)
                .setTimeout(timeout)
                .addSentinelAddress(nodes)
                // 在Redisson启动期间启用sentinels列表检查,默认为true,这里我们设置为false,不检查
                .setCheckSentinelsList(false);
        return Redisson.create(config);
    }

    /**
     * 集群模式
     */
    private RedissonClient redissonCluster() {
        String[] nodes = cluster.split(",");
        //redisson版本是3.5，集群的ip前面要加上“redis://”，不然会报错，3.2版本可不加
        for(int i=0;i<nodes.length;i++){
            nodes[i] = ADDRESS_PREFIX+nodes[i];
        }
        Config config = new Config();
        //设置
        config.setCodec(new StringCodec())
                //这是用的集群server
                .useClusterServers()
                //设置集群状态扫描时间
                .setScanInterval(scanInterval)
                .addNodeAddress(nodes)
                .setPassword(password)
                .setReadMode(ReadMode.MASTER);;
        return Redisson.create(config);
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

这样，我们就配置好了redisson,我们可以在代码中使用了。

示例：分布式锁

以下是一个使用redisson 分布式锁的示例代码

import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
@Slf4j
public class RedissonTestService {


    @Resource
    private RedissonClient redissonClient;

    //锁过期时间
    private static final Long LOCK_KEY_TIME = 120L;

    public void doJobTask() {
        //定时任务执行周期较短，为防止数据重复修改，加入锁
        RLock lock = redissonClient.getLock("your_task_name");
        // 尝试获取锁并设定锁的过期时间
        boolean acquired = false;
        try {
            //获取锁
            acquired = lock.tryLock(0, LOCK_KEY_TIME, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            log.error("取锁失败");
        }
        if (acquired) {
            try {
                // 执行业务逻辑

            }catch (Exception e) {
                log.error("处理失败");
                //业务异常处理逻辑

            }finally {
                // 释放锁
                lock.unlock();
            }

        } else {
            // 获取锁失败，说明有其他线程或进程正在处理数据
            // 可以进行重试或触发告警机制
            
        }
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

这只是一个简单的示例，你可以根据需要使用更高级的Redisson功能。

总结

通过集成Redisson，我们可以轻松地实现分布式系统中的各种功能，提高应用程序的可伸缩性和可靠性。我们在生产环境会经常有跨机房使用承载网连接redis的情况，我们后续会在写一篇关于redisson实现承载网转换源码改造的文章。希望本文能够帮助你快速入门Spring Boot集成Redisson，并在实际项目中应用这些功能。