Redis集群 之 Sentinel模式Windows篇

时间  2020-12-23
标签 html git github web redis spring json windows api 服务器 栏目 Redis 繁體版
原文   原文链接

1.环境html

　　a.下载Redis：访问 https://github.com/MicrosoftArchive/redis/releases 下载Windows版Redis，并解压git

 

 

2.哨兵模式配置github

　　a.复制3份Redis做为3个节点，分别命名为808一、808二、8083web

 

　　b.修改 Redis 各节点中的 redis.windows.conf 配置文件redis

　　　　1）8081节点：spring

#端口号改成8081
port 8081

　　　　2）8082节点：json

#端口号改成8082
port 8082
#设置该slave的master服务器为8081
slaveof 127.0.0.1 8081

　　　　3）8083节点：windows

#端口号改成8083
port 8083
#设置该slave的master服务器为8081
slaveof 127.0.0.1 8081

 

　　c.在Redis 各节点中建立 sentinel.conf 哨兵配置文件api

　　　　1）8081节点：服务器

#绑定0.0.0.0解读没法访问的问题
bind 0.0.0.0
#当前Sentinel服务运行的端口
port 8091
#去监视一个名为mymaster的主redis实例，这个主实例的IP地址为本机地址127.0.0.1，端口号为6379，而将这个主实例判断为失效至少须要2个 Sentinel进程的赞成，只要赞成Sentinel的数量不达标，自动failover就不会执行
sentinel monitor mymaster 127.0.0.1 8081 2
#指定了Sentinel认为Redis实例已经失效所需的毫秒数。当 实例超过该时间没有返回PING，或者直接返回错误，那么Sentinel将这个实例标记为主观下线。只有一个 Sentinel进程将实例标记为主观下线并不必定会引发实例的自动故障迁移：只有在足够数量的Sentinel都将一个实例标记为主观下线以后，实例才会被标记为客观下线，这时自动故障迁移才会执行
sentinel down-after-milliseconds mymaster 5000
#指定了在执行故障转移时，最多能够有多少个从Redis实例在同步新的主实例，在从Redis实例较多的状况下这个数字越小，同步的时间越长，完成故障转移所需的时间就越长
sentinel parallel-syncs mymaster 1
#若是在该时间（ms）内未能完成failover操做，则认为该failover失败
sentinel failover-timeout mymaster 15000

　　　　2）8082节点：

#绑定0.0.0.0解读没法访问的问题
bind 0.0.0.0
#当前Sentinel服务运行的端口
port 8092
#去监视一个名为mymaster的主redis实例，这个主实例的IP地址为本机地址127.0.0.1，端口号为6379，而将这个主实例判断为失效至少须要2个 Sentinel进程的赞成，只要赞成Sentinel的数量不达标，自动failover就不会执行
sentinel monitor mymaster 127.0.0.1 8081 2
#指定了Sentinel认为Redis实例已经失效所需的毫秒数。当 实例超过该时间没有返回PING，或者直接返回错误，那么Sentinel将这个实例标记为主观下线。只有一个 Sentinel进程将实例标记为主观下线并不必定会引发实例的自动故障迁移：只有在足够数量的Sentinel都将一个实例标记为主观下线以后，实例才会被标记为客观下线，这时自动故障迁移才会执行
sentinel down-after-milliseconds mymaster 5000
#指定了在执行故障转移时，最多能够有多少个从Redis实例在同步新的主实例，在从Redis实例较多的状况下这个数字越小，同步的时间越长，完成故障转移所需的时间就越长
sentinel parallel-syncs mymaster 1
#若是在该时间（ms）内未能完成failover操做，则认为该failover失败
sentinel failover-timeout mymaster 15000

　　　　3）8083节点：

#绑定0.0.0.0解读没法访问的问题
bind 0.0.0.0
#当前Sentinel服务运行的端口
port 8093
#去监视一个名为mymaster的主redis实例，这个主实例的IP地址为本机地址127.0.0.1，端口号为6379，而将这个主实例判断为失效至少须要2个 Sentinel进程的赞成，只要赞成Sentinel的数量不达标，自动failover就不会执行
sentinel monitor mymaster 127.0.0.1 8081 2
#指定了Sentinel认为Redis实例已经失效所需的毫秒数。当 实例超过该时间没有返回PING，或者直接返回错误，那么Sentinel将这个实例标记为主观下线。只有一个 Sentinel进程将实例标记为主观下线并不必定会引发实例的自动故障迁移：只有在足够数量的Sentinel都将一个实例标记为主观下线以后，实例才会被标记为客观下线，这时自动故障迁移才会执行
sentinel down-after-milliseconds mymaster 5000
#指定了在执行故障转移时，最多能够有多少个从Redis实例在同步新的主实例，在从Redis实例较多的状况下这个数字越小，同步的时间越长，完成故障转移所需的时间就越长
sentinel parallel-syncs mymaster 1
#若是在该时间（ms）内未能完成failover操做，则认为该failover失败
sentinel failover-timeout mymaster 15000

 

　　d.建立启动脚本

　　　　1）建立 8081 节点 Redis 启动脚本 start8081.bat：

cd 8081 title redis-8081 redis-server.exe redis.windows.conf

　　　　2）建立 8082 节点 Redis 启动脚本 start8082.bat：

cd 8082 title redis-8082 redis-server.exe redis.windows.conf

　　　　3）建立 8083 节点 Redis 启动脚本 start8083.bat：

cd 8083 title redis-8083 redis-server.exe redis.windows.conf

　　　　4）建立 8081 节点 哨兵Sentinel 启动脚本 startsentinel8081.bat：

cd 8081 title sentinel-8081 redis-server.exe sentinel.conf --sentinel

　　　　5）建立 8082 节点 哨兵Sentinel 启动脚本 startsentinel8082.bat：

cd 8082 title sentinel-8082 redis-server.exe sentinel.conf --sentinel

　　　　6）建立 8083 节点 哨兵Sentinel 启动脚本 startsentinel8083.bat：

cd 8083 title sentinel-8083 redis-server.exe sentinel.conf --sentinel

 

 

3.测试

　　a.启动Reids和哨兵Sentinel：一次双击 start8081.bat、start8082.bat、start8083.bat、startsentinel8081.bat、startsentinel8082.bat、startsentinel8083.bat 启动服务

　　b.关闭 8081 节点的Redis服务（因为没有开启后台运行，直接关闭窗口便可）

　　c.查看 8081 节点哨兵Sentinel窗口的日志：8081节点 Redis服务关闭后，master由8081切换成了8083

 

 

4.Jedis操做Sentinel模式的Redis

　　1）导入maven依赖

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

　　2）使用

public class TestSentinel { private static JedisSentinelPool pool; static { init(); } /** * 初始化redis链接池 */
    private static void init(){ JedisPoolConfig config = new JedisPoolConfig(); config.setMaxIdle(5);   //最大空闲数
        config.setMaxWaitMillis(60000); //链接时最大的等待时间（毫秒）
        config.setMaxTotal(500);    //最大链接数
        config.setTestOnBorrow(true);   //在提取一个jedis实例时，是否提早进行验证操做；若是为true，则获得的jedis实例均是可用的 //与sentinel.conf中的名称相对应
        String masterName = "mymaster"; //哨兵ip及端口
        Set<String> sentinels = new HashSet<>(); sentinels.add("127.0.0.1:8091"); sentinels.add("127.0.0.1:8092"); sentinels.add("127.0.0.1:8093"); pool = new JedisSentinelPool(masterName, sentinels, config); } public static Jedis getJedis() { return pool.getResource(); } public static void returnJedis(Jedis jedis){ if(jedis != null){ jedis.close(); } } /** * 测试 * @param args */
    public static void main(String[] args) { Jedis jedis = TestSentinel.getJedis(); jedis.set("name", "zwin"); jedis.set("age", "29"); returnJedis(jedis); jedis = TestSentinel.getJedis(); String name = jedis.get("name"); String age = jedis.get("age"); System.out.println("name[" + name + "], age[" + age + "]"); returnJedis(jedis); } }

 

 

5.Spring操做Sentinel模式的Redis集群

　　a.导入maven依赖

<properties> ..... <!-- spring -->
    <spring.version>5.1.1.RELEASE</spring.version>
    <!-- jackson-json -->
    <jackson.version>2.9.4</jackson.version>
    <!-- log4j -->
    <slf4j.version>1.7.18</slf4j.version>
    <log4j.version>1.2.17</log4j.version>
  </properties>

  <dependencies>
    <!-- spring -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-oxm</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>${spring.version}</version>
    </dependency>

    <!-- Jackson -->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>${jackson.version}</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>${jackson.version}</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>${jackson.version}</version>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>

    <!-- AOP -->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjrt</artifactId>
      <version>1.8.6</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.6</version>
    </dependency>

    <!-- 日志相关 -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>${log4j.version}</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${slf4j.version}</version>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>${slf4j.version}</version>
    </dependency>

    <!-- redis -->
    <dependency>
      <groupId>org.springframework.data</groupId>
      <artifactId>spring-data-redis</artifactId>
      <version>2.1.1.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>redis.clients</groupId>
      <artifactId>jedis</artifactId>
      <version>2.10.0</version>
    </dependency>
  </dependencies>

 

　　b.建立spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 自动扫描的包名 -->
    <context:component-scan base-package="com.wode" />

    <!-- 开启AOP代理 -->
    <aop:aspectj-autoproxy proxy-target-class="true" />

    <!--开启注解处理器 -->
    <context:annotation-config>
    </context:annotation-config>

    <context:property-placeholder location="classpath:redis.properties"/>
    <!-- Spring中引入其余配置文件 -->
    <import resource="classpath*:/spring-redis.xml" />

</beans>

 

　　c.建立spring-redis.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:p="http://www.springframework.org/schema/p" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">

    <!-- jedis配置 -->
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <!-- 最大空闲数：空闲链接数大于maxIdle时，将进行回收 -->
        <property name="maxIdle" value="${redis.maxIdle}" />
        <!-- 最大链接数：可以同时创建的最大链接个数 -->
        <property name="maxTotal" value="${redis.maxTotal}" />
        <!-- 最大等待时间：单位ms -->
        <property name="maxWaitMillis" value="${redis.maxWait}" />
        <!-- 使用链接时，检测链接是否成功 -->
        <property name="testOnBorrow" value="${redis.testOnBorrow}" />
    </bean>

    <!--redis哨兵 -->
    <bean id="redisSentinelConfiguration" class="org.springframework.data.redis.connection.RedisSentinelConfiguration">
        <property name="master">
            <bean class="org.springframework.data.redis.connection.RedisNode">
                <property name="name" value="mymaster"/>
            </bean>
        </property>
        <property name="sentinels">
            <set>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="127.0.0.1"/>
                    <constructor-arg name="port" value="8091"/>
                </bean>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="127.0.0.1"/>
                    <constructor-arg name="port" value="8092"/>
                </bean>
                <bean class="org.springframework.data.redis.connection.RedisNode">
                    <constructor-arg name="host" value="127.0.0.1"/>
                    <constructor-arg name="port" value="8093"/>
                </bean>
            </set>
        </property>
    </bean>

    <bean id="redisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" p:password="${redis.password}">
        <constructor-arg name="sentinelConfig" ref="redisSentinelConfiguration"></constructor-arg>
        <constructor-arg name="poolConfig" ref="jedisPoolConfig"></constructor-arg>
    </bean>

    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
        <property name="connectionFactory" ref="redisConnectionFactory" />
        <!-- 配置Serializer -->
        <property name="keySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="hashKeySerializer">
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
        </property>
        <property name="valueSerializer">
            <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>
        </property>
        <property name="hashValueSerializer">
            <bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>
        </property>
    </bean>
</beans>

 

　　d.建立redis.properties

redis.password= redis.maxIdle=5 redis.maxWait=60000 redis.maxTotal=500 redis.testOnBorrow=true

 

　　e.建立实体类

public class TestBean { private String name; private int age; public TestBean(){} public TestBean(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } @Override public String toString() { return "[TestBean]: name[" + name + "], age[" + age + "]"; } }

 

　　f.使用

@Component public class TestSpringSentinel { @Resource private RedisTemplate redisTemplate; public void set(String key, Object value){ // redisTemplate.boundValueOps(key).set(value);
 redisTemplate.opsForValue().set(key, value); } public Object get(String key){ // return redisTemplate.boundValueOps(key).get();
        return redisTemplate.opsForValue().get(key); } public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml"); TestSpringSentinel testSpringSentinel = (TestSpringSentinel) context.getBean("testSpringSentinel"); testSpringSentinel.set("name", "zwj"); testSpringSentinel.set("age", "28"); testSpringSentinel.set("bean", new TestBean("xf", 26)); String name = (String) testSpringSentinel.get("name"); String age = (String) testSpringSentinel.get("age"); System.out.println("name[" + name + "], age[" + age + "]"); TestBean bean = (TestBean) testSpringSentinel.get("bean"); System.out.println(bean); } }

 

 

6.参考文档：

　　https://www.cnblogs.com/justdoyou/p/10253668.html

　　https://www.cnblogs.com/yu421/p/8081544.html

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程