Springboot-Redisson - 1.简介和配置-后端-CSS教程

Springboot-Redisson - 1.简介和配置

👀 简介

Redisson是一个基于java的Redis客户端库，它提供了许多有用的功能和工具，使得在使用Redis时更加方便和强大。Redisson可以与Spring Boot集成，以简化在Spring应用程序中使用Redis的过程。

以下是关于Redisson的一些主要特点和功能：

分布式对象模型：Redisson允许您将Java对象保存在Redis中，这些对象可以通过Redis的分布式特性进行管理和共享。这意味着您可以使用Redis作为分布式缓存和数据存储，而不必手动处理序列化和反序列化。
分布式锁：Redisson提供了分布式锁的支持，可以用于在多个应用程序实例之间同步对共享资源的访问。这对于实现分布式任务调度和资源管理非常有用。
分布式集合：Redisson支持分布式集合数据结构，如List、Set、Map等，这些数据结构可以在多个节点之间共享和操作。
分布式队列和主题：Redisson提供了分布式队列和主题（Pub/Sub）的实现，用于实现事件驱动的架构和消息传递。
Redis连接池管理：Redisson自动管理Redis连接池，确保连接的高效使用和释放，同时提供了连接监控和负载均衡功能。
Spring Boot集成：Redisson提供了与Spring Boot的集成，您可以通过简单的配置将Redisson集成到Spring Boot应用程序中。这样，您可以轻松地使用Redisson的功能来处理Redis操作。

👀 配置方法

在 Redisson 中，有许多配置项可以根据应用的需求进行调整。下面是一个详细的配置示例，用于在 Spring Boot 中配置 Redisson：

首先，确保你已在 pom.xml 中添加了 Redisson 的依赖：

<!-- Redisson Spring Boot Starter 依赖 -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.15.0</version> <!-- 根据实际情况选择版本 -->
</dependency>

接下来，在 application.properties 或 application.yml 中指定 Redisson 配置文件的位置：

# 指定 Redisson 配置文件的位置
redisson.config=classpath:redisson.yaml

现在，我们将创建一个 redisson.yaml 文件来进行详细的配置。将此文件放在 resources 文件夹下。

# 单一 Redis 服务器模式
singleServerConfig:
  # Redis 服务器的地址
  address: "redis://127.0.0.1:6379"
  # 连接池的大小
  connectionPoolSize: 64
  # Redis 服务器的密码
  password: "your_password"
  # Redis 数据库索引
  database: 0
  # 客户端名称
  clientName: "your_client_name"
  # 超时时间，单位为毫秒
  timeout: 3000
  # Redis 命令失败重试次数
  retryAttempts: 3
  # 两次命令之间重试的时间间隔，单位为毫秒
  retryInterval: 1500
  # 发布和订阅的连接的最小数量
  subscriptionConnectionMinimumIdleSize: 1
  # 发布和订阅的连接池的大小
  subscriptionConnectionPoolSize: 50
  # 当前处理 Redis 命令的线程共享的联接
  connectionMinimumIdleSize: 10

# 集群模式的配置 (需要注释或删除 singleServerConfig 当使用此模式)
#clusterServersConfig:
#  scanInterval: 2000
#  slaveConnectionPoolSize: 64
#  slaveConnectionMinimumIdleSize: 24
#  masterConnectionPoolSize: 64
#  masterConnectionMinimumIdleSize: 24
#  readMode: "SLAVE"
#  nodeAddresses:
#    - "redis://127.0.0.1:7001"
#    - "redis://127.0.0.1:7002"
#    - "redis://127.0.0.1:7003"
#  password: "your_password"

# 其他模式，如 sentinel, masterSlave, replicated 可以在这里配置，但确保只有一个模式处于未注释状态

# 线程工厂配置
threads: 16
***tyThreads: 32

# 编解码器配置，默认是 Jackson
codec: !<org.redisson.codec.JsonJacksonCodec> {}

# 传输模式，默认是 NIO
transportMode: "NIO"

上述配置涵盖了 Redisson 的许多常见配置项。当然，Redisson 还提供了许多其他的高级配置，如 SSL 配置、云服务配置等。根据你的实际需求，可以进一步定制此配置文件。

这就是在 Spring Boot 中进行 Redisson 详细配置的方法。这个配置文件使用了单一服务器模式，但 Redisson 还支持许多其他的服务器配置模式，如集群、哨兵、主从等。这些模式的配置项也可以在上面的示例中找到，但默认是被注释掉的。

结合Spring Boot, Redisson为Java提供了Redis的客户端，支持大量的分布式Java对象和服务。以下是Redisson的几种主要配置方法：

✌1. 程序化配置方法

✍作用:

通过Java代码来配置Redisson客户端，提供了一种动态的方式来调整和设置Redisson的参数。

✍使用场景:

当应用程序需要基于不同的条件（如环境、用户输入或其他动态因素）来配置Redisson时。

✍优缺点:

优点：非常灵活，可以根据实时的应用需求或条件来调整。
缺点：可能导致配置逻辑分散在代码的多个位置，增加了代码的复杂性。

🎷示例

在Spring Boot中，您可以使用Java代码来配置Redisson客户端。这种方法非常适合动态配置，或者根据不同的条件来设置配置。

🎯 示例：

💡 首先，确保您已在pom.xml中添加了Redisson和Spring Boot的依赖：

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>最新版本</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

💡 接下来，在Spring Boot的主配置类或一个配置类中，您可以这样配置Redisson：

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RedissonConfig {

    @Bean(destroyMethod="shutdown")
    public RedissonClient redisson() {
        Config config = new Config();
        config.useSingleServer()
              .setAddress("redis://127.0.0.1:6379")
              .setPassword("yourPassword"); // 如果设置了密码
              
        return Redisson.create(config);
    }
}

💡 在上面的代码中，我们配置了一个单一的Redis服务器实例。您可以根据您的需求调整配置，例如使用哨兵模式、集群模式等。

💡 现在，您可以在任何Spring组件或服务中注入RedissonClient，然后使用它来与Redis交互。

import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class SomeService {

    @Autowired
    private RedissonClient redissonClient;

    public void someMethod() {
        // 使用redissonClient进行操作...
    }
}

✌2. 文件方式配置

✍作用:

允许开发者使用外部的配置文件（如YAML或JSON）来设置Redisson客户端。

✍使用场景:

适用于大部分应用，特别是当配置信息相对静态，或需要在不同的环境中共享相同的配置时。

✍优缺点:

优点：配置清晰，集中，容易进行版本控制。
缺点：需要重新启动应用来应用配置的更改。

🎷示例

添加 Maven 依赖：

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

在 application.yml 文件中配置 Redisson：

redisson:
  config: classpath:redisson-config.yml

创建一个 redisson-config.yml 文件，该文件包含 Redisson 的配置：

singleServerConfig:
  idleConnectionTimeout: 10000
  pingTimeout: 1000
  connectTimeout: 10000
  timeout: 3000
  retryAttempts: 3
  retryInterval: 1500
  password: null
  subscriptionsPerConnection: 5
  clientName: null
  address: "redis://127.0.0.1:6379"
  subscriptionConnectionMinimumIdleSize: 1
  subscriptionConnectionPoolSize: 50
  connectionMinimumIdleSize: 10
  connectionPoolSize: 64
  database: 0
  dnsMonitoringInterval: 5000
threads: 16
***tyThreads: 32
codec: !<org.redisson.codec.JsonJacksonCodec> {}

在 Spring Boot 应用程序中使用 Redisson：

@RestController
public class RedisController {

    @Autowired
    private RedissonClient redissonClient;

    @GetMapping("/set")
    public String setKey(@RequestParam String key, @RequestParam String value) {
        RMap<String, String> map = redissonClient.getMap("myMap");
        map.put(key, value);
        return "Value set!";
    }

    @GetMapping("/get")
    public String getKey(@RequestParam String key) {
        RMap<String, String> map = redissonClient.getMap("myMap");
        return map.get(key);
    }
}

✌3. 常用设置

不同的Redisson编码方式的名称、作用和使用场景：

编码方式	作用和特点	使用场景
JsonJacksonCodec	Jackson JSON编码，默认编码方式	一般的JSON数据序列化和反序列化
AvroJacksonCodec	二进制的JSON编码，高性能	需要高性能的二进制JSON数据编码
SmileJacksonCodec	另一种二进制的JSON编码，紧凑	紧凑的二进制JSON数据编码
CborJacksonCodec	CBOR二进制JSON编码	高效的CBOR格式数据编码
MsgPackJacksonCodec	MsgPack二进制JSON编码	高效的MsgPack格式数据编码
IonJacksonCodec	Amazon Ion编码，类似JSON	与Amazon Ion格式交互的情况
KryoCodec	二进制对象序列化编码，高性能	需要高性能的Java对象序列化
SerializationCodec	JDK序列化编码，性能较差	原生Java对象序列化
FstCodec	FST二进制对象序列化编码，高性能	高性能Java对象序列化
LZ4Codec	压缩型序列化对象编码，高效	高效压缩的数据存储和检索
SnappyCodec	压缩型序列化对象编码，高效	高效压缩的数据存储和检索
JsonJacksonMapCodec	基于Jackson的映射类使用的编码	映射类数据的序列化和反序列化
StringCodec	纯字符串编码，无转换	存储和检索简单字符串数据
LongCodec	纯整长型数字编码，无转换	存储和检索长整数数据
ByteArrayCodec	字节数组编码	存储和检索原始字节数据
***positeCodec	组合多种不同编码方式	根据需求选择不同的编码方式

✍作用:

涉及Redisson客户端的常规设置，如连接池大小、连接超时、线程设置等。

✍使用场景:

根据应用的规模和需求来调整和优化Redisson客户端的性能。

✍优缺点:

优点：提供了对Redisson行为的细致控制，可以优化性能。
缺点：需要对Redis和Redisson有一定了解，以确保正确的配置。

🎷示例

Redisson 是一个功能强大的 Java 客户端库，用于与 Redis 交互。它提供了丰富的设置选项，用于配置 Redisson 的行为和性能。下面是一些 Redisson 的常用设置示例，以及如何在 Spring Boot 中配置和使用它们。

1. 配置 Redisson 连接

首先，在 Spring Boot 的 application.properties 或 application.yml 文件中配置 Redisson 连接：

# Redisson 连接配置
redisson:
  single-server:
    address: "redis://localhost:6379" # Redis 服务器地址
    password: your_password # 如果需要密码认证的话
  # 或者配置 Redis 集群连接
  # cluster-servers:
  #   - "redis://node1_host:6379"
  #   - "redis://node2_host:6379"
  #   ...

single-server：使用单个 Redis 服务器配置。
cluster-servers：使用 Redis 集群配置。

2. 配置 Redisson 客户端

创建一个配置类，用于配置 Redisson 客户端并创建 RedissonClient 实例：

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;

@Configuration
public class RedissonConfig {

    @Value("${redisson.single-server.address}")
    private String redisAddress;

    @Value("${redisson.single-server.password}")
    private String redisPassword;

    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useSingleServer()
              .setAddress(redisAddress)
              .setPassword(redisPassword);

        return Redisson.create(config);
    }
}

3. 常用设置示例

下面是一些 Redisson 常用设置的示例：

3.1. 配置超时时间

import org.redisson.config.Config;
// ...

Config config = new Config();
config.useSingleServer()
      .setAddress(redisAddress)
      .setPassword(redisPassword)
      .setTimeout(3000); // 设置连接超时时间为 3000 毫秒

3.2. 配置连接池大小

import org.redisson.config.Config;
// ...

Config config = new Config();
config.useSingleServer()
      .setAddress(redisAddress)
      .setPassword(redisPassword)
      .setConnectionPoolSize(100); // 设置连接池大小为 100

3.3. 配置编码器

import org.redisson.config.Config;
import org.redisson.codec.JsonJacksonCodec;
// ...

Config config = new Config();
config.useSingleServer()
      .setAddress(redisAddress)
      .setPassword(redisPassword)
      .setCodec(JsonJacksonCodec.INSTANCE); // 设置自定义编码器

4. 使用 Redisson 设置

在你的服务类中注入 RedissonClient 并使用它来执行 Redisson 操作。以下是示例服务类：

import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class RedissonService {

    private final RedissonClient redissonClient;

    @Autowired
    public RedissonService(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }

    /**
     * 示例方法：向 Redis 写入数据
     *
     * @param key   Redis 键
     * @param value Redis 值
     */
    public void writeToRedis(String key, String value) {
        // 使用 RedissonClient 执行写入操作
        redissonClient.getBucket(key).set(value);
    }

    /**
     * 示例方法：从 Redis 读取数据
     *
     * @param key Redis 键
     * @return Redis 值
     */
    public String readFromRedis(String key) {
        // 使用 RedissonClient 执行读取操作
        return redissonClient.getBucket(key).get();
    }
}

5. 常见的 Redisson 设置参数
在 Spring Boot 中使用 Redisson 配置常见的 Redisson 设置参数可以通过在 Spring Boot 项目的配置文件（如 application.properties 或 application.yml）中设置相应的属性来实现。下面是如何在 Spring Boot 中结合 Redisson 配置常用的设置参数的示例，以及详细的注释：

# Redisson 配置
redisson:
  codec: org.redisson.codec.MsgPackJacksonCodec # 设置编码方式为 MsgPackJacksonCodec
  threads: 16 # 设置线程池数量为 16
  ***tyThreads: 32 # 设置 ***ty 线程池数量为 32
  lockWatchdogTimeout: 60000 # 设置锁的看门狗超时时间为 60 秒
  keepPubSubOrder: true # 保持订阅发布顺序
  performanceMode: HIGHER_THROUGHPUT # 设置高性能模式为高通量

# 或者使用 Java 配置类
# 使用 @ConfigurationProperties(prefix = "redisson") 注解绑定配置属性

# application.properties
# redisson.codec=org.redisson.codec.MsgPackJacksonCodec
# redisson.threads=16
# redisson.***tyThreads=32
# redisson.lockWatchdogTimeout=60000
# redisson.keepPubSubOrder=true
# redisson.performanceMode=HIGHER_THROUGHPUT

接下来，你可以创建一个 Redisson 配置类来读取这些属性并配置 Redisson 客户端。以下是示例 Redisson 配置类：

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

    private String codec;
    private int threads;
    private int ***tyThreads;
    private long lockWatchdogTimeout;
    private boolean keepPubSubOrder;
    private String performanceMode;

    // 省略 getter 和 setter 方法

    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        // 设置编码方式
        config.setCodec(codec);
        // 设置线程池数量
        config.setThreads(threads);
        // 设置 ***ty 线程池数量
        config.set***tyThreads(***tyThreads);
        // 设置锁的看门狗超时时间
        config.setLockWatchdogTimeout(lockWatchdogTimeout);
        // 保持订阅发布顺序
        config.setKeepPubSubOrder(keepPubSubOrder);
        // 设置高性能模式
        config.setPerformanceMode(performanceMode);

        return Redisson.create(config);
    }
}

在上述示例中，我们通过 @ConfigurationProperties 注解将配置文件中的属性与配置类的属性绑定在一起，并在 RedissonConfig 类的 redissonClient 方法中使用这些属性来配置 Redisson 客户端。

✌4. 集群模式

✍作用:

允许Redisson客户端连接到Redis集群，提供数据分片和高可用性。

✍使用场景:

用于大型应用或有高可用性需求的应用。

✍优缺点:

优点：提供高可用性、数据冗余。
缺点：配置和维护相对复杂。

🎷示例

在 Spring Boot 中使用 Redisson 来配置和使用 Redis 集群模式需要执行一系列步骤。下面是一个详细的示例，每个步骤都有详细的注释。

步骤 1: 添加 Redisson 依赖

首先，在项目的 Maven pom.xml 文件中添加 Redisson 的依赖：

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.16.2</version> <!-- 请使用最新版本 -->
</dependency>

步骤 2: 配置 Redisson 集群

在 Spring Boot 应用程序的配置文件（application.properties 或 application.yml）中配置 Redisson 的集群信息：

# Redisson 集群配置
redisson:
  cluster-servers:
    - "redis://node1_host:6379"
    - "redis://node2_host:6379"
    - "redis://node3_host:6379"
  password: your_password # 如果需要密码认证的话

请将上述配置中的 node1_host、node2_host、node3_host 替换为你的 Redis 集群中的实际节点主机和端口，并设置密码（如果需要）。

步骤 3: 创建 Redisson 配置类

创建一个配置类，用于配置 Redisson 并创建 RedissonClient 实例。这里使用 Java 代码示例：

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;

@Configuration
public class RedissonConfig {

    @Value("${redisson.cluster-servers}")
    private String[] clusterServers;

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

    @Bean
    public RedissonClient redissonClient() {
        // 创建 Redisson 配置对象
        Config config = new Config();
        config.useClusterServers()
              .setScanInterval(2000) // 集群节点扫描间隔时间
              .addNodeAddress(clusterServers)
              .setPassword(password);

        // 使用配置对象创建 RedissonClient 实例
        return Redisson.create(config);
    }
}

上述配置类读取了在配置文件中定义的 Redisson 集群配置信息，并使用这些信息创建了 RedissonClient 实例。

步骤 4: 创建服务类

创建一个服务类，用于演示如何在 Spring Boot 中使用 Redisson 进行集群操作。以下是示例服务类：

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class RedisClusterService {

    private final RedissonClient redissonClient;

    @Autowired
    public RedisClusterService(RedissonClient redissonClient) {
        this.redissonClient = redissonClient;
    }

    /**
     * 示例方法：获取分布式锁并执行操作
     */
    public void executeWithLock() {
        // 获取名为 "myLock" 的分布式锁
        RLock lock = redissonClient.getLock("myLock");
        lock.lock(); // 获取锁

        try {
            // 在锁的保护下执行需要加锁的操作
            // ...
        } finally {
            lock.unlock(); // 释放锁
        }
    }

    /**
     * 示例方法：向 Redis 集群写入数据
     *
     * @param key   Redis 键
     * @param value Redis 值
     */
    public void writeToCluster(String key, String value) {
        // 使用 RedissonClient 执行写入操作
        redissonClient.getBucket(key).set(value);
    }

    /**
     * 示例方法：从 Redis 集群读取数据
     *
     * @param key Redis 键
     * @return Redis 值
     */
    public String readFromCluster(String key) {
        // 使用 RedissonClient 执行读取操作
        return redissonClient.getBucket(key).get();
    }
}

上述示例服务类包含了三个方法，分别演示了获取分布式锁、向 Redis 集群写入数据以及从 Redis 集群读取数据的操作。

步骤 5: 使用 Redisson 集群

在你的 Spring Boot 应用程序中，你可以注入 RedisClusterService 并使用它来执行 Redisson 集群操作。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/redis-cluster")
public class RedisClusterController {

    private final RedisClusterService redisClusterService;

    @Autowired
    public RedisClusterController(RedisClusterService redisClusterService) {
        this.redisClusterService = redisClusterService;
    }

    @GetMapping("/lock")
    public String executeWithLock() {
        // 执行带锁的操作
        redisClusterService.executeWithLock();
        return "Operation executed with lock.";
    }

    @GetMapping("/write")
    public String writeToCluster() {
        // 向 Redis 集群写入数据
        redisClusterService.writeToCluster("myKey", "myValue");
        return "Data written to Redis cluster.";
    }

    @GetMapping("/read")
    public String readFromCluster() {
        // 从 Redis 集群读取数据
        String value = redisClusterService.readFromCluster("myKey");
        return "Value from Redis cluster: " + value;
    }
}

以上是一个完整的示例，演示了如何在 Spring Boot 中配置和使用 Redisson 的集群模式。确保按照示例中的步骤配置项目，并根据需要调整配置和操作。

✌5. 云托管模式

✍作用:

为在云服务（如Amazon AWS, Azure等）上托管的Redis服务提供专门的配置。

✍使用场景:

在云平台上运行的应用，使用云服务提供的Redis实例。

✍优缺点:

优点：简化了在云平台上部署和扩展Redis的过程。
缺点：可能需要对特定的云平台有所了解。

🎷示例

Redisson 的云托管模式允许你将 Redisson 客户端连接到云中托管的 Redis 服务，如云提供商（例如，AWS Elasticache、Azure Cache for Redis 或 Google Cloud Memorystore）中的 Redis。在这种情况下，你通常不需要配置底层的 Redis 连接信息，因为这些信息已经由云提供商进行管理。

以下是一个示例，展示如何在 Spring Boot 中配置 Redisson 的云托管模式，并连接到云中的 Redis 服务。请注意，云托管模式的具体配置可能因云提供商而异，这里提供了一个通用示例。

首先，确保你的项目中包含了 Redisson 的依赖。你可以在 pom.xml 中添加以下依赖：

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.16.0</version> <!-- 请根据你的需求选择合适的版本 -->
</dependency>

接下来，创建一个 Spring Boot 配置类，用于配置 Redisson 的云托管模式。以下是示例配置类，包括详细的注释：

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

@Configuration
public class RedissonConfig {

    @Value("${spring.redis.host}") // 获取 Redis 云托管的主机地址
    private String redisHost;

    @Value("${spring.redis.port}") // 获取 Redis 云托管的端口
    private int redisPort;

    @Value("${spring.redis.password}") // 获取 Redis 密码（如果有）
    private String redisPassword;

    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        // 使用云托管模式
        config.useSingleServer()
              .setAddress("redis://" + redisHost + ":" + redisPort)
              .setPassword(redisPassword);

        // 创建 Redisson 客户端
        return Redisson.create(config);
    }
}

在上述示例中，我们使用 Spring 的 @Value 注解从 Spring Boot 的配置文件（如 application.properties 或 application.yml）中获取 Redis 云托管的主机地址、端口和密码。然后，我们使用这些信息配置 Redisson 的单机模式，创建一个 Redisson 客户端。

确保在你的 Spring Boot 项目中设置了正确的 Redis 云托管配置信息，以便连接到云中托管的 Redis 服务。

这只是一个通用示例，实际的云托管配置可能因云提供商而异。请根据你使用的云提供商的文档和要求来进行配置。

✌6. 单Redis节点模式

✍作用:

连接到单个的Redis服务器实例。

✍使用场景:

小型应用或开发和测试环境。

✍优缺点:

优点：配置简单，部署快速。
缺点：没有数据冗余或高可用性。

🎷示例

Redisson 的单 Redis 节点模式是一种常见的使用场景，它允许你连接到单个独立的 Redis 服务器。以下是一个详细的示例，展示如何在 Spring Boot 中配置 Redisson 的单 Redis 节点模式，以及如何使用它。每个方法和配置都有详细的注释。

首先，确保你的项目中包含了 Redisson 的依赖。你可以在 pom.xml 中添加以下依赖：

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.16.0</version> <!-- 请根据你的需求选择合适的版本 -->
</dependency>

接下来，创建一个 Spring Boot 配置类，用于配置 Redisson 的单 Redis 节点模式。以下是示例配置类，包括详细的注释：

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;

@Configuration
public class RedissonConfig {

    @Value("${spring.redis.host}") // 获取 Redis 主机地址
    private String redisHost;

    @Value("${spring.redis.port}") // 获取 Redis 端口
    private int redisPort;

    @Value("${spring.redis.password}") // 获取 Redis 密码（如果有）
    private String redisPassword;

    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        // 配置单节点模式
        config.useSingleServer()
              .setAddress("redis://" + redisHost + ":" + redisPort) // 设置 Redis 地址
              .setPassword(redisPassword); // 设置 Redis 密码

        // 创建 Redisson 客户端
        return Redisson.create(config);
    }
}

在上述示例中，我们使用 Spring 的 @Value 注解从 Spring Boot 的配置文件（如 application.properties 或 application.yml）中获取 Redis 主机地址、端口和密码。然后，我们使用这些信息配置 Redisson 的单节点模式，创建一个 Redisson 客户端。

确保在你的 Spring Boot 项目中设置了正确的 Redis 单节点配置信息，以便连接到指定的 Redis 服务器。

现在，你可以在 Spring Boot 应用程序中注入 RedissonClient bean，并使用它来与 Redis 进行交互。以下是一个示例：

import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {

    @Autowired
    private RedissonClient redissonClient;

    @GetMapping("/set")
    public String setValue() {
        // 使用 Redisson 客户端设置键值对
        redissonClient.getBucket("myKey").set("myValue");
        return "Key-Value set su***essfully!";
    }

    @GetMapping("/get")
    public String getValue() {
        // 使用 Redisson 客户端获取键的值
        String value = redissonClient.getBucket("myKey").get();
        return "Value for 'myKey': " + value;
    }
}

在上述示例中，我们通过注入 RedissonClient bean 来获取 Redisson 客户端，并使用它来设置和获取 Redis 中的键值对。

这就是如何配置和使用 Redisson 的单 Redis 节点模式的详细示例。确保在你的应用程序中使用正确的配置信息和 Redisson 客户端来与 Redis 进行交互。

✌7. 哨兵模式

✍作用:

使用Redis哨兵提供高可用性和故障转移。

✍使用场景:

需要高可用性但不想使用集群的应用。

✍优缺点:

优点：自动故障转移，提供系统的韧性。
缺点：需要额外的哨兵节点配置和维护。

🎷示例

Redisson 的哨兵模式允许你连接到 Redis Sentinel（哨兵）集群，这是一种高可用性配置，其中多个 Redis 服务器实例通过 Sentinel 进程监控并自动切换主服务器以确保可用性。以下是一个详细的示例，展示如何在 Spring Boot 中配置 Redisson 的哨兵模式，以及如何使用它。每个方法和配置都有详细的注释。

首先，确保你的项目中包含了 Redisson 的依赖。你可以在 pom.xml 中添加以下依赖：

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.16.0</version> <!-- 请根据你的需求选择合适的版本 -->
</dependency>

接下来，创建一个 Spring Boot 配置类，用于配置 Redisson 的哨兵模式。以下是示例配置类，包括详细的注释：

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;

@Configuration
public class RedissonConfig {

    @Value("${spring.redis.sentinel.master}") // 获取 Sentinel 主服务器名称
    private String masterName;

    @Value("${spring.redis.sentinel.nodes}") // 获取 Sentinel 节点地址列表
    private String sentinelNodes;

    @Value("${spring.redis.password}") // 获取 Redis 密码（如果有）
    private String redisPassword;

    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        // 配置哨兵模式
        config.useSentinelServers()
              .setMasterName(masterName) // 设置 Sentinel 主服务器名称
              .addSentinelAddress(sentinelNodes.split(",")) // 设置 Sentinel 节点地址列表
              .setPassword(redisPassword); // 设置 Redis 密码

        // 创建 Redisson 客户端
        return Redisson.create(config);
    }
}

在上述示例中，我们使用 Spring 的 @Value 注解从 Spring Boot 的配置文件（如 application.properties 或 application.yml）中获取 Sentinel 主服务器名称、Sentinel 节点地址列表和 Redis 密码（如果有）。然后，我们使用这些信息配置 Redisson 的哨兵模式，创建一个 Redisson 客户端。

确保在你的 Spring Boot 项目中设置了正确的哨兵配置信息，以便连接到 Redis Sentinel 集群。

现在，你可以在 Spring Boot 应用程序中注入 RedissonClient bean，并使用它来与 Redis 进行交互。以下是一个示例：

import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {

    @Autowired
    private RedissonClient redissonClient;

    @GetMapping("/set")
    public String setValue() {
        // 使用 Redisson 客户端设置键值对
        redissonClient.getBucket("myKey").set("myValue");
        return "Key-Value set su***essfully!";
    }

    @GetMapping("/get")
    public String getValue() {
        // 使用 Redisson 客户端获取键的值
        String value = redissonClient.getBucket("myKey").get();
        return "Value for 'myKey': " + value;
    }
}

在上述示例中，我们通过注入 RedissonClient bean 来获取 Redisson 客户端，并使用它来设置和获取 Redis 中的键值对。

这就是如何配置和使用 Redisson 的哨兵模式的详细示例。确保在你的应用程序中使用正确的配置信息和 Redisson 客户端来与 Redis Sentinel 集群进行交互。

✌8. 主从模式

✍作用:

设置Redis的主从复制来实现数据冗余。

✍使用场景:

需要数据冗余但不要求高可用性的应用。

✍优缺点:

优点：数据冗余，提高数据的安全性。
缺点：没有自动的故障转移。

🎷示例

Redisson 的主从模式允许你连接到 Redis 主服务器和一个或多个 Redis 从服务器。这种配置允许在主服务器上进行写操作，并在从服务器上进行读操作，从而分担主服务器的负载。以下是一个详细的示例，展示如何在 Spring Boot 中配置 Redisson 的主从模式，以及如何使用它。每个方法和配置都有详细的注释。

首先，确保你的项目中包含了 Redisson 的依赖。你可以在 pom.xml 中添加以下依赖：

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.16.0</version> <!-- 请根据你的需求选择合适的版本 -->
</dependency>

接下来，创建一个 Spring Boot 配置类，用于配置 Redisson 的主从模式。以下是示例配置类，包括详细的注释：

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;

@Configuration
public class RedissonConfig {

    @Value("${spring.redis.master}") // 获取 Redis 主服务器地址
    private String masterAddress;

    @Value("${spring.redis.slave}") // 获取 Redis 从服务器地址
    private String slaveAddress;

    @Value("${spring.redis.password}") // 获取 Redis 密码（如果有）
    private String redisPassword;

    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        // 配置主从模式
        config.useMasterSlaveServers()
              .setMasterAddress(masterAddress) // 设置主服务器地址
              .addSlaveAddress(slaveAddress) // 添加从服务器地址
              .setPassword(redisPassword); // 设置 Redis 密码

        // 创建 Redisson 客户端
        return Redisson.create(config);
    }
}

在上述示例中，我们使用 Spring 的 @Value 注解从 Spring Boot 的配置文件（如 application.properties 或 application.yml）中获取 Redis 主服务器地址、从服务器地址和 Redis 密码（如果有）。然后，我们使用这些信息配置 Redisson 的主从模式，创建一个 Redisson 客户端。

确保在你的 Spring Boot 项目中设置了正确的主从配置信息，以便连接到 Redis 主服务器和从服务器。

现在，你可以在 Spring Boot 应用程序中注入 RedissonClient bean，并使用它来与 Redis 进行交互。以下是一个示例：

import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {

    @Autowired
    private RedissonClient redissonClient;

    @GetMapping("/set")
    public String setValue() {
        // 使用 Redisson 客户端设置键值对（写操作在主服务器上执行）
        redissonClient.getBucket("myKey").set("myValue");
        return "Key-Value set su***essfully on master!";
    }

    @GetMapping("/get")
    public String getValue() {
        // 使用 Redisson 客户端获取键的值（读操作在从服务器上执行）
        String value = redissonClient.getBucket("myKey").get();
        return "Value for 'myKey' (from slave): " + value;
    }
}

在上述示例中，我们通过注入 RedissonClient bean 来获取 Redisson 客户端，并使用它来设置和获取 Redis 中的键值对。请注意，写操作在主服务器上执行，而读操作在从服务器上执行，以减轻主服务器的负载。

这就是如何配置和使用 Redisson 的主从模式的详细示例。确保在你的应用程序中使用正确的配置信息和 Redisson 客户端来与 Redis 主从集群进行交互。

spring boot 后端 java

转载请说明出处内容投诉
CSS教程_站长资源网 » Springboot-Redisson - 1.简介和配置

Dx

分享到：

👀 简介

👀 配置方法

✌1. 程序化配置方法

✍作用:

✍使用场景:

✍优缺点:

🎷示例

✌2. 文件方式配置

✍作用:

✍使用场景:

✍优缺点:

🎷示例

✌3. 常用设置

✍作用:

✍使用场景:

✍优缺点:

🎷示例

✌4. 集群模式

✍作用:

✍使用场景:

✍优缺点:

🎷示例

✌5. 云托管模式

✍作用:

✍使用场景:

✍优缺点:

🎷示例

✌6. 单Redis节点模式

✍作用:

✍使用场景:

✍优缺点:

🎷示例

✌7. 哨兵模式

✍作用:

✍使用场景:

✍优缺点:

🎷示例

✌8. 主从模式

✍作用:

✍使用场景:

✍优缺点:

🎷示例

Dx

相关推荐

发表评论

一个令你着迷的主题！