java连接redis集群

注：如果需要自己搭建redis集群请下载我的搭建教程资源包，该教程是在本地虚拟机搭建的伪集群：https://download.csdn.net/download/qq_37519791/12419299

<dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>

第一种：JRedisCluster

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

import java.util.LinkedHashSet;
import java.util.Set;


public class JRedisCluster {

    private static volatile JedisCluster cluster;

    private static JedisCluster getInstance() {
        if (cluster == null) {
            synchronized (ShardedJedisClusterUtil.class) {
                if (cluster == null) {
                    //可以设置单节点即可访问所有节点数据
                    Set<HostAndPort> nodes = new LinkedHashSet<>();
                    //Set<HostAndPort> set = new HashSet<>();
                    nodes.add(new HostAndPort("192.168.21.221", 7001));
                    nodes.add(new HostAndPort("192.168.21.221", 7002));
                    nodes.add(new HostAndPort("192.168.21.221", 7003));
                    nodes.add(new HostAndPort("192.168.21.221", 7004));
                    nodes.add(new HostAndPort("192.168.21.221", 7005));
                    nodes.add(new HostAndPort("192.168.21.221", 7006));
                    //connectionTimeout 连接超时时间，soTimeout 读取数据超时，maxAttempts 重试次数
                    cluster = new JedisCluster(nodes,5000,3000,10,"123456", new JedisPoolConfig());
                    return cluster;
                }
            }
        }
        return cluster;
    }

    //test
    public static void main(String[] args) {
        System.out.println(setValue("qjtest","测试"));
//        System.out.println(delKey("name"));
//        System.out.println(getValue("qj"));
    }

    public static String getValue(String key){
        cluster = getInstance();
        return cluster.get(key);
    }

    /**
     * 设置参数
     * @param key 键
     * @param value 值
     * @return 结果
     */
    public static String setValue(String key,String value){
        cluster = getInstance();
        return cluster.set(key,value);
    }

    /**
     * 设置参数
     * @param key 键
     * @param value 值
     * @param time 时间 单位：秒
     * @return 结果
     */
    public static String setValue(String key,String value,int time){
        cluster = getInstance();
        return cluster.setex(key,time,value);
    }

    /**
     * 删除key
     * @param key 键
     * @return 结果 成功返回1 失败返回0
     */
    public static Long delKey(String key){
        cluster = getInstance();
        return cluster.del(key);
    }
}

第二种：ShardedJedisCluster

import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.JedisShardInfo;
import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;

import java.io.IOException;
import java.lang.reflect.Field;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

/**
 *
 * @author qiaojun
 * @date 2020/4/20
 */
@Slf4j
public class ShardedJedisClusterUtil {

    private static final Logger logger = LoggerFactory.getLogger(RedisUtil.class);

    private static ShardedJedisPool shardedJedisPool;
    // 静态代码初始化池配置
    static {
        JedisPoolConfig config = new JedisPoolConfig();

        //是否启用后进先出, 默认true
        config.setLifo(true);
        //最大空闲连接数, 默认8个
        config.setMaxIdle(8);
        //最小空闲连接数, 默认0
        config.setMinIdle(0);
        //最大连接数, 默认8个
        config.setMaxTotal(8);
        //获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间, 默认-1
        config.setMaxWaitMillis(-1);
        //逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
        config.setMinEvictableIdleTimeMillis(1800000);
        //每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
        config.setNumTestsPerEvictionRun(3);
        //对象空闲多久后逐出, 当空闲时间>该值 且 空闲连接>最大空闲数 时直接逐出,不再根据MinEvictableIdleTimeMillis判断 (默认逐出策略)
        config.setSoftMinEvictableIdleTimeMillis(1800000);
        //在获取连接的时候检查有效性, 默认false
        config.setTestOnBorrow(false);
        //在空闲时检查有效性, 默认false 设置为true，从连接池中获取对象时，会进行检查，检查不通过，会从连接池中移走并销毁
        config.setTestWhileIdle(false);
        //设置为true，归还连接时，会进行检查，检查不通过，销毁
        config.setTestOnReturn(false);


        //创建四个redis服务实例，并封装在list中
        List<JedisShardInfo> list = new LinkedList<>();
//        JedisShardInfo jedisShardInfo = new JedisShardInfo("test2.juxinbox.com", 6379,3000);
//        jedisShardInfo.setPassword("123456");
        JedisShardInfo js1 = new JedisShardInfo("192.168.21.221", 7001,3000);
        JedisShardInfo js2 = new JedisShardInfo("192.168.21.221", 7002,3000);
        JedisShardInfo js3 = new JedisShardInfo("192.168.21.221", 7003,3000);
        JedisShardInfo js4 = new JedisShardInfo("192.168.21.221", 7004,3000);
        JedisShardInfo js5 = new JedisShardInfo("192.168.21.221", 7005,3000);
        JedisShardInfo js6 = new JedisShardInfo("192.168.21.221", 7006,3000);
        js1.setPassword("123456");js2.setPassword("123456");js3.setPassword("123456");
        js4.setPassword("123456");js5.setPassword("123456");js6.setPassword("123456");
        list.add(js1);list.add(js2);list.add(js3);list.add(js4);list.add(js5);list.add(js6);
//        list.add(new JedisShardInfo("192.168.21.221", 7001,3000));
//        list.add(new JedisShardInfo("192.168.21.221", 7002,3000));
//        list.add(new JedisShardInfo("192.168.21.221", 7003,3000));
//        list.add(new JedisShardInfo("192.168.21.221", 7004,3000));
//        list.add(new JedisShardInfo("192.168.21.221", 7005,3000));
//        list.add(new JedisShardInfo("192.168.21.221", 7006,3000));
//            list.add(newInstance(new JedisShardInfo("192.168.21.221", 7006,3000)));
        //创建具有分片功能的的Jedis连接池
        shardedJedisPool = new ShardedJedisPool(config, list);
    }

    private static JedisShardInfo newInstance(JedisShardInfo jedisShardInfo) {
        Class<? extends JedisShardInfo> clz = jedisShardInfo.getClass();
        Field declaredField = null;
        try {
            declaredField = clz.getDeclaredField("db");
            declaredField.setAccessible(true);
            declaredField.set(jedisShardInfo, Integer.parseInt(Constants.REDIS_DATABASE));
        } catch (NoSuchFieldException | IllegalAccessException e) {
            log.error(e.getMessage(),e);
        }
        return jedisShardInfo;
    }

    private static ShardedJedis getResource()
    {
        ShardedJedis jedis = null;
        try
        {
            jedis = shardedJedisPool.getResource();
            logger.debug("getResource:{}", jedis);
        }
        catch (Exception e)
        {
            logger.error("连接redis服务器异常！--->详细信息如下：" + e.getMessage(), e);
        }
        return jedis;
    }

    public static void main(String[] args) {
        String key = "name";
        ShardedJedis jedis = getResource();
        String name2 = jedis.get(key);
        System.out.println("ShardedJedis-name：" + name2);
        jedis.close();
        shardedJedisPool.close();
    }
}