redis

redis一般运行在linux上，所以要安装在linux系统里。
安装redis
1）通过filezilla把文件发送到/usr/local/temp文件夹
2）解压文件 #tar zxvf 文件名
3）复制文件到/usr/local/redis: #cp -r 文件名 /usr/local/redis
4）安装，在/usr/local/redis文件夹下，执行#make和#make install 命令，即可安装redis

redis写helloworld
1）首先创建一个myredis文件夹，把redis.conf文件复制到该文件夹下
2）vim redis.conf ，修改no为yes

################################# GENERAL #####################################
# By default Redis does not run as a daemon. Use 'yes' if you need it.
# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
daemonize yes

#ps -ef|grep redis 查看redis服务是否启动
启动redis，需要进入/usr/local/bin
#redis-server /myredis/redis.conf
#redis-cli -p 6379

127.0.0.1:6379> ping
PONG          启动成功的标志

redis常用命令：

redis默认16个库，可以通过查看redis.conf进行查看，统一密码管理，所有库密码都一样
select index：切换数据库
dbsize：查看当前数据库的key的数量
flushDb：清空当前数据库
flushall：清空所有数据库

del指令：del key [key...]
	删除给定的一个key或多个key，不存在的就忽略，返回被删除key的数量
exists指令：exists key 
	检查key是否存在，存在则返回1，不存在则返回0
expire指令：expire key seconds
	给key设置一个生存时间，当key过期是，会被自动删除
pexpire: 同上，不过设置的生存时间为毫秒
pexpireat: pexpireat key milliseconds-timestamp
	设置时间戳
ttl：ttl key
	返回key的生存时间，单位为秒
pttl: 单位为毫秒
keys指令：keys pattern
	查找所有给定pattern的key
	keys * 匹配所有的key
	keys h?llo  匹配hello，hallo，hcllo
	keys h*llo  匹配hallo，hllo ，heeeeeello
	keys h[ae]llo  匹配hallo，hello，不匹配hillo，特殊符号记得转义 \
move: move key db
	将当前数据库的key移到指定的数据库中，成功返回1，否则返回0
randomkey：randomkey
	从当前数据库随机返回一个key，不删除
rename：rename key newkey
	修改key为newkey，成功返回OK，否则返回错误
type：type key
	返回key存储值得类型，none表示不存在

redis的五大数据类型
1）string（字符串）

（1.1）set/get/del/qppend/sstrlen
（1.2）incr/decr/incrby/decrby  一定要是数字才能进行加减
（1.3）getrange/setrange  ：getrange key start end
（1.4）setex(set with expire )键秒值/setnx(set if not exists)
（1.5）mset/mget/msetnx
（1.6）getset(先get，在set)

2）hash（哈希）
（2.1）kv模式不变，但是v是一个键值对

hset/hget/hmset/hmget/hgetall/hdel：
hlen：
hexists key 在key里面某个值的key：
hkeys/hvals
hincrby/hincrbyfloat
hsetnx:

3）list（列表）
（3.1）单值多value

lpush/rpush/lrange   LPUSH lists[key] lisi wangwu zhangergou   lrange lists 0 -1
lpushx/rpushx   key存在才推入
lpop/rpop
lindex：按照索引下标获得元素（从上到下）
llen：list长度
lrem key n value：删n个value
ltrim key 开始index 结束index：截取指定范围的值在赋给key
rpoplpush 源列表 目的列表：截取指定范围的值后再赋值给key
lset key index value：设置key的索引位置的值为value
linsert key before/after 值1 值2：往key里面的值1前面/后面插入值2

4）set（集合）
（4.1）单值多value

sadd/smembers/sismember
scard：获取集合里面的元素个数
srem key value：删除集合中的元素
srandmember key：随机出几个数
spop key：随机出栈
smove key1 key2 key1里的某个值：移动值

(4.2数学集合类)

差集：sdiff    去掉第一个集合中和其他集合相同的元素
交集：sinter
并集：sunion

5）zset（有序集合）
在set的基础上，加了一个score值，之前是k1 v1 v2 v3，现在zset就是 k1 score1 v1 score2 v2

zadd/zrange： zadd  k1 score1 v1 score2 v2
zrangebyscore key 开始score 结束score：1.withscore 2.(不包含  3.limit作用是返回限制：limit开始下标步 多少步
zrem key 某score下对应的value值：删除某个元素
zcard/zcount key score区间/zrank key values值：作用是获得下标值/zcard key 对应值，获得分数
zrevrank key values值：作用是逆序获得下标值
zrevrange :
zrevrangebyscore key:

redis键

exists key的名字：判断某个key是否存在
move key db：把某个key转移到某个库中
expire key 秒钟：为给定的key设置时间
ttl key：查看key还有多久过期，-1表示永不过期，-2表示已经过期
type key：查看你的key是什么类型

常见配置redis.conf介绍参数说明
redis.conf配置项说明如下:
1. Redis默认不是以守护进程的方式运行，可以通过该配置项修改，使用yes启用守护进程daemonize na
 2.当Redis以守护进程方式运行时，Redis默认 会把pid写入/var/run/redis.pid文件，可以通过pidfile指定pidfile /var/run/redis.pid
3.指定Redis监听端口，默认端口为6379,作者在自己的- -篇博文中解释了为什么选用6379作为默认端口，因为6379在手机按键上MERZ对应的号码，而MERZ取自意大利歌女Alessia Merz的名字port 6379
4.绑定的主机地址bind 127.0.0.1
5.当 客户端闲置多长时间后关闭连接，如果指定为0,表示关闭该功能timeout 300
6.指定日志记录级别，Redis总 共支持四个级别: debug、 verbose. notice. warning,默认为verboseloglevel verbose
7.日志记录方式，默认为标准输出，如果配置Redis为守护进程方式运行，而这里又配置为日志记录方式为标准输出，则日志将会发送给/dev/null     logfile stdout
8.设置数据库的数量，默认数据库为0，可以使用SEL ECT <dbid>命令在连接上指定数据库iddatabases 16
9.指定在多长时间内，有多少次更新操作，就将数据同步到数据文件，可以多个条件配合save <seconds> <changes>Redis默认配置文件中提供了三个条件:save 900 1save 300 10save 60 10000分别表示900秒(15分钟)内有1个更改，300秒 (5分钟)内有10个更改以及60秒内有10000个更改。
10.指定存储至本地数据库时是否压缩数据，默认为yes, Redis采用LZF压缩，如果为了节省CPU时间，可以关闭该选项，但会导致数据库文件变的巨大rdbcompression yes
11.指定本地数据库文件名，默认值为dump.rdbdbfilename dump.rdb
12.指定本地数据库存放目录dir ./  
13.设置当本机为slav服务时，设置master服务的IP地址及端口，在Redis启动时，它会自动从master进行数据同步slaveof <masterip> <masterport>
14.当master服务设置了密码保护时，slav服务连接master的密码masterauth <master-password>
15.设置Redis连接密码，如果配置了连接密码，客户端在连接Redis时需要通过AUTH < password>命令提供密码，默认关闭requirepass foobared
16.设置同一时间最大客户端连接数，默认无限制，Redis可 以同时打开的客户端连接数为Redis进程可以打开的最大文件描述符数，如果设置maxclients 0,表示不作限制。当客户端连接数到达限制时，Redis会关闭新的连接并向客户端返回max number of clients reached错误信息maxclients 128
17.指定Redis最大内存限制，Redis在 启动时会把数据加载到内存中，达到最大内存后，Redis会先尝 试清除已到期或即将到期的Key,当此方法处理后，仍然到达最大内存设置，将无法再进行写入操作，但仍然可以进行读取操作。Redis新的vm机制，会把Key存放内存，Value会存放在swap区maxmemory <bytes>
18.指定是否在每次更新操作后进行日志记录，Redis在默认情况下是异步的把数据写入磁盘，如果不开启，可能会在断电时导致一段时间内的数据丢失。 因为redis本身同步数据文件是按上面save条件来同步的，所以有的数据会在一段时间内只存在于内存中 。默认为noappendonly no
19.指定更新日志文件名，默认为appendonly.aof
	appendfilename appendonly .aof
20.指定更新日志条件，共有3个可选值:
	no:表示等操作系统进行数据缓存同步到磁盘(快)
	always:表示每次更新操作后手动调用fsync()将数据写到磁盘(慢，安全)
	everysec:表示每秒同步- -次(折衷,默认值)
	appendfsync everysec
21.指定是否启用虚拟内存机制，默认值为no,简单的介绍一下，VM机制将数据分页存放，由Redis将访问量较少的页冷数据swap到磁盘上, 访问多的页面由磁盘自动换出到内存中(在后面的文章我会仔细分析Redis的VM机制)
	vm-enabled no
22.虛拟内存文件路径，默认值为/tmp/redis.swap, 不可多个Redis实例共享
	vm-swap-file /tmp/redis.swap
23.将所有大于vm-max memory的数据存入虚拟内存,无论vm-max-memory设置多小,所有索引数据都是内存存储的(Redis的索引数据就是keys),也就是说,当vm-max-memory设置为0的时候,其实是所有value都存在于磁盘。默认值为0
	vm-max-memory 0
24. Redis swap文件分成了很多的page, -一个对象可以保存在多个page上面，但- -个page上不能被多个对象共享，vm-page-size是 要根据存储的数据大小来设定的，作者建议如果存储很多小对象，page大小最好设置为32或者64bytes;如果存储很大大对象，则可以使用更大的page,如果不确定，就使用默认值
	vm-page-size 32
25.设置swap文件中的page数量，由于页表(一种表示页面空闲或使用的bitmap)是在放在内存中的，,在磁盘上每8个pages将消耗1byte的内存。
	vm-pages 134217728
26.设置访问swap文件的线程数,最好不要超过机器的核数如果设置为0,那么所有对swap文件的操作都是串行的，可能会造成比较长时间的延迟。默认值为4
	vm-max-threads 4
27.设置在向客户端应答时，是否把较小的包合并为一一个包发送，默认为开启
	glueoutputbuf yes
28.指定在超过一定的数量或者最大的元素超过某-临界值时， 采用- -种特殊的哈希算法
	hash-max zipmap-entries
	64hash-max-zipmap-value 512
29.指定是否激活重置哈希，默认为开启(后面在介绍Redis的哈希算法时具体介绍)
	activerehashing yes
30.指定包含其它的配置文件，可以在同一主机上多个Redis实例之间使用同一-份配置文件，而同时各个实例又拥有自己的特定配置文件
	include /path/to/local.conf

redis持久化机制：

快照：
	这种方式可以将某一时刻的所有数据写入硬盘中，这也是redis默认开启的持久化方式。保存的文件是以rdb结尾的，所以也被成为rdb方式
快照生成方式：
	客户端方式：
		BGSAVE：
			客户端可以使用BGSAVE命令来创建一个快照，当接收到客户端的BGSAVE命令时, redis会调用fork '来创建一个子进程，然后子进程负责将快照写入磁盘中,而父进程则继续处理命令请求。
			名词解释:fork当一个进程创建子进程的时候，底层的操作系统会创建该进程的一个副本,在类unix系统中创建子进程的操作会进行优化:在刚开始的时候，父子进程共享相同内存，直到父进程或子进程对内存进行了写之后,对被写入的内存的共享才会结束服务
		SAVE指令 ：
			客户端还可以使用SAVE命令来创建一个快照，接收到SAVE命令的redis服务器在快照创建完毕之前将不再响应任何其他的命令
	服务器配置自动触发：
		如果用户在redis.conf中设置了save配置选项, redis会在save选项条件满足之后自动触发一次BGSAVE命令，如果设置多个save配置选项,当任意一个save配置选项条件满足,redis也会触发一次BGSAVE命令
		filename：修改生成的rdb文件名
		./ : 修改生成rdb文件位置，已redis-server所在目录为当前目录

aof：处理速度慢，但是数据精度能够得到保证
	这种方式可以将所有客户端执行的写命令记录到日志文件中,AOF持久化会将被执行的写命令写到AOF的文件末尾,以此来记录数据发生的变化,因此只要redis从头到尾执行一次AOF文件所包含的所有写命令,就可以恢复AOF文件的记录的数据集.
	开启：	默认不开启
		修改conf文件，将appendonly no改成yes
		appendfsync everysec：默认日志追加频率
			always：每个redis写命令都要同步写入硬盘，严重降低redis速度，不推荐
			everysec：推荐使用，每秒执行一次同步显示的将多个写命令同步到磁盘
			no：由系统决定何时同步，不推荐
	AOF文件的重写：用来在一定程度上减小AOF文件的体积
		客户端触发重写：BGREWRITEAOF，不会阻塞redis服务
		服务器配置自动重写：
			如果设置auto-aof-rewrite-percentage值为100和auto-aof-rewrite-min-size 64mb,并且启用的AOF持久化时,那么当AOF文件体积大于64N,并且AOF文件的体积比上一次重写之后体积大了至少一倍(100%)时，会自动触发，
			如果重写过于频繁,用户可以考虑将auto-aof-rewrite-percentage设置为更大
			重写原理：
				注意:重写aof文件的操作，并没有读取旧的aof文件，而是将整个内存中的数据库内容用命令的方式重写了一个新的aof文件,替换原有的文件这点和快照有点类似。
			重写流程：
				- 1. redis调用fork ，现在有父子两个进程子进程根据内存中的数据库快照，往临时文件中写入重建数据库状态的命令
				- 2、父进程继续处理client请求，除了把写命令写入到原来的aof文件中。同时把收到的写命令缓存起来。这样就能保证如果子进程重写失败的话并不会出问题。
				- 3，当子进程把快照内容写入已命令方式写到临时文件中后，子进程发信号通知父进程。然后父进程把缓存的写命令也写入到临时文件。
				- 4、现在父进程可以使用临时文件替换老的aof文件，并重命名，后面收到的写命令也开始往新的aof文件中追加。

使用：建议混合使用，在两者并存的情况下，会优先加载aof文件，把rdb改成15分钟进行一次操作save 900 1
异常恢复处理：redis-check-aof --fix aof文件

开启redis远程连接

vim redis.conf
将bind 127.0.0.1 改成 bind 0.0.0.0,重新启动必须根据你改的配置文件启动

JAVA操作redis

1. 引入依赖
	<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
	<dependency>
	    <groupId>redis.clients</groupId>
	    <artifactId>jedis</artifactId>
	    <version>3.3.0</version>
	</dependency>
2. 操作
	public static void main(String[] args) {
        // 创建jedis客户端对象
        Jedis jedis = new Jedis("redis安装地址",6379);

        // 选择使用一个库
        jedis.select(0);

        // 获取所有key信息
        Set<String> keys = jedis.keys("*");
        keys.forEach(key -> System.out.println("key----"+key) );

        // 释放资源
        jedis.close();
    }

springboot整合redis

Spring Boot Data(数据)Redis 中提供了RedisTemplate和StringRedisTemplate，其中StringRedisTemplate是RedisTemplate的子类，
两个方法基本一致，不同之处主要体现在操作的数据类型不同，RedisTemplate中的两个泛型都是object，意味着存储的key和value都可以是一个对象，
而StringRedisTemplate的两个泛型都是String，意味着StringRedisTemplate的key和value都只能是字符串。

环境搭建
1.引入依赖
	<dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-data-redis</artifactId>
     </dependency>
application.properties:
	spring.redis.host=redis安装地址
	spring.redis.port=6379
	spring.redis.database=0


StringRedisTemplate的使用:
	@SpringBootTest(classes = SpringbootRedisApplication.class)
	@RunWith(SpringRunner.class)
	public class TestStringRedisTemplate {
	
	    // 注入StringRedisTemplate
	    @Autowired
	    private StringRedisTemplate stringRedisTemplate;
	
	    @Test
	    public void testKey(){
	        Boolean hasKey = stringRedisTemplate.hasKey("name");
	        Boolean delete = stringRedisTemplate.delete("name");
	    }
	
	    //操作redis中字符串,opsForValue操作的就是redis中的String类型
	    @Test
	    public void testString(){
	        stringRedisTemplate.opsForValue().set("name","xiuzhiwu");
	        stringRedisTemplate.opsForValue().set("yanzhengma","123456",300, TimeUnit.SECONDS);
	    }
	
	    @Test
	    public void testList(){
	        stringRedisTemplate.opsForList().leftPush("lists","zhangsna");
	        stringRedisTemplate.opsForList().leftPushAll("lists","zhangsna","lisi","wangwu ");
	    }
	
	    @Test
	    public void testSets(){
	        stringRedisTemplate.opsForSet().add("sets","zhagnsna","lishi","wanguw","zhaoliu");
	        Set<String> sets = stringRedisTemplate.opsForSet().members("sets");
	        sets.forEach(value -> System.out.println("sets:"+value));
	
	        Long size = stringRedisTemplate.opsForSet().size("sets");
	        System.out.println("size:"+size);
	    }
	
	    @Test
	    public void testZSets(){
	        stringRedisTemplate.opsForZSet().add("zsets","zhangsna",13);
	        stringRedisTemplate.opsForZSet().rangeByScoreWithScores("zsets",0,30,0,30);
	    }
	
	    @Test
	    public void testHash(){
	        stringRedisTemplate.opsForHash().put("maps","name","zhangsna");
	
	        Map<String,String> map = new HashMap<>();
	        map.put("age","18");
	        map.put("content","sfasdf");
	        stringRedisTemplate.opsForHash().putAll("mapss",map);
	
	        List<Object> lists = stringRedisTemplate.opsForHash().multiGet("mapss", Arrays.asList("age", "content"));
	        lists.forEach(list -> System.out.println("lsits:"+list));
	    }
	}


redisTemplate的使用 : 使用和StringRedisTemplate基本一致，对象要实现序列化。
	@Data
	public class User implements Serializable {
	    private String id;
	    private String name;
	    private String sex;
	    private Date birth;
	}
	
	@SpringBootTest(classes = SpringbootRedisApplication.class)
	@RunWith(SpringRunner.class)
	public class TestRedisTemplate {
	
	    @Autowired
	    private RedisTemplate redisTemplate;
	
	    @Test
	    public void testRedisTemplate(){
	        // 修改key序列化方案
	        redisTemplate.setKeySerializer(new StringRedisSerializer());
	        // 修改hash里面的key序列化方法
	        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
	
	        User user = new User();
	        user.setId(UUID.randomUUID().toString());
	        user.setName("臧三");
	        user.setSex("2");
	        user.setBirth(new Date());
	
	        redisTemplate.opsForValue().set("user",user);
	    }
	}

bounds：对key进行绑定，简化操作
	

redis分布式缓存

第一步：开启mybatis缓存
	<!--EmpMapper开启二级缓存-->
    <!--<cache type="com.xiuzhiwu.springboot_redis.cache.RedisCache.java"/>-->

    <!--userMapper开启关联关系的缓存处理-->
    <cache-ref namespace="com.xiuzhiwu.springboot_redis.mapper.EmpMapper"/>
第二步：利用工程获取redisTemplate
	//用来获取springboot工厂
	@Configuration
	public class ApplicationContextUtils implements ApplicationContextAware {
	
	    private static ApplicationContext applicationContext;
	
	    @Override
	    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
	        this.applicationContext = applicationContext;
	    }
	
	    public static Object getBean(String beanName){
	        return applicationContext.getBean(beanName);
	    }
	}
第三步：编写RedisCache 类，记住，使用redis的实体类一定要序列化
	public class RedisCache implements Cache {
	    private final String id;
	
	    public RedisCache(String id){
	        this.id = id;
	    }
	
	    @Override
	    public String getId() {
	        return id;
	    }
	
	    @Override
	    public void putObject(Object o, Object o1) {
	
	        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("RedisTemplate");
	        // 修改key序列化方案
	        redisTemplate.setKeySerializer(new StringRedisSerializer());
	        // 修改hash里面的key序列化方法
	        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
	
	        redisTemplate.opsForHash().put(getMD5Key(id.toString()),getMD5Key(o.toString()),o1);
	    }
	
	    @Override
	    public Object getObject(Object o) {
	
	        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("RedisTemplate");
	        // 修改key序列化方案
	        redisTemplate.setKeySerializer(new StringRedisSerializer());
	        // 修改hash里面的key序列化方法
	        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
	
	        return redisTemplate.opsForHash().get(getMD5Key(id.toString()),getMD5Key(o.toString()));
	    }
	    
	    // 目前没什么用
	    @Override
	    public Object removeObject(Object o) {
	        return null;
	    }
	
	    @Override
	    public void clear() {
	        RedisTemplate redisTemplate = (RedisTemplate) ApplicationContextUtils.getBean("RedisTemplate");
	        // 修改key序列化方案
	        redisTemplate.setKeySerializer(new StringRedisSerializer());
	        // 修改hash里面的key序列化方法
	        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
	
	        redisTemplate.opsForHash().delete(getMD5Key(id.toString()));
	    }
	
	    @Override
	    public int getSize() {
	        return 0;
	    }
	
	    public String getMD5Key(String key){
	        return DigestUtils.md5DigestAsHex(key.getBytes(StandardCharsets.UTF_8));
	    }
	}

缓存穿透：
	定义:客户端查询了一个数据库中没有的数据记录导致缓存在这种情况下无法利用称之为缓存穿透或者是缓存击穿
	mybatis中cache解决了缓存穿透:将数据库中没有查询到结果也进行缓存
缓存雪崩：
	定义;在系统运行的某一时刻,突然系统中缓存全部失效,恰好在这一时刻涌来大量客户端请求,导致所有模块缓存无法利用,大量请求涌向数据库导致极端情况，数据库阻塞或挂起
	缓存存储时:业务系统非常大模块多业务数据不同︰不同模块在放入缓存时都会设置一个缓存超时时间
	解决方案:
		1.缓存永久存储
		2.针对于不同业务数据一定要设置不同超时时间

redis事务
redis事务命令：
1.discard：取消事务，放弃执行事务块内所有命令
2.exec：执行事务块内所有的命令
3.multi：标记一个事务块的开始
4.unwatch：取消watch对所有key的监视
5.watch key[key…]：监视一个或多个key，如果执行事务之前，这些key被改动过，所有事务将被打断

redis主从复制

1.配从库不配主库
2.从库配置：slaveof 主库ip 主库端口
3.修改配置文件细节操作
4.常用3招：一主二仆，薪火相传，
反客为主:slaveof no one(主机宕机后，可以使用这个命令让当前机器变成主机)
info replication

哨兵模式：

1.先创建一个sentinel.conf
2.配置哨兵，填充内容：sentinel monitor 被监控数据库名字 127.0.0.1 6379 1(数字1代表主机挂掉后slave投票看让谁接替成主机，得票多少后成为主机)
3.启动哨兵：redis-sentinel sentinel.conf

springboot操作哨兵：
	properties配置
		#redis sentinel配置
		# master写的是哨兵监听的那个名称
		spring.redis.sentinel.master=mysentinel
		#连接的不再是一个具体的主机，书写的是多个哨兵节点
		spring.redis.sentinel.nodes=192.168.1.31:26379
	sentinel.conf
		bind 0.0.0.0

Redis集群

-所有的redis节点彼此互联(PING-PONG机制),内部使用二进制协议优化传输速度和带宽．
-节点的fail是通过集群中超过半数的节点检测失效时才生效.
-客户端与redis节点直连,不需要中间proxy层.客户端不需要连接集群所有节点,连接集群中任何一个可用节点即可
- redis-cluster把所有的物理节点映射到[0-16383]slot上, cluster 负责维护node<->slot<->value

CRC16算法特点
	1.对集群模式下的所有key进行CRC16计算,计算的结果始终在0-16383之间
	2.对客户端的key进行CRC16计算时同一个key多次经过CRC16计算结果始终一致
	3.对客户端的不同key进行CRC16计算,计算的记过会出现不能key的结果一致


搭建集群：
	环境准备：
		yum install ruby
		yum install rubygems
		gem install redis
	配置文件
		port 6379   //修改端口
		bind 0.0.0.0   //开启远程连接
		cluster-enabledyes  //开启集群模式
		cluster-config-file nodes-port.conf //集群节点配置文件
		cluster-node-timeout 5088  //集群节点超时时间
		appendonly yes		//开启AOF持久化
		daemonize yes  // 以守护进程方式启动redis
	查看进程  ps aux|grep redis
	将源码的redis-trib.rb复制到安装目录：cp redis-trib.rb /usr/redis/bin/
创建集群;
	./redis-trib.rb create --replicas 1 192.168.282.205:7000 192.168.282.285:7001 192.168.282.285:7082192.168.282.285:7803192.168.202.205:7004192.168.282.205:7005
查看集群状态：
	/ redis-trib.rb check 192.168.202.205:7088
添加主节点
	1.添加主节点add-node[新加入节点].[原始集群中低意节点]
		./redis-trib.rb add-node 192.168.1.158:7006 192.168.1.158:7005
添加从节点
	1.添加从节点add-node --slave[新加入节点][集群中任意节点]
		./redis-trib.rb add-node --slave 192.168.1.158:7086192.168.1.158:7888
		注意:当添加副本节点时没有指定主节点, redis会随机给副本节点较少的主节点添加当前副本节点
	⒉.为确定的master节点添加主节点add-node --slave --master-id master节点id〔新加入节点].〔集群任意节点]-
		./redis-trib.rb add-node --slave --master-id 3c3a8c74aae0b56178ccb83a76b68cfe7dc1912e 127.0.0.1:7006 127.8.0.1 :7000
删除节点
	1.删除节点del-node[集群中任意节点]〔删除节点id]
		./redis-trib.rb del-node 127.0.0.1:7002 8ca3f102ecf8c888fc7a7ce43a13e9be9f6d3dd1
		注意: 被删除的节点必须是从节点或没有被分配hash slots的节点
集群在线分片
	1.在线分片reshard[集群中任意节点] [无]
		./redis-trib.rb reshard 192.168.1.158:7000

springboot操作集群节点：
	配置文件：最好把所有redis节点都写上，防止redis宕机后无法操作redis
		#springboot操作redis集群
		spring.redis.cluster.nodes=192.168.1.31:6379,192.168.1.31:6380
	

Redis实现分布式session管理

管理机制：
	redis的session管理是利用spring提供的session管理解决方案,将一个应用session交绐Redis存储,整个应用中所有session的请求都会去redis中获取对应的session数据。

开发Session管理
	<!-- 别忘了引入redis依赖s -->
	<dependency>
		<groupId>org.springframework.session
		</groupId><artifactId>spring-session-data-redis</artifactId>
	< / dependency>
开发session管理配置类
@Configuration
@EnableRedisHttpSession
public class_RedisSessionManager {
	
}