devbox
小蓝xlanll
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Redisson连接Redis单机&集群&哨兵配置示例_redissonconfig集群配置

作者：小蓝xlanll | 2024-06-13 06:19:10

赞

踩

redissonconfig集群配置

Redisson简介

         Redission是什么就不在这里多说了，可以自己百度或者查看最强分布式锁工具

Redisson配置

        看了很多博主对 Redission配置基本都是单机模式，实际生产环境Redis部署有主从、哨兵、集群； Redission对不同Redis模式的配置区别挺大；同时，现在大部分项目都是SpringBoot项目，对Redis的使用基本都是使用Spring官网的starter；

        所以这里基于SpringBoot-1.5.22.RELEASE，解释一下结合spring-boot-starter-data-redis集成Redission的用法

pom依赖

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         <artifactId>spring-boot-starter-parent</artifactId>
  8.         <version>1.5.22.RELEASE</version>
  9.         <relativePath/> <!-- lookup parent from repository -->
  10.     </parent>
  11.     <groupId>com.idto</groupId>
  12.     <artifactId>redis-demo</artifactId>
  13.     <version>0.0.1-SNAPSHOT</version>
  14.     <name>redis-demo</name>
  15.     <description>redis-demo</description>
  16.     <properties>
  17.         <java.version>1.8</java.version>
  18.     </properties>
  19.     <dependencies>
  20.         <dependency>
  21.             <groupId>org.redisson</groupId>
  22.             <artifactId>redisson</artifactId>
  23.             <version>3.15.3</version>
  24.         </dependency>
  25.         <dependency>
  26.             <groupId>org.apache.commons</groupId>
  27.             <artifactId>commons-lang3</artifactId>
  28.             <version>3.12.0</version>
  29.         </dependency>
  30.         <dependency>
  31.             <groupId>org.springframework.boot</groupId>
  32.             <artifactId>spring-boot-starter-web</artifactId>
  33.         </dependency>
  34.         <dependency>
  35.             <groupId>org.springframework.boot</groupId>
  36.             <artifactId>spring-boot-starter-data-redis</artifactId>
  37.         </dependency>
  38.     </dependencies>
  39.  
  40.     <build>
  41.         <plugins>
  42.             <plugin>
  43.                 <groupId>org.springframework.boot</groupId>
  44.                 <artifactId>spring-boot-maven-plugin</artifactId>
  45.             </plugin>
  46.         </plugins>
  47.     </build>
  48.  
  49. </project>

RedissonClient创建

针对Redis不同的部署模式，对RedissonClient进行不同的初始化

  1. package com.idto.config;
  2.  
  3. import org.apache.commons.lang3.StringUtils;
  4. import org.redisson.Redisson;
  5. import org.redisson.api.RedissonClient;
  6. import org.redisson.config.ClusterServersConfig;
  7. import org.redisson.config.Config;
  8. import org.redisson.config.SentinelServersConfig;
  9. import org.redisson.config.SingleServerConfig;
  10. import org.slf4j.Logger;
  11. import org.slf4j.LoggerFactory;
  12. import org.springframework.beans.factory.annotation.Autowired;
  13. import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
  14. import org.springframework.context.annotation.Bean;
  15. import org.springframework.context.annotation.Configuration;
  16.  
  17. import java.util.List;
  18. import java.util.Objects;
  19.  
  20.  
  21. @Configuration
  22. public class RedissonConfig {
  23.  
  24.     Logger log = LoggerFactory.getLogger(RedissonConfig.class);
  25.  
  26.  
  27.     # 直接使用starter注入的redis配置信息
  28.     @Autowired
  29.     private RedisProperties redisProperties;
  30.  
  31.     private int timeout = 3000;
  32.     private int connectionPoolSize = 64;
  33.     private int connectionMinimumIdleSize = 10;
  34.     private int pingConnectionInterval = 60000;
  35.     private static String ADDRESS_PREFIX = "redis://";
  36.  
  37.     /**
  38.      * 单机模式
  39.      */
  40.     @Bean
  41.     public RedissonClient initBean() {
  42.         // 哨兵模式
  43.         RedisProperties.Sentinel sentinel = redisProperties.getSentinel();
  44.         if (Objects.nonNull(sentinel)) {
  45.             log.info("redis is sentinel mode");
  46.             return redissonSentinel();
  47.         }
  48.         // 集群模式
  49.         RedisProperties.Cluster cluster = redisProperties.getCluster();
  50.         if (Objects.nonNull(cluster)) {
  51.             log.info("redis is cluster mode");
  52.             return redissonCluster();
  53.         }
  54.         // 单机模式
  55.         String host = redisProperties.getHost();
  56.         if (StringUtils.isNotBlank(host)) {
  57.             log.info("redis is single mode");
  58.             return redissonSingle();
  59.         }
  60.  
  61.         log.error("redisson config can not support this redis mode");
  62.         return null;
  63.     }
  64.  
  65.     /**
  66.      * 单机模式
  67.      */
  68.     private RedissonClient redissonSingle() {
  69.         String host = redisProperties.getHost();
  70.         String password = redisProperties.getPassword();
  71.         int port = redisProperties.getPort();
  72.         // 设置超时时间
  73.         if (redisProperties.getTimeout() > 0) {
  74.             timeout = redisProperties.getTimeout();
  75.         }
  76.         // 声明一个配置类
  77.         Config config = new Config();
  78.         SingleServerConfig serverConfig = config.useSingleServer()
  79.                 .setAddress(ADDRESS_PREFIX + host + ":" + port)
  80.                 .setTimeout(timeout)
  81.                 .setPingConnectionInterval(pingConnectionInterval)
  82.                 .setConnectionPoolSize(this.connectionPoolSize)
  83.                 .setConnectionMinimumIdleSize(this.connectionMinimumIdleSize);
  84.         // 判断密码
  85.         if (!StringUtils.isEmpty(password)) {
  86.             serverConfig.setPassword(password);
  87.         }
  88.         return Redisson.create(config);
  89.     }
  90.  
  91.  
  92.     /**
  93.      * 哨兵模式
  94.      */
  95.     private RedissonClient redissonSentinel() {
  96.         // mymaster
  97.         String masterName = redisProperties.getSentinel().getMaster();
  98.         // 127.0.0.1:26389,127.0.0.1:26379
  99.         String nodes = redisProperties.getSentinel().getNodes();
  100.         String password = redisProperties.getPassword();
  101.         // 设置超时时间
  102.         if (redisProperties.getTimeout() > 0) {
  103.             timeout = redisProperties.getTimeout();
  104.         }
  105.         // 声明一个配置类
  106.         Config config = new Config();
  107.         SentinelServersConfig sentinelServersConfig = config.useSentinelServers();
  108.         // 扫描间隔
  109.         sentinelServersConfig.setScanInterval(2000);
  110.         // 判断密码
  111.         if (!StringUtils.isEmpty(password)) {
  112.             sentinelServersConfig.setPassword(password);
  113.         }
  114.         sentinelServersConfig.setMasterName(masterName);
  115.         String[] nodeArr = StringUtils.split(nodes, ",");
  116.         for (int i = 0; i < nodeArr.length; i++) {
  117.             nodeArr[i] = ADDRESS_PREFIX + nodeArr[i];
  118.         }
  119.         // 添加redis节点
  120.         sentinelServersConfig.addSentinelAddress(nodeArr);
  121.         return Redisson.create(config);
  122.     }
  123.  
  124.     /**
  125.      * 集群模式
  126.      */
  127.     private RedissonClient redissonCluster() {
  128.         // 192.168.116.156:1901,192.168.116.156:1902
  129.         List<String> nodes = redisProperties.getCluster().getNodes();
  130.         String password = redisProperties.getPassword();
  131.         // 设置超时时间
  132.         if (redisProperties.getTimeout() > 0) {
  133.             timeout = redisProperties.getTimeout();
  134.         }
  135.         // 声明一个配置类
  136.         Config config = new Config();
  137.         ClusterServersConfig clusterServersConfig = config.useClusterServers();
  138.         // 扫描间隔
  139.         clusterServersConfig.setScanInterval(2000);
  140.         // 判断密码
  141.         if (!StringUtils.isEmpty(password)) {
  142.             clusterServersConfig.setPassword(password);
  143.         }
  144.         // 添加redis节点
  145.         for (String node : nodes) {
  146.             clusterServersConfig.addNodeAddress(ADDRESS_PREFIX + node);
  147.         }
  148.         return Redisson.create(config);
  149.     }
  150. }

Redis配置

  1. spring:
  2.   redis:
  3.  
  4.     # 单机/主从模式
  5. #    host: 192.168.8.129
  6. #    port: 7001
  7.  
  8.     # 哨兵模式
  9. #    sentinel:
  10. #      master: mymaster
  11. #      nodes: 192.168.8.129:27001,192.168.8.129:27002,192.168.8.129:27003
  12.  
  13.     # 集群模式
  14.     cluster:
  15.       nodes: 192.168.8.129:8001,192.168.8.129:8002,192.168.8.129:8003,192.168.8.129:8004,192.168.8.129:8005,192.168.8.129:8006
  16.  
  17.     # redis服务数据库下标
  18.     database: 2
  19.     # redis服务密码
  20. #    password: 111111
  21.     pool:
  22.       max-idle: 100
  23.       min-idle: 1
  24.       max-active: 10
  25.       max-wait: 5000

Redisson简单测试

  1. package com.idto.controller;
  2.  
  3. import org.redisson.api.RLock;
  4. import org.redisson.api.RedissonClient;
  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.web.bind.annotation.GetMapping;
  9. import org.springframework.web.bind.annotation.RestController;
  10.  
  11. import java.util.concurrent.TimeUnit;
  12.  
  13.  
  14. @RestController
  15. public class RedissionController {
  16.  
  17.     Logger log = LoggerFactory.getLogger(RedissionController.class);
  18.  
  19.     @Autowired
  20.     private RedissonClient redissonClient;
  21.  
  22.     @GetMapping("/lock")
  23.     public String lock() throws InterruptedException {
  24.         String lockKey = "lock";
  25.         RLock lock = redissonClient.getLock(lockKey);
  26.         boolean lockResult = lock.tryLock();
  27.         log.info("lock key {} lock result {}", lockKey, lockResult);
  28.         TimeUnit.SECONDS.sleep(5);
  29.         lock.unlock();
  30.         log.info("lock key {} unlock ", lockKey);
  31.         return System.currentTimeMillis() + "---" + lockResult;
  32.     }
  33.  
  34.  
  35. }
  36.

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号