docker-compose 部署redis集群模式

curise666

354人浏览 · 2025-08-10 16:27:26

curise666 · 2025-08-10 16:27:26 发布

docker-compose 部署redis集群模式

前言
1.编写docker-compose.yml文件
2.配置redis.conf
3.启动+检查
4.java集成redisson

前言

[root@centos10-1 redis]# tree
.
├── docker-compose.yml
└── redis-cluster
    ├── redis-node-0
    │   ├── data
    │   │   ├── appendonlydir
    │   │   │   ├── appendonly.aof.1.base.rdb
    │   │   │   ├── appendonly.aof.1.incr.aof
    │   │   │   └── appendonly.aof.manifest
    │   │   ├── dump.rdb
    │   │   └── nodes.conf
    │   └── redis.conf
    ├── redis-node-1
    │   ├── data
    │   │   ├── appendonlydir
    │   │   │   ├── appendonly.aof.1.base.rdb
    │   │   │   ├── appendonly.aof.1.incr.aof
    │   │   │   └── appendonly.aof.manifest
    │   │   ├── dump.rdb
    │   │   └── nodes.conf
    │   └── redis.conf
    ├── redis-node-2
    │   ├── data
    │   │   ├── appendonlydir
    │   │   │   ├── appendonly.aof.1.base.rdb
    │   │   │   ├── appendonly.aof.1.incr.aof
    │   │   │   └── appendonly.aof.manifest
    │   │   ├── dump.rdb
    │   │   └── nodes.conf
    │   └── redis.conf
    ├── redis-node-3
    │   ├── data
    │   │   ├── appendonlydir
    │   │   │   ├── appendonly.aof.2.base.rdb
    │   │   │   ├── appendonly.aof.2.incr.aof
    │   │   │   └── appendonly.aof.manifest
    │   │   ├── dump.rdb
    │   │   └── nodes.conf
    │   └── redis.conf
    ├── redis-node-4
    │   ├── data
    │   │   ├── appendonlydir
    │   │   │   ├── appendonly.aof.2.base.rdb
    │   │   │   ├── appendonly.aof.2.incr.aof
    │   │   │   └── appendonly.aof.manifest
    │   │   ├── dump.rdb
    │   │   └── nodes.conf
    │   └── redis.conf
    └── redis-node-5
        ├── data
        │   ├── appendonlydir
        │   │   ├── appendonly.aof.2.base.rdb
        │   │   ├── appendonly.aof.2.incr.aof
        │   │   └── appendonly.aof.manifest
        │   ├── dump.rdb
        │   └── nodes.conf
        └── redis.conf

如上是redis目录结构,data只需要创建文件夹即可

1.编写docker-compose.yml文件

version: '3.8'

services:

  redis-node-0:
    image: redis:7.0
    container_name: redis-node-0
    ports:
      - "6379:6379"
      - "16379:16379"
    volumes:
      - ./redis-cluster/redis-node-0/data:/data
      - ./redis-cluster/redis-node-0/redis.conf:/usr/local/etc/redis/redis.conf
    command: redis-server /usr/local/etc/redis/redis.conf
    networks:
      - redis-cluster-net

  redis-node-1:
    image: redis:7.0
    container_name: redis-node-1
    ports:
      - "6380:6379"
      - "16380:16379"
    volumes:
      - ./redis-cluster/redis-node-1/data:/data
      - ./redis-cluster/redis-node-1/redis.conf:/usr/local/etc/redis/redis.conf
    command: redis-server /usr/local/etc/redis/redis.conf
    networks:
      - redis-cluster-net

  redis-node-2:
    image: redis:7.0
    container_name: redis-node-2
    ports:
      - "6381:6379"
      - "16381:16379"
    volumes:
      - ./redis-cluster/redis-node-2/data:/data
      - ./redis-cluster/redis-node-2/redis.conf:/usr/local/etc/redis/redis.conf
    command: redis-server /usr/local/etc/redis/redis.conf
    networks:
      - redis-cluster-net

  redis-node-3:
    image: redis:7.0
    container_name: redis-node-3
    ports:
      - "6382:6379"
      - "16382:16379"
    volumes:
      - ./redis-cluster/redis-node-3/data:/data
      - ./redis-cluster/redis-node-3/redis.conf:/usr/local/etc/redis/redis.conf
    command: redis-server /usr/local/etc/redis/redis.conf
    networks:
      - redis-cluster-net

  redis-node-4:
    image: redis:7.0
    container_name: redis-node-4
    ports:
      - "6383:6379"
      - "16383:16379"
    volumes:
      - ./redis-cluster/redis-node-4/data:/data
      - ./redis-cluster/redis-node-4/redis.conf:/usr/local/etc/redis/redis.conf
    command: redis-server /usr/local/etc/redis/redis.conf
    networks:
      - redis-cluster-net

  redis-node-5:
    image: redis:7.0
    container_name: redis-node-5
    ports:
      - "6384:6379"
      - "16384:16379"
    volumes:
      - ./redis-cluster/redis-node-5/data:/data
      - ./redis-cluster/redis-node-5/redis.conf:/usr/local/etc/redis/redis.conf
    command: redis-server /usr/local/etc/redis/redis.conf
    networks:
      - redis-cluster-net

  redis-cluster-init:
    image: redis:7.0
    container_name: redis-cluster-init
    depends_on:
      - redis-node-0
      - redis-node-1
      - redis-node-2
      - redis-node-3
      - redis-node-4
      - redis-node-5
    entrypoint: ["/bin/sh", "-c", "until redis-cli -h redis-node-0 -p 6379 ping; do sleep 1; done; until redis-cli -h redis-node-1 -p 6379 ping; do sleep 1; done; until redis-cli -h redis-node-2 -p 6379 ping; do sleep 1; done; until redis-cli -h redis-node-3 -p 6379 ping; do sleep 1; done; until redis-cli -h redis-node-4 -p 6379 ping; do sleep 1; done; until redis-cli -h redis-node-5 -p 6379 ping; do sleep 1; done; redis-cli --cluster create redis-node-0:6379 redis-node-1:6379 redis-node-2:6379 redis-node-3:6379 redis-node-4:6379 redis-node-5:6379 --cluster-replicas 1 --cluster-yes"]

    networks:
      - redis-cluster-net

networks:
  redis-cluster-net:
    driver: bridge

一共部署了6台,3主3从

2.配置redis.conf

# 基础配置
port 6379
bind 0.0.0.0
daemonize no
protected-mode no
appendonly yes
dir /data

# 集群配置
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 192.168.137.101
cluster-announce-port 6379
cluster-announce-bus-port 16379

# 性能调优
tcp-keepalive 300
timeout 0

此处注意,每台机器的配置保持一样即可

3.启动+检查

启动redis
docker compose up -d
检查redis是否启动成功
docker ps -a
redis-cluster-init在启动时会去初始化其他节点,全部节点启动成功后会退出
进入其中一个节点进行测试
docker exec -it redis-node-0 /bin/bash
连接redis
redis-cli
可依次检查其他redis是否也启动成功

4.java集成redisson

1.导入依赖

        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
        </dependency>

2.配置文件appliction.yml

# Redisson 配置（Redis 客户端）
redisson:
  cluster:
    # Redis 集群节点配置
    nodes:
      - "redis://192.168.137.101:6379"  # 节点1
      - "redis://192.168.137.101:6380"  # 节点2
      - "redis://192.168.137.101:6381"  # 节点3
      - "redis://192.168.137.101:6382"  # 节点4
      - "redis://192.168.137.101:6383"  # 节点5
      - "redis://192.168.137.101:6384"  # 节点6
    scan-interval: 2000  # 集群扫描间隔（毫秒），用于检测节点状态变化
  threads: 8  # Redisson 内部工作线程数
  netty-threads: 16  # Netty 线程数

3.配置类

@Data
@Configuration
@ConfigurationProperties(prefix = "redisson")
public class RedissonProperties {

    private Cluster cluster = new Cluster();
    private int threads = 8;
    private int nettyThreads = 16;

    @Data
    public static class Cluster {
        private List<String> nodes;
        private int scanInterval = 2000;
    }
}

@Configuration
public class RedissonConfig {

    @Autowired
    private RedissonProperties redissonProperties;

    @Bean(destroyMethod = "shutdown")
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useClusterServers()
                .setScanInterval(redissonProperties.getCluster().getScanInterval())
                .addNodeAddress(redissonProperties.getCluster().getNodes().toArray(new String[0]))
                .setRetryAttempts(3)
                .setRetryInterval(1500)
                .setTimeout(3000)
                .setConnectTimeout(10000);

        config.setThreads(redissonProperties.getThreads())
                .setNettyThreads(redissonProperties.getNettyThreads())
                .setTransportMode(org.redisson.config.TransportMode.NIO);

        return Redisson.create(config);
    }
}

4.工具类

/**
 * Redisson工具类
 */
@Component
@SuppressWarnings("unused")
public class RedissonUtil {

    @Autowired
    private RedissonClient redissonClient;

    /**
     * 获取Redisson客户端
     *
     * @return RedissonClient
     */
    public RedissonClient getRedissonClient() {
        return redissonClient;
    }

    /**
     * 设置字符串值
     *
     * @param key   键
     * @param value 值
     */
    public void setString(String key, String value) {
        RBucket<String> bucket = redissonClient.getBucket(key);
        bucket.set(value);
    }

    /**
     * 设置字符串值并指定过期时间
     *
     * @param key     键
     * @param value   值
     * @param timeout 过期时间
     * @param unit    时间单位
     */
    public void setString(String key, String value, long timeout, TimeUnit unit) {
        RBucket<String> bucket = redissonClient.getBucket(key);
        bucket.set(value, timeout, unit);
    }

    /**
     * 获取字符串值
     *
     * @param key 键
     * @return 值
     */
    public String getString(String key) {
        RBucket<String> bucket = redissonClient.getBucket(key);
        return bucket.get();
    }

    /**
     * 删除键
     *
     * @param key 键
     * @return 是否删除成功
     */
    public boolean delete(String key) {
        return redissonClient.getBucket(key).delete();
    }

    /**
     * 判断键是否存在
     *
     * @param key 键
     * @return 是否存在
     */
    public boolean exists(String key) {
        return redissonClient.getBucket(key).isExists();
    }

    /**
     * 设置对象值
     *
     * @param key   键
     * @param value 对象值
     * @param <T>   对象类型
     */
    public <T> void setObject(String key, T value) {
        RBucket<T> bucket = redissonClient.getBucket(key);
        bucket.set(value);
    }

    /**
     * 设置对象值并指定过期时间
     *
     * @param key     键
     * @param value   对象值
     * @param timeout 过期时间
     * @param unit    时间单位
     * @param <T>     对象类型
     */
    public <T> void setObject(String key, T value, long timeout, TimeUnit unit) {
        RBucket<T> bucket = redissonClient.getBucket(key);
        bucket.set(value, timeout, unit);
    }

    /**
     * 获取对象值
     *
     * @param key 键
     * @param <T> 对象类型
     * @return 对象值
     */
    public <T> T getObject(String key, Class<T> clazz) {
        RBucket<T> bucket = redissonClient.getBucket(key);
        return bucket.get();
    }

    /**
     * 增加数字值
     *
     * @param key   键
     * @param delta 增加的值
     * @return 增加后的值
     */
    public long increment(String key, long delta) {
        RAtomicLong atomicLong = redissonClient.getAtomicLong(key);
        return atomicLong.addAndGet(delta);
    }

    /**
     * 减少数字值
     *
     * @param key   键
     * @param delta 减少的值
     * @return 减少后的值
     */
    public long decrement(String key, long delta) {
        RAtomicLong atomicLong = redissonClient.getAtomicLong(key);
        return atomicLong.addAndGet(-delta);
    }

    /**
     * 获取分布式锁
     *
     * @param key 锁的键
     * @return RLock对象
     */
    public RLock getLock(String key) {
        return redissonClient.getLock(key);
    }

    /**
     * 获取可重入锁并执行操作
     *
     * @param key      锁的键
     * @param timeout  锁超时时间
     * @param timeUnit 时间单位
     * @param action   要执行的操作
     * @return 是否执行成功
     */
    public boolean executeWithLock(String key, long timeout, TimeUnit timeUnit, Runnable action) {
        RLock lock = redissonClient.getLock(key);
        try {
            if (lock.tryLock(timeout, timeUnit)) {
                try {
                    action.run();
                    return true;
                } finally {
                    if (lock.isHeldByCurrentThread()) {
                        lock.unlock();
                    }
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return false;
    }

    /**
     * 获取公平锁
     *
     * @param key 锁的键
     * @return RFairLock对象
     */
    public RLock getFairLock(String key) {
        return redissonClient.getFairLock(key);
    }

    /**
     * 获取读写锁
     *
     * @param key 锁的键
     * @return RReadWriteLock对象
     */
    public RReadWriteLock getReadWriteLock(String key) {
        return redissonClient.getReadWriteLock(key);
    }

    /**
     * 获取信号量
     *
     * @param key 键
     * @return RSemaphore对象
     */
    public RSemaphore getSemaphore(String key) {
        return redissonClient.getSemaphore(key);
    }

    /**
     * 获取计数信号量
     *
     * @param key 键
     * @return RCountDownLatch对象
     */
    public RCountDownLatch getCountDownLatch(String key) {
        return redissonClient.getCountDownLatch(key);
    }

    /**
     * 向列表左侧添加元素
     *
     * @param key   键
     * @param value 值
     * @param <T>   元素类型
     */
    public <T> void listLeftPush(String key, T value) {
        RList<T> list = redissonClient.getList(key);
        list.add(0, value);
    }

    /**
     * 向列表右侧添加元素
     *
     * @param key   键
     * @param value 值
     * @param <T>   元素类型
     */
    public <T> void listRightPush(String key, T value) {
        RList<T> list = redissonClient.getList(key);
        list.add(value);
    }

    /**
     * 从列表左侧弹出元素
     *
     * @param key 键
     * @param <T> 元素类型
     * @return 元素值
     */
    public <T> T listLeftPop(String key) {
        RList<T> list = redissonClient.getList(key);
        return list.isEmpty() ? null : list.remove(0);
    }

    /**
     * 从列表右侧弹出元素
     *
     * @param key 键
     * @param <T> 元素类型
     * @return 元素值
     */
    public <T> T listRightPop(String key) {
        RList<T> list = redissonClient.getList(key);
        return list.isEmpty() ? null : list.remove(list.size() - 1);
    }

    /**
     * 获取列表大小
     *
     * @param key 键
     * @return 列表大小
     */
    public int listSize(String key) {
        RList<?> list = redissonClient.getList(key);
        return list.size();
    }

    /**
     * 向集合中添加元素
     *
     * @param key   键
     * @param value 值
     * @param <T>   元素类型
     */
    public <T> void setAdd(String key, T value) {
        RSet<T> set = redissonClient.getSet(key);
        set.add(value);
    }

    /**
     * 判断集合中是否包含元素
     *
     * @param key   键
     * @param value 值
     * @param <T>   元素类型
     * @return 是否包含
     */
    public <T> boolean setContains(String key, T value) {
        RSet<T> set = redissonClient.getSet(key);
        return set.contains(value);
    }

    /**
     * 从集合中移除元素
     *
     * @param key   键
     * @param value 值
     * @param <T>   元素类型
     * @return 是否移除成功
     */
    public <T> boolean setRemove(String key, T value) {
        RSet<T> set = redissonClient.getSet(key);
        return set.remove(value);
    }

    /**
     * 获取集合大小
     *
     * @param key 键
     * @return 集合大小
     */
    public int setSize(String key) {
        RSet<?> set = redissonClient.getSet(key);
        return set.size();
    }

    /**
     * 向哈希表中添加键值对
     *
     * @param key   哈希表键
     * @param field 字段
     * @param value 值
     * @param <V>   值类型
     */
    public <V> void hashPut(String key, String field, V value) {
        RMap<String, V> map = redissonClient.getMap(key);
        map.put(field, value);
    }

    /**
     * 从哈希表中获取值
     *
     * @param key   哈希表键
     * @param field 字段
     * @param <V>   值类型
     * @return 值
     */
    public <V> V hashGet(String key, String field) {
        RMap<String, V> map = redissonClient.getMap(key);
        return map.get(field);
    }

    /**
     * 判断哈希表中是否存在字段
     *
     * @param key   哈希表键
     * @param field 字段
     * @return 是否存在
     */
    public boolean hashExists(String key, String field) {
        RMap<String, ?> map = redissonClient.getMap(key);
        return map.containsKey(field);
    }

    /**
     * 从哈希表中删除字段
     *
     * @param key   哈希表键
     * @param field 字段
     * @return 是否删除成功
     */
    public boolean hashDelete(String key, String field) {
        RMap<String, ?> map = redissonClient.getMap(key);
        return map.remove(field) != null;
    }

    /**
     * 获取哈希表大小
     *
     * @param key 哈希表键
     * @return 哈希表大小
     */
    public int hashSize(String key) {
        RMap<String, ?> map = redissonClient.getMap(key);
        return map.size();
    }

    /**
     * 向有序集合中添加元素
     *
     * @param key   键
     * @param value 值
     * @param score 分数
     * @param <T>   元素类型
     */
    public <T> void zSetAdd(String key, T value, double score) {
        RScoredSortedSet<T> sortedSet = redissonClient.getScoredSortedSet(key);
        sortedSet.add(score, value);
    }

    /**
     * 从有序集合中移除元素
     *
     * @param key   键
     * @param value 值
     * @param <T>   元素类型
     * @return 是否移除成功
     */
    public <T> boolean zSetRemove(String key, T value) {
        RScoredSortedSet<T> sortedSet = redissonClient.getScoredSortedSet(key);
        return sortedSet.remove(value);
    }

    /**
     * 获取有序集合大小
     *
     * @param key 键
     * @return 有序集合大小
     */
    public int zSetSize(String key) {
        RScoredSortedSet<?> sortedSet = redissonClient.getScoredSortedSet(key);
        return sortedSet.size();
    }

    /**
     * 获取有序集合中元素的排名（按分数从小到大）
     *
     * @param key   键
     * @param value 值
     * @param <T>   元素类型
     * @return 排名
     */
    public <T> Integer zSetRank(String key, T value) {
        RScoredSortedSet<T> sortedSet = redissonClient.getScoredSortedSet(key);
        return sortedSet.rank(value);
    }
}

5.测试类(可省略)

/**
 * Redisson测试类
 */
@Component
public class RedissonTest {

    private static final Logger logger = LoggerFactory.getLogger(RedissonTest.class);

    @Autowired
    private RedissonUtil redissonUtil;

    @PostConstruct
    public void testRedisson() {
        logger.info("开始测试Redisson功能...");

        try {
            // 测试基本的键值操作
            testBasicOperations();

            // 测试分布式锁
            testDistributedLock();

            // 测试公平锁
            testFairLock();

            logger.info("Redisson测试完成！");
        } catch (Exception e) {
            logger.error("Redisson测试失败: ", e);
        }
    }

    /**
     * 测试基本的键值操作
     */
    private void testBasicOperations() {
        logger.info("测试基本键值操作...");

        String testKey = "redisson:test:key";
        String testValue = "Hello Redisson!";

        // 设置值
        redissonUtil.setString(testKey, testValue, 5, TimeUnit.MINUTES);
        logger.info("设置键值对: {} = {}", testKey, testValue);

        // 获取值
        String value = redissonUtil.getString(testKey);
        logger.info("获取键值对: {} = {}", testKey, value);

        // 检查是否存在
        boolean exists = redissonUtil.exists(testKey);
        logger.info("键 {} 是否存在: {}", testKey, exists);

        // 删除键
        boolean deleted = redissonUtil.delete(testKey);
        logger.info("删除键 {}: {}", testKey, deleted);

        logger.info("基本键值操作测试完成");
    }

    /**
     * 测试分布式锁
     */
    private void testDistributedLock() {
        logger.info("测试分布式锁...");

        String lockKey = "redisson:test:lock";
        RLock lock = redissonUtil.getLock(lockKey);

        try {
            // 尝试获取锁
            if (lock.tryLock(3, 10, TimeUnit.SECONDS)) {
                logger.info("成功获取分布式锁");

                // 模拟业务处理
                Thread.sleep(2000);

                logger.info("业务处理完成");
            } else {
                logger.warn("获取分布式锁失败");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            logger.error("获取锁时被中断", e);
        } finally {
            // 释放锁
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
                logger.info("释放分布式锁");
            }
        }

        logger.info("分布式锁测试完成");
    }

    /**
     * 测试公平锁
     */
    private void testFairLock() {
        logger.info("测试公平锁...");

        String fairLockKey = "redisson:test:fairlock";
        RLock fairLock = redissonUtil.getFairLock(fairLockKey);

        try {
            // 尝试获取公平锁
            if (fairLock.tryLock(3, 10, TimeUnit.SECONDS)) {
                logger.info("成功获取公平锁");

                // 模拟业务处理
                Thread.sleep(2000);

                logger.info("公平锁业务处理完成");
            } else {
                logger.warn("获取公平锁失败");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            logger.error("获取公平锁时被中断", e);
        } finally {
            // 释放锁
            if (fairLock.isHeldByCurrentThread()) {
                fairLock.unlock();
                logger.info("释放公平锁");
            }
        }

        logger.info("公平锁测试完成");
    }
}

6.启动项目

2025-08-10 16:23:50.143 [main] INFO  org.redisson.Version - Redisson 3.24.1
2025-08-10 16:23:50.296 [main] INFO  o.r.cluster.ClusterConnectionManager - Redis cluster nodes configuration got from 192.168.137.101/192.168.137.101:6379:
41cf97637a171a9d1c5742ec6ccccd4939de29bf 192.168.137.101:6383@16383 slave b39fdfad8a14d999b43541a8d5c9bd8480a0b607 0 1754814229036 1 connected
54070ccbf7a4ba89181d829642bbffb4bc6aa405 192.168.137.101:6380@16380 master - 0 1754814229539 2 connected 5461-10922
b39fdfad8a14d999b43541a8d5c9bd8480a0b607 192.168.137.101:6379@16379 myself,master - 0 1754814229000 1 connected 0-5460
c77db0a565cd951e6269b85f3a1c41d396b3ecba 192.168.137.101:6382@16382 slave c777e9d00b52f05bfffd722b113cf01237506354 0 1754814228031 3 connected
c777e9d00b52f05bfffd722b113cf01237506354 192.168.137.101:6381@16381 master - 0 1754814230043 3 connected 10923-16383
95adc2121e393702e34b323f3c0e0e019e311e63 192.168.137.101:6384@16384 slave 54070ccbf7a4ba89181d829642bbffb4bc6aa405 0 1754814229000 2 connected

2025-08-10 16:23:50.308 [redisson-netty-2-16] INFO  o.r.c.p.MasterPubSubConnectionPool - 1 connections initialized for 192.168.137.101/192.168.137.101:6379
2025-08-10 16:23:50.308 [redisson-netty-2-15] INFO  o.r.c.p.MasterPubSubConnectionPool - 1 connections initialized for 192.168.137.101/192.168.137.101:6381
2025-08-10 16:23:50.309 [redisson-netty-2-9] INFO  o.r.c.p.MasterPubSubConnectionPool - 1 connections initialized for 192.168.137.101/192.168.137.101:6380
2025-08-10 16:23:50.332 [redisson-netty-2-12] INFO  o.r.c.pool.MasterConnectionPool - 24 connections initialized for 192.168.137.101/192.168.137.101:6381
2025-08-10 16:23:50.333 [redisson-netty-2-4] INFO  o.r.c.pool.MasterConnectionPool - 24 connections initialized for 192.168.137.101/192.168.137.101:6379
2025-08-10 16:23:50.333 [redisson-netty-2-9] INFO  o.r.c.pool.MasterConnectionPool - 24 connections initialized for 192.168.137.101/192.168.137.101:6380
2025-08-10 16:23:50.333 [redisson-netty-2-8] INFO  o.r.c.pool.PubSubConnectionPool - 1 connections initialized for 192.168.137.101/192.168.137.101:6382
2025-08-10 16:23:50.334 [redisson-netty-2-6] INFO  o.r.c.pool.PubSubConnectionPool - 1 connections initialized for 192.168.137.101/192.168.137.101:6383
2025-08-10 16:23:50.334 [redisson-netty-2-5] INFO  o.r.c.pool.PubSubConnectionPool - 1 connections initialized for 192.168.137.101/192.168.137.101:6384
2025-08-10 16:23:50.352 [redisson-netty-2-13] INFO  o.r.cluster.ClusterConnectionManager - slaves: [redis://192.168.137.101:6382] added for slot ranges: [[10923-16383]]
2025-08-10 16:23:50.352 [redisson-netty-2-13] INFO  o.r.cluster.ClusterConnectionManager - master: redis://192.168.137.101:6381 added for slot ranges: [[10923-16383]]
2025-08-10 16:23:50.352 [redisson-netty-2-13] INFO  o.r.c.pool.SlaveConnectionPool - 24 connections initialized for 192.168.137.101/192.168.137.101:6382
2025-08-10 16:23:50.352 [redisson-netty-2-14] INFO  o.r.cluster.ClusterConnectionManager - slaves: [redis://192.168.137.101:6384] added for slot ranges: [[5461-10922]]
2025-08-10 16:23:50.352 [redisson-netty-2-15] INFO  o.r.cluster.ClusterConnectionManager - slaves: [redis://192.168.137.101:6383] added for slot ranges: [[0-5460]]
2025-08-10 16:23:50.352 [redisson-netty-2-14] INFO  o.r.cluster.ClusterConnectionManager - master: redis://192.168.137.101:6380 added for slot ranges: [[5461-10922]]
2025-08-10 16:23:50.352 [redisson-netty-2-15] INFO  o.r.cluster.ClusterConnectionManager - master: redis://192.168.137.101:6379 added for slot ranges: [[0-5460]]
2025-08-10 16:23:50.352 [redisson-netty-2-14] INFO  o.r.c.pool.SlaveConnectionPool - 24 connections initialized for 192.168.137.101/192.168.137.101:6384
2025-08-10 16:23:50.352 [redisson-netty-2-15] INFO  o.r.c.pool.SlaveConnectionPool - 24 connections initialized for 192.168.137.101/192.168.137.101:6383
2025-08-10 16:23:50.368 [main] INFO  c.c.b.common.utils.RedissonTest - 开始测试Redisson功能...
2025-08-10 16:23:50.368 [main] INFO  c.c.b.common.utils.RedissonTest - 测试基本键值操作...
2025-08-10 16:23:50.388 [main] INFO  c.c.b.common.utils.RedissonTest - 设置键值对: redisson:test:key = Hello Redisson!
2025-08-10 16:23:50.391 [main] INFO  c.c.b.common.utils.RedissonTest - 获取键值对: redisson:test:key = Hello Redisson!
2025-08-10 16:23:50.391 [main] INFO  c.c.b.common.utils.RedissonTest - 键 redisson:test:key 是否存在: true
2025-08-10 16:23:50.392 [main] INFO  c.c.b.common.utils.RedissonTest - 删除键 redisson:test:key: true
2025-08-10 16:23:50.392 [main] INFO  c.c.b.common.utils.RedissonTest - 基本键值操作测试完成
2025-08-10 16:23:50.392 [main] INFO  c.c.b.common.utils.RedissonTest - 测试分布式锁...
2025-08-10 16:23:50.399 [main] INFO  c.c.b.common.utils.RedissonTest - 成功获取分布式锁
2025-08-10 16:23:52.407 [main] INFO  c.c.b.common.utils.RedissonTest - 业务处理完成
2025-08-10 16:23:52.417 [main] INFO  c.c.b.common.utils.RedissonTest - 释放分布式锁
2025-08-10 16:23:52.418 [main] INFO  c.c.b.common.utils.RedissonTest - 分布式锁测试完成
2025-08-10 16:23:52.418 [main] INFO  c.c.b.common.utils.RedissonTest - 测试公平锁...
2025-08-10 16:23:52.419 [main] INFO  c.c.b.common.utils.RedissonTest - 成功获取公平锁
2025-08-10 16:23:54.424 [main] INFO  c.c.b.common.utils.RedissonTest - 公平锁业务处理完成
2025-08-10 16:23:54.431 [main] INFO  c.c.b.common.utils.RedissonTest - 释放公平锁
2025-08-10 16:23:54.431 [main] INFO  c.c.b.common.utils.RedissonTest - 公平锁测试完成
2025-08-10 16:23:54.432 [main] INFO  c.c.b.common.utils.RedissonTest - Redisson测试完成！

看到如上打印日志则启动redisson成功

腾讯云开发者社区

腾讯云面向开发者汇聚海量精品云计算使用和开发经验，营造开放的云计算技术生态圈。

更多推荐

Elasticsearch复杂数据类型终极指南：从入门到精通

Elasticsearch作为功能强大的搜索引擎，支持多种复杂数据类型，让开发者能够灵活处理各种结构化和非结构化数据。本文将带你全面了解Elasticsearch中的复杂数据类型，从基础概念到实际应用，助你轻松掌握数据建模的核心技巧。## 内部对象：构建层级化数据结构在Elasticsearch中，对象类型（Object）是最基础的复杂数据类型之一，用于表示具有嵌套关系的数据。例如，我们可

腾讯云开发者社区

终极指南：Flink SQL连接器版本管理从混乱到有序的升级之路

Apache Flink作为流处理领域的佼佼者，其SQL连接器的版本管理一直是开发者面临的核心挑战。本文将系统讲解Flink SQL连接器版本管理的最佳实践，帮助你轻松应对版本兼容性问题，实现从混乱到有序的升级之旅。## 连接器版本管理的常见痛点 😫在Flink应用开发中，连接器版本管理常常让开发者头疼不已。不同版本的连接器可能导致各种兼容性问题，例如API变更、功能差异甚至运行时错误。

腾讯云开发者社区

如何快速搭建Neon无服务器PostgreSQL：面向初学者的完整指南

Neon是一款革命性的无服务器PostgreSQL解决方案，它通过分离存储和计算层，实现了自动扩缩容、类代码式数据库分支以及零级扩展能力。本指南将帮助你从零开始搭建Neon开发环境，体验这款创新数据库的强大功能。## 准备工作：环境要求与依赖项在开始搭建Neon环境前，请确保你的系统满足以下要求：- Linux操作系统（推荐Ubuntu 20.04+或Debian 11+）- Git