Redis主从+哨兵模式搭建及java配置（window单机版）

注意

可将配置好的3个redis安装到window服务中自启（参考地址有说明）
先启动redis服务后，在启动哨兵服务

Windows环境下安装Redis

参考地址：https://www.cnblogs.com/skmobi/p/11696620.html

搭建redis sentinel一主二从三哨兵环境

1.复制3份已安装并配置好的redis文件夹,并修改相应文件名（自定义）

2. 配置主节点 找到Redis-master文件下redis.windows.conf配置

	master配置：
 		port 6379
 		#密码
		requirepass 123456
		#rdb
		dbfilename "dump.rdb"
		#日志
		logfile "server_log.txt"
		#设置了主节点密码，主和从的redis.windows.conf都需要配置相同的密码
		masterauth "123456"

3. 配置从节点 找到Redis-salve-6380与Redis-salve-6381文件下redis.windows.conf配置

	salve配置：
 		port 6379
	 	#密码
		requirepass 123456
		#rdb
		dbfilename "dump.rdb"
		#日志
		logfile "server_log.txt"
		#设置主节点密码
		masterauth "123456"
 		#在主节点配置的基础上增加slaveof配置，对应主节点的ip与端口 
 		slaveof 127.0.0.1 6379 

4. 在每个节点创建一个哨兵配置文件 sentinel.conf

#主节点6379目录下的sentinel.conf
bind 127.0.0.1
port 26379
# logfile "sentinel-26379.log"
dbfilename "dump-26379.rdb"
# 哨兵监听的主服务器
sentinel monitor mymaster 127.0.0.1 6380 1
#主服务有密码所以这也要配置
sentinel down-after-milliseconds mymaster 1000
#指定了Sentinel认为Redis实例已经失效所需的毫秒数。当 #实例超过该时间没有返回PING，或者直接返回错误，那么Sentinel将这个实例标记为主观下线。
#只有一个 #Sentinel进程将实例标记为主观下线并不一定会引起实例的自动故障迁移：只有在足够数量的Sentinel都将一个实#例标记为主观下线之后，实例才会被标记为客观下线，这时自动故障迁移才会执行
sentinel auth-pass mymaster 123456
#指定了在执行故障转移时，最多可以有多少个从Redis实例在同步新的主实例，在从Redis实例较多的情况下这个数#字越小，同步的时间越长，完成故障转移所需的时间就越长
sentinel config-epoch mymaster 29
#如果在该时间（ms）内未能完成failover操作，则认为该failover失败
sentinel leader-epoch mymaster 29

#子节点6380目录下的sentinel.conf
bind 127.0.0.1
port 26380
# logfile "sentinel-26380.log"
dbfilename "dump-26380.rdb"
# 哨兵监听的主服务器
sentinel monitor mymaster 127.0.0.1 6380 1
#主服务有密码所以这也要配置
sentinel down-after-milliseconds mymaster 1000
#指定了Sentinel认为Redis实例已经失效所需的毫秒数。当 #实例超过该时间没有返回PING，或者直接返回错误，那么Sentinel将这个实例标记为主观下线。
#只有一个 #Sentinel进程将实例标记为主观下线并不一定会引起实例的自动故障迁移：只有在足够数量的Sentinel都将一个实#例标记为主观下线之后，实例才会被标记为客观下线，这时自动故障迁移才会执行
sentinel auth-pass mymaster 123456
#指定了在执行故障转移时，最多可以有多少个从Redis实例在同步新的主实例，在从Redis实例较多的情况下这个数#字越小，同步的时间越长，完成故障转移所需的时间就越长
sentinel config-epoch mymaster 29
#如果在该时间（ms）内未能完成failover操作，则认为该failover失败
sentinel leader-epoch mymaster 29

#子节点6381目录下的sentinel.conf
bind 127.0.0.1
port 26381
# logfile "sentinel-26381.log"
dbfilename "dump-26381.rdb"
# 哨兵监听的主服务器
sentinel monitor mymaster 127.0.0.1 6380 1
#主服务有密码所以这也要配置
sentinel down-after-milliseconds mymaster 1000
#指定了Sentinel认为Redis实例已经失效所需的毫秒数。当 #实例超过该时间没有返回PING，或者直接返回错误，那么Sentinel将这个实例标记为主观下线。
#只有一个 #Sentinel进程将实例标记为主观下线并不一定会引起实例的自动故障迁移：只有在足够数量的Sentinel都将一个实#例标记为主观下线之后，实例才会被标记为客观下线，这时自动故障迁移才会执行
sentinel auth-pass mymaster 123456
#指定了在执行故障转移时，最多可以有多少个从Redis实例在同步新的主实例，在从Redis实例较多的情况下这个数#字越小，同步的时间越长，完成故障转移所需的时间就越长
sentinel config-epoch mymaster 29
#如果在该时间（ms）内未能完成failover操作，则认为该failover失败
sentinel leader-epoch mymaster 29

5.写个window脚本一键启动3个哨兵（D:\Program Files\Redis-server是我的路径，根据自己路径进行修改）

@echo off 
start cmd /k "cd/d D:\Program Files\Redis-server\Redis-master&&redis-server.exe sentinel.conf --sentinel"
start cmd /k "cd/d D:\Program Files\Redis-server\Redis-salve-6380&&redis-server.exe sentinel.conf --sentinel"
start cmd /k "cd/d D:\Program Files\Redis-server\Redis-salve-6381&&redis-server.exe sentinel.conf --sentinel"

6.java配置

1.使用springboot 配置

		<!--springboot redis 需引入的包-->
		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
         <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
        </dependency>

yml文件 配置

#Redis
  redis:
 	host: 127.0.0.1
 	port: 6379
 	database: 0
    password: 123456
    timeout: 60000
    #设置哨兵服务
    sentinel:
      master: mymaster
      nodes: 192.168.1.39:26379,192.168.1.39:26380,192.168.1.39:26381
    expire-time: 1800
    jedis:
      pool:
        max-active: 10000
        max-wait: -1
        max-idle: 10
        min-idle: 0

RedisTemplate相关配置

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
    @Override
    @Bean
    public KeyGenerator keyGenerator() {
        return (target, method, params) -> {
            StringBuilder sb = new StringBuilder();
            sb.append(target.getClass().getName());
            sb.append(method.getName());
            for (Object obj : params) {
                sb.append(obj.toString());
            }
            return sb.toString();
        };
    }

    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }


    public class MyObjectMapper extends ObjectMapper {
        private static final long serialVersionUID = 1L;
        public MyObjectMapper() {
            super();
            // 去掉各种@JsonSerialize注解的解析
            //this.configure(MapperFeature.USE_ANNOTATIONS, false);
            // 只针对非空的值进行序列化
            this.setSerializationInclusion(JsonInclude.Include.CUSTOM);
            // 将类型序列化到属性json字符串中
            this.enableDefaultTyping(DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
            // 对于找不到匹配属性的时候忽略报错
            this.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
            // 不包含任何属性的bean也不报错
            this.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
        }
    }
}

2.使用spring jedis 配置

		<!-- ssm整合redis -->
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.9.0</version>
		</dependency>

@Slf4j
public class JedisUtils {

    /*单redis使用*/
    /*private static String host = "127.0.0.1";
    private static String password = "123456";*/

    /*哨兵模式服务*/
    private static String clusterName = "mymaster";
    private static String hostAndPort = "192.168.1.39:26379";
    private static String hostAndPort1 = "192.168.1.39:26380";
    private static String hostAndPort2 = "192.168.1.39:26381";
    private static String password = "123456";

    private static Integer timeout = 1800000;
    private static int MAX_TOTAL = 8;
    //最小空闲连接数, 默认0
    private static int MIN_IDLE = 0;
    //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
    //最大空闲连接数, 默认8个
    private static int MAX_IDLE = 8;
    //获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间,  默认-1
    //等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
    private static int MAX_WAIT = -1;
    //连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true
    private static boolean BLOCK_WHEN_EXHAUSTED = false;
    //设置的逐出策略类名, 默认DefaultEvictionPolicy(当连接超过最大空闲时间,或连接数超过最大空闲连接数)
    private static String EVICTION_POLICY_CLASSNAME = "org.apache.commons.pool2.impl.DefaultEvictionPolicy";
    //是否启用pool的jmx管理功能, 默认true
    private static boolean JMX_ENABLED = true;
    //MBean ObjectName = new ObjectName("org.apache.commons.pool2:type=GenericObjectPool,name=" + "pool" + i); 
    默认为"pool", JMX不熟,具体    	不知道是干啥的...默认就好.
    private static String JMX_NAME_PREFIX = "pool";
    //是否启用后进先出, 默认true
    private static boolean LIFO = true;
    //逐出连接的最小空闲时间 默认1800000毫秒(30分钟)
    private static long MIN_EVICTABLE_IDLE_TIME_MILLIS = 1800000L;
    //对象空闲多久后逐出, 当空闲时间>该值 且 空闲连接>最大空闲数 时直接逐出,不再根据MinEvictableIdleTimeMillis判断  (默认逐出策略)
    private static long SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS = 1800000L;

    //每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3
    private static int NUM_TESTS_PER_EVICYION_RUN = 3;
    //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
    //在获取连接的时候检查有效性, 默认false
    private static boolean TEST_ON_BORROW = false;
    //在空闲时检查有效性, 默认false
    private static boolean TEST_WHILEIDLE = false;
    //逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
    private static long TIME_BERWEEN_EVICTION_RUNS_MILLIS = -1;
    private static JedisSentinelPool jedisPool = null;
    //private static JedisPool jedisPool = null;

    private static void initJedisPool() {
        try {
            GenericObjectPoolConfig config = new GenericObjectPoolConfig();
            config.setBlockWhenExhausted(BLOCK_WHEN_EXHAUSTED);
            config.setEvictionPolicyClassName(EVICTION_POLICY_CLASSNAME);
            config.setJmxEnabled(JMX_ENABLED);
            config.setJmxNamePrefix(JMX_NAME_PREFIX);
            config.setLifo(LIFO);
            config.setMaxIdle(MAX_IDLE);
            config.setMaxTotal(MAX_TOTAL);
            config.setMaxWaitMillis(MAX_WAIT);
            config.setMinEvictableIdleTimeMillis(MIN_EVICTABLE_IDLE_TIME_MILLIS);
            config.setMinIdle(MIN_IDLE);
            config.setNumTestsPerEvictionRun(NUM_TESTS_PER_EVICYION_RUN);
            config.setSoftMinEvictableIdleTimeMillis(SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS);
            config.setTestOnBorrow(TEST_ON_BORROW);
            config.setTestWhileIdle(TEST_WHILEIDLE);
            config.setTimeBetweenEvictionRunsMillis(TIME_BERWEEN_EVICTION_RUNS_MILLIS);
            /*单redis连接池*/
            //jedisPool = new JedisPool(config, host, 6379, timeout, password);
            Set sentinels = new HashSet();
            sentinels.add(hostAndPort);
            sentinels.add(hostAndPort1);
            sentinels.add(hostAndPort2);
            /*主从+哨兵连接池*/
            jedisPool = new JedisSentinelPool(clusterName, sentinels, config, timeout, password);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /*主从+哨兵的连接池*/
    public synchronized static JedisSentinelPool getJedisSentinelPool() {
        if (jedisPool == null) {
            initJedisPool();
        }
        return jedisPool;
    }

    /*单redis的连接池*/
    public synchronized static JedisSentinelPool getJedisPool() {
        if (jedisPool == null) {
            initJedisPool();
        }
        return jedisPool;
    }
    
    /**
     * 调用连接redis
     *
     * @param jedis
     */
    public synchronized static Jedis getJedis(int database) {
        try {
            if (getJedisSentinelPool() != null) {
                Jedis resource = jedisPool.getResource();
                resource.select(database);
                return resource;
            }
            initJedisPool();
            return getJedisSentinelPool().getResource();
        } catch (Exception e) {
            log.error(e.getMessage());
            initJedisPool();
            return getJedisSentinelPool().getResource();
        }
    }

    /**
     * 释放jedis资源
     *
     * @param jedis
     */
    public static void close(final Jedis jedis) {
        if (jedis != null) {
            jedis.close();
        }
    }
    
    /**
     * get操作
     *
     * @param jedis
     */
    public static String get(String k) {
        Jedis jedis = getJedis();
        String str = null;
        try {
            str = jedis.get(k);
        } catch (Exception e) {
            log.error(e.getMessage());
        } finally {
            close(jedis);
        }
        return str;
    }
    
     /**
     * set操作
     *
     * @param jedis
     */
	public static boolean set(String k, String v) {
        Jedis jedis = getJedis();
        boolean f = false;
        try {
            f = jedis.set(k, v) == "OK";
        } catch (Exception e) {
            log.error(e.getMessage());
        } finally {
            close(jedis);
        }
        return f;
	}

}

/*测试是否成功*/
public static void main(String[] args) {
        set("k2","200");
        String k2 = get("k2");
        System.out.println(k2);
}