Redis学习秘籍

# 1.说明: 
- 这一类数据库主要会使用到一个哈希表，这个表中有一个特定的键和一个指针指向特定的数据。

# 2.特点
- Key/value模型对于IT系统来说的优势在于简单、易部署。  
- 但是如果DBA只对部分值进行查询或更新的时候，Key/value就显得效率低下了。                                                                                                                                               
# 3.相关产品
- Tokyo Cabinet/Tyrant,
- Redis key value  内存
- SSDB  key value  磁盘
- Voldemort 
- Oracle BDB

# 1.说明
- 这部分数据库通常是用来应对分布式存储的海量数据。 

# 2.特点
- 键仍然存在，但是它们的特点是指向了多个列。这些列是由列家族来安排的。 

# 3.相关产品
- Cassandra、HBase(hadoop )、Riak.

# 1.说明
- 文档型数据库的灵感是来自于Lotus Notes办公软件的，而且它同第一种键值存储相类似该类型的数据模型是版本化的文档，半结构化的文档以特定的格式存储，比如JSON。文档型数据库可 以看作是键值数据库的升级版，允许之间嵌套键值。而且文档型数据库比键值数据库的查询效率更高

# 2.特点
- 以文档形式存储

# 3.相关产品
- MongoDB、CouchDB、 MongoDb(4.x)(单条支持事务)  

# 1.说明
- 图形结构的数据库同其他行列以及刚性结构的SQL数据库不同，它是使用灵活的图形模型，并且能够扩展到多个服务器上。
- NoSQL数据库没有标准的查询语言(SQL)，因此进行数据库查询需要制定数据模型。许多NoSQL数据库都有REST式的数据接口或者查询API。

# 2.特点

# 3.相关产品
- Neo4J、InfoGrid()、 Infinite Graph、

redis-4.0.10.tar.gz

		yum -y install gcc  #redis是C语言写的

        yum install -y vim*  #//在线安装vim

		在CRT中 alt+p , 直接拖进

		tar -zxvf xxx.zip

		make
   		#如果遇到致命错误：执行    
   		# zmalloc.h:50:31:致命错误：jemalloc/jemalloc.h:没有那个文件或目录
   		make MALLOC=libc

		make install PREFIX=/usr/redis

		./redis-server 
		#默认执行配置文件  /path/to/redis.conf
		
		#将配置文件拷贝到 /usr/redis目录    进入到家目录解压完成之后的redis中执行
		cp redis.conf /usr/redis
		#指定配置文件启动  usr/bin目录下执行
		./redis-server  ../redis.conf

	#将redis.conf中的默认端口修改为指定端口
	
	#默认启动端口 port 6379    port 7000

		#默认连接
		./redis-cli
		
		#指定端口连接 指定IP连接
		./redis-cli –p 6379 -h localhost

		#将redis.conf中的默认端口修改为指定端口
		daemonize no    改为 daemonize yes

		systemctl stop firewalld

		ps aux|grep redis
		
		#杀死进程
		kill -9 8989

# 1.Redis中库说明
- 使用redis的默认配置器动redis服务后,默认会存在16个库,编号从0-15  默认进入的是0号库
- 可以使用select 库的编号 来选择一个redis的库

# 2.Redis中操作库的指令
- 清空当前的库  FLUSHDB
- 清空全部的库  FLUSHALL

# 3.redis客户端显示中文
-	./redis-cli  -p 7000 --raw

#删除给定的某个 key 
DEL key

eg:127.0.0.1:6379> DEL name
eg:eg:(integer) 1

#删除给定的一多个 key 
DEL [key ...]

eg:127.0.0.1:6379> DEL name type website
eg:(integer) 3

#返回值： 被删除 key 的数量。
#不存在的 key 会被忽略。

#查找所有符合给定模式 pattern 的 key 。
KEYS pattern

#匹配数据库中所有 key 
keys *

eg:127.0.0.1:6379> keys *
eg:1) "age"
eg:2) "name"

#匹配 hello ，hallo 和 hxllo 等。
KEYS h?llo 
# ?匹配一个任意字符

eg:127.0.0.1:6379> KEYS t??
eg:1) "two"

#匹配 hllo 和 heeeeello 等。
KEYS h*llo 
# *匹配多个任意字符

eg:127.0.0.1:6379> KEYS *o*
eg:1) "four"
eg:2) "two"
eg:3) "one"

#匹配 hello 和 hallo ，但不匹配 hillo 。
KEYS h[ae]llo 
## 匹配一个[]中包含的一个字符

eg:127.0.0.1:6379> KEYS t[w]*
eg:1) "two"

#判断某个key是否存在
EXISTS key 

eg:127.0.0.1:6379> EXISTS name
eg:(integer) 1
#判断多个key是否存在
EXISTS [key ...] 

eg:127.0.0.1:6379> EXISTS name age
eg:(integer) 2
#返回值： 若 key 存在，返回 1 ，否则返回 0 

#为给定 key 设置生存时间，当 key 过期时 (生存时间为 0 )，它会被自动删除。
expire key seconds    #时间单位为seconds

eg:127.0.0.1:6379> expire age 10
eg:(integer) 0
eg:127.0.0.1:6379> set age 18
eg:OK
eg:127.0.0.1:6379> expire age 10
eg:(integer) 1

#返回值： 设置成功，返回 1 ，否则返回 0 
#注意：当 key 不存在或者不能为 key 设置生存时间时 (比如在低于 2.1.3 版本的 Redis 中你尝试更新 key 的
#生存时间)，返回 0 。
eg:127.0.0.1:6379> expire age -1 //标识永不过期  默认

pexpire key milliseSeconds    #时间单位为milliseSeconds

eg:127.0.0.1:6379> pexpire age 10000
eg:(integer) 1

ttl key 返回单位 秒
#返回值：
#	当key 不存在时，返回-2 。
#	当key 存在但没有设置剩余生存时间时，返回-1 。
#	否则，以秒为单位，返回key 的剩余生存时间。

eg:127.0.0.1:6379> ttl name
eg:(integer) -1
eg:127.0.0.1:6379> ttl hehe
eg:(integer) -2
eg:127.0.0.1:6379> ttl age
eg:(integer) 96

pttl key 返回单位 毫秒

eg:127.0.0.1:6379> pttl age
eg:(integer) 26301

#将当前数据库的 key 移动到指定的数据库 db 当中。
MOVE key 库的编号   

#如果当前数据库 (源数据库) 和给定数据库 (目标数据库) 有相同名字的给定 key ，或者 key 不存在于当前数据库，那么 MOVE 没有任何效果。
#因此，也可以利用这特性，将MOVE 当作锁 (locking) 原语 (primitive)

#返回值： 移动成功返回 1 ，失败则返回 0 。

select 库的编号

eg:127.0.0.1:6379> select 1
eg:OK
eg:127.0.0.1:[1]> 

randomkey

#从当前数据库中随机返回(不删除) 一个key 
#返回值：当数据库不为空时，返回一个key 。当数据库为空时，返回nil 

eg:127.0.0.1:6379> randomkey
eg:"age"
eg:127.0.0.1:6379> randomkey
eg:"name"

RENAME key newkey

#作用 : 将key 改名为newkey 。当key 和newkey 相同，或者key 不存在时，返回一个错误。当newkey 已经存在时，RENAME 命令将覆盖旧值。
#返回值： 改名成功时提示OK ，失败时候返回一个错误。

TYPE key

#作用 :  返回key 所储存的值的类型。
#返回值：
#	none (key 不存在)
#	string (字符串)
#	list (列表)
#	set (集合)
#	zset (有序集)
#	hash (哈希表)

# 1.客户端方式之BGSAVE
- a.客户端可以使用BGSAVE命令来创建一个快照,当接收到客户端的BGSAVE命令时,redis会调用fork¹来创建一个子进程,然后子进程负责将快照写入磁盘中,而父进程则继续处理命令请求。
	
	`名词解释: fork当一个进程创建子进程的时候,底层的操作系统会创建该进程的一个副本,在类unix系统中创建子进程的操作会进行优化:在刚开始的时候,父子进程共享相同内存,直到父进程或子进程对内存进行了写之后,对被写入的内存的共享才会结束服务`

# 2.客户端方式之SAVE
- b.客户端还可以使用SAVE命令来创建一个快照,接收到SAVE命令的redis服务器在快照创建完毕之前将不再响应任何其他的命令
- 



- **注意: SAVE命令并不常用,使用SAVE命令在快照创建完毕之前,redis处于阻塞状态,无法对外服务**

```markdown
# 3.服务器配置方式之满足配置自动触发
- 如果用户在redis.conf中设置了save配置选项,redis会在save选项条件满足之后自动触发一次BGSAVE命令,如果设置多个save配置选项,当任意一个save配置选项条件满足,redis也会触发一次BGSAVE命令

# 4.服务器接收客户端shutdown指令
- 当redis通过shutdown指令接收到关闭服务器的请求时,会执行一个save命令,阻塞所有的客户端,不再执行客户端执行发送的任何命令,并且在save命令执行完毕之后关闭服务器

# 1.修改生成快照名称
- dbfilename dump.rdb

# 2.修改生成位置
- dir ./

# 1.开启AOF持久化
- a.修改 appendonly yes 开启持久化
- b.修改 appendfilename "appendonly.aof" 指定生成文件名称

# 1.always 【谨慎使用】
- 说明: 每个redis写命令都要同步写入硬盘,严重降低redis速度
- 解释: 如果用户使用了always选项,那么每个redis写命令都会被写入硬盘,从而将发生系统崩溃时出现的数据丢失减到最少;遗憾的是,因为这种同步策略需要对硬盘进行大量的写入操作,所以redis处理命令的速度会受到硬盘性能的限制;
- 注意: 转盘式硬盘在这种频率下200左右个命令/s ; 固态硬盘(SSD) 几百万个命令/s;  1k ssd
- 警告: 使用SSD用户请谨慎使用always选项,这种模式不断写入少量数据的做法有可能会引发严重的写入放大问题,导致将固态硬盘的寿命从原来的几年降低为几个月。

# 2.everysec 【推荐】
- 说明: 每秒执行一次同步将多个写命令同步到磁盘 
- 解释： 为了兼顾数据安全和写入性能,用户可以考虑使用everysec选项,让redis每秒一次的频率对AOF文件进行同步;redis每秒同步一次AOF文件时性能和不使用任何持久化特性时的性能相差无几,而通过每秒同步一次AOF文件,redis可以保证,即使系统崩溃,用户最多丢失一秒之内产生的数据。

# 3.no	【不推荐】
- 说明: 由操作系统决定何时同步 
- 解释：最后使用no选项,将完全有操作系统决定什么时候同步AOF日志文件,这个选项不会对redis性能带来影响但是系统崩溃时,会丢失不定数量的数据,另外如果用户硬盘处理写入操作不够快的话,当缓冲区被等待写入硬盘数据填满时,redis会处于阻塞状态,并导致redis的处理命令请求的速度变慢。

# 1.修改日志同步频率
- 修改appendfsync everysec|always|no 指定

# 1.客户端方式触发重写
- 执行BGREWRITEAOF命令  不会阻塞redis的服务

# 2.服务器配置方式自动触发
- 配置redis.conf中的auto-aof-rewrite-percentage选项 参加下图↓↓↓
- 如果设置auto-aof-rewrite-percentage值为100和auto-aof-rewrite-min-size 64mb,并且启用的AOF持久化时,那么当AOF文件体积大于64M,并且AOF文件的体积比上一次重写之后体积大了至少一倍(100%)时,会自动触发,如果重写过于频繁,用户可以考虑将auto-aof-rewrite-percentage设置为更大

# 重写流程
- 1. redis调用fork ，现在有父子两个进程 子进程根据内存中的数据库状态快照，往临时文件中写入重建数据库状态的命令
- 2. 父进程继续处理client请求，除了把写命令写入到原来的aof文件中。同时把收到的写命令缓存起来。这样就能保证如果子进程重写失败的话并不会出问题。
- 3. 当子进程把快照内容写入新文件已命令方式写到临时文件中后，子进程发信号通知父进程。然后父进程把缓存的写命令也写入到临时文件。
- 4. 现在父进程可以使用临时文件替换老的aof文件，并重命名，后面收到的写命令也开始往新的aof文件中追加。
1.创建父子进程
2.子进程将当前的数据状态拍一个快照
3.将快照转化为写命令
4.父进程急需处理客户端写操作
5.继续将写命令向老的Aof文件中追加  同时再缓存一份 新的谢命令
6.子进程将快照写入临时文件之后通知父进程,父进程将缓存的新命令加入临时文件中
7.使用新的Aof文件替换老的Aof文件

<!--引入jedis连接依赖-->
<dependency>
  <groupId>redis.clients</groupId>
  <artifactId>jedis</artifactId>
  <version>2.9.0</version>
</dependency>

 public static void main(String[] args) {
   //1.创建jedis对象
   Jedis jedis = new Jedis("192.168.112.102", 6379);//1.redis服务必须关闭防火墙  2.redis服务必须开启远程连接
   jedis.select(0);//选择操作的库默认0号库
   //2.执行相关操作
   //....
   //3.释放资源
   jedis.close();
 }

private Jedis jedis;
    @Before
    public void before(){
        this.jedis = new Jedis("192.168.202.205", 7000);
    }
    @After
    public void after(){
        jedis.close();
    }

    //测试key相关
    @Test
    public void testKeys(){
        //删除一个key
        jedis.del("name");
        //删除多个key
        jedis.del("name","age");

        //判断一个key是否存在exits
        Boolean name = jedis.exists("name");
        System.out.println(name);

        //设置一个key超时时间 expire pexpire
        Long age = jedis.expire("age", 100);
        System.out.println(age);

        //获取一个key超时时间 ttl
        Long age1 = jedis.ttl("newage");
        System.out.println(age1);

        //随机获取一个key
        String s = jedis.randomKey();

        //修改key名称
        jedis.rename("age","newage");

        //查看可以对应值的类型
        String name1 = jedis.type("name");
        System.out.println(name1);
        String maps = jedis.type("maps");
        System.out.println(maps);
    }

//测试String相关
    @Test
    public void testString(){
        //set
        jedis.set("name","小陈");
        //get
        String s = jedis.get("name");
        System.out.println(s);
        //mset
        jedis.mset("content","好人","address","海淀区");
        //mget
        List<String> mget = jedis.mget("name", "content", "address");
        mget.forEach(v-> System.out.println("v = " + v));
        //getset
        String set = jedis.getSet("name", "小明");
        System.out.println(set);

        //............
    }

//测试List相关
    @Test
    public void testList(){

        //lpush
        jedis.lpush("names1","张三","王五","赵柳","win7");

        //rpush
        jedis.rpush("names1","xiaomingming");

        //lrange

        List<String> names1 = jedis.lrange("names1", 0, -1);
        names1.forEach(name-> System.out.println("name = " + name));

        //lpop rpop
        String names11 = jedis.lpop("names1");
        System.out.println(names11);

        //llen
        jedis.linsert("lists", BinaryClient.LIST_POSITION.BEFORE,"xiaohei","xiaobai");

      	//........

    }

//测试SET相关
@Test
public void testSet(){

  //sadd
  jedis.sadd("names","zhangsan","lisi");

  //smembers
  jedis.smembers("names");

  //sismember
  jedis.sismember("names","xiaochen");

  //...
}

//测试ZSET相关
@Test
public void testZset(){

  //zadd
  jedis.zadd("names",10,"张三");

  //zrange
  jedis.zrange("names",0,-1);

  //zcard
  jedis.zcard("names");

  //zrangeByScore
  jedis.zrangeByScore("names","0","100",0,5);

  //..

}

//测试HASH相关
@Test
public void testHash(){
  //hset
  jedis.hset("maps","name","zhangsan");
  //hget
  jedis.hget("maps","name");
  //hgetall
  jedis.hgetAll("mps");
  //hkeys
  jedis.hkeys("maps");
  //hvals
  jedis.hvals("maps");
  //....
}

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

spring.redis.host=localhost
spring.redis.port=6379
spring.redis.database=0

//key相关操作
@Test
public void testKey() {
    
    //查看所有key
    Set<String> keys = stringRedisTemplate.keys("*");
    keys.forEach(key -> System.out.println(key));

    //删除一个key  //成功返回true  否则返回false
    System.out.println("name是否删除成功: "+stringRedisTemplate.delete("name"));
    //删除多个key //删除成功几个key返回就是数字几
    System.out.println("成功删除了个数为: "+stringRedisTemplate.delete(Arrays.asList("name", "age")));

    //判断某个key是否存在 //存在返回 true
    System.out.println("maps是否存在: "+stringRedisTemplate.hasKey("maps"));
        
    //设置key超时时间  参数:key,时间,时间单位
        Boolean nsme = stringRedisTemplate.expire("nsme", 30, TimeUnit.SECONDS);
        System.out.println("给nsme设置超时时间的状态:"+nsme);
    
    //获取key超时时间  //返回的是存活时间 默认毫秒
    System.out.println("name过期时间: "+stringRedisTemplate.getExpire("name")); //-2
    
    //参数1:查看那个key超时时间  参数2:返回时间单位
    System.out.println("lists超时时间: "+stringRedisTemplate.getExpire("lists", TimeUnit.SECONDS)); //-2

    //移动key 到某一个库
    System.out.println("是否移动成功: "+stringRedisTemplate.move("sets", 3));

    //随机返回一个key
    System.out.println("随机返回的key: "+stringRedisTemplate.randomKey());
}

@Test
public void testString(){
    
    //设置一个值  //永久设置一个key value
    stringRedisTemplate.opsForValue().set("name","张三");
    //设置一个key同时 指定key超时时间
    stringRedisTemplate.opsForValue().set("age","19",10,TimeUnit.HOURS);

    //在value后追加值
    stringRedisTemplate.opsForValue().append("name"," 他是一个好人");

    //给key对应数字类型value进行自减操作 -1
    stringRedisTemplate.opsForValue().decrement("age");
    //参数2:自减步长
    stringRedisTemplate.opsForValue().decrement("age",2);

    System.out.println(stringRedisTemplate.opsForValue().get("name"));
    System.out.println(stringRedisTemplate.opsForValue().get("age"));

    //获取value指定范围内结果
    System.out.println(stringRedisTemplate.opsForValue().get("name", 0, -1));
    //获取原始并设置新value
    System.out.println(stringRedisTemplate.opsForValue().getAndSet("name", "小明明"));
    //存在key不做任何操作不存在则设置value
    stringRedisTemplate.opsForValue().setIfAbsent("aa","xiaoming");
    //一次性设置多个key value 只要其中存在一个key 不做任何操作  原子性
    //stringRedisTemplate.opsForValue().multiSetIfAbsent(map)
    //获取key所对应值的长度
    System.out.println(stringRedisTemplate.opsForValue().size("name"));
}

@Test
public void testList(){

    //获取list类型操作对象
    ListOperations<String, String> listOperations = stringRedisTemplate.opsForList();
    //创建lists列表并放入一个值
    listOperations.leftPush("lists","zhangsan");
    //创建lists列表并放入多个元素
    listOperations.leftPushAll("names","张三","李四","王五");
    listOperations.leftPushAll("ages",Arrays.asList("19","18","17"));
    //获取一个列表
    listOperations.range("names",0,-1).forEach(name-> System.out.println(name));
    System.out.println("=================================");
    //列表中某个元素之前 leftpush  之后 rightpush插入元素
    listOperations.leftPush("names","李四","小陈");
    listOperations.rightPush("names","李四","小明");
    listOperations.range("names",0,-1).forEach(name-> System.out.println(name));

    //获取指定下标的元素
    System.out.println(listOperations.index("names", 1));
    //向list放入一个值  保证list必须存在  不会创建新的列表
    listOperations.leftPushIfPresent("names","xxx");  //names: xx 王五  ...      ages: 小明 17 18 19
    //针对于两个列表 说明:从参数1列表右边弹出一个元素并把弹出元素放入参数2列表左边  参数1: 列表  参数2:列表
    System.out.println(listOperations.rightPopAndLeftPush("names","ages"));
    //remove删除重复元素
    listOperations.remove("names",2,"zhangsan");
    //根据下标修改一个值
    listOperations.set("names",2,"xiaochen");
    //截取list列表中指定内容 注意:修改list内容
    listOperations.trim("names",0,4);
    //查询列表长度
    System.out.println(listOperations.size("names"));
}

@Test
public void testSet(){
    
    SetOperations<String, String> setOperations = stringRedisTemplate.opsForSet();
    //向set集合添加一个元素
    setOperations.add("sets","xxx","123","234");
    //查看集合成员
    setOperations.members("sets").forEach(val-> System.out.println(val));
    System.out.println("===================================");
    //从set集合随机返回指定元素
    setOperations.distinctRandomMembers("sets",4).forEach( val-> System.out.println(val));

    //查询集合元素个数
    System.out.println(setOperations.size("sets"));

    //从集合中返回并移除一个元素
    System.out.println(setOperations.pop("sets"));
    //从一个集合移动到另一个集合中 注意:必须是同一种类型
    setOperations.move("sets","xxx","sets1");

    //去掉第一个集合中其它集合含有的相同元素
    setOperations.difference("sets","sets1");
    setOperations.difference("sets",Arrays.asList("sets1","sets2","sets3"));

    //求多个集合元素交集
    setOperations.intersect("sets1","sets");
    setOperations.intersect("sets1",Arrays.asList("sets","sets2"));

    //求多个集合合集
    setOperations.union("sets","sets1");
    setOperations.union("sets",Arrays.asList("sets1","sets2"));
}

@Test
public void testZset(){

    //获取Zset操作对象
    ZSetOperations<String, String> zSetOperations = stringRedisTemplate.opsForZSet();

    //创建一个zsets集合并放入一个元素
    zSetOperations.add("zsets","张三",10.0);
    HashSet<ZSetOperations.TypedTuple<String>> sets = new HashSet<>();
    sets.add(new DefaultTypedTuple<>("小黑",8.0));
    sets.add(new DefaultTypedTuple<>("小名",2.0));
    sets.add(new DefaultTypedTuple<>("小网",6.0));
    zSetOperations.add("zsets",sets);

    //返回zsets集合中指定范围元素
    zSetOperations.range("zsets", 0, -1).forEach(el-> System.out.println(el));  //all
    System.out.println("========================");    //all score
    zSetOperations.rangeWithScores("zsets", 0, -1).forEach(t-> System.out.println("el: "+t.getValue()+" score: "+t.getScore()));
    System.out.println("========================");

    //返回zsets集合中指定分数范围的元素        //小x
    zSetOperations.rangeByScore("zsets",0.0,8.0).forEach(el-> System.out.println(el));
    System.out.println("========================");
    //分页返回zsets集合中指定分数范围的元素           //小名 小网
    zSetOperations.rangeByScore("zsets",0.0,8.0,0,2).forEach(el-> System.out.println(el));
    System.out.println("========================");     //小x score
    zSetOperations.rangeByScoreWithScores("zsets",0.0,8.0).forEach(t-> System.out.println("el: "+t.getValue()+" score: "+t.getScore()));

    //正向排名    升序
    zSetOperations.rank("zsets","张三");
    //反向排名    降序
    zSetOperations.reverseRank("zsets","张三");

    //返回指定元素分数
    zSetOperations.score("zsets","小名");

    //移除某一个元素
    zSetOperations.remove("zsets","张三");

    //给某个元素自增分数
    zSetOperations.incrementScore("zsets","张三",2.0);
}

@Test
public void testHash(){
    //获取hash类型操作对象
    HashOperations<String, Object, Object> hashOperations = stringRedisTemplate.opsForHash();
    //hset
    hashOperations.put("maps","name","张三");
    //hmset
    HashMap<String, String> m = new HashMap<>();
    m.put("address","xxx");
    m.put("content","xxx");
    hashOperations.putAll("maps", m);
    //hgetall
    hashOperations.entries("maps").forEach((k,v)-> System.out.println("key: "+k +" value: "+v));
    //hget
    hashOperations.get("maps","name");
    //hmget
    hashOperations.multiGet("maps",Arrays.asList("name","addres","content")).forEach(val-> System.out.println(val));
    //hdel
    hashOperations.delete("maps","name");
    //hexists
    hashOperations.hasKey("maps","name");
    //hkeys
    hashOperations.keys("maps");
    //hvals
    hashOperations.values("maps");
    //hsetnx
    hashOperations.putIfAbsent("maps","name","xiaochen");
    //hincrby
    hashOperations.increment("maps","age",11.11);

}

@Autowired
private StringRedisTemplate stringRedisTemplate;  //对字符串支持比较友好,不能存储对象
@Autowired
private RedisTemplate redisTemplate;  //存储对象

@Test
public void testRedisTemplate(){
    System.out.println(redisTemplate);
    //设置redistemplate值使用对象序列化策略
    redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());//指定值使用对象序列化
    //redisTemplate.opsForValue().set("user",new User("21","小黑",23,new Date()));
    User user = (User) redisTemplate.opsForValue().get("user");
    System.out.println(user);
}

@Test
public void test(){

    ValueOperations<String, String> valueOperations = stringRedisTemplate.opsForValue();
    valueOperations.set("name","zhangsan");
    valueOperations.append("name","this is good man");
    valueOperations.size("name");

    //String
    //stringRedisTemplate.boundValueOps()
    BoundValueOperations<String, String> nameOperations = stringRedisTemplate.boundValueOps("name");
    nameOperations.set("xiaochen");
    nameOperations.append("this is good man");
    nameOperations.size();

    //list
    ListOperations<String, String> listOperations = stringRedisTemplate.opsForList();
    listOperations.leftPush("lists","zhangsan");
    listOperations.size("lists");
    listOperations.range("lists",0,-1);

    BoundListOperations<String, String> listsOperations = stringRedisTemplate.boundListOps("lists");
    listsOperations.leftPush("zhangsan");
    listsOperations.leftPush("xiaozhang");
    listsOperations.size();
    listsOperations.range(0,-1);

    //stringRedisTemplate.boundSetOps()
    //stringRedisTemplate.boundZsetOps()
    //stringRedisTemplate.boundHashOps()
}

port 7001
bind 0.0.0.0

port 7002
bind 0.0.0.0
slaveof 10.15.0.5 7001

port 7003
bind 0.0.0.0
slaveof 10.15.0.5 7001

# 5.启动3台机器进行测试
- cd /usr/redis/bin
- ./redis-server /root/master/redis.conf
- ./redis-server /root/slave1/redis.conf
- ./redis-server /root/slave2/redis.conf

sentinel monitor aa 10.15.0.5 7001 1

cp redis-4.0.10/src/redis-sentinel /usr/redis/

./redis-sentinel /root/sentinel/sentinel.conf

# redis sentinel 配置
# master书写是使用哨兵监听的那个名称
spring.redis.sentinel.master=mymaster
# 连接的不再是一个具体redis主机,书写的是多个哨兵节点
spring.redis.sentinel.nodes=192.168.202.206:26379

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

# 1.准备环境安装ruby以及redis集群依赖
- yum install -y ruby rubygems
- gem install redis-xxx.gem

# 2.在一台机器创建7个目录

# 3.每个目录复制一份配置文件
[root@localhost ~]# cp redis-4.0.10/redis.conf 7000/
[root@localhost ~]# cp redis-4.0.10/redis.conf 7001/
[root@localhost ~]# cp redis-4.0.10/redis.conf 7002/
[root@localhost ~]# cp redis-4.0.10/redis.conf 7003/
[root@localhost ~]# cp redis-4.0.10/redis.conf 7004/
[root@localhost ~]# cp redis-4.0.10/redis.conf 7005/
[root@localhost ~]# cp redis-4.0.10/redis.conf 7006/

# 4.修改不同目录配置文件
- port 	6379 .....                		 //修改端口
- bind  0.0.0.0                   		 //开启远程连接
- cluster-enabled  yes 	        		 //开启集群模式
- cluster-config-file  nodes-port.conf   //集群节点配置文件
- cluster-node-timeout  5000      	     //集群节点超时时间
- appendonly  yes   		             //开启AOF持久化

# 5.指定不同目录配置文件启动七个节点
- [root@localhost bin]# ./redis-server  /root/7000/redis.conf
- [root@localhost bin]# ./redis-server  /root/7001/redis.conf
- [root@localhost bin]# ./redis-server  /root/7002/redis.conf
- [root@localhost bin]# ./redis-server  /root/7003/redis.conf
- [root@localhost bin]# ./redis-server  /root/7004/redis.conf
- [root@localhost bin]# ./redis-server  /root/7005/redis.conf
- [root@localhost bin]# ./redis-server  /root/7006/redis.conf

# 6.查看进程
- [root@localhost bin]# ps aux|grep redis

# 1.复制集群操作脚本到bin目录中
- [root@localhost bin]# cp /root/redis-4.0.10/src/redis-trib.rb /usr/redis/bin

# 2.创建集群
- ./redis-trib.rb create --replicas 1 192.168.202.205:7000 192.168.202.205:7001 192.168.202.205:7002 192.168.202.205:7003 192.168.202.205:7004 192.168.202.205:7005

eg:

./redis-trib.rb create --replicas  192.168.112.102:7000 192.168.112.102:7001 192.168.112.102:7002 192.168.112.102:7003 192.168.112.102:7004 192.168.112.102:7005

./redis-trib.rb  #启动的脚本
create --replicas 创建集群
1 一个主节点下有几个从节点 

# 3.集群创建成功出现如下提示

# 1.查看集群状态 check [原始集群中任意节点] [无]
- ./redis-trib.rb check 192.168.202.205:7000

# 2.集群节点状态说明
- 主节点 
	主节点存在hash slots,且主节点的hash slots 没有交叉
	主节点不能删除
	一个主节点可以有多个从节点
	主节点宕机时多个副本之间自动选举主节点

- 从节点
	从节点没有hash slots
	从节点可以删除
	从节点不负责数据的写,只负责数据的同步

# 1.添加主节点 add-node [新加入节点] [原始集群中任意节点]
- ./redis-trib.rb add-node 192.168.1.158:7006  192.168.1.158:7005
- 注意:
	1.该节点必须以集群模式启动
	2.默认情况下该节点就是以master节点形式添加

# 1.添加从节点 add-node --slave [新加入节点] [集群中任意节点]
- ./redis-trib.rb  add-node --slave 192.168.1.158:7006 192.168.1.158:7000
- 注意:
	当添加副本节点时没有指定主节点,redis会随机给副本节点较少的主节点添加当前副本节点
	
# 2.为确定的master节点添加主节点 add-node --slave --master-id master节点id [新加入节点] [集群任意节点]
- ./redis-trib.rb  add-node --slave --master-id 3c3a0c74aae0b56170ccb03a76b60cfe7dc1912e 127.0.0.1:7006  127.0.0.1:7000


./redis-trib.rb add-node --slave --master-id b75d75e28525e67152ae618245b33ca41e2f1c41 192.168.112.102:7003 192.168.112.102:7000

# 1.删除节点 del-node [集群中任意节点] [删除节点id]
- ./redis-trib.rb  del-node 127.0.0.1:7002 0ca3f102ecf0c888fc7a7ce43a13e9be9f6d3dd1
- 注意:
  1.被删除的节点必须是从节点或没有被分配hash slots的节点

# 1.在线分片 reshard [集群中任意节点] [无]
- ./redis-trib.rb  reshard  192.168.1.158:7000   

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

server:
  port: 9696
  servlet:
    context-path: /redis

@Controller
@RequestMapping("test")
public class TestController {

    @RequestMapping("session")
    public void testSession(HttpServletRequest request, HttpServletResponse response) throws IOException {

        //redis
        ArrayList<String> list = (ArrayList<String>) request.getSession().getAttribute("list");
        
        if(list==null){
            list = new ArrayList<String>();           request.getSession().setAttribute("list",list);
        }

        list.add("hello redis session");

        //响应
        response.getWriter().print("<h1> sessionId: "+request.getSession().getId()+"</h1>");
        response.getWriter().print("<h1> sise: "+list.size()+"</h1>");

    }
}

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

spring:
  redis:
    host: 192.168.112.102
    port: 7000
    database: 3

@Autowired
StringRedisTemplate stringRedisTemplate;

@Test
void contextLoadss() {

    //获取所有key   参数: * n?me n[as]me  n*me
    Set<String> keys = stringRedisTemplate.keys("*");
    for (String key : keys) {
        System.out.println("获取所有的key:"+key);
    }
}

<dependency>
  <groupId>org.springframework.session</groupId>
  <artifactId>spring-session-data-redis</artifactId>
</dependency>

@Configuration  //xml   bean    //@Component  创建单个对象 bean
@EnableRedisHttpSession
public class RedisSessionManager {
   
}

@Controller
@RequestMapping("test")
public class TestController {

    @RequestMapping("session")
    public void testSession(HttpServletRequest request, HttpServletResponse response) throws IOException {

        //redis
        ArrayList<String> list = (ArrayList<String>) request.getSession().getAttribute("list");

        //tomcat jvm  session  @101  list @102
        //session  list的地址
        //list

        if(list==null){
            list = new ArrayList<String>();
        }

        list.add("hello redis session");
        request.getSession().setAttribute("list",list);

        //响应
        response.getWriter().print("<h1> sessionId: "+request.getSession().getId()+"</h1>");
        response.getWriter().print("<h1> sise: "+list.size()+"</h1>");

    }
}