SpringBoot 프로젝트를 Redis 클러스터에 연결하는 방법

구성 매개변수

이 글에서는 Redis 클러스터 구성을 소개하지 않기 때문에 여기서는 이미 Redis 클러스터 환경이 있다고 가정하고 프로젝트에서 다음 부분을 조정해야 합니다Redis 集群的搭建，这里我们假设已经有了一个 Redis 的集群环境，我们项目中需要调整以下几个部分

1. 修改配置参数，集群的节点和密码配置；

2. 确保引入的 Jedis 版本支持设置密码，spring-data-redis 1.8 以上，SpringBoot 1.5 以上才支持设置密码；

3. 注入 RedisTemplate；

4. 编写工具类；

修改配置参数

############### Redis 集群配置 #########################
spring.custome.redis.cluster.nodes=172.20.0.1:7001,172.20.0.2:7002,172.20.0.3:7003
spring.custome.redis.cluster.max-redirects=3
spring.custome.redis.cluster.max-active=500
spring.custome.redis.cluster.max-wait=-1
spring.custome.redis.cluster.max-idle=500
spring.custome.redis.cluster.min-idle=20
spring.custome.redis.cluster.timeout=3000
spring.custome.redis.cluster.password=redis.cluster.password

引入依赖（如果需要）

确保  SpringBoot 的版本大于 1.4.x 如果不是的话，采用如下配置，先排除 SpringBoot 中旧版本 Jedis 和 spring-data-redis，再依赖高版本的 Jedis 和 spring-data-redis。

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

            

            

                
                    redis.clients
                    jedis

                

                
                    org.springframework.data
                    spring-data-redis

                

            

        

        

        
            redis.clients
            jedis
            2.9.0

        

        
            org.springframework.data
            spring-data-redis
            1.8.0.RELEASE

注入 RedisTemplate

注入 RedisTemplate 我们需要三个组件，分别是JedisConnectionFactory 、RedisClusterConfiguration、JedisPoolConfig，下面是注入RedisTempalte 的代码。先根据配置创建 JedisConnectFactory 同时需要配置 RedisClusterConfiguration、JedisPoolConfig，最后将JedisConnectionFactory 返回用于创建RedisTemplate

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
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.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;


import java.time.Duration;
import java.util.ArrayList;
import java.util.List;


public class RedisClusterConfig {


    @Bean(name = "redisTemplate")
    @Primary
    public RedisTemplate redisClusterTemplate(@Value("${spring.custome.redis.cluster.nodes}") String host,
                                     @Value("${spring.custome.redis.cluster.password}") String password,
                                     @Value("${spring.custome.redis.cluster.timeout}") long timeout,
                                     @Value("${spring.custome.redis.cluster.max-redirects}") int maxRedirect,
                                     @Value("${spring.custome.redis.cluster.max-active}") int maxActive,
                                     @Value("${spring.custome.redis.cluster.max-wait}") int maxWait,
                                     @Value("${spring.custome.redis.cluster.max-idle}") int maxIdle,
                                     @Value("${spring.custome.redis.cluster.min-idle}") int minIdle) {


        JedisConnectionFactory connectionFactory =  jedisClusterConnectionFactory(host, password,
                timeout, maxRedirect, maxActive, maxWait, maxIdle, minIdle);
        return createRedisClusterTemplate(connectionFactory);
    }


    private JedisConnectionFactory jedisClusterConnectionFactory(String host, String password,
                                                                   long timeout, int maxRedirect, int maxActive, int maxWait, int maxIdle, int minIdle) {
        RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();
        List nodeList = new ArrayList();
        String[] cNodes = host.split(",");
        //分割出集群节点
        for (String node : cNodes) {
            String[] hp = node.split(":");
            nodeList.add(new RedisNode(hp[0], Integer.parseInt(hp[1])));
        }
        redisClusterConfiguration.setClusterNodes(nodeList);
        redisClusterConfiguration.setPassword(password);
        redisClusterConfiguration.setMaxRedirects(maxRedirect);


        // 连接池通用配置
        GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();
        genericObjectPoolConfig.setMaxIdle(maxIdle);
        genericObjectPoolConfig.setMaxTotal(maxActive);
        genericObjectPoolConfig.setMinIdle(minIdle);
        genericObjectPoolConfig.setMaxWaitMillis(maxWait);
        genericObjectPoolConfig.setTestWhileIdle(true);
        genericObjectPoolConfig.setTimeBetweenEvictionRunsMillis(300000);


        JedisClientConfiguration.DefaultJedisClientConfigurationBuilder builder = (JedisClientConfiguration.DefaultJedisClientConfigurationBuilder) JedisClientConfiguration
                .builder();
        builder.connectTimeout(Duration.ofSeconds(timeout));
        builder.usePooling();
        builder.poolConfig(genericObjectPoolConfig);
        JedisConnectionFactory connectionFactory = new JedisConnectionFactory(redisClusterConfiguration, builder.build());
        // 连接池初始化
        connectionFactory.afterPropertiesSet();


        return connectionFactory;
    }


    private RedisTemplate createRedisClusterTemplate(JedisConnectionFactory redisConnectionFactory) {
        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(redisConnectionFactory);


        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);


        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        redisTemplate.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();


        return redisTemplate;
    }
}

编写工具类

其实到这里基本上已经完成了，我们可以看到 SpringBoot 项目接入 Redis 集群还是比较简单的，而且如果之前单机环境就是采用RedisTemplate

1. 구성 매개변수, 클러스터 노드 및 비밀번호 구성을 수정하세요. 🎜
2. 🎜소개된 Jedis 버전이 비밀번호 설정을 지원하는지 확인하세요. , spring-data-redis 1.8 이상, SpringBoot 1.5 이상은 비밀번호 설정만 지원합니다. 🎜
3. 🎜Inject RedisTemplate; 🎜
4. 🎜도구 클래스 작성;🎜

🎜구성 매개변수 수정🎜

/**
     *  删除KEY
     * @param key
     * @return
     */
    public boolean delete(String key) {
        try {
            return getTemplate().delete(key);
        } catch (Exception e) {
            log.error("redis hasKey() is error");
            return false;
        }
    }


    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {


        return key == null ? null : getTemplate().opsForValue().get(key);
    }


    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {


        try {
            getTemplate().opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            log.error("redis set() is error");
            return false;
        }


    }


    /**
     * 普通缓存放入并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                getTemplate().opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            log.error("redis set() is error");
            return false;
        }
    }


    /**
     * 计数器
     *
     * @param key 键
     * @return 值
     */
    public Long incr(String key) {


        return getTemplate().opsForValue().increment(key);
    }


    public Long incrBy(String key, long step) {


        return getTemplate().opsForValue().increment(key, step);
    }


    /**
     * HashGet
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public Object hget(String key, String item) {


        return getTemplate().opsForHash().get(key, item);
    }


    /**
     * 获取hashKey对应的所有键值
     *
     * @param key 键
     * @return 对应的多个键值
     */
    public Map hmget(String key) {


        return getTemplate().opsForHash().entries(key);
    }


    /**
     * 获取hashKey对应的批量键值
     * @param key
     * @param values
     * @return
     */
    public List<Object> hmget(String key, List values) {


        return getTemplate().opsForHash().multiGet(key, values);
    }

🎜종속성 소개(필요한 경우)🎜🎜SpringBoot 버전이 1.4보다 큰지 확인하세요. .x. 그렇지 않은 경우 다음 구성을 사용하여 먼저 SpringBoot에서 Jedis 및 spring-data-redis의 이전 버전을 제외하고 Jedis 및 spring-data-redis의 상위 버전을 사용합니다. 🎜rrreee🎜Inject RedisTemplate🎜🎜Inject RedisTemplate 세 가지 구성 요소, 즉 JedisConnectionFactory, RedisClusterConfiguration, 가 필요합니다. JedisPoolConfig에서 다음은 RedisTempalte를 주입하는 코드입니다. 먼저 구성에 따라 JedisConnectFactory를 생성하고 RedisClusterConfiguration, JedisPoolConfig를 구성하고 마지막으로 JedisConnectionFactory를 반환하여 생성해야 합니다. RedisTemplate🎜rrreee🎜Writing tool class🎜🎜사실 기본적으로 여기서는 SpringBoot 프로젝트를 에 연결하는 것이 비교적 간단하다는 것을 알 수 있습니다. >Redis 클러스터. 이전에 독립 실행형 환경에서 RedisTemplate을 사용했다면 이제 도구 클래스를 작성할 필요가 없으며 이전 작업은 여전히 ​​유효합니다. 🎜아아아아

위 내용은 SpringBoot 프로젝트를 Redis 클러스터에 연결하는 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!