redis集群（四）springboot集成redis集群实例

青旅半醒 2023-02-15 05:24 74阅读 0赞

现有redis主从+哨兵集群：

<table> 
 <thead> 
  <tr> 
   <th>IP地址</th> 
   <th>端口号</th> 
   <th>角色</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>xxx.xx.xxx.151</td> 
   <td>6379</td> 
   <td>主机（master）</td> 
  </tr> 
  <tr> 
   <td>xxx.xx.xxx.32</td> 
   <td>6380</td> 
   <td>从机（slave）</td> 
  </tr> 
  <tr> 
   <td>xxx.xx.xxx.126</td> 
   <td>6381</td> 
   <td>从机（slave）</td> 
  </tr> 
 </tbody> 
</table>

每台机器上各有一个哨兵部署在26379端口。

一、代码：现连接redis集群实现redis连接和session共享：

由于使用了哨兵模式，节点经过故障转移后，主从结构已经发生了改变且主已经死亡，如果还按照之前那样写死IP的方式连接Redis主机的话，会出现错误。可以想到，在Sentinel结构下，你必须向哨兵询问获取谁是Master。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70][]

1、pom：没有改变

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.demo</groupId>
        <artifactId>redisgroup</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>1.4.1.RELEASE</version>
        </parent>
    
        <dependencies>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-redis</artifactId>
            </dependency>
    
            
            <dependency>
                <groupId>org.springframework.session</groupId>
                <artifactId>spring-session-data-redis</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.session</groupId>
                <artifactId>spring-session</artifactId>
            </dependency>
    
            <dependency>
                <groupId>redis.clients</groupId>
                <artifactId>jedis</artifactId>
            </dependency>
    
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>1.2.33</version>
            </dependency>
        </dependencies>
    
    </project>

2、配置文件：加上哨兵的配置，去掉主机配置：

server.port=9999
    server.context-path=/redisgroup
    
    #主机配置删除
    #my.redis.server.host=xxx.xx.xxx.151
    #my.redis.server.port=6379
    #my.redis.server.password = wtyy
    #redis配置
    my.redis.server.jedis.pool.maxTotal=500
    my.redis.server.jedis.pool.maxIdle=10
    my.redis.server.jedis.pool.maxWaitMillis=5000
    my.redis.server.jedis.pool.min-idle=5
    my.redis.server.timeout=5000 
    #哨兵配置
    my.redis.sentinel.nodes=xxx.xx.xxx.151:26379,xxx.xx.xxx.32:26379,xxx.xx.xxx:26379
    my.redis.sentinel.password=wtyy
    my.redis.sentinel.master-name=mymaster
    my.redis.sentinel.pool.max-total=10
    my.redis.sentinel.pool.max-idle=5
    my.redis.sentinel.pool.min-idle=5
    
    #session共享
    spring.redis.sentinel.master = mymaster
    spring.redis.sentinel.nodes = xxx.xx.xxx.151:26379,xxx.xx.xxx.32:26379,xxx.xx.xxx:26379
    spring.redis.password = wtyy
    #不指定默认是redis第一个数据库
    spring.redis.database = 10
    spring.redis.timeout = 15000
    spring.redis.jedis.pool.max-active = 8

3、redis配置类：

package com.demo.config;
    
    import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    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.data.redis.support.collections.RedisProperties;
    import redis.clients.jedis.JedisPool;
    import redis.clients.jedis.JedisPoolConfig;
    import redis.clients.jedis.JedisSentinelPool;
    
    import java.util.Arrays;
    import java.util.HashSet;
    import java.util.Set;
    
    @Configuration
    public class JedisConfig {
    
        private Logger logger = LoggerFactory.getLogger(JedisConfig.class);
    
        @Value("${my.redis.server.jedis.pool.maxTotal}")
        private int maxTotal;
    
        @Value("${my.redis.server.jedis.pool.maxIdle}")
        private int maxIdle;
    
        @Value("${my.redis.server.jedis.pool.maxWaitMillis}")
        private int maxWaitMillis;
    
        @Value("${my.redis.server.timeout}")
        private int timeout;
    
        @Value("${my.redis.sentinel.nodes}")
        private String redisSentinelNodes;
    
        @Value("${my.redis.sentinel.pool.max-total}")
        private int redisSentinelMaxTotal;
    
        @Value("${my.redis.sentinel.pool.max-idle}")
        private int redisSentinelMaxIdle;
    
        @Value("${my.redis.sentinel.pool.min-idle}")
        private int redisSentinelMinIdle;
    
        @Value("${my.redis.sentinel.master-name}")
        private String redisSentinelMasterName;
        @Value("${my.redis.sentinel.password}")
        private String redisSentinelPassword;
    
        @Bean(name = "jedisPool")
        public JedisSentinelPool jedisPool() {
            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
            jedisPoolConfig.setMaxTotal(maxTotal);
            jedisPoolConfig.setMaxIdle(maxIdle);
            jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);
            //sentinel
            String[] hosts = redisSentinelNodes.split(",");
            Set<String> sentinels = new HashSet<>(Arrays.asList(hosts));
            GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
            poolConfig.setMaxTotal(redisSentinelMaxTotal);
            poolConfig.setMaxIdle(redisSentinelMaxIdle);
            poolConfig.setMinIdle(redisSentinelMinIdle);
            JedisSentinelPool jedisSentinelPool = new JedisSentinelPool(redisSentinelMasterName,
                    sentinels, jedisPoolConfig,redisSentinelPassword);
            return  jedisSentinelPool;
        }
    }

4、redis操作util：

package com.demo.config;
    
    import java.util.Date;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import org.apache.log4j.Logger;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    import redis.clients.jedis.JedisSentinelPool;
    import redis.clients.jedis.Tuple;
    
    
    @SuppressWarnings("unused")
    @Component
    public class RedisClient {
        private static boolean BORROW = true; // 在borrow一个事例时是否提前进行validate操作
        private static Logger logger = Logger.getLogger(RedisClient.class);
        @Autowired
        private JedisSentinelPool pool;
    
    
        /**
         * 获取连接
         */
        public  synchronized Jedis getJedis() {
            try {
                if (pool != null) {
                    return pool.getResource();
                } else {
                    return null;
                }
            } catch (Exception e) {
                logger.info("连接池连接异常");
                return null;
            }
    
        }
    
    
    
    
        /**
         * @Description: 关闭连接
         * @param @param jedis
         * @return void 返回类型
         */
    
        public static void getColse(Jedis jedis) {
            if (jedis != null) {
                jedis.close();
            }
        }
    
    
        /**
         * 格式化Key
         */
        public static String format(String formatKey, String... keyValues) {
            if (keyValues == null || keyValues.length == 0) {
                return formatKey;
            }
            StringBuilder key = new StringBuilder();
            char[] chars = formatKey.toCharArray();
            int index = -1;
            boolean inmark = false;
            boolean firstinmark = false;
            for (int i = 0; i < chars.length; i++) {
                char ch = chars[i];
                if (ch == '{') {
                    index++;
                    inmark = true;
                    firstinmark = true;
                } else if (ch == '}') {
                    inmark = false;
                } else if (inmark) {
                    if (firstinmark) {
                        firstinmark = false;
                        key.append(keyValues[index]);
                    }
                } else {
                    key.append(chars[i]);
                }
            }
            return key.toString();
        }
    
        /********************************** 针对key的操作 **************************************/
    
        /**
         * 删除一个key
         *
         * @param keyFormat
         *            key标识
         * @param keyValues
         *            key变量
         * @return 被删除的keys的数量
         */
        public Long del(String keyFormat, String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.del(key);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
        /**
         * 查询一个key是否存在
         *
         * @param keyFormat
         *            key标识
         * @param keyValues
         *            key变量
         * @return key是否存在。
         */
        public boolean exists(String keyFormat, String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.exists(key);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
        /**
         * 设置一个key的过期的秒数
         *
         * @param keyFormat
         *            key标识
         * @param seconds
         *            过期的秒数
         * @param keyValues
         *            key变量
         * @return 1表示设置成功， 0 表示设置失败或者无法被设置
         */
        public Long expire(String keyFormat, int seconds, String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.expire(key, seconds);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
        /**
         * 设置一个UNIX时间戳的过期时间
         *
         * @param keyFormat
         *            key标识
         * @param expireDate
         *            过期时间
         * @param keyValues
         *            key变量
         * @return 1表示设置成功， 0 表示设置失败或者无法被设置
         */
        public Long expireAt(String keyFormat, Date expireDate, String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.pexpireAt(key, expireDate.getTime());
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
        /**
         * 移除给定key的生存时间，将这个 key 从『易失的』(带生存时间 key )转换成『持久的』(一个不带生存时间、永不过期的 key )。
         *
         * @param keyFormat
         *            key标识
         * @param keyValues
         *            key变量
         * @return 当生存时间移除成功时，返回 1 . 如果 key 不存在或 key 没有设置生存时间，返回 0 .
         */
        public Long persist(String keyFormat, String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.persist(key);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
        /**
         * 设置一个key的过期的毫秒数
         *
         * <pre>
         * 这个命令和 EXPIRE 命令的作用类似，但是它以毫秒为单位设置 key 的生存时间，而不像 EXPIRE 命令那样，以秒为单位。
         * </pre>
         *
         * @param keyFormat
         *            key标识
         * @param milliSeconds
         *            过期的毫秒数
         * @param keyValues
         *            key变量
         * @return 设置成功，返回 1，不存在或设置失败，返回 0
         */
        public Long pexpire(String keyFormat, long milliSeconds,
                            String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.pexpire(key, milliSeconds);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
        /**
         * 获取key的有效毫秒数
         *
         * <pre>
         * 这个命令类似于 TTL 命令，但它以毫秒为单位返回 key 的剩余生存时间，而不是像 TTL 命令那样，以秒为单位。
         * </pre>
         *
         * @param keyFormat
         *            key标识
         * @param keyValues
         *            key变量
         * @return 当 key 不存在时，返回 -2 。当 key 存在但没有设置剩余生存时间时，返回 -1 。否则，以毫秒为单位，返回 key
         *         的剩余生存时间。
         */
        public Long pttl(String keyFormat, String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.pttl(key);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
    
        /**
         * 获取key的有效时间（单位：秒）
         *
         * <pre>
         * 以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)。
         * </pre>
         *
         * @param keyFormat
         *            key标识
         * @param keyValues
         *            key变量
         * @return 当 key 不存在时，返回 -2 。当 key 存在但没有设置剩余生存时间时，返回 -1 。否则，以秒为单位，返回 key
         *         的剩余生存时间。
         */
        public Long ttl(String keyFormat, String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.ttl(key);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
        /********************************** 针对字符串（string）的操作 **************************************/
    
        /**
         * 追加一个值到key上
         *
         * <pre>
         * 如果 key 已经存在，并且值为字符串，那么这个命令会把 value 追加到原来值（value）的结尾。
         * 如果 key 不存在，那么它将首先创建一个空字符串的key，再执行追加操作，这种情况 APPEND 将类似于 SET 操作。
         * </pre>
         *
         * @param keyFormat
         *            key标识
         * @param value
         *            要追加的值
         * @param keyValues
         *            key变量
         * @return 返回append后字符串值（value）的长度。
         */
        public Long append(String keyFormat, String value, String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.append(key, value);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
        /**
         * 整数原子减1
         *
         * <pre>
         * 对key对应的数字做减1操作。如果key不存在，那么在操作之前，这个key对应的值会被置为0。
         * 如果key有一个错误类型的value或者是一个不能表示成数字的字符串，就返回错误。
         * 这个操作最大支持在64位有符号的整型数字。
         * </pre>
         *
         * @param keyFormat
         *            key标识
         * @param keyValues
         *            key变量
         * @return 数字：减小之后的value
         */
        public Long decr(String keyFormat, String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.decr(key);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
        /**
         * 原子减指定的整数
         *
         * <pre>
         * 将key对应的数字减decrement。如果key不存在，操作之前，key就会被置为0。
         * 如果key的value类型错误或者是个不能表示成数字的字符串，就返回错误。
         * 这个操作最多支持64位有符号的正型数字。
         * </pre>
         *
         * @param keyFormat
         *            key标识
         * @param integer
         *            要减小的数值
         * @param keyValues
         *            key变量
         * @return 返回一个数字：减少之后的value值。
         */
        public Long decrby(String keyFormat, long integer, String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.decrBy(key, integer);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
        /**
         * @param keyFormat
         *            key标识
         * @param keyValues
         *            key变量
         * @return key对应的value，或者null（key不存在时）
         */
        public String get(String keyFormat, String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.get(key);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
        /**
         * 设置一个key的value，并获取设置前的值
         *
         * <pre>
         * 自动将key对应到value并且返回原来key对应的value。如果key存在但是对应的value不是字符串，就返回错误。
         * exp:
         * GETSET可以和INCR一起使用实现支持重置的计数功能。
         * 举个例子：每当有事件发生的时候，一段程序都会调用INCR给key mycounter加1，但是有时我们需要获取计数器的值，并且自动将其重置为0。
         * 这可以通过GETSET mycounter "0"来实现：
         * </pre>
         *
         * @param keyFormat
         *            key标识
         * @param value
         *            要设置的值
         * @param keyValues
         *            key变量
         * @return 设置之前的值
         */
        public String getSet(String keyFormat, String value, String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.getSet(key, value);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
        /**
         * 执行原子加1操作
         *
         * <pre>
         * 对key对应的数字做加1操作。如果key不存在，那么在操作之前，这个key对应的值会被置为0。
         * 如果key有一个错误类型的value或者是一个不能表示成数字的字符串，就返回错误。这个操作最大支持在64位有符号的整型数字。
         * 提醒：这是一个string操作，因为Redis没有专用的数字类型。key对应的string都被解释成10进制64位有符号的整型来执行这个操作。
         * Redis会用相应的整数表示方法存储整数，所以对于表示数字的字符串，没必要为了用字符串表示整型存储做额外开销。
         * </pre>
         *
         * @param keyFormat
         *            key标识
         * @param keyValues
         *            key变量
         * @return 增加之后的value
         */
        public Long incr(String keyFormat, String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.incr(key);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
        /**
         * 执行原子加1操作，并且设置过期时间（单位：s）
         *
         * <pre>
         * 本操作是在{@linkplain RedisClient#incr(String, String...)}之上增加了一个设置过期时间的操作
         * </pre>
         *
         * @param keyFormat
         *            key标识
         * @param expireTime
         *            过期时间（单位：s）
         * @param keyValues
         *            key变量
         * @return 增加之后的value
         */
        public Long incr(String keyFormat, int expireTime, String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                long result = jedis.incr(key);
                jedis.expire(key, expireTime);
                return result;
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
        /**
         * 执行原子增加一个整数
         *
         * <pre>
         * 将key对应的数字加increment。如果key不存在，操作之前，key就会被置为0。
         * 如果key的value类型错误或者是个不能表示成数字的字符串，就返回错误。这个操作最多支持64位有符号的正型数字。
         * 查看方法{@linkplain RedisClient#incr(String, String...)}了解关于增减操作的额外信息。
         * </pre>
         *
         * @param keyFormat
         *            key标识
         * @param increment
         *            要增加的数值
         * @param keyValues
         *            key变量
         * @return 增加后的value
         */
        public Long incrBy(String keyFormat, long increment, String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.incrBy(key, increment);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
        /**
         * 执行原子增加一个浮点数
         *
         * <pre>
         * 将key对应的数字加increment。如果key不存在，操作之前，key就会被置为0。
         * 如果key的value类型错误或者是个不能表示成数字的字符串，就返回错误。
         * </pre>
         *
         * @param keyFormat
         *            key标识
         * @param increment
         *            要增加的数值
         * @param keyValues
         *            key变量
         * @return 增加后的value
         */
        public Double incrByFloat(String keyFormat, double increment,
                                  String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.incrByFloat(key, increment);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
        /**
         * 设置一个key的value值
         *
         * <pre>
         * 警告：如果key已经存在了，它会被覆盖，而不管它是什么类型。
         * </pre>
         *
         * @param keyFormat
         *            key标识
         * @param value
         *            要设置的值
         * @param keyValues
         *            key变量
         *
         * @return 总是"OK"
         */
        public String set(String keyFormat, String value, String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.set(key, value);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
        /**
         * 设置key-value并设置过期时间（单位：秒）
         *
         * <pre>
         * 设置key对应字符串value，并且设置key在给定的seconds时间之后超时过期。
         * 该命令相当于执行了{@link #set(String, String, String...) SET} + {@link #expire(String, int, String...) EXPIRE}.并且该操作是原子的
         * </pre>
         *
         * @param keyFormat
         *            key标识
         * @param seconds
         *            超时时间(单位：s)
         * @param value
         *            设置的值
         * @param keyValues
         *            key变量
         * @return 状态码
         */
        public String setex(String keyFormat, int seconds, String value,
                            String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.setex(key, seconds, value);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
        /**
         * 设置key-value并设置过期时间（单位：毫秒）
         *
         * <pre>
         * 跟{@link #setex(String, int, String, String...)}效果差不多，唯一区别是超时时间是ms
         * </pre>
         *
         * @param keyFormat
         *            key标识
         * @param milliseconds
         *            超时时间(单位：ms)
         * @param value
         *            设置的值
         * @param keyValues
         *            key变量
         * @return 状态码
         */
        public String psetex(String keyFormat, int milliseconds, String value,
                             String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.psetex(key, (long) milliseconds, value);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
        /**
         * 设置的一个关键的价值，只有当该键不存在
         *
         * <pre>
         * 如果key不存在，就设置key对应字符串value。在这种情况下，该命令和SET一样。
         * 当key已经存在时，就不做任何操作。SETNX是"SET if Not eXists"。
         * </pre>
         *
         * @param keyFormat
         *            key标识
         * @param value
         *            设置的value
         * @param keyValues
         *            key变量
         * @return 1 如果key被set，0 如果key没有被set
         */
        public Long setnx(String keyFormat, String value, String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.setnx(key, value);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
    
        /**
         * 设置hash里面一个字段的值
         *
         * @param keyFormat
         *            key标识
         * @param field
         *            字段
         * @param value
         *            值
         * @param keyValues
         *            key变量
         * @return 含义如下:1如果field是一个新的字段 0如果field原来在map里面已经存在
         *
         */
        public Long hset(String keyFormat, String field, String value,
                         String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.hset(key, field, value);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
       
    
        /******************************* SET 操作 *************************/
    
        /**
         * 添加一个元素到集合(set)里
         *
         * <pre>
         * 添加一个指定的member元素到集合的 key中.
         * 如果已经在集合key中存在则忽略.如果集合key 不存在，则新建集合key,并添加member元素到集合key中.
         * 如果key 的类型不是集合则返回错误.
         * </pre>
         *
         * @param keyFormat
         *            key标识
         * @param value
         *            元素
         * @param keyValues
         *            key变量
         * @return 返回新成功添加到集合里元素的数量，不包括已经存在于集合中的元素.
         */
        public Long sadd(String keyFormat, String value, String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.sadd(key, value);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
        
    
        /**
         * 获取集合里面的元素数量
         *
         * @param keyFormat
         *            key标识
         * @param keyValues
         *            key变量
         * @return 集合的基数(元素的数量),如果key不存在,则返回 0.
         */
        public Long scard(String keyFormat, String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.scard(key);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
        
    
        /**
         * 获取集合里面的所有key
         *
         * @param keyFormat
         *            key标识
         * @param keyValues
         *            key变量
         * @return 集合中的所有元素.
         */
        public Set<String> smembers(String keyFormat, String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.smembers(key);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
        /**
         * 删除并获取一个集合里面的元素
         *
         * <pre>
         * 移除并返回一个集合中的随机元素
         * 该命令与 {@link #srandmember(String, String...)}相似,不同的是srandmember命令返回一个随机元素但是不移除.
         * </pre>
         *
         * @param keyFormat
         *            key标识
         * @param keyValues
         *            key变量
         * @return 被移除的元素, 当key不存在的时候返回 null .
         */
        public String spop(String keyFormat, String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.spop(key);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    
      
        /**
         * 从集合里删除一个元素
         *
         * @param keyFormat
         *            key标识
         * @param member
         *            要删除的元素
         * @param keyValues
         *            key变量
         * @return 从集合中移除元素的个数，不包括不存在的成员.
         */
        public Long srem(String keyFormat, String member, String... keyValues) {
            String key = format(keyFormat, keyValues);
            Jedis jedis = null;
            try {
                jedis = getJedis();
                return jedis.srem(key, member);
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
        
        /**省略 其他不常用操作**/
    
    }

5、测试接口：

package com.demo.controller;
    
    import com.demo.config.RedisClient;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.servlet.http.HttpServletRequest;
    
    @RestController
    @RequestMapping("index")
    public class IndexController {
    
        @Autowired
        private RedisClient redisClient;
    
        private String nameFormat = "redis:name:{name}";
    
        @RequestMapping("/setName")
        public void setName(String key,String value){
            redisClient.set(nameFormat,value,key);
        }
    
        @RequestMapping("/getName")
        public String getName(String key){
            return  redisClient.get(nameFormat,key);
        }
    
        @RequestMapping("/sessionSetName")
        public void sessionSetName(HttpServletRequest request,String value){
            request.getSession().setAttribute("test",value);
        }
    
        @RequestMapping("/sessionGetName")
        public String sessionGetName(HttpServletRequest request){
            return (String) request.getSession().getAttribute("test");
        }
    }

6、启动类：

package com.demo;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class Application {
        public static void main(String args[]){
            SpringApplication.run(Application.class,args);
        }
    }

二、测试：

启动项目后，修改端口号为7777再启动一次。

1、测试redis存：

localhost:9999/redisgroup/index/setName?key=user&value=wtyy测试哨兵连接

验证：

![20200904150619708.png][]![20200904150700704.png][]

![20200904150721796.png][]

2、测试redis取：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 1][]

3、测试session存：

![20200904150821861.png][]

4、测试session取：

（1）9999端口：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 2][]

（2）7777端口：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 3][]

redis数据库中也存储成功了：

151:

![20200910091701417.png][]

32:

![20200910091720372.png][]

126:

![20200910091739818.png][]

三、测试redis宕机：现在关闭主机151上的redis服务：

![20200904152729742.png][]

32成了新的主机：

![20200904152827649.png][]

从项目的日志里面可以看到，自动连接了新的主机：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 4][]

现在再测试一遍代码：

1、redis存：

![20200904152953212.png][]

看下redis数据：

![20200904153103503.png][]

![20200904153049141.png][]

2、redis取：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 5][]

3、session存：

![20200904153247979.png][]

4、session取：

（1）9999端口：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 6][]

（2）7777端口：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 7][]

可见，完全不受影响。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200904150043623.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k=,size_16,color_FFFFFF,t_70
[20200904150619708.png]: https://img-blog.csdnimg.cn/20200904150619708.png
[20200904150700704.png]: https://img-blog.csdnimg.cn/20200904150700704.png
[20200904150721796.png]: https://img-blog.csdnimg.cn/20200904150721796.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200904150751498.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k=,size_16,color_FFFFFF,t_70
[20200904150821861.png]: https://img-blog.csdnimg.cn/20200904150821861.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200904150908918.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200904150928950.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k=,size_16,color_FFFFFF,t_70
[20200910091701417.png]: https://img-blog.csdnimg.cn/20200910091701417.png
[20200910091720372.png]: https://img-blog.csdnimg.cn/20200910091720372.png
[20200910091739818.png]: https://img-blog.csdnimg.cn/20200910091739818.png
[20200904152729742.png]: https://img-blog.csdnimg.cn/20200904152729742.png
[20200904152827649.png]: https://img-blog.csdnimg.cn/20200904152827649.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200908102133896.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k=,size_16,color_FFFFFF,t_70
[20200904152953212.png]: https://img-blog.csdnimg.cn/20200904152953212.png
[20200904153103503.png]: https://img-blog.csdnimg.cn/20200904153103503.png
[20200904153049141.png]: https://img-blog.csdnimg.cn/20200904153049141.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200904153201632.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k=,size_16,color_FFFFFF,t_70
[20200904153247979.png]: https://img-blog.csdnimg.cn/20200904153247979.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200904153301866.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200904153337581.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dfdF95X3k=,size_16,color_FFFFFF,t_70