Redis集群部署及Springboot架构下应用（Cluster分区集群模式）

#后台运行（守护进程）
daemonize yes 
#去除保护模式（允许远程访问）
protected-mode no
#去除绑定（远程访问）
#bind 127.0.0.1
# 设置密码
requirepass redispwd

# db写入磁盘目录位置（文件夹路径如果不存在，需要手动创建）：【单机非必须】
dir ./cluster6379 
#日志目录，默认运行命令时的目录【单机非必须】
logfile "./cluster6379/cluster6379.log"
#pid写入位置，默认/var/run/redis_6379.pid【单机非必须】
pidfile "/var/run/redis_6379.pid"
# 开启集群 
cluster-enabled yes

# redis端口【单机非必须】
port 6380
 # db写入磁盘目录位置（文件夹路径如果不存在，需要手动创建）：【单机非必须】
dir ./cluster6380
#日志目录，默认运行命令时的目录【单机非必须】
logfile "./cluster6380/cluster6380.log"
#pid写入位置，默认/var/run/redis_6379.pid【单机非必须】
pidfile /var/run/redis_6380.pid

# redis端口【单机非必须】
port 6381
 # db写入磁盘目录位置（文件夹路径如果不存在，需要手动创建）：【单机非必须】
dir ./cluster6381
#日志目录，默认运行命令时的目录【单机非必须】
logfile "./cluster6381/cluster6381.log"
#pid写入位置，默认/var/run/redis_6379.pid【单机非必须】
pidfile /var/run/redis_6381.pid

./bin/redis-server redis-cluster6379.conf 
./bin/redis-server redis-cluster6380.conf
./bin/redis-server redis-cluster6381.conf

 ./bin/redis-cli --cluster create 192.168.1.17:6379 192.168.1.17:6380 --cluster-replicas 0 -a redispwd

 ./bin/redis-cli --cluster create 192.168.1.17:6379 192.168.1.17:6380 192.168.1.17:6381 --cluster-replicas 0 -a redispwd

#redis端口【单机非必须】
port 6382
 # db写入磁盘目录位置（文件夹路径如果不存在，需要手动创建）：【单机非必须】
dir ./cluster6382
#日志目录，默认运行命令时的目录【单机非必须】
logfile "./cluster6382/cluster6382.log"
#pid写入位置，默认/var/run/redis_6379.pid【单机非必须】
pidfile /var/run/redis_6382.pid

./bin/redis-server redis-cluster6382.conf

#-a 后面跟的是密码，如果没有密码则不需要-a参数 
#add-node 后面的参数形式 new_host:new_port existing_host:existing_port
./bin/redis-cli --cluster add-node 192.168.1.17:6382 192.168.1.17:6380 -a redispwd

./bin/redis-cli --cluster reshard 192.168.1.17:6379 -a redispwd

#准备挪出来多少个槽点
How many slots do you want to move (from 1 to 16384)? 800
#哪个节点准备接受新分配的槽点
What is the receiving node ID? 18936b87abadcb66135e243fa3fe49e88e8bbdc7
#准备从哪些节点上挪出这800（向上看这个数的来源）个槽点
Please enter all the source node IDs.
	# 所有节点
  Type 'all' to use all the nodes as source nodes for the hash slots.
  #指定节点
  Type 'done' once you entered all the source nodes IDs.
Source node #1: all
#是否执行reshare
Do you want to proceed with the proposed reshard plan (yes/no)? yes

#挪出多少槽点（5195），把6380节点挪出来，节点数在该询问上面，不需要你计算
How many slots do you want to move (from 1 to 16384)? 5195
#哪个节点接收（18936b87abadcb66135e243fa3fe49e88e8bbdc7）6382节点接收
What is the receiving node ID? 18936b87abadcb66135e243fa3fe49e88e8bbdc7
#从哪挪
Please enter all the source node IDs.
 Type 'all' to use all the nodes as source nodes for the hash slots.
 Type 'done' once you entered all the source nodes IDs.
 #6380上挪，如果需要删除多个节点，继续回车填写下一个就行，填写完毕最后一个节点键入‘done’即可完成
Source node #1: 50a78a3daad0e95ed04e10ac2e115fbc3ff1f9da
Source node #2: done

./bin/redis-cli --cluster del-node 192.168.1.17:6380 50a78a3daad0e95ed04e10ac2e115fbc3ff1f9da -a redispwd

 <!-- springboot整合redis -->
  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
  </dependency>

spring:
  redis:
  # 集群（分片）模式
    cluster:
      max-redirects: 3
      #节点
      nodes:
        - 192.168.1.17:6379
        - 192.168.1.17:6381
        - 192.168.1.17:6382
    # Redis服务器连接密码（默认为空）
    password: redispwd
    #jedis连接池信息仅供参考
    jedis:
      pool:
        #连接池最大连接数（使用负值表示没有限制）
        max-active: 8
        # 连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1
        # 连接池中的最大空闲连接
        pool.max-idle: 8
        # 连接池中的最小空闲连接
        pool.min-idle: 0

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.util.HashSet;

@Configuration
@EnableCaching
public class MyRedisConfig {

    @Bean
    public RedisClusterConfiguration redisClusterConfiguration(RedisProperties redisProperties){
        RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration(new HashSet<>(redisProperties.getCluster().getNodes()));
        redisClusterConfiguration.setPassword(redisProperties.getPassword().toCharArray());
        return redisClusterConfiguration;
    }
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // 使用Jackson2JsonRedisSerialize 替换默认的jdkSerializeable序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        // 设置value的序列化规则和 key的序列化规则
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
    /**
     * 对redis字符串类型数据操作
     *
     * @param stringRedisTemplate
     * @return
     */
    @Bean({"valueoperations"})
    public ValueOperations<String, String> valueOperations(StringRedisTemplate stringRedisTemplate) {
        return stringRedisTemplate.opsForValue();
    }
}

import com.platform.test.common.exception.BusinessException;
import com.platform.test.service.SysService;
import com.platform.test.vo.BaseRespVo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpSession;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.concurrent.TimeUnit;

@RestController
@RequestMapping("/sys")
public class SysController {
    static final Logger logger = LoggerFactory.getLogger(SysController.class);
    @Autowired
    @Qualifier("valueoperations")
    ValueOperations<String, String> valueOperations;
    @Autowired
    RedisClusterConfiguration redisClusterConfiguration;
    @Autowired
    RedisTemplate<Object,Object> redisTemplate;
    @Autowired
    SysService sysService;
    final static String REDIS_TEST_KEY_VALUE = "__REDIS_TEST_KEY_VALUE";

    @RequestMapping("/health")
    public BaseRespVo health(HttpSession session) throws BusinessException {
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        HashMap<String, Object> data = new HashMap<>();
        data.put("time-server",sf.format(new Date()));
        data.put("status-redis",checkRedis());
        return new BaseRespVo(data);
    }

    private boolean checkRedis() {
        long time = System.currentTimeMillis();
        if(valueOperations == null){
            return false;
        }
        try {
            valueOperations.set(REDIS_TEST_KEY_VALUE+time,REDIS_TEST_KEY_VALUE,30000, TimeUnit.MILLISECONDS);
            logger.info("写入redis key: "+ REDIS_TEST_KEY_VALUE+time +" value:"+REDIS_TEST_KEY_VALUE);
            Thread.sleep(100);
            String value = valueOperations.get(REDIS_TEST_KEY_VALUE+time);
            if (value!=null && REDIS_TEST_KEY_VALUE.equals(value)) {
                logger.info("读取redis key: "+ REDIS_TEST_KEY_VALUE+time +" value:"+value);
                return true;
            }
        }catch (Exception e){
            logger.error("redis test exception!",e);
        }
        return false;
    }
}