Redis详细介绍Redis 是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库。 Redis支持

Redis简介

Redis 是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库。

Redis 与其他 key - value 缓存产品有以下三个特点：

Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。
Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。
Redis支持数据的备份，即master-slave模式的数据备份。

Redis与Memcache对比

Memcache优点：
1、简单的key-value存储
2、内存使用率比较高
3、多核处理，多线程
缺点：
1、无法容灾
2、无法持久化
Redis优点：
1、丰富的数据结构
2、持久化
3、主从同步、故障转移
4、内存数据库
Redis缺点：
1、单线程
2、单核

Redis安装与配置

官网下载地址： redis.io/ 下载后上传到linux下/home/software目录下。

安装步骤

1、解压缩

tar -zxvf redis-6.0.9.tar.gz

2、安装gcc编译环境

yum install gcc-c++

3、进入解压后的redis-6.0.9目录下

make && make install

执行完毕后安装成功
注意：我在安装的时候报错如下：make[1]: *** [server.o]
原因是因为gcc版本过低，yum安装的gcc是4.8.5的。因此需要升级gcc，升级过程如下：

yum -y install centos-release-scl

yum -y install devtoolset-9-gcc devtoolset-9-gcc-c++ devtoolset-9-binutils

scl enable devtoolset-9 bash

echo "source /opt/rh/devtoolset-9/enable" >> /etc/profile

gcc -v

重新 make && make install即可

配置步骤

1、进入解压后得到的文件夹redis-6.0.9 ，在utils下，拷贝redis_init_script 到 /etc/init.d目录，目的是要把redis作为开机自启动。

cp redis_init_script /etc/init.d/

2、创建目录，用于存放配置文件

mkdir /usr/local/redis

3、拷贝配置文件到此目录下

cp redis.conf /usr/local/redis/

4、修改redis.conf这个核心配置文件

1、修改daemonize no 为yes,目的是为了让redis启动在linux后台运行
daemonize yes
2、修改redis的工作目录
dir /usr/local/redis/working
3、修改如下内容，绑定ip为0.0.0.0，代表可以让远程连接，不限制ip
# bind 127.0.0.1
bind 0.0.0.0
4、最关键的密码，默认为没有，一定要设置
requirepass imooc
5、进入/etc/init.d文件夹下修改redis_init_script文件
这里修改为/usr/local/redis/redis.conf

6、为redis启动脚本添加执行权限，随后运行启动redis
chmod 777 redis_init_script
./redis_init_script start
7、检查redis进程
ps -ef | grep redis
8、设置开机自启动
chkconfig redis_init_script on

关闭redis方式：编辑redis_init_script文件，添加 -a + 密码
之后执行./redis_init_script stop 即可

Redis的命令行客户端

redis-cli：进入到redis客户端
auth pwd : 输入密码
set key value: 设置缓存
get key: 获得缓存
del key: 删除缓存
redis-cli -a password ping: 查看是否存活

Redis的数据类型

key相关

keys * : 查看所有的key(不建议在生产上使用，有性能上的影响) type key: key的类型

String 字符串

String: 最简单的字符串类型键值对缓存，也是最基本的。
相关命令：

get/set/del：查询/设置/删除  
set rekey data: 设置已存在的key,会覆盖  
setnx rekey data: 设置已经存在的key,不会覆盖  
set key value ex time: 设置带过期时间的数据  
expire key: 设置过期时间  
ttl: 查看剩余时间，-1永不过期，-2过期

append key value: 合并字符串  
strlen key: 字符串长度

incr key: 累加1  
decr key: 累减1  
incrby key num: 累加给定数值  
decrby key num: 累减给定数值

getrange key start end:截取数据，end=-1代表到最后  
setrange key start newdata: 从start位置开始替换数据

mset:连续设值
mget:连续取值
msetnx:连续设置，如果存在则不设置

redis默认16个数据库，用命令select index选择相应的数据库。
flushdb，清楚当前数据库，flushall，清楚所有数据库。

Hash 数据类型

hash:类似map,存储结构化数据结构，比如存储一个对象
相关命令：

hset key property value:
创建一个user对象，这个对象中包含name属性，name值为imooc
hset user name lucy
获取用户对象中name的值
hget user name
hmset:设置对象中的多个键值对
hmset user age 18 phone 139123123
hmget:获取对象中的多个属性
hmget user age phone
hgetall：获得对象中所有的属性
hgetall user
hkeys：获取对象中所有的属性名
hkeys user
hvals:获取对象中所有的属性值
hvals user
hincrby user age 2:累加属性
hlen user:有多少个属性
hexists user age:判断属性是否存在
hdel user + 属性: 删除对象某个属性

List 数据类型

list：列表，{a,b,c,d……}
相关命令：

lpush userlist 1 2 3 4 5:构建一个list,从左边开始存入数据
rpush userlist 1 2 3 4 5:构建一个list,从右边开始存入数据
lrange list start end: 获取数据,这里的l可不是left,是list
lpop:从左侧开始拿出一个数据
rpop:从右侧开始拿出一个数据
llen list: list的长度
lindex list index：获取list下标的值
lset list index value:把某个下标的值替换
linsert list before/after pivot value: 在某个值pivot前，插入一个新的值value
lrem list count value:删除count个相同的value
ltrim list start end: 截取值，替换原来的list
del list:删除list

Set 数据类型

set 集合,可以实现去除
相关命令：

sadd set + value:向集合添加数据
smembers set：查看集合所有内容
scard set: 查看set里面元素的数量
sismember set pig：看元素pig是否存在于set中
srem set pig：删除集合中的元素pig
spop set +数字：随机出来两个元素
srandmember set +数字：随机弹出几个数字
sdiff set1 set2：取set1中包含，set2不包含的元素，做差集
sinter set1 set2:取set1,set2共同包含的元素，取交集
sunion set1 set2:对set1，set2最并集

Zset 数据类型

zset 集合,可以实现去重+排序
相关命令：

zadd zset 10 duck 20 pig:设置member和对应的分数
zrange zset 0 -1:查看所有zset中的内容
zrange zset 0 -1 withscores:带有分数
zrank zset duck:查看对应的排序下标
zscore zset duck:查看对应的分数
zcard zset:统计个数
zcount zset 分数1 分数2：统计分数1和分数2之间的个数
zrangebyscore zset 分数1 分数2：查询分数之间的member(包含分数1和分数2）
zrangebyscore zset (分数1 (分数2：查询分数1，2之间的memeber,不包含分数1，2
zrangebyscore zset 分数1 分数2 limit start end:取end-start+1项
zrem zset duck:啥除duck项

更多的命令可以参考如下网网址：redisdoc.com/

SpringBoot整合redis实战

导入依赖编写配置文件

 <!--导入redis依赖-->
  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
  </dependency>

spring:
  redis:
    database: 1
    host: 121.*9.***.81
    port: 6379
    password: ****

编写controller进行测试

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import springfox.documentation.annotations.ApiIgnore;

@RestController
@ApiIgnore
@RequestMapping("redis")
public class RedisController {

    @Autowired
    private RedisTemplate redisTemplate;

    @GetMapping("/set")
    public Object set(String key,String value){
       redisTemplate.opsForValue().set(key,value);
        return "OK";
    }
    @GetMapping("/get")
    public Object get(String key){
        String o = (String) redisTemplate.opsForValue().get(key);
        return o;
    }
    @GetMapping("/del")
    public Object del(String key){
        redisTemplate.delete(key);
        return "OK";
    }
}

浏览器测试访问

http://localhost:8088/redis/set?key=name&value=zhangsan

登录到linux查看相应的结果

自定义的Redis工具类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisClusterConnection;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.StringRedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisOperations;
import org.springframework.data.redis.core.SessionCallback;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @Title: Redis 工具类
 */
@Component
public class RedisOperator {
	
//	@Autowired
//    private RedisTemplate<String, Object> redisTemplate;
	
	@Autowired
	private StringRedisTemplate redisTemplate;
	
	// Key（键），简单的key-value操作

	/**
	 * 实现命令：TTL key，以秒为单位，返回给定 key的剩余生存时间(TTL, time to live)。
	 * 
	 * @param key
	 * @return
	 */
	public long ttl(String key) {
		return redisTemplate.getExpire(key);
	}
	
	/**
	 * 实现命令：expire 设置过期时间，单位秒
	 * 
	 * @param key
	 * @return
	 */
	public void expire(String key, long timeout) {
		redisTemplate.expire(key, timeout, TimeUnit.SECONDS);
	}
	
	/**
	 * 实现命令：INCR key，增加key一次
	 * 
	 * @param key
	 * @return
	 */
	public long incr(String key, long delta) {
		return redisTemplate.opsForValue().increment(key, delta);
	}

	/**
	 * 实现命令：KEYS pattern，查找所有符合给定模式 pattern的 key
	 */
	public Set<String> keys(String pattern) {
		return redisTemplate.keys(pattern);
	}

	/**
	 * 实现命令：DEL key，删除一个key
	 * 
	 * @param key
	 */
	public void del(String key) {
		redisTemplate.delete(key);
	}

	// String（字符串）

	/**
	 * 实现命令：SET key value，设置一个key-value（将字符串值 value关联到 key）
	 * 
	 * @param key
	 * @param value
	 */
	public void set(String key, String value) {
		redisTemplate.opsForValue().set(key, value);
	}

	/**
	 * 实现命令：SET key value EX seconds，设置key-value和超时时间（秒）
	 * 
	 * @param key
	 * @param value
	 * @param timeout
	 *            （以秒为单位）
	 */
	public void set(String key, String value, long timeout) {
		redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
	}

	/**
	 * 实现命令：GET key，返回 key所关联的字符串值。
	 * 
	 * @param key
	 * @return value
	 */
	public String get(String key) {
		return (String)redisTemplate.opsForValue().get(key);
	}

	/**
	 * 批量查询，对应mget
	 * @param keys
	 * @return
	 */
	public List<String> mget(List<String> keys) {
		return redisTemplate.opsForValue().multiGet(keys);
	}

	/**
	 * 批量查询，管道pipeline
	 * @param keys
	 * @return
	 */
	public List<Object> batchGet(List<String> keys) {

//		nginx -> keepalive
//		redis -> pipeline

		List<Object> result = redisTemplate.executePipelined(new RedisCallback<String>() {
			@Override
			public String doInRedis(RedisConnection connection) throws DataAccessException {
				StringRedisConnection src = (StringRedisConnection)connection;

				for (String k : keys) {
					src.get(k);
				}
				return null;
			}
		});

		return result;
	}


	// Hash（哈希表）

	/**
	 * 实现命令：HSET key field value，将哈希表 key中的域 field的值设为 value
	 * 
	 * @param key
	 * @param field
	 * @param value
	 */
	public void hset(String key, String field, Object value) {
		redisTemplate.opsForHash().put(key, field, value);
	}

	/**
	 * 实现命令：HGET key field，返回哈希表 key中给定域 field的值
	 * 
	 * @param key
	 * @param field
	 * @return
	 */
	public String hget(String key, String field) {
		return (String) redisTemplate.opsForHash().get(key, field);
	}

	/**
	 * 实现命令：HDEL key field [field ...]，删除哈希表 key 中的一个或多个指定域，不存在的域将被忽略。
	 * 
	 * @param key
	 * @param fields
	 */
	public void hdel(String key, Object... fields) {
		redisTemplate.opsForHash().delete(key, fields);
	}

	/**
	 * 实现命令：HGETALL key，返回哈希表 key中，所有的域和值。
	 * 
	 * @param key
	 * @return
	 */
	public Map<Object, Object> hgetall(String key) {
		return redisTemplate.opsForHash().entries(key);
	}

	// List（列表）

	/**
	 * 实现命令：LPUSH key value，将一个值 value插入到列表 key的表头
	 * 
	 * @param key
	 * @param value
	 * @return 执行 LPUSH命令后，列表的长度。
	 */
	public long lpush(String key, String value) {
		return redisTemplate.opsForList().leftPush(key, value);
	}

	/**
	 * 实现命令：LPOP key，移除并返回列表 key的头元素。
	 * 
	 * @param key
	 * @return 列表key的头元素。
	 */
	public String lpop(String key) {
		return (String)redisTemplate.opsForList().leftPop(key);
	}

	/**
	 * 实现命令：RPUSH key value，将一个值 value插入到列表 key的表尾(最右边)。
	 * 
	 * @param key
	 * @param value
	 * @return 执行 LPUSH命令后，列表的长度。
	 */
	public long rpush(String key, String value) {
		return redisTemplate.opsForList().rightPush(key, value);
	}

}

Redis持久化

RDB: 快照模式
Redis默认是快照RDB的持久化方式
快照形式是直接把内存中的数据保存到一个 dump 文件中，定时保存，保存策略。
当 Redis 需要做持久化时，Redis 会 fork 一个子进程，子进程将数据写到磁盘上一个临时 RDB 文件中。当子进程完成写临时文件后，将原来的 RDB 替换掉，这样的好处就是可以 copy-on-write。
RDB恢复数据速度快于AOF的方式。
优点：
这种文件非常适合用于进行备份：比如说，你可以在最近的 24 小时内，每小时备份一次 RDB 文件，并且在每个月的每一天，也备份一个 RDB 文件。这样的话，即使遇上问题，也可以随时将数据集还原到不同的版本。RDB 非常适用于灾难恢复（disaster recovery）。
缺点：
性能： RDB方式没有办法做到实时、秒级别的持久化。因为bgsave每次运行都要fork操作创建子线程，是一个重量级的操作，操作频繁成本比较高。
数据完整性：如果你需要尽量避免在服务器故障时丢失数据，那么 RDB 不适合你。虽然 Redis 允许你设置不同的保存点（save point）来控制保存 RDB 文件的频率，但是，因为RDB 文件需要保存整个数据集的状态，所以它并不是一个轻松的操作。因此你可能会至少 5 分钟才保存一次 RDB 文件。在这种情况下，一旦发生故障停机，你就可能会丢失好几分钟的数据。

900秒之内，如果超过1个key被修改，则发起快照保存；  
300秒内，如果超过10个key被修改，则发起快照保存；
1分钟之内，如果1万个key被修改，则发起快照保存；
save 900 1
save 300 10
save 60 10000
# 保存时发生错误，停止写入
stop-writes-on-bgsave-error yes
# 文件压缩开启选项
rdbcompression yes
# rdb文件名
dbfilename dump.rdb
# rdb文件存放路径
dir /usr/local/redis/working

AOF: 日志模式
AOF：把所有的对Redis的服务器进行修改的命令都存到一个文件里，命令的集合。

使用 AOF 做持久化，每一个写命令都通过write函数追加到 appendonly.aof 中

优点：
使用 AOF 持久化会让 Redis 变得非常耐久（much more durable）：你可以设置不同的 fsync 策略，比如无 fsync ，每秒钟一次 fsync ，或者每次执行写入命令时 fsync 。 AOF 的默认策略为每秒钟 fsync 一次，在这种配置下，Redis 仍然可以保持良好的性能，并且就算发生故障停机，也最多只会丢失一秒钟的数据（ fsync 会在后台线程执行，所以主线程可以继续努力地处理命令请求）。

缺点：
对于相同的数据集来说，AOF 文件的体积通常要大于 RDB 文件的体积。根据所使用的 fsync 策略，AOF 的速度可能会慢于 RDB。在一般情况下，每秒 fsync 的性能依然非常高。不过在处理巨大的写入载入时，RDB 可以提供更有保证的最大延迟时间（latency）。

# AOF开启选项
appendonly no
# AOF日志名称
appendfilename "appendonly.aof"
# 备份方式
appendfsync always
appendfsync everysec
appendfsync no #关闭
# 重写时是否追加，建议关闭，避免数据不一致
no-appendfsync-on-rewrite no
# 当前文件大小超过上次文件大小的一倍后，进行重写
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

AOF文件依旧存在配置文件中指定的dir目录下。

Redis主从架构

简单介绍

单机的 redis，能够承载的 QPS 大概就在上万到几万不等。对于缓存来说，一般都是用来支撑读高并发的。因此架构做成主从(master-slave)架构，一主多从，主负责写，并且将数据复制到其它的 slave 节点，从节点负责读。所有的读请求全部走从节点。这样也可以很轻松实现水平扩容，支撑读高并发。 redis replication -> 主从架构 -> 读写分离 -> 水平扩容支撑读高并发

核心原理

当启动一个 slave node 的时候，它会发送一个 PSYNC 命令给 master node。

如果这是 slave node 初次连接到 master node，那么会触发一次 full resynchronization 全量复制。此时 master 会启动一个后台线程，开始生成一份 RDB 快照文件，同时还会将从客户端 client 新收到的所有写命令缓存在内存中。RDB 文件生成完毕后， master 会将这个 RDB 发送给 slave，slave 会先写入本地磁盘，然后再从本地磁盘加载到内存中，接着 master 会将内存中缓存的写命令发送到 slave，slave 也会同步这些数据。slave node 如果跟 master node 有网络故障，断开了连接，会自动重连，连接之后 master node 仅会复制给 slave 部分缺少的数据。注意：如果采用了主从架构，那么建议必须开启 master node 的持久化，不建议用 slave node 作为 master node 的数据热备，因为那样的话，如果你关掉 master 的持久化，可能在 master 宕机重启的时候数据是空的，然后可能一经过复制， slave node 的数据也丢了。

实战主从架构搭建

# 用info replication查看当前节点的状态

这里我们为了方便，搭建一主一从，主节点我们没有必要进行配置，下面主要针对从节点进行配置，这里采用两台云服务器。在从节点的redis.conf中首先修改如下地方： replicaof + master IP + master Port 其次，我们要把master的密码配上，命令为：masterauth+password
核对配置文件，确保从节点只读不写。

最后，别忘了针对从节点进行重启。 /etc/init.d/redis_init_script stop , /etc/init.d/redis_init_script start

重启后，可以发现主节点的数据已经同步到从节点了，用info replication可以进一步查看相关信息。
从节点：

主节点：

这时，如果master宕机，slave依旧时slave,用 info replication ，查看发现master处于down状态，重启master即可恢复正常，具体如下：

Redis无磁盘化复制

如果磁盘是机械硬盘，磁盘的IO效率比较低，可以使用无磁盘复制。
master 在内存中直接创建 RDB，然后发送给 slave，不会在自己本地落地磁盘了。只需要在配置文件中开启 repl-diskless-sync yes 即可。

repl-diskless-sync yes
# 等待 5s 后再开始复制，因为要等更多 slave 重新连接过来
repl-diskless-sync-delay 5

Redis缓存过期策略

定期删除：每秒检测10次(默认),配置如下，对CPU不友好。
惰性删除：对CPU友好，对内存不友好。

Redis内存淘汰管理机制

当内存沾满了，可以使用硬盘，但是没有意义，因为硬盘没有内存快，会影响redis性能，所以，当内存占满之后，redis提供了一套淘汰机制：MEMORY MANAGEMENT。
maxmemory: 当内存已使用率到达，则开始清理缓存。

noeviction: 旧缓存永不过期，新缓存设置不了，返回错误
allkeys-lru:清除最少用的旧缓存，然后保存新的缓存(推荐使用)
allkeys-random:在所有的缓存中随机删除(不推荐)
volatile-lru:在那些设置了expire过期时间的缓存中，清除最少使用的旧缓存，然后保存新缓存
volatile-random:在那些设置了expire过期时间的缓存中，随机删除缓存
volatile-ttl:在那些设置了expire过期时间的缓存中，删除即将过期的。

Redis哨兵机制

前面在讲主从架构的时候，有个问题就是如果master宕机了，该怎么办，哨兵机制就是来解决这个问题的。

哨兵就是用来监控Redis集群中master状态的工具，是redis高可用解决方案，哨兵可以监视一个或者多个redis master服务，以及这些master服务的所有从服务，当某个master服务宕机后，会把这个master下的某个从服务升级为master来代替已宕机的master继续工作。

配置

进入redis解压目录，拷贝sentinel.conf到/usr/local/redis目录下。

cp sentinel.conf /usr/local/redis/

主要配置如下：

- 普通配置：
# 关闭保护模式
protected-mode no
port:26379
# 开启后台运行
daemonize yes
pidfile /var/run/redis-sentinel.pid
logfile /usr/local/redis/sentinel/redis-sentinel.log
dir /usr/local/redis/sentinel/
- 核心配置
# 这里的2指的是两个哨兵,两个哨兵发现主节点宕机才是宕机
sentinel monitor mymaster 121.**.195.81 6379 2
# 密码
sentinel auth-pass mymaster ****
# master被sentinel认定为失效的间隔时间
sentinel down-after-milliseconds mymaster 30000
# 剩余的slaves重新和master做同步的并行个数
sentinel parallel-syncs mymaster 1
# 主备切换的超时时间，哨兵要去做故障转移，这个时候sentinel也是一个进程，
如果他没有去执行，超过这个时间后，会有其他的哨兵去执行。
sentinel failover-timeout mymaster 180000

注意：每个redis节点都需要有这个配置文件。

启动哨兵：

redis-sentinel sentinel.conf

测试

这里为了方便起见，仍然以两台云服务器为例，搭建一主一从，带有哨兵机制的主从架构。这里注意两台服务器内网不互通，当master宕机时，用info replication命令查看发现slave不能切换成master。用tail -f 动态查看sentinel.log日志发现报错如下：FAILOVER-ABORT-NOT-ELECTED 。

经排查，造成这个现象的原因是两台云服务器不能内网互通。修改sentinel.conf配置。
只需要在sentinel.conf中定义sentinel announce-ip "你服务器的ip"来指定sentinel对外发现的ip地址就可以了,这样，其它sentinel相互通信的时候就不是使用内网ip了，直接使用你定义的当前服务器的ip，就能成功通信了。

注意：

实际情况下，哨兵节点要有至少3个或者奇数个节点，才有意义
哨兵分布式部署在不同的计算机节点
一组哨兵只监听一组主从

SpringBoot集成Redis哨兵

与前面的SpringBoot整合redis实战相同，配置文件修改如下：

  redis:
    database: 1
    password: pass
    sentinel:
      master: mymaster
      nodes: 121.89.***.81:26379,121.*.**.241:26379

测试方法和前面的SpringBoot整合redis实战相同,测试成功。

Redis集群(Cluster)

这里搭建三主三从的redis-cluster集群。

redis.conf 配置

# 开启集群
cluster-enabled yes
# 每个节点需要有一个配置文件，需要6份。每个节点处于集群的角色都需要告诉其他所有节点，彼此知道，这个文件用于存储集群模式下的集群状态等信息，这个文件由redis自己维护，我们无需理会。
cluster-config-file nodes-201.conf
#超时时间，超时则认为master宕机，随后主备切换
cluster-node-timeout 5000
# 开启AOF
appendonly yes

启动6个redis实例

删除原来的appendonly.aof及dump.rdb，不然在构建集群的时候会报错。
做完以上操作后，重启redis。

创建集群

在这里，主节点与从节点的比例为1，1-3为主节点，4-6为从节点，1和4，2和5，3和6分别对应为主从关系，这也是最经典的最多的集群模式

redis-cli --cluster create ip1:port1 ip2:port2 ip3:port3 ip4:port4 ip5:port5 ip6:port6 --cluster-replicas 1

如果出现没有权限的提示，则需要添加密码。

redis-cli -a password --cluster create ip1:port1 ip2:port2 ip3:port3 ip4:port4 ip5:port5 ip6:port6 --cluster-replicas 1

检查集群信息

redis-cli -a password --cluster check 192.168.25.64:6379

slot槽节点的概念

操slot总数为16384个，其平均分配给各个master。数据存在相应的槽内部。

redis客户端连接到集群

-c 代表集群

redis-cli -c -a password -h ip -p port

进去后可以用cluster info 查看集群信息，cluster nodes 查看集群节点信息。

SpringBoot集成Redis集群

  redis：
    password: pass
    cluster:
      nodes: 121.89.***.81:6379,121.*.**.241:6379,121.89.***.81:6379,121.*.**.241:6379,121.89.***.81:6379,121.*.**.241:6379 # 6个不同节点

Redis详细介绍