526互联

lettuce+redisTemplate实现redis单击和集群的整合

发布时间 2023-06-19 22:56:15作者: 红尘过客2022

lettuce+redisTemplate实现redis单击和集群的整合

Springboot 整合redis是非常方便的，大致包含如下四部分

  • pom start相关jar的引入
  • properties/yaml 基础配置信息
  • config bean的init
  • bean的注入及使用

如果遇到网上的自动装配的实例直接跳过吧，哪怕再小的公司，密码也会加密处理，不可能自动装配。

1、pom

引入Springboot的redis相关组件

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

2、properties基础配置

这里主要配置数据源，其他配置项没有，暂时简化了配置，一切使用默认

为了适配真实业务，这里采用的是双数据源配置，亦真亦假，一单节点一集群。

redis.biz.alone.host=39.105.198.245:6379
redis.biz.alone.auth=hcgk&2022
redis.biz.cluster.host=10.22.251.21:6379,10.22.251.28:6379,10.22.251.23:6379
redis.biz.cluster.auth=7ujm*IK<
lettuce.pool.max-total=12
# 最大活跃链接数 默认8（使用负值表示没有限制）
lettuce.pool.max-active=12
# 最大空闲连接数 默认8
lettuce.pool.max-idle=12
# 最小空闲连接数 默认0
lettuce.pool.min-idle=0
# 连接池最大阻塞等待时间（使用负值表示没有限制）
lettuce.pool.max-wait=-1

3、config

支持单击和集群

package com.wht.test.config;

import io.lettuce.core.ReadFrom;
import io.lettuce.core.TimeoutOptions;
import io.lettuce.core.cluster.ClusterClientOptions;
import io.lettuce.core.cluster.ClusterTopologyRefreshOptions;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisNode;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.StringRedisTemplate;

import java.time.Duration;
import java.util.HashSet;
import java.util.Set;

/**
 * 支持单机、集群和多实例
 *
 * @Author 红尘过客
 * @DateTime 2023-06-19 22:00:12
 */
@Configuration
public class LettuceRedisConfig {

    @Value("${redis.biz.alone.host}")
    private String bizAloneHost;

    @Value("${redis.biz.alone.auth}")
    private String bizAloneAuth;


    @Value("${redis.biz.cluster.host}")
    private String bizClusterHost;

    @Value("${redis.biz.cluster.auth}")
    private String bizClusterAuth;


    @Primary
    @Bean("bizAlone")
    public StringRedisTemplate bizAlone() {
        return getStringRedisTemplate(bizAloneHost, bizAloneAuth);
    }

//    @Primary
//    @Bean("bizCluster")
//    public StringRedisTemplate bizCluster() {
//        return getStringRedisTemplate(bizClusterHost, bizClusterAuth);
//    }

    /**
     * 封装单例配置
     *
     * @param host
     * @param password
     * @return
     */
    private RedisStandaloneConfiguration getRedisStandaloneConfiguration(String host, String password) {
        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
        String[] redisNode = host.split(":");
        if (redisNode.length == 2) {
            redisStandaloneConfiguration.setHostName(redisNode[0]);
            redisStandaloneConfiguration.setPort(Integer.parseInt(redisNode[1]));
        }
        if (password != null || password.trim().length() > 0) {
            redisStandaloneConfiguration.setPassword(password);
        }
        return redisStandaloneConfiguration;
    }

    /**
     * 把集群连接串拆分为redisNodes
     *
     * @param host
     * @return
     */
    private Set<RedisNode> getClusterNodes(String host) {
        String[] nodesArray = host.split(",");
        Set<RedisNode> clusterNodes = new HashSet<>();
        for (String node : nodesArray) {
            String[] redisNode = node.split(":");
            clusterNodes.add(new RedisNode(redisNode[0], Integer.parseInt(redisNode[1])));
        }
        return clusterNodes;
    }

    /**
     * 封装集群配置
     *
     * @param host
     * @param password
     * @return
     */
    private RedisClusterConfiguration getRedisClusterConfiguration(String host, String password) {
        RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();
        redisClusterConfiguration.setClusterNodes(getClusterNodes(host));
        if (password != null || password.trim().length() > 0) {
            redisClusterConfiguration.setPassword(password);
        }
        return redisClusterConfiguration;
    }

    /**
     * 创建alone bean
     * 这里用LettucePoolingClientConfiguration 预留了连接池
     *
     * @param host
     * @param password
     * @return
     */
    private StringRedisTemplate getStringRedisTemplate(String host, String password) {
        LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder builder = LettucePoolingClientConfiguration.builder();
//        builder.poolConfig(pool)
        LettuceConnectionFactory connectionFactory = null;
        // 集群要做拓扑刷新，应对准备切换，摸个节点挂掉等问题
        if (host.contains(",")) {
            ClusterTopologyRefreshOptions topologyRefreshOptions = ClusterTopologyRefreshOptions.builder()
                    .enablePeriodicRefresh(Duration.ofSeconds(10))
                    .enableAllAdaptiveRefreshTriggers()
                    .build();
            ClusterClientOptions clusterClientOptions = ClusterClientOptions.builder()
                    .timeoutOptions(TimeoutOptions.enabled(Duration.ofSeconds(60)))
                    .topologyRefreshOptions(topologyRefreshOptions)
                    .build();

            LettuceClientConfiguration clientConfiguration = builder.commandTimeout(Duration.ofSeconds(60))
                    .readFrom(ReadFrom.REPLICA_PREFERRED)
                    .clientOptions(clusterClientOptions)
                    .build();
            connectionFactory = new LettuceConnectionFactory(getRedisClusterConfiguration(host, password), clientConfiguration);
        } else {
            connectionFactory = new LettuceConnectionFactory(getRedisStandaloneConfiguration(host, password), builder.build());
        }
        connectionFactory.afterPropertiesSet();
        return getStringRedisTemplate(connectionFactory);
    }

    private StringRedisTemplate getStringRedisTemplate(LettuceConnectionFactory connectionFactory) {
        StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
        stringRedisTemplate.setConnectionFactory(connectionFactory);
        return stringRedisTemplate;
    }
}

4、使用

这里简单搞个schedule任务

package com.wht.test.schedule;

import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.time.Duration;

/**
 * desc
 *
 * @Author 红尘过客
 * @DateTime 2023-06-15 10:15:35
 */
@Component
public class RedisTestJob {
    @Resource(name = "bizAlone")
    private StringRedisTemplate stringRedisTemplate;

    @Scheduled(cron = "* * * * * * ")
    public void test() {
        for (int i = 0; i < 100; i++) {
            String key = "test_" + i;
            stringRedisTemplate.opsForValue().set(key, "test_value_" + i, Duration.ofHours(1));
            String name = (String) stringRedisTemplate.opsForValue().get(key);
            System.out.println("value = " + name);
        }


    }
}

可以正常写入数据到redis了