Springboot-Redisson - 1.简介和配置

最新推荐文章于 2024-09-18 10:35:09 发布
最新推荐文章于 2024-09-18 10:35:09 发布
阅读量6.8k 收藏 19
点赞数 13
分类专栏： Spring & Redisson 文章标签： spring boot 后端 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yueerba126/article/details/134073777
版权

👀 简介

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

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

  1. 分布式对象模型：Redisson允许您将Java对象保存在Redis中，这些对象可以通过Redis的分布式特性进行管理和共享。这意味着您可以使用Redis作为分布式缓存和数据存储，而不必手动处理序列化和反序列化。

  2. 分布式锁：Redisson提供了分布式锁的支持，可以用于在多个应用程序实例之间同步对共享资源的访问。这对于实现分布式任务调度和资源管理非常有用。

  3. 分布式集合：Redisson支持分布式集合数据结构，如List、Set、Map等，这些数据结构可以在多个节点之间共享和操作。

  4. 分布式队列和主题：Redisson提供了分布式队列和主题（Pub/Sub）的实现，用于实现事件驱动的架构和消息传递。

  5. Redis连接池管理：Redisson自动管理Redis连接池，确保连接的高效使用和释放，同时提供了连接监控和负载均衡功能。

  6. 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
nettyThreads: 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客户端。

✍使用场景:

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

✍优缺点:

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

🎷示例

  1. 添加 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>
  1. 在 application.yml 文件中配置 Redisson：
redisson:
  config: classpath:redisson-config.yml
  1. 创建一个 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
nettyThreads: 32
codec: !<org.redisson.codec.JsonJacksonCodec> {}
  1. 在 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编码方式的名称、作用和使用场景：

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

✍作用:

涉及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
  nettyThreads: 32 # 设置 Netty 线程池数量为 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.nettyThreads=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 nettyThreads;
    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);
        // 设置 Netty 线程池数量
        config.setNettyThreads(nettyThreads);
        // 设置锁的看门狗超时时间
        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 successfully!";
    }

    @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 successfully!";
    }

    @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 successfully 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 主从集群进行交互。

yueerba126
关注
专栏目录
springboot-redis-redisson分布式锁
没啥简介
01-17 1875
springboot-redis-redisson分布式锁一、Redis分布式锁实现原理简介1.普通分布式锁2.哨兵模式3.集群模式唯一ID看门狗Watchdog可重入锁获取锁释放锁二、 完整代码依赖application.properties配置配置类锁后业务接口规范redis加锁接口规范redis加锁实现类自定义异常测试类 比较：redis很明显优于zookeeper；就分布式锁实现的健壮性而言，zookeeper很明显优于redis。如何选择，取决于你的业务！ 一、Redis分布式锁实现原理 简介
springboot整合redisson（一）搭建Redisson环境
2301_76238237的博客
04-04 1410
我们总是喜欢瞻仰大厂的大神们，但实际上大神也不过凡人，与菜鸟程序员相比，也就多花了几分心思，如果你再不努力，差距也只会越来越大。实际上，作为程序员，丰富自己的知识储备，提升自己的知识深度和广度是很有必要的。
Redisson 总结
最新发布
凡的博客
09-18 967
Redisson 总结
SpringBoot整合Redisson（Redisson的配置）
小小得愿望-博客
07-22 4976
SpringBoot整合Redisson
springboot集成redisson配置
SKTDream的博客
05-25 1544
redisson.yml中的配置。
Spring Boot集成Redisson详细介绍
修己xj的博客
01-29 3079
Redisson是一个用于Java的分布式和高可用的Java对象的框架，它基于Redis实现。在Spring Boot应用程序中集成Redisson可以帮助我们更轻松地实现分布式锁、分布式对象、分布式集合等功能。本文将介绍如何在Spring Boot项目中集成Redisson，并展示一些基本用法。
Spring Boot整合Redisson的两种方式
涛哥是个大帅比
04-24 7116
Redis是一个开源的内存数据库，支持多种数据类型，如字符串、哈希、列表、集合和有序集合等，常用于缓存、消息队列、计数器、分布式锁和搜索等应用场景。Redisson则是一个基于Redis实现的Java驻内存数据网格，提供了一系列分布式的Java常用对象和多种锁机制，以及分布式服务，使开发者能更集中于处理业务逻辑。Redisson不支持字符串操作、排序、事务、管道、分区等Redis特性，但Redisson 提供了许多其他功能，如分布式闭锁、分布式计数器、分布式信号量等。
Redission分布式锁-本地单机Redis实战-springboot-redis-lock.zip
01-31
此外，SpringBoot还支持通过配置RedissonClient来使用Redisson提供的高级功能。 4. **Redission实现分布式锁**：Redisson提供了RLock接口，它是Java Lock接口的实现，可以创建可重入的分布式锁。通过`RLock lock = ...
案例实战-SpringBoot整合Redisson实现RedLock分布式锁同步
06-26
本教程将基于SpringBoot框架，结合Redisson库来实现RedLock分布式锁，确保高可用性和数据一致性。 首先，让我们了解SpringBoot。SpringBoot是由Pivotal团队提供的全新框架，它简化了基于Spring的应用程序开发过程，...
【SpringBoot】整合Redisson（使用redisson-spring-boot-starter）
热门推荐
qq_27579471的博客
01-10 3万+
public boolean tryLock(String lockKey, TimeUnit unit, long waitTime, long leaseTime){ RLock lock = redissonClient.getLock(lockKey); try { return lock.tryLock(waitTime, leaseTime, unit); } ...
redisson教程java,SpringBoot整合Redisson实战（通过redisson-spring-boot-starter）
weixin_35244067的博客
03-12 1765
SpringBoot整合Redisson实战(通过redisson-spring-boot-starter)点进来看整合的小伙伴肯定都了解Redisson的概念和背景了，这里就直接开始；SpringBoot整合Redisson有个比较好用的starter包就是redisson-spring-boot-starter，这也是官方比较推荐的配置方式，本文就使用redisson-spring-boot-...
spring boot 利用redisson实现redis的分布式锁（二）
05-01
NULL 博文链接：https://liaoke0123.iteye.com/blog/2375556
SpringBoot使用Redisson实现分布式锁（秒杀系统）
08-25
主要为大家详细介绍了SpringBoot使用Redisson实现分布式锁，秒杀系统，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
SpringBoot--配置Redisson的方法
IT利刃出鞘的博客
09-14 2万+
本文介绍如何在SpringBoot中配置Redisson。
SpringBoot使用Redisson操作Redis及使用场景实战
ToBeMaybe_的博客
07-11 4225
从 spring-boot 2.x 版本开始，spring-boot-data-redis 默认使用 Lettuce 客户端操作数据。
SpringBoot配置Redisson客户端
流沙QuickSand
04-07 974
Redisson，最出名的莫过于扩展了Redis应有的功能，提供了简而易用的分布式锁。更多详细介绍不作赘述。
SpringBoot集成Redisson
qq_38254635的博客
08-18 5143
Redisson
springboot redissionl配置
李振伟的博客
08-19 1041
【代码】springboot redissionl配置。
springboot集成redisson
broccoli2的博客
12-29 1315
1.添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> <version>2.4.1</version> </dependency&g
springboot配置redisson
08-24
SpringBoot配置Redisson可以通过以下步骤进行： 1. 引入Redisson的依赖：在pom.xml文件中添加Redisson的依赖项，例如： ``` <dependency> <groupId>org.redisson</groupId> <artifactId>redisson-spring-boot-starter</artifactId> <version>3.15.5</version> </dependency> ``` 2. 配置Redisson连接信息：在application.properties（或application.yml）文件中配置Redisson的连接信息，例如： ``` # Redisson连接配置 spring.redisson.address=redis://localhost:6379 spring.redisson.password=yourpassword ``` 其中，address用于指定Redis的地址和端口号，password用于指定Redis的密码（若有）。 3. 根据需要配置其他Redisson的参数：你可以在application.properties（或application.yml）文件中配置其他Redisson的参数，例如： ``` # Redisson配置参数 spring.redisson.database=0 spring.redisson.timeout=3000 ``` 其中，database用于指定Redis的数据库索引，timeout用于指定Redisson的操作超时时间（单位为毫秒）。 4. 使用Redisson：在代码中注入RedissonClient对象，并使用它进行相关操作，例如： ``` @Autowired private RedissonClient redissonClient; public void someMethod() { RLock lock = redissonClient.getLock("my-lock"); // 进行相关操作 } ``` 在以上代码中，通过@Autowired注解将RedissonClient对象注入，然后使用getLock方法获取一个锁对象进行操作。 通过以上步骤，你就可以成功配置和使用Redisson来进行SpringBoot项目中的分布式锁等操作。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [Springboot集成MyBatisplus并且实现自动生成代码模板](https://download.csdn.net/download/qq_33417321/88237864)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* *3* [SpringBoot整合Redisson](https://blog.csdn.net/weixin_53922163/article/details/127482085)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

yueerba126

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值