SpringBoot使用多数据源的redis集群

ps:网上大多博客都是讲述使用多个redis数据源但是不是集群  我在各位网友的代码基础上稍加修改  可以实现配置多个 redis集群数据源  代码可以直接复制改改即可用 

并且有两种方式  有使用JedisCluster连接和RedisTemplate

 

pom文件

<!-- 添加redis支持 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

application.properties

#
spring.redis-ad.cluster.nodes=127.0.0.1:7001, 127.0.0.1:7002, 127.0.0.1:7003, 127.0.0.1:7004, 127.0.0.1:7005, 127.0.0.1:7006
#
spring.redis-bubble.cluster.nodes=127.0.0.1:7001, 127.0.0.1:7002, 127.0.0.1:7003
#
spring.redis-push.cluster.nodes=127.0.0.1:7004, 127.0.0.1:7005, 127.0.0.1:7006

首先贴上JedisCluster连接方式的配置类  这种代码比较少比较简单

package com.bootdo.config;

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Autowired;
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.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;

import java.util.HashSet;
import java.util.Set;

import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPoolConfig;

@Configuration
public class JedisClusterConfig {


    @Value("${spring.redis-ad.cluster.nodes}")
    String redisAd;

    @Value("${spring.redis-bubble.cluster.nodes}")
    String redisBubble;

    @Value("${spring.redis-push.cluster.nodes}")
    String redisPush;
    /**
     * 注意：
     * 这里返回的JedisCluster是单例的，并且可以直接注入到其他类中去使用
     * @return
     */
    @Bean(name = "redisAd")
    @Primary
    public JedisCluster getJedisCluster1() {
        String[] serverArray =redisAd.split(",");//获取服务器数组(这里要相信自己的输入，所以没有考虑空指针问题)
        Set<HostAndPort> nodes = new HashSet<>();
 
        for (String ipPort : serverArray) {
            String[] ipPortPair = ipPort.split(":");
            nodes.add(new HostAndPort(ipPortPair[0].trim(), Integer.valueOf(ipPortPair[1].trim())));
        }
        return new JedisCluster(nodes,10000,1000,1,new GenericObjectPoolConfig());//需要密码连接的创建对象方式
    }
    /**
     * 注意：
     * 这里返回的JedisCluster是单例的，并且可以直接注入到其他类中去使用
     * @return
     */
    @Bean(name = "redisBubble")
    public JedisCluster getJedisCluster2() {
        String[] serverArray =redisBubble.split(",");//获取服务器数组(这里要相信自己的输入，所以没有考虑空指针问题)
        Set<HostAndPort> nodes = new HashSet<>();

        for (String ipPort : serverArray) {
            String[] ipPortPair = ipPort.split(":");
            nodes.add(new HostAndPort(ipPortPair[0].trim(), Integer.valueOf(ipPortPair[1].trim())));
        }
        return new JedisCluster(nodes,10000,1000,1,new GenericObjectPoolConfig());//需要密码连接的创建对象方式
    }

    /**
     * 注意：
     * 这里返回的JedisCluster是单例的，并且可以直接注入到其他类中去使用
     * @return
     */
    @Bean(name = "redisPush")
    public JedisCluster getJedisCluster3() {
        String[] serverArray =redisPush.split(",");//获取服务器数组(这里要相信自己的输入，所以没有考虑空指针问题)
        Set<HostAndPort> nodes = new HashSet<>();

        for (String ipPort : serverArray) {
            String[] ipPortPair = ipPort.split(":");
            nodes.add(new HostAndPort(ipPortPair[0].trim(), Integer.valueOf(ipPortPair[1].trim())));
        }
        return new JedisCluster(nodes,10000,1000,1,new GenericObjectPoolConfig());//需要密码连接的创建对象方式
    }






}

使用案例: 使用不同的bean名称即可使用不用的redis集群数据源

@Autowired
    @Qualifier("redisAd")
    private JedisCluster redisUtil;

接下来贴上redistemplate的配置类

  @Primary代表默认的数据源

package com.bootdo.config;

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.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisNode;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.util.HashSet;
import java.util.Set;

import redis.clients.jedis.JedisPoolConfig;

/**
 * @program: itv-ad-app
 * @description:
 * @author: hw
 * @create: 2019-04-29 09:22
 **/
@Configuration
public class RedisDevConfiguration {
    @Value("${spring.redis-ad.cluster.nodes}")
    String clusterNodes;

    @Value("${spring.redis-bubble.cluster.nodes}")
    String redisBubble;

    @Value("${spring.redis-push.cluster.nodes}")
    String redisPush;
    /**
     * Redis集群的配置
     *
     * @return RedisClusterConfiguration
     * @throws
     */
    @Bean(name = "redisAd1")
    @Primary
    public RedisTemplate redisClusterConfiguration() {
        RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();
        //Set<RedisNode> clusterNodes
        String[] serverArray = clusterNodes.split(",");
        Set<RedisNode> nodes = new HashSet<RedisNode>();
        for (String ipPort : serverArray) {
            String[] ipAndPort = ipPort.split(":");
            nodes.add(new RedisNode(ipAndPort[0].trim(), Integer.valueOf(ipAndPort[1])));
        }
        redisClusterConfiguration.setClusterNodes(nodes);
        //集群模式
        JedisConnectionFactory factory = new JedisConnectionFactory(redisClusterConfiguration,new JedisPoolConfig() );
        factory.setUsePool(true);
        //实例化redistemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }

    /**
     * Redis集群的配置
     *
     * @return RedisClusterConfiguration
     * @throws
     */
    @Bean(name = "redisBubble1")
    public RedisTemplate redisClusterConfiguration2() {
        RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();
        //Set<RedisNode> clusterNodes
        String[] serverArray = redisPush.split(",");
        Set<RedisNode> nodes = new HashSet<RedisNode>();
        for (String ipPort : serverArray) {
            String[] ipAndPort = ipPort.split(":");
            nodes.add(new RedisNode(ipAndPort[0].trim(), Integer.valueOf(ipAndPort[1])));
        }
        redisClusterConfiguration.setClusterNodes(nodes);
        //集群模式
        JedisConnectionFactory factory = new JedisConnectionFactory(redisClusterConfiguration,new JedisPoolConfig() );
        factory.setUsePool(true);
        //实例化redistemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }


    /**
     * Redis集群的配置
     *
     * @return RedisClusterConfiguration
     * @throws
     */
    @Bean(name = "redisPush1")
    public RedisTemplate redisClusterConfiguration3() {
        RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();
        //Set<RedisNode> clusterNodes
        String[] serverArray = redisBubble.split(",");
        Set<RedisNode> nodes = new HashSet<RedisNode>();
        for (String ipPort : serverArray) {
            String[] ipAndPort = ipPort.split(":");
            nodes.add(new RedisNode(ipAndPort[0].trim(), Integer.valueOf(ipAndPort[1])));
        }
        redisClusterConfiguration.setClusterNodes(nodes);
        //集群模式
        JedisConnectionFactory factory = new JedisConnectionFactory(redisClusterConfiguration,new JedisPoolConfig() );
        factory.setUsePool(true);
        //实例化redistemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }





}

顺带贴上帮助类 能方便的使用redistemplate

package com.bootdo.util;

import com.fasterxml.jackson.core.JsonProcessingException;

import java.util.Map;
import java.util.Set;

/**
 * redis 的操作开放接口
 * 
 * @author hk
 * 
 *         
 */
public interface RedisService {

    /**
     * 如果key不在的话就给set一个默认1  如果在则获取
     *
     * @param key
     * @return
     */
    public long getorset(String key);


    public Long setIncrValue1(String key);
    /**
     * 通过key删除
     * 
     * @param keys
     */
    public  long del(String... keys);

    /**
     * 添加key value 并且设置存活时间(byte)
     * 
     * @param key
     * @param value
     * @param liveTime
     */
    public abstract void set(byte[] key, byte[] value, long liveTime);

    /**
     * 添加key value 并且设置存活时间
     * 
     * @param key
     * @param value
     * @param liveTime
     *            单位秒
     */
    public abstract void set(String key, String value, long liveTime);

    /**
     * 添加key value
     * 
     * @param key
     * @param value
     */
    public abstract void set(String key, String value);

    /**
     * 添加key value (字节)(序列化)
     * 
     * @param key
     * @param value
     */
    public abstract void set(byte[] key, byte[] value);
    public abstract void setMap(String key, Map<String, Object> map) throws JsonProcessingException;
    public abstract Map<String,Object> getMap(String key);

    /**
     * 获取redis value (String)
     * 
     * @param key
     * @return
     */
    public abstract String get(String key);

    /**
     * 通过正则匹配keys
     * 
     * @param pattern
     * @return
     */
    public abstract  Set keys(String pattern);

    /**
     * 检查key是否已经存在
     * 
     * @param key
     * @return
     */
    public abstract boolean exists(String key);

    /**
     * 清空redis 所有数据
     * 
     * @return
     */
    public abstract String flushDB();

    /**
     * 查看redis里有多少数据
     */
    public abstract long dbSize();

    /**
     * 有序集合 添加数据
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key, Object value, double scoure);
    
    /**
     * 有序集合 根据分数（范围） 获取值
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     */
    public Set<Object> rangeByScore(String key, double scoure, double scoure1);
    
    /**
     * 检查是否连接成功
     * 
     * @return
     */
    public abstract String ping();
       
    
    /**
     * 获取自增的值
     * @param key
     * @return
     */
    public abstract long setIncrValue(String key);

}

 注意,实现类里面用到的redistemplate  你需要根据你 自身所需再创建不同的实现类注入不同bean名称的redistemp即可

package com.bootdo.util;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import redis.clients.jedis.JedisCluster;

/**
 * 封装redis 缓存服务器服务接口
 *
 * @author hk
 * <p>
 * 2012-12-16 上午3:09:18
 */
@Service(value = "redisService")
@SuppressWarnings("unchecked")
public class RedisServiceImpl implements RedisService {
    @SuppressWarnings("rawtypes")
    private static String redisCode = "utf-8";

    @Autowired
    @Qualifier("redisAd1")
    private RedisTemplate redisTemplate;

    @Autowired
   private JedisCluster jedisCluster;
    private static final org.slf4j.Logger logger = LoggerFactory.getLogger(RedisServiceImpl.class);

    /**
     * @param keys
     */

    public long del(final String... keys) {
        return ((long) redisTemplate.execute(new RedisCallback() {
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                long result = 0;
                for (int i = 0; i < keys.length; i++) {
                    result = connection.del(keys[i].getBytes());
                }
                return result;
            }
        }));
    }

    /**
     * @param key
     * @param value
     * @param liveTime
     */
    public void set(final byte[] key, final byte[] value, final long liveTime) {
        redisTemplate.execute(new RedisCallback() {
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                connection.set(key, value);
                if (liveTime > 0) {
                    connection.expire(key, liveTime);
                }
                return 1L;
            }
        });
    }

    /**
     * @param key
     * @param value
     * @param liveTime
     */
    public void set(String key, String value, long liveTime) {
        this.set(key.getBytes(), value.getBytes(), liveTime);
    }

    /**
     * @param key
     * @param value
     */
    public void set(String key, String value) {
        this.set(key, value, 0L);
    }

    /**
     * @param key
     * @param value
     */
    public void set(byte[] key, byte[] value) {
        this.set(key, value, 0L);
    }

    /**
     * @param key
     * @param map
     */
    public void setMap(String key, Map map) throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        this.set(key, objectMapper.writeValueAsString(map), 0L);
    }

    /**
     * @param key
     */
    public Map<String, Object> getMap(String key) {
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            return objectMapper.readValue(this.get(key), Map.class);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return new HashMap<>();
    }

    /**
     * @param key
     * @return
     */
    public String get(final String key) {
        return (String) redisTemplate.execute(new RedisCallback() {
            public String doInRedis(RedisConnection connection) throws DataAccessException {
                String s;
                try {
                    logger.info(key);
                    s = new String(connection.get(key.getBytes()), redisCode);
                } catch (Exception e) {
                   return "";
                }
                return s;
            }
        });
    }

    /**
     * @param pattern
     * @return
     */
    public Set keys(String pattern) {
        return redisTemplate.keys(pattern);

    }

    /**
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return (boolean) redisTemplate.execute(new RedisCallback() {
            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                return connection.exists(key.getBytes());
            }
        });
    }

    /**
     * @return
     */
    public String flushDB() {
        return (String) redisTemplate.execute(new RedisCallback() {
            public String doInRedis(RedisConnection connection) throws DataAccessException {
                connection.flushDb();
                return "ok";
            }
        });
    }

    /**
     * @return
     */
    public long dbSize() {
        return (long) redisTemplate.execute(new RedisCallback() {
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                return connection.dbSize();
            }
        });
    }

    /**
     * @return
     */
    public String ping() {
        return (String) redisTemplate.execute(new RedisCallback() {
            public String doInRedis(RedisConnection connection) throws DataAccessException {

                return connection.ping();
            }
        });
    }

    public void zAdd(String key, Object value, double score) {
        ZSetOperations<String, Object> zset = this.redisTemplate.opsForZSet();
        zset.add(key, value, score);
    }

    public Set<Object> rangeByScore(String key, double scoure, double scoure1) {
        ZSetOperations<String, Object> zset = this.redisTemplate.opsForZSet();
        return zset.rangeByScore(key, scoure, scoure1);
    }

    private RedisServiceImpl() {

    }

    /**
     * 如果key不在的话就给set一个默认0  如果在则获取
     *
     * @param key
     * @return
     */
    public long getorset(String key) {
        if (exists(key)) {
            return Integer.parseInt(get(key));
        } else {
            set(key, "0");
            return 1;
        }

    }

    /**
     *
     * @param key
     * @return
     */
    public Long setIncrValue1(String key) {

        Long increment = redisTemplate.opsForValue().increment(key, 1);
        return increment;
    }

    /**
     * 获取自增的值
     *
     * @param key
     * @return
     */
    public long setIncrValue(String key) {
        // TODO Auto-generated method stub
//        if (exists(key)) {
//            //旧值
//            Integer i = Integer.parseInt(get(key));
//            Integer i1 = i + 1;
//            set(key, i1.toString());
//            return i1;
//        } else {//不存在则新设置
//            set(key, "1");
//            return 1;
//        }

        return redisTemplate.opsForValue().increment(key, 1);





      /*return (long) redisTemplate.execute(new RedisCallback<Long>() {
         @Override
         public Long doInRedis(RedisConnection connection) throws DataAccessException {
            RedisSerializer<String> serializer=redisTemplate.getStringSerializer();
            byte[] rowkey=serializer.serialize(key);
            byte[] rowval=connection.get(rowkey);
            try {
               String val=serializer.deserialize(rowval);
               return Long.parseLong(val);
            } catch (Exception e) {
               return 0L;
            }
         }
      });*/
    }



}

使用示例: 这里通过注入不同的实现类来达到使用不同的数据源的目的

@Resource(name = "redisService")
    RedisService redisUtil1;