springboot 整合 redis 集群（哨兵模式） 基于docker环境

                                                                               springboot 整合 redis 集群（哨兵模式）

• #拉取镜像
  docker pull redis:5.0.4 

•   创建本地挂载文件
• 
•     修改本地挂载文件redis.conf

• 1，/6379/conf  vi redis.conf，内容如下：
  daemonize no
  protected-mode no
  requirepass 123456
  masterauth 123456
  #指定 slave的ip  这边设置是为了防止主挂掉后，重启后ip会变成自己容器中的IP
  slave-announce-ip 106.15.51.2
  #指定 salve的端口
  slave-announce-port 6379
  #0.0.0.0在服务器的环境中，指的就是服务器上所有的ipv4地址
  bind 0.0.0.0
  
  2，/6380/conf vi redis.conf，内容如下：
  daemonize no
  #关闭保护模式
  protected-mode no 
  #设置密码       
  requirepass 123456
  #集群中其它客户端设置密码后，这里要相应的指定
  masterauth  123456
  slaveof 106.15.51.2 6379
  slave-announce-ip 106.15.51.2
  slave-announce-port 6380
  #0.0.0.0在服务器的环境中，指的就是服务器上所有的ipv4地址
  bind 0.0.0.0
  
  3，/6381/conf vi redis.conf，内容如下：
  daemonize no
  protected-mode no
  requirepass 123456
  masterauth  123456
  slaveof 106.15.51.2 6379
  slave-announce-ip 106.15.51.2
  slave-announce-port 6381
  #0.0.0.0在服务器的环境中，指的就是服务器上所有的ipv4地址
  bind 0.0.0.0

•  采用docker-compose.yml 创建redis 集群

• version: '3'
  services:
    master:
      image: redis:5.0.4
      container_name: redis_6379
      environment:
       - compose_project_name=redis_6379
      ports:
        - "6379:6379"
      restart: always
      command: redis-server /usr/local/etc/redis/redis.conf
      volumes: 
        - /software/redis/6379/data:/data
        - /software/redis/6379/conf/redis.conf:/usr/local/etc/redis/redis.conf
    slave1:
      image: redis:5.0.4
      container_name: redis_6380
      environment:
       - compose_project_name=redis_6380
      ports:
        - "6380:6379"
      restart: always
      command: redis-server /usr/local/etc/redis/redis.conf
      volumes: 
         - /software/redis/6380/data:/data
         - /software/redis/6380/conf/redis.conf:/usr/local/etc/redis/redis.conf
    slave2:
      image: redis:5.0.4
      container_name: redis_6381
      environment:
       - compose_project_name=redis_6381
      ports:
        - "6381:6379"
      restart: always
      command: redis-server /usr/local/etc/redis/redis.conf
      volumes: 
        - /software/redis/6381/data:/data
        - /software/redis/6381/conf/redis.conf:/usr/local/etc/redis/redis.conf
  #networks:
  #  default:
  #    external:
  #      name: network_bridge
  

  注意不能指定网络 network 要不springboot 就访问不了docker 容器 内置ip 

• 执行 docker-compose up -d

• 

• 进入6380容器

• 

• 创建哨兵 docker-compose.yml

• version: '3'
  services: 
    sentinel1:
      image: redis:5.0.4 
      container_name: redis-sentinel-1
      ports:
        - 26379:26379
      command: redis-sentinel /usr/local/etc/redis/sentinel.conf
      volumes:
        - /software/redis/26379/data:/data
        - /software/redis/26379/conf/sentinel.conf:/usr/local/etc/redis/sentinel.conf
  #networks:
  #  default:
  #    external:
  #      name: network_bridge
  

• sentinel.conf 本地挂载 文件

• #关闭保护模式
  protected-mode no
  port 26379
  #监听主节点的  Ip  端口
  sentinel monitor mymaster 106.15.51.2 6379 1
  sentinel down-after-milliseconds mymaster 5000
  sentinel failover-timeout mymaster 10000
  #有密码的时候需要设置
  sentinel auth-pass mymaster 123456
  #唢兵指定IP 端口
  sentinel announce-ip 106.15.51.2
  sentinel announce-port 26379

• 执行 docker-compose up -d
• 
• 测试 哨兵
• cat sentinel.conf
• 
• 停掉 6379的master
• docker stop c067ddd08d35
• 查看sentinel.conf 的变化  Master 端口从原先 6379 变为  6381
• 
• 创建springboot项目
• 
• pom

• <dependency>
  			<groupId>org.springframework.boot</groupId>
  			<artifactId>spring-boot-starter-data-redis</artifactId>
  			<!-- 采用jedis 排除lettuce -->
  			 <exclusions>
  		        <exclusion>
  		            <groupId>io.lettuce</groupId>
  		            <artifactId>lettuce-core</artifactId>
  		        </exclusion>
  		    </exclusions>
  		</dependency>
          

   

• application.yml配置文件 这边采用的 jedis 连接方式 

• #数据库配置
  spring:
    redis:
        #单机配置
        #host: 192.168.43.188
        #port: 6379
  #    timeout: 5000
      password: 123456
      ###################以下为redis哨兵增加的配置###########################
      sentinel:
        nodes: 106.15.51.2:26379
        master: mymaster
      ###################以下为lettuce连接池增加的配置###########################
      jedis:
        pool:
          #最大连接数
          max-active: 1024
          #最大阻塞等待时间(负数表示没限制)
          max-wait: 20000
          #最大空闲
          max-idle: 200
          #最小空闲
          min-idle: 10

•  RedisSentinelConfig 配置文件

• package com.microservice.soa.conf;
  
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  
  import org.springframework.beans.factory.annotation.Value;
  import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
  import org.springframework.boot.context.properties.ConfigurationProperties;
  import org.springframework.context.annotation.Bean;
  import org.springframework.context.annotation.Configuration;
  import org.springframework.data.redis.connection.RedisNode;
  import org.springframework.data.redis.connection.RedisSentinelConfiguration;
  import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
  
  import redis.clients.jedis.JedisPoolConfig;
  
  @Configuration
  @EnableAutoConfiguration
  public class RedisSentinelConfig {
   
  //    @Value("#{'${spring.redis.sentinel.nodes}'.split(',')}")
  	 @Value("${spring.redis.sentinel.nodes}")
       private List<String> nodes;
  	 @Value("${spring.redis.password}")
  	 private String password;
   
      @Bean
      @ConfigurationProperties(prefix="spring.redis")
      public JedisPoolConfig getRedisConfig(){
          JedisPoolConfig config = new JedisPoolConfig();
          return config;
      }
      @Bean
      public RedisSentinelConfiguration sentinelConfiguration(){
          RedisSentinelConfiguration redisSentinelConfiguration = new RedisSentinelConfiguration();
          //配置matser的名称
          redisSentinelConfiguration.master("mymaster");
          //配置redis的哨兵sentinel
          Set<RedisNode> redisNodeSet = new HashSet<>();
          nodes.forEach(x->{
              redisNodeSet.add(new RedisNode(x.split(":")[0],Integer.parseInt(x.split(":")[1])));
          });
          System.out.print("redisNodeSet -->"+redisNodeSet);
          //哨兵模式添加set
          redisSentinelConfiguration.setSentinels(redisNodeSet);
          redisSentinelConfiguration.setPassword(password);
          return redisSentinelConfiguration;
      }
   
      @Bean
      public JedisConnectionFactory jedisConnectionFactory(JedisPoolConfig jedisPoolConfig, RedisSentinelConfiguration sentinelConfig) {
          JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory(sentinelConfig,jedisPoolConfig);
          return jedisConnectionFactory;
      }
  }

  创建测试类

• package com.microservice.entrance;
  
  import java.time.LocalDateTime;
  
  import javax.annotation.Resource;
  
  import org.junit.jupiter.api.Test;
  import org.mybatis.spring.annotation.MapperScan;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.boot.test.context.SpringBootTest;
  import org.springframework.context.annotation.ComponentScan;
  import org.springframework.data.redis.core.RedisTemplate;
  import org.springframework.data.redis.core.StringRedisTemplate;
  
  import com.microservice.soa.dao.order.EquipOrderDao;
  
  @SpringBootTest(classes=UmzMerchantPlatformApplicationTests.class)
  @MapperScan(value = "com.microservice.*")
  @ComponentScan(basePackages = {"com.microservice.*"})
  class UmzMerchantPlatformApplicationTests {
  //	@Autowired
  //	private RedisTemplate redisTemplate;
  	 @Autowired
  	 StringRedisTemplate redisTemplate;
  	
  	@Test
  	void contextLoads() {
  		System.out.println("测试reis-sentinel ");
          redisTemplate.opsForValue().set("name","lili");
          String name = redisTemplate.opsForValue().get("name");
          System.out.println("值:"+name);
          
  	}
  
  }
  

   

  

注 

• 连接客户端  服务器采用的是阿里云服务器 需要开启端口才能访问 配置安全组 打开端口