Springboot-Redisson - 1.简介和配置

最新推荐文章于 2024-05-18 19:50:56 发布
最新推荐文章于 2024-05-18 19:50:56 发布
阅读量6.3k 收藏 18
点赞数 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
关注
  • 13
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
Spring Boot中使用Redisson
Chen_sj的博客
03-29 5513
微服务项目中，很多资源需要互斥使用，比如一些分布式任务，比如下单的处理，退货的处理等等。这些都需要用到借助分布式锁来保证处理的唯一性。 一开始我们也手工实现了分布式锁，但是随着业务的发展，我们对锁的特性也要求越来越完善，最后选用了Redis官方推荐的Redisson。 一、Spring Boot中使用Redisson Spring Boot使用Redisson特别简单，只要引入一个依赖就可以，redis的配置跟其他的redis客户端可以兼容，可以不用再额外配置 二、引入依赖 <de..
分布式锁简单入门以及三种实现方式介绍
AlbenXie的博客
10-12 571
很多小伙伴在学习Java的时候，总是感觉Java多线程在实际的业务中很少使用，以至于不会花太多的时间去学习，技术债不断累积！等到了一定程度的时候对于与Java多线程相关的东西就很难理解，今天需要探讨的东西也是一样的和Java多线程相关的！做好准备，马上开车！ 学过Java多线程的应该都知道什么是锁，没学过的也不用担心，Java中的锁可以简单的理解为多线程情况下访问临界资源的一种线程同步机制。 在学习或者使用Java的过程中进程会遇到各种各样的锁的概念：公平锁、非公平锁、自旋锁、可重入锁、偏向锁、轻量级锁
SpringBoot集成Redisson分布式锁（Redis集群方式）
最新发布
weixin_42553047的博客
05-18 1052
在大多数项目中，都会使用缓存中间件，例如Redis、Memcached等，一般会选择项目适配的中间件，能够提高数据的访问速度，减轻后端服务器和数据库的压力，但在使用缓存时，又不得不考虑其线程安全问题，特别是现在大多数项目都使用了分布式架构，因此就需要对中间件进行优化和加强。
超详细的Redisson实现分布式锁原理解析_1
guntun8987的博客
05-28 3421
超详细的Redisson原理解析
Redis入门到精通(十一),Redission操作Redis
热门推荐
weixin_62319133的博客
07-12 2万+
Redis入门到精通 专栏会分几期介绍Redis的概念操作，以及生产过程中频繁出现的一些问题及解决方案，在几期内逐渐深入带你全面了解Reids 本文为该专栏第十一期，主要介绍Redis的几种主流框架之Redisson............
springboot集成redisson
lizsy的博客
08-24 1326
springboot集成有两种方式，分别是集成redisson-spring-boot-starter或redisson-spring-data。由于作者的项目和redisson-spring-boot-starter有冲突，所以选择集成redisson-spring-data，下面介绍集成集成步骤，已单机版redis为列。
案例实战-SpringBoot整合Redisson实现RedLock分布式锁同步
06-26
本教程将基于SpringBoot框架，结合Redisson库来实现RedLock分布式锁，确保高可用性和数据一致性。 首先，让我们了解SpringBoot。SpringBoot是由Pivotal团队提供的全新框架，它简化了基于Spring的应用程序开发过程，...
Redission分布式锁-本地单机Redis实战-springboot-redis-lock.zip
01-31
此外，SpringBoot还支持通过配置RedissonClient来使用Redisson提供的高级功能。 4. **Redission实现分布式锁**：Redisson提供了RLock接口，它是Java Lock接口的实现，可以创建可重入的分布式锁。通过`RLock lock = ...
SpringBoot集成Redisson实现分布式锁的方法示例
08-25
然后，在application.properties文件中添加Redisson配置： ``` server.port=3000 redisson.address=redis://127.0.0.1:6379 redisson.password= redisson.master-name=master redisson.password= redisson.sentinel...
SpringBoot-Druid.zip
06-24
在本项目中，我们主要关注的是SpringBoot框架与Druid数据库连接池的集成，以及如何在SpringBoot项目中实现MongoDB、Redis的整合和auth登录鉴权功能。下面将详细介绍这些核心知识点。 首先，SpringBoot是Spring框架...
java springboot redisson mybatis maven.zip
02-28
标题中的"java springboot redisson mybatis maven.zip"表明这是一个使用Java编程语言，基于Spring Boot框架，并结合Redisson、MyBatis以及Maven构建的项目。这个项目可能是一个Web应用，利用了Spring Boot的便利性...
spring boot 利用redisson实现redis的分布式锁（二）
05-01
NULL 博文链接：https://liaoke0123.iteye.com/blog/2375556
redisson配置类---SpringBoot集成、redis单机和集群模式配置
Harden_zsc的博客
08-14 5180
【代码】redisson配置类---SpringBoot集成、redis单机和集群模式配置。
Springboot + redis操作多种实现（以及Jedis,Redisson,Lettuce的区别比较）
诗和远方，任重道远
10-16 1万+
Springboot + redis 操作多种实现一、Jedis,Redisson,Lettuce三者的区别二、Jedis三、RedisTemplate3.1、使用配置3.2、使用示例3.3、扩展3.3.1、spring-boot-starter-data-redis的依赖包3.3.2、stringRedisTemplate API（部分展示）3.3.3 StringRedisTemplate默认...
springboot2.x整合Redission
胖虎儿的博客
03-31 1万+
Reddissin也是一个redis客户端，其在提供了redis基本操作的同时，还具备其他客户端一些不具备的高精功能，例如 分布式锁+看门狗、分布式限流、远程调用等等
Redis分布式锁的正确使用姿势
施小楠的博客
06-08 1720
前言 日常开发中，秒杀下单、抢红包等等业务场景，都需要用到分布式锁。而Redis非常适合作为分布式锁使用。本文将分七个方案展开，跟大家探讨Redis分布式锁的正确使用方式。如果有不正确的地方，欢迎大家指出哈，一起学习一起进步。 公众号：捡田螺的小男孩 什么是分布式锁 方案一：SETNX + EXPIRE 方案二：SETNX + value值是（系统时间+过期时间） 方案三：使用Lua脚本(包含SETNX + EXPIRE两条指令) 方案四：SET的扩展命令（
Spring使用Redisson工具类操作ZSet集合（基础操作汇总）
张小凡
03-19 3491
主要介绍Spring，如何使用Redisson工具类操作ZSet集合！
RedisConfig,RedissonConfig,ScheduledLockConfig,redid配置，分布式锁配置，基于redis的SchedulerLocks使用
qq_36428598的博客
09-05 1108
redis f分布式锁，定时任务锁
spring redisson 使用样例
haole的专栏
06-21 1282
# spring redisson 使用样例 ## 目标 1. 尽量避免重复造轮子 2. 与spring data保持数据兼容 3. 配置信息使用spring通用的配置机制 ## redisson spring starter redisson提供了对spring的支持，url地址:https://github.com/redisson/redisson/tree/master/redisson-spring-boot-starter#spring-boot-starter 。此star.
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、付费专栏及课程。

余额充值