索取营销诊断书
QQ
您的位置：上海毫米网络优化公司 > 小程序 > 百度小程序 >
相关推荐recommended
Springboot-Redisson - 1.简介和配置
作者：mmseoamin日期：2023-12-21

👀 简介

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 的依赖：



    org.redisson
    redisson-spring-boot-starter
    3.15.0

接下来，在 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: ! {}
# 传输模式，默认是 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的依赖：

    
    org.redisson
    redisson-spring-boot-starter
    最新版本


    org.springframework.boot
    spring-boot-starter-data-redis

    💡 接下来，在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 依赖：
      
    org.redisson
    redisson-spring-boot-starter
    3.16.1


    org.springframework.boot
    spring-boot-starter-data-redis
      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: ! {}
      1. 在 Spring Boot 应用程序中使用 Redisson：
      @RestController
public class RedisController {
    @Autowired
    private RedissonClient redissonClient;
    @GetMapping("/set")
    public String setKey(@RequestParam String key, @RequestParam String value) {
        RMap map = redissonClient.getMap("myMap");
        map.put(key, value);
        return "Value set!";
    }
    @GetMapping("/get")
    public String getKey(@RequestParam String key) {
        RMap 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 的依赖：

            
    org.redisson
    redisson
    3.16.2

            步骤 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 中添加以下依赖：

              
    org.redisson
    redisson-spring-boot-starter
    3.16.0

              接下来，创建一个 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 中添加以下依赖：

                
    org.redisson
    redisson-spring-boot-starter
    3.16.0

                接下来，创建一个 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 中添加以下依赖：

                  
    org.redisson
    redisson-spring-boot-starter
    3.16.0

                  接下来，创建一个 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 中添加以下依赖：

                    
    org.redisson
    redisson-spring-boot-starter
    3.16.0

                    接下来，创建一个 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 主从集群进行交互。

上一篇：饥荒服务器面板 dst-admin-go 版本安装

下一篇：SQL开窗函数之前后函数（LEAD、LAG）

关注我们
扫描二维码
获取更多信息
精彩一手掌握