redis读写分离之lettuce

ゞ 浴缸里的玫瑰 2022-12-20 11:16 278阅读 0赞

问题

redis使用过程中，很多情况都是读多写少，而不管是主从、哨兵、集群，从节点都只是用来备份，为了最大化节约用户成本，我们需要利用从节点来进行读，分担主节点压力，这里我们继续上一章的jedis的读写分离，由于springboot现在redis集群默认用的是lettuce，所以介绍下lettuce读写分离

读写分离

主从读写分离

这里先建一个主从集群，1主3从，一般情况下只需要进行相关配置如下：

  1. spring:
  2.   redis:
  3.     host: redisMastHost
  4.     port: 6379
  5.     lettuce:
  6.       pool:
  7.         max-active: 512
  8.         max-idle: 256
  9.         min-idle: 256
  10.         max-wait: -1

这样就可以直接注入redisTemplate，读写数据了，但是这个默认只能读写主，如果需要设置readfrom，则需要自定义factory，下面给出两种方案

方案一（适用于非aws）

只需要配置主节点，从节点会信息会自动从主节点获取

  1. @Configuration
  2. class WriteToMasterReadFromReplicaConfiguration {
  4.   @Bean
  5.   public LettuceConnectionFactory redisConnectionFactory() {
  7.     LettuceClientConfiguration clientConfig = LettuceClientConfiguration.builder()
  8.       .readFrom(ReadFrom.SLAVE_PREFERRED)
  9.       .build();
  11.     RedisStandaloneConfiguration serverConfig = new RedisStandaloneConfiguration("server", 6379);
  13.     return new LettuceConnectionFactory(serverConfig, clientConfig);
  14.   }
  15. }

方案二（云上redis，比如aws）

下面给个demo

  1. import io.lettuce.core.ReadFrom;
  2. import io.lettuce.core.models.role.RedisNodeDescription;
  3. import org.apache.commons.lang3.StringUtils;
  4. import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;
  7. import org.springframework.beans.factory.annotation.Qualifier;
  8. import org.springframework.beans.factory.annotation.Value;
  9. import org.springframework.context.annotation.Bean;
  10. import org.springframework.context.annotation.Configuration;
  11. import org.springframework.data.redis.connection.RedisStaticMasterReplicaConfiguration;
  12. import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
  13. import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
  14. import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
  15. import org.springframework.data.redis.core.RedisTemplate;
  16. import org.springframework.data.redis.serializer.StringRedisSerializer;
  18. import java.time.Duration;
  19. import java.util.List;
  20. import java.util.concurrent.atomic.AtomicInteger;
  21. import java.util.stream.Collectors;
  22. import java.util.stream.IntStream;
  23. import java.util.stream.Stream;
  25. @Configuration
  26. public class RedisConfig {
  27.     @Value("${spring.redis1.master}")
  28.     private String master;
  29.     @Value("${spring.redis1.slaves:}")
  30.     private String slaves;
  32.     @Value("${spring.redis1.port}")
  33.     private int port;
  35.     @Value("${spring.redis1.timeout:200}")
  36.     private long timeout;
  38.     @Value("${spring.redis1.lettuce.pool.max-idle:256}")
  39.     private int maxIdle;
  41.     @Value("${spring.redis1.lettuce.pool.min-idle:256}")
  42.     private int minIdle;
  44.     @Value("${spring.redis1.lettuce.pool.max-active:512}")
  45.     private int maxActive;
  47.     @Value("${spring.redis1.lettuce.pool.max-wait:-1}")
  48.     private long maxWait;
  50.     private static Logger logger = LoggerFactory.getLogger(RedisConfig.class);
  51.     private final AtomicInteger index = new AtomicInteger(-1);
  52.     @Bean(value = "lettuceConnectionFactory1")
  53.     LettuceConnectionFactory lettuceConnectionFactory1(GenericObjectPoolConfig genericObjectPoolConfig) {
  54.         RedisStaticMasterReplicaConfiguration configuration = new RedisStaticMasterReplicaConfiguration(
  55.                 this.master, this.port);
  56.         if(StringUtils.isNotBlank(slaves)){
  57.             String[] slaveHosts=slaves.split(",");
  58.             for (int i=0;i<slaveHosts.length;i++){
  59.                 configuration.addNode(slaveHosts[i], this.port);
  60.             }
  61.         }
  62.         LettuceClientConfiguration clientConfig =
  63.                 LettucePoolingClientConfiguration.builder().readFrom(ReadFrom.SLAVE).commandTimeout(Duration.ofMillis(timeout))
  64.                         .poolConfig(genericObjectPoolConfig).build();
  65.         return new LettuceConnectionFactory(configuration, clientConfig);
  66.     }
  68.     /**
  69.      * GenericObjectPoolConfig 连接池配置
  70.      * @return
  71.      */
  72.     @Bean
  73.     public GenericObjectPoolConfig genericObjectPoolConfig() {
  74.         GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();
  75.         genericObjectPoolConfig.setMaxIdle(maxIdle);
  76.         genericObjectPoolConfig.setMinIdle(minIdle);
  77.         genericObjectPoolConfig.setMaxTotal(maxActive);
  78.         genericObjectPoolConfig.setMaxWaitMillis(maxWait);
  79.         return genericObjectPoolConfig;
  80.     }
  82.     @Bean(name = "redisTemplate1")
  83.     public RedisTemplate redisTemplate(@Qualifier("lettuceConnectionFactory1") LettuceConnectionFactory connectionFactory) {
  84.         RedisTemplate<String,String> template = new RedisTemplate<String,String>();
  85.         template.setConnectionFactory(connectionFactory);
  86.         template.setKeySerializer(new StringRedisSerializer());
  87.         template.setValueSerializer(new StringRedisSerializer());
  88.         template.setHashKeySerializer(new StringRedisSerializer());
  89.         template.setHashValueSerializer(new StringRedisSerializer());
  90.         logger.info("redis 连接成功");
  91.         return template;
  92.     }
  95. }

这里的核心代码在readfrom的设置，lettuce提供了5中选项，分别是

  • MASTER
  • MASTER_PREFERRED
  • SLAVE_PREFERRED
  • SLAVE

  • NEAREST
    最新的版本SLAVE改成了ReadFrom.REPLICA
    这里设置为SlAVE，那么读请求都会走从节点，但是这里有个bug，每次都会读取最后一个从节点，其他从节点都不会有请求过去，跟踪源代码发现节点顺序是一定的，但是每次getConnection时每次都会获取最后一个，下面是缓存命令情况
    在这里插入图片描述
    解决方案就是自定义一个readFrom，如下

    LettuceClientConfiguration clientConfig =

    1.             LettucePoolingClientConfiguration.builder().readFrom(new ReadFrom() {
    2.                 @Override
    3.                 public List<RedisNodeDescription> select(Nodes nodes) {
    4.                     List<RedisNodeDescription> allNodes = nodes.getNodes();
    5.                     int ind = Math.abs(index.incrementAndGet() % allNodes.size());
    6.                     RedisNodeDescription selected = allNodes.get(ind);
    7.                     logger.info("Selected random node {} with uri {}", ind, selected.getUri());
    8.                     List<RedisNodeDescription> remaining = IntStream.range(0, allNodes.size())
    9.                             .filter(i -> i != ind)
    10.                             .mapToObj(allNodes::get).collect(Collectors.toList());
    11.                     return Stream.concat(
    12.                             Stream.of(selected),
    13.                             remaining.stream()
    14.                     ).collect(Collectors.toList());
    15.                 }
    16.             }).commandTimeout(Duration.ofMillis(timeout))
    17.                     .poolConfig(genericObjectPoolConfig).build();
    18.     return new LettuceConnectionFactory(configuration, clientConfig);

手动实现顺序读各个从节点，修改后调用情况如下，由于还有其他应用连接该redis，所以监控图中非绝对均衡
在这里插入图片描述

哨兵模式

这个我就提供一个简单demo

  1. @Configuration
  2. @ComponentScan("com.redis")
  3. public class RedisConfig {
  5.     @Bean
  6.     public LettuceConnectionFactory redisConnectionFactory() {
  7. //        return new LettuceConnectionFactory(new RedisStandaloneConfiguration("192.168.80.130", 6379));
  8.         RedisSentinelConfiguration sentinelConfig = new RedisSentinelConfiguration()
  9.                 .master("mymaster")
  10.                 // 哨兵地址
  11.                 .sentinel("192.168.80.130", 26379)
  12.                 .sentinel("192.168.80.130", 26380)
  13.                 .sentinel("192.168.80.130", 26381);
  15.         LettuceClientConfiguration clientConfig = LettuceClientConfiguration.builder().
  16.         readFrom(ReadFrom.SLAVE_PREFERRED).build();
  17.         return new LettuceConnectionFactory(sentinelConfig, clientConfig);
  18.     }
  20.     @Bean
  21.     public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
  22.         RedisTemplate redisTemplate = new RedisTemplate();
  23.         redisTemplate.setConnectionFactory(redisConnectionFactory);
  24.         // 可以配置对象的转换规则，比如使用json格式对object进行存储。
  25.         // Object --> 序列化 --> 二进制流 --> redis-server存储
  26.         redisTemplate.setKeySerializer(new StringRedisSerializer());
  27.         redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());
  28.         return redisTemplate;
  29.     }
  31. }

集群模式

集群模式就比较简单了，直接套用下面demo

  1. import io.lettuce.core.ReadFrom;
  2. import io.lettuce.core.resource.ClientResources;
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.apache.commons.lang3.StringUtils;
  5. import org.springframework.beans.factory.annotation.Qualifier;
  6. import org.springframework.beans.factory.annotation.Value;
  7. import org.springframework.context.annotation.Bean;
  8. import org.springframework.context.annotation.Configuration;
  9. import org.springframework.data.redis.connection.RedisClusterConfiguration;
  10. import org.springframework.data.redis.connection.RedisConnectionFactory;
  11. import org.springframework.data.redis.connection.RedisNode;
  12. import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
  13. import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
  14. import org.springframework.data.redis.core.RedisTemplate;
  15. import org.springframework.data.redis.serializer.StringRedisSerializer;
  17. import java.time.Duration;
  18. import java.util.HashSet;
  19. import java.util.Set;
  21. @Slf4j
  22. @Configuration
  23. public class Redis2Config {
  25.     @Value("${spring.redis2.cluster.nodes: com:9736}")
  26.     public String REDIS_HOST;
  28.     @Value("${spring.redis2.cluster.port:9736}")
  29.     public int REDIS_PORT;
  31.     @Value("${spring.redis2.cluster.type:}")
  32.     public String REDIS_TYPE;
  33.     @Value("${spring.redis2.cluster.read-from:master}")
  34.     public String READ_FROM;
  35.     @Value("${spring.redis2.cluster.max-redirects:1}")
  36.     public int REDIS_MAX_REDIRECTS;
  38.     @Value("${spring.redis2.cluster.share-native-connection:true}")
  39.     public boolean REDIS_SHARE_NATIVE_CONNECTION;
  41.     @Value("${spring.redis2.cluster.validate-connection:false}")
  42.     public boolean VALIDATE_CONNECTION;
  44.     @Value("${spring.redis2.cluster.shutdown-timeout:100}")
  45.     public long SHUTDOWN_TIMEOUT;
  47.     @Bean(value = "myRedisConnectionFactory")
  48.     public RedisConnectionFactory connectionFactory(ClientResources clientResources) {
  49.         RedisClusterConfiguration clusterConfiguration = new RedisClusterConfiguration();
  50.         if (StringUtils.isNotEmpty(REDIS_HOST)) {
  51.             String[] serverArray = REDIS_HOST.split(",");
  52.             Set<RedisNode> nodes = new HashSet<RedisNode>();
  53.             for (String ipPort : serverArray) {
  54.                 String[] ipAndPort = ipPort.split(":");
  55.                 nodes.add(new RedisNode(ipAndPort[0].trim(), Integer.valueOf(ipAndPort[1])));
  56.             }
  57.             clusterConfiguration.setClusterNodes(nodes);
  58.         }
  59.         if (REDIS_MAX_REDIRECTS > 0) {
  60.             clusterConfiguration.setMaxRedirects(REDIS_MAX_REDIRECTS);
  61.         }
  63.         LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder clientConfigurationBuilder = LettucePoolingClientConfiguration.builder()
  64.                 .clientResources(clientResources).shutdownTimeout(Duration.ofMillis(SHUTDOWN_TIMEOUT));
  65.         if (READ_FROM.equals("slave")) {
  66.             clientConfigurationBuilder.readFrom(ReadFrom.SLAVE_PREFERRED);
  67.         } else if (READ_FROM.equals("nearest")) {
  68.             clientConfigurationBuilder.readFrom(ReadFrom.NEAREST);
  69.         } else if (READ_FROM.equals("master")) {
  70.             clientConfigurationBuilder.readFrom(ReadFrom.MASTER_PREFERRED);
  71.         }
  72.         LettuceConnectionFactory lettuceConnectionFactory = new LettuceConnectionFactory(clusterConfiguration, clientConfigurationBuilder.build());
  73.         lettuceConnectionFactory.afterPropertiesSet();
  74.         return lettuceConnectionFactory;
  75.     }
  77.     @Bean(name = "myRedisTemplate")
  78.     public RedisTemplate myRedisTemplate(@Qualifier("myRedisConnectionFactory") RedisConnectionFactory connectionFactory) {
  79.         RedisTemplate template = new RedisTemplate();
  80.         template.setConnectionFactory(connectionFactory);
  81.         template.setKeySerializer(new StringRedisSerializer());
  82.         template.setValueSerializer(new StringRedisSerializer());
  83.         return template;
  84.     }
  87. }

不过这里集群模式不推荐读取从节点，因为在生产中有可能导致某一分片挂掉以至于整个集群都不可用，可以考虑从节点整多个，然后配置读写分离。

发表评论

表情：
评论列表 （有 0 条评论，278人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Redis读写分离

    概述： 1. 为什么要用redis读写分离：单机情况下redis能承受大约2万的QPS（具体数据因机器配置与业务场景而异），如果想要承接更高数值的QP

    港控/mmm°港控/mmm°/ 0 赞/ 71 阅读

    相关 redis读写分离之lettuce

    问题 redis使用过程中，很多情况都是读多写少，而不管是主从、哨兵、集群，从节点都只是用来备份，为了最大化节约用户成本，我们需要利用从节点来进行读，分担主节点压力，这里

    ゞ 浴缸里的玫瑰ゞ 浴缸里的玫瑰/ 0 赞/ 279 阅读

    相关 redis主从库读写分离

    前言：随着web2.0的进一步发展，网民的生产力进一步提升，存储总量开始增加。 此时虽然仍然是读多写少的模式，但写入量已经大大提升。 原有的缓存技术不能缓解写入压力，而且原有的

    墨蓝墨蓝/ 0 赞/ 272 阅读

    相关 Redis读写分离

    场景：Redis的主从架构，能帮助我们实现读多，写少的情况 意义： 读写分离主要是为了扩展读。你也可以理解为提高了并发吞吐和负载能力。 读写分离一致性 

    悠悠悠悠/ 0 赞/ 302 阅读