IT评测·应用市场-qidao123.com技术社区

标题: Redis 万字入门教程 [打印本页]
作者: 宁睿    时间: 2024-10-18 10:46
标题: Redis 万字入门教程
0. 前言


文章已经收录到 GitHub 个人博客项目，接待 Star：
  1. https://github.com/chenyl8848/chenyl8848.github.io
复制代码
大概访问网站，进行在线浏览：
  1. https://chenyl8848.github.io/
复制代码
1. NoSQL

1.1 NoSQL 介绍

NoSQL(Not Only SQL )，意即不仅仅是 SQL,泛指非关系型的数据库。NoSQL 这个技术门类，早期就有人提出，发展至2009年趋势越发高涨。
随着互联网网站的鼓起，传统的关系数据库在应付动态网站，特别是超大规模和高并发的纯动态网站已经显得力不从心，暴露了很多难以克服的问题。如商城网站中对商品数据频繁查询、对热搜商品的排行统计、订单超时问题、以及微信朋友圈（音频，视频）存储等相干使用传统的关系型数据库实现就显得非常复杂，虽然能实现相应功能但是在性能上却不是那么乐观。NoSQL 这个技术门类的出现，更好的办理了这些问题，它告诉了天下不仅仅是 SQL.
关注微信公众号：【Java陈序员】，获取开源项目分享、AI副业分享、超200本经典盘算机电子册本等。
1.2 NoSQL 四大分类

  1. 1. 说明
  2.   这一类数据库主要会使用到一个哈希表，这个表中有一个特定的键和一个指针指向特定的数据。
  4. 2. 特点
  5.   Key/Value 模型对于 IT 系统来说的优势在于简单、易部署。  
  6.   但是如果 DBA 只对部分值进行查询或更新的时候，Key/Value 就显得效率低下了。
  8. 3. 相关产品
  9.   Tokyo Cabinet/Tyrant
  10.   Redis
  11.   SSDB
  12.   Voldemort
  13.   Oracle BDB
复制代码
  1. 1. 说明
  2.   这部分数据库通常是用来应对分布式存储的海量数据。
  4. 2. 特点
  5.   键仍然存在，但是它们的特点是指向了多个列。这些列是由列家族来安排的。
  7. 3. 相关产品
  8.   Cassandra、HBase、Riak
复制代码
  1. 1. 说明
  2.   文档型数据库的灵感是来自于 Lotus Notes 办公软件的，而且它同第一种键值存储相类似该类型的数据模型是版本化的文档，半结构化的文档以特定的格式存储，比如 JSON.文档型数据库可以看作是键值数据库的升级版，允许之间嵌套键值，而且文档型数据库比键值数据库的查询效率更高。
  4. 2. 特点
  5.   以文档形式存储
  7. 3. 相关产品
  8.   MongoDB、CouchDB,国内也有文档型数据库 SequoiaDB,已经开源。
复制代码
  1. 1. 说明
  2. 图形结构的数据库同其他行列以及刚性结构的 SQL 数据库不同，它是使用灵活的图形模型，并且能够扩展到多个服务器上。
  3. NoSQL 数据库没有标准的查询语言(SQL)，因此进行数据库查询需要制定数据模型。许多 NoSQL 数据库都有 REST 式的数据接口或者查询 API.
  5. 2. 特点
  7. 3. 相关产品
  8. Neo4J、InfoGrid、 Infinite Graph
复制代码
1.3 NoSQL 应用场景

2. Redis

2.1 Redis 介绍


Redis is an open source (BSD licensed), in-memory data structure store, used as a database, cache and message broker.
Redis 是一个遵循 BSD 开源的基于内存数据存储库，可用于作为数据库、缓存 、消息中心件。
总结: Redis 是一个内存型的数据库。
2.2 Redis 特点

2.3 Redis 安装
  1. 0. 准备环境
  2.   - vmware15.x+
  3.   - centos7.x+
  5. 1. 下载 Redis 源码包
  6.   https://redis.io/
复制代码
  1. 2. 下载完整源码包
  2.   redis-4.0.10.tar.gz
复制代码
  1. 3. 将下载的 Redis 安装包上传到 Linux 中
复制代码
  1. 4. 解压缩文件
  2.   tar -zxvf redis-4.0.10.tar.gz
  3.   ll
复制代码
  1. 5. 安装 gcc  
  2.   yum install -y gcc
  4. 6. 进入解压缩目录执行如下命令
  5.   make MALLOC=libc
  7. 7. 编译完成后执行如下命令
  8.   make install PREFIX=/usr/redis
  10. 8. 进入 /usr/redis 目录启动 Redis 服务
  11.   ./redis-server
复制代码
  1. 9. Redis 服务端口默认是 6379
  3. 10. 进入 bin 目录执行客户端连接操作
  4.   ./redis-cli –p 6379
复制代码
  1. 11.  连接成功出现上面界面连接成功
复制代码
3. Redis 数据库相干指令

3.1 数据库操作指令
  1. 1. Redis 库说明
  2.   使用 Redis 的默认配置启动 Redis 服务后，默认会存在 16 个库，编号从 0-15
  3.   可以使用 select 库的编号 来选择一个 Redis 的库
  5. 2. Redis 操作库的指令
  6.   清空当前的库 FLUSHDB
  7.   清空全部的库 FLUSHALL
  9. 3. Redis 客户端显示中文
  10.   ./redis-cli -p 7000 --raw
复制代码
3.2 Key 操作指令
  1. 1. DEL 指令
  2.   语法：DEL key [key ...]
  3.   作用：删除给定的一个或多个 key,不存在的 key 会被忽略
  4.   可用版本：>= 1.0.0
  5.   返回值：被删除 key 的数量
  7. 2. EXISTS 指令
  8.   语法：EXISTS key
  9.   作用：检查给定 key 是否存在
  10.   可用版本：>= 1.0.0
  11.   返回值：若 key 存在，返回 1,否则返回 0
  13. 3. EXPIRE
  14.   语法：EXPIRE key seconds
  15.   作用：为给定 key 设置生存时间，当 key 过期时(生存时间为0 )，它会被自动删除。
  16.   可用版本： >= 1.0.0
  17.   时间复杂度： O(1)
  18.   返回值：设置成功返回 1
  20. 4. KEYS
  21.   语法：KEYS pattern
  22.   作用：查找所有符合给定模式 pattern 的 key
  23.   语法:
  24.           KEYS * 匹配数据库中所有 key
  25.           KEYS h?llo 匹配 hello、hallo 和 hxllo 等
  26.           KEYS h*llo 匹配 hllo 和 heeeeello 等
  27.           KEYS h[ae]llo 匹配 hello 和 hallo,但不匹配 hillo,特殊符号用 "" 隔开
  28.   可用版本：>= 1.0.0
  29.   返回值：符合给定模式的 key 列表
  31. 5. MOVE
  32.   语法：MOVE key db
  33.   作用：将当前数据库的 key 移动到给定的数据库 db 当中
  34.   可用版本：>= 1.0.0
  35.   返回值：移动成功返回 1, 失败则返回 0
  37. 6. PEXPIRE
  38.   语法：PEXPIRE key milliseconds
  39.   作用：这个命令和 EXPIRE 命令的作用类似，但是它以毫秒为单位设置 key 的生存时间，而不像 EXPIRE 命令以秒为单位
  40.   可用版本：>= 2.6.0
  41.   时间复杂度：O(1)
  42.   返回值：设置成功，返回 1,key 不存在或设置失败，返回 0
  44. 7. PEXPIREAT
  45.   语法：PEXPIREAT key milliseconds-timestamp
  46.   作用：这个命令和 EXPIREAT 命令类似，但它以毫秒为单位设置 key 的过期 Unix 时间戳，而不是像 EXPIREAT 以秒为单位
  47.   可用版本：>= 2.6.0
  48.   返回值：如果生存时间设置成功，返回 1,当 key 不存在或没办法设置生存时间时，返回 0
  50. 8. TTL
  51.   语法：TTL key
  52.   作用：以秒为单位，返回给定 key 的剩余生存时间(TTL, time to live)
  53.   可用版本：>= 1.0.0
  54.   返回值：
  55.           当 key 不存在时，返回 -2
  56.           当 key 存在但没有设置剩余生存时间时，返回 -1
  57.           否则，以秒为单位，返回 key 的剩余生存时间
  58.   注意：在 Redis2.8 以前，当 key 不存在，或者 key 没有设置剩余生存时间时，命令都返回-1
  60. 9. PTTL
  61.   语法：PTTL key
  62.   作用：这个命令类似于 TTL 命令，但它以毫秒为单位返回 key 的剩余生存时间，而不是像 TTL 命令以秒为单位
  63.   可用版本：>= 2.6.0
  64.   返回值：
  65.     当 key 不存在时，返回 -2
  66.     当 key 存在但没有设置剩余生存时间时，返回 -1
  67.   否则，以毫秒为单位，返回 key 的剩余生存时间
  68.   注意：在 Redis2.8 以前，当 key 不存在，或者 key 没有设置剩余生存时间时，命令都返回 -1
  70. 10. RANDOMKEY
  71.   语法：RANDOMKEY
  72.   作用：从当前数据库中随机返回（不删除） 一个 key
  73.   可用版本：>= 1.0.0
  74.   返回值：当数据库不为空时，返回一个 key,当数据库为空时，返回 nil
  76. 11. RENAME
  77.   语法：RENAME key newkey
  78.   作用：将 key 改名为 newkey,当 key 和 newkey 相同，或者 key 不存在时，返回一个错误；当 newkey 已经存在时，RENAME 命令将覆盖旧值
  79.   可用版本：>= 1.0.0
  80.   返回值：改名成功时提示 OK,失败时候返回一个错误
  82. 12. TYPE
  83.   语法：TYPE key
  84.   作用：返回 key 所储存的值的类型
  85.   可用版本：>= 1.0.0
  86.   返回值：
  87.     none (key 不存在)
  88.     string (字符串)
  89.     list (列表)
  90.     set (集合)
  91.     zset (有序集)
  92.     hash (哈希表)
复制代码
3.3 String 类型


下令阐明set设置一个key/valueget根据key获得对应的valuemset一次设置多个key valuemget一次获得多个key的valuegetset获得原始key的值，同时设置新值strlen获得对应key存储value的长度append为对应key的value追加内容getrange 索引0开始截取value的内容setex设置一个key存活的有效期（秒）psetex设置一个key存活的有效期（毫秒）setnx存在不做任何操作,不存在添加msetnx原子操作(只要有一个存在不做任何操作)可以同时设置多个key,只有有一个存在都不生存decr进行数值类型的-1操作decrby根据提供的数据进行减法操作Incr进行数值类型的+1操作incrby根据提供的数据进行加法操作Incrbyfloat根据提供的数据参加浮点数3.4 List 类型

List 类型相当于 Java 中 List 聚集，元素有序且可以重复。

下令阐明lpush将某个值参加到一个 key 列表头部lpushx同 lpush,但是必须要包管这个 key 存在rpush将某个值参加到一个 key 列表末尾rpushx同 rpush,但是必须要包管这个 key 存在lpop返回和移除列表左边的第一个元素rpop返回和移除列表右边的第一个元素lrange获取某一个下标区间内的元素llen获取列表元素个数lset设置某一个指定索引的值(索引必须存在)lindex获取某一个指定索引位置的元素lrem删除重复元素ltrim保留列表中特定区间内的元素linsert在某一个元素之前，之后插入新元素3.5 Set 类型

Set 类型相当于 Java 中的 Set 聚集，元素无序且不可以重复。

下令阐明sadd为聚集添加元素smembers显示聚会合所有元素 无序scard返回聚会合元素的个数spop随机返回一个元素 并将元素在聚会合删除smove从一个聚会合向另一个聚集移动元素  必须是同一种类型srem从聚会合删除一个元素sismember判断一个聚会合是否含有这个元素srandmember随机返回元素sdiff去掉第一个聚会合别的聚集含有的相同元素sinter求交集sunion求和集3.6 ZSet 类型

ZSet 类型是可排序的 Set 聚集，但不可重复。

下令阐明zadd添加一个有序聚集元素zcard返回聚集的元素个数zrange 升序 zrevrange 降序返回一个范围内的元素zrangebyscore按照分数查找一个范围内的元素zrank返回排名zrevrank倒序排名zscore显示某一个元素的分数zrem移除某一个元素zincrby给某个特定元素加分3.7 Hash 类型

Hash 类型中的 Value 是一个 Map 结构。

下令阐明hset设置一个 key/value 对hget获得一个 key 对应的 valuehgetall获得所有的 key/value 对hdel删除某一个 key/value 对hexists判断一个 key 是否存在hkeys获得所有的 keyhvals获得所有的 valuehmset设置多个 key/valuehmget获得多个 key的valuehsetnx设置一个不存在的 key 的值hincrby为 value 进行加法运算hincrbyfloat为 value 参加浮点值4. Redis 持久化机制

client redis[内存] -->  内存数据 - 数据持久化 --> 磁盘
Redis 官方提供了两种不同的持久化方法来将数据存储到硬盘里面分别是：
4.1 快照(Snapshot)

这种方式可以将某一时候的所有数据都写入硬盘中，当然这也是 Redis 的默认开启持久化方式，生存的文件是以 .rdb 形式结尾的文件因此这种方式也称之为 RDB 方式。


  1. 1. 客户端方式之 BGSAVE
  2.   客户端可以使用 BGSAVE 命令来创建一个快照，当接收到客户端的 BGSAVE 命令时，Redis 会调用 fork 来创建一个子进程，然后子进程负责将快照写入磁盘中，而父进程则继续处理命令请求。
  3.        
  4.         名词解释: fork 当一个进程创建子进程的时候，底层的操作系统会创建该进程的一个副本，在类 Unix 系统中创建子进程的操作会进行优化：在刚开始的时候，父子进程共享相同内存，直到父进程或子进程对内存进行了写之后，对被写入的内存的共享才会结束服务。
复制代码
  1. 2. 客户端方式之SAVE
  2.   客户端还可以使用 SAVE 命令来创建一个快照，接收到 SAVE 命令的 Redis 服务器在快照创建完毕之前将不再响应任何其他的命令。
复制代码

留意：SAVE 下令并不常用，使用 SAVE 下令在快照创建完毕之前，Redis 处于阻塞状态，无法对外服务。
  1. 3. 服务器配置方式之满足配置自动触发
  2.   如果用户在 redis.conf 中设置了 save 配置选项，Redis 会在 save 选项条件满足之后自动触发一次 BGSAVE 命令，如果设置多个 save 配置选项，当任意一个 save 配置选项条件满足，Redis也会触发一次 BGSAVE 命令。
复制代码
  1. 4. 服务器接收客户端 shutdown 指令
  2.   当 Redis 通过 shutdown 指令接收到关闭服务器的请求时，会执行一个 save 命令，阻塞所有的客户端，不再执行客户端执行发送的任何命令，并且在 save 命令执行完毕之后关闭服务器。
复制代码
  1. 1. 修改生成快照名称
  2.   dbfilename dump.rdb
  4. 2. 修改生成位置
  5.   dir ./
复制代码

4.2 AOF 只追加日志文件

这种方式可以将所有客户端执行的写下令记录到日志文件中，AOF 持久化会将被执行的写下令写到 AOF 的文件末尾，以此来记录数据发生的变革，因此只要 Redis 从头至尾执行一次AOF文件所包含的所有写下令，就可以恢复AOF文件的记录的数据集。

在 Redis 的默认配置中AOF持久化机制是没有开启的，需要在配置中开启。
  1. 1. 开启AOF持久化
  2.   修改 appendonly yes 开启持久化
  3.   修改 appendfilename "appendonly.aof" 指定生成文件名称
复制代码

  1. 1. always 【谨慎使用】
  2.   说明：每个 Redis 写命令都要同步写入硬盘，严重降低 Redis 速度
  3.   解释：如果用户使用了 always 选项，那么每个 Redis 写命令都会被写入硬盘，从而将发生系统崩溃时出现的数据丢失减到最少；遗憾的是，因为这种同步策略需要对硬盘进行大量的写入操作，所以 Redis 处理命令的速度会受到硬盘性能的限制
  4.   注意：转盘式硬盘在这种频率下200左右个命令/s;固态硬盘(SSD) 几百万个命令/s
  5.   警告：使用 SSD 用户请谨慎使用 always 选项，这种模式不断写入少量数据的做法有可能会引发严重的写入放大问题，导致将固态硬盘的寿命从原来的几年降低为几个月
  7. 2. everysec 【推荐】
  8.   说明：每秒执行一次同步显式的将多个写命令同步到磁盘
  9.   解释：为了兼顾数据安全和写入性能，用户可以考虑使用 everysec 选项，让 Redis 每秒一次的频率对 AOF 文件进行同步；Redis 每秒同步一次 AOF 文件时性能和不使用任何持久化特性时的性能相差无几，而通过每秒同步一次 AOF 文件，Redis 可以保证，即使系统崩溃，用户最多丢失一秒之内产生的数据
  11. 3. no        【不推荐】
  12.   说明：由操作系统决定何时同步
  13.   解释：最后使用 no 选项，将完全有操作系统决定什么时候同步 AOF 日志文件，这个选项不会对 Redis 性能带来影响但是系统崩溃时，会丢失不定数量的数据，另外如果用户硬盘处理写入操作不够快的话，当缓冲区被等待写入硬盘数据填满时，Redis 会处于阻塞状态，并导致 Redis 的处理命令请求的速度变慢
复制代码
  1. 1. 修改日志同步频率
  2.   修改 appendfsync everysec|always|no 指定
复制代码

4.3 AOF 文件的重写

AOF 的方式也同时带来了另一个问题：持久化文件会变的越来越大。
例如我们调用 incr test 下令 100 次，文件中必须生存全部的100条下令，着实有99条都是多余的。因为要恢复数据库的状态着实文件中生存一条 set test 100 就够了。为了压缩 AOF 的持久化文件 Redis 提供了 AOF 重写(ReWriter)机制。
用来在肯定程度上减小 AOF 文件的体积。
  1. 1. 客户端方式触发重写
  2.   执行 BGREWRITEAOF 命令，不会阻塞 Redis 的服务
  4. 2. 服务器配置方式自动触发
  5.   配置 redis.conf 中的 auto-aof-rewrite-percentage 选项
  6.   如果设置 auto-aof-rewrite-percentage 值为 100 和 auto-aof-rewrite-min-size 64mb,并且启用的 AOF 持久化时，那么当 AOF 文件体积大于64M,并且 AOF 文件的体积比上一次重写之后体积大了至少一倍(100%)时，会自动触发，如果重写过于频繁，用户可以考虑将 auto-aof-rewrite-percentage 设置为更大
复制代码

留意：重写 AOF 文件的操作，并没有读取旧的 AOF 文件，而是将整个内存中的数据库内容用下令的方式重写了一个新的 AOF 文件，更换原有的文件这点和快照有点类似。
  1. 重写流程：
  2.   1. Redis 调用 fork,现在有父子两个进程，子进程根据内存中的数据库快照，往临时文件中写入重建数据库状态的命令
  3.   2. 父进程继续处理 Client 请求，除了把写命令写入到原来的 AOF 文件中，同时把收到的写命令缓存起来，这样就能保证如果子进程重写失败的话并不会出问题
  4.   3. 当子进程把快照内容写入已命令方式写到临时文件中后，子进程发信号通知父进程，然后父进程把缓存的写命令也写入到临时文件
  5.   4. 现在父进程可以使用临时文件替换老的 AOF 文件，并重命名，后面收到的写命令也开始往新的 AOF 文件中追加
复制代码

4.4 持久化总结

两种持久化方案既可以同时使用，又可以单独使用，在某种情况下也可以都不使用，详细使用那种持久化方案取决于用户的数据和应用决定。
无论使用 AOF 还是快照机制持久化，将数据持久化到硬盘都是有必要的，除了持久化外，用户还应该对持久化的文件进行备份（最好备份在多个不同地方）。
5. Java 操作 Redis

5.1 情况准备

  1. <dependency>
  2.   <groupId>redis.clients</groupId>
  3.   <artifactId>jedis</artifactId>
  4.   <version>2.9.0</version>
  5. </dependency>
复制代码
  1. public static void main(String[] args) {
  2.    //1.创建jedis对象
  3.    Jedis jedis = new Jedis("192.168.40.4", 6379);//1.redis服务必须关闭防火墙  2.redis服务必须开启远程连接
  4.    jedis.select(0);//选择操作的库默认0号库
  5.    //2.执行相关操作
  6.    //....
  7.    //3.释放资源
  8.    jedis.close();
  9. }
复制代码

5.2 操作 Key 相干API
  1. private Jedis jedis;
  2.     @Before
  3.     public void before(){
  4.         this.jedis = new Jedis("192.168.202.205", 7000);
  5.     }
  6.     @After
  7.     public void after(){
  8.         jedis.close();
  9.     }
  11.     //测试key相关
  12.     @Test
  13.     public void testKeys(){
  14.         //删除一个key
  15.         jedis.del("name");
  16.         //删除多个key
  17.         jedis.del("name","age");
  19.         //判断一个key是否存在exits
  20.         Boolean name = jedis.exists("name");
  21.         System.out.println(name);
  23.         //设置一个key超时时间 expire pexpire
  24.         Long age = jedis.expire("age", 100);
  25.         System.out.println(age);
  27.         //获取一个key超时时间 ttl
  28.         Long age1 = jedis.ttl("newage");
  29.         System.out.println(age1);
  31.         //随机获取一个key
  32.         String s = jedis.randomKey();
  34.         //修改key名称
  35.         jedis.rename("age","newage");
  37.         //查看可以对应值的类型
  38.         String name1 = jedis.type("name");
  39.         System.out.println(name1);
  40.         String maps = jedis.type("maps");
  41.         System.out.println(maps);
  42.     }
复制代码

5.3 操作 String 相干API
  1. //测试String相关
  2.     @Test
  3.     public void testString(){
  4.         //set
  5.         jedis.set("name","小陈");
  6.         //get
  7.         String s = jedis.get("name");
  8.         System.out.println(s);
  9.         //mset
  10.         jedis.mset("content","好人","address","海淀区");
  11.         //mget
  12.         List<String> mget = jedis.mget("name", "content", "address");
  13.         mget.forEach(v-> System.out.println("v = " + v));
  14.         //getset
  15.         String set = jedis.getSet("name", "小明");
  16.         System.out.println(set);
  18.         //............
  19.     }
复制代码

5.4 操作 List 相干 API
  1. //测试List相关
  2.     @Test
  3.     public void testList(){
  5.         //lpush
  6.         jedis.lpush("names1","张三","王五","赵柳","win7");
  8.         //rpush
  9.         jedis.rpush("names1","xiaomingming");
  11.         //lrange
  13.         List<String> names1 = jedis.lrange("names1", 0, -1);
  14.         names1.forEach(name-> System.out.println("name = " + name));
  16.         //lpop rpop
  17.         String names11 = jedis.lpop("names1");
  18.         System.out.println(names11);
  20.         //llen
  21.         jedis.linsert("lists", BinaryClient.LIST_POSITION.BEFORE,"xiaohei","xiaobai");
  23.               //........
  25.     }
复制代码

5.5 操作 Set 的相干 API
  1. //测试SET相关
  2. @Test
  3. public void testSet(){
  5.   //sadd
  6.   jedis.sadd("names","zhangsan","lisi");
  8.   //smembers
  9.   jedis.smembers("names");
  11.   //sismember
  12.   jedis.sismember("names","xiaochen");
  14.   //...
  15. }
复制代码

5.6 操作 ZSet 相干 API
  1. //测试ZSET相关
  2. @Test
  3. public void testZset(){
  5.   //zadd
  6.   jedis.zadd("names",10,"张三");
  8.   //zrange
  9.   jedis.zrange("names",0,-1);
  11.   //zcard
  12.   jedis.zcard("names");
  14.   //zrangeByScore
  15.   jedis.zrangeByScore("names","0","100",0,5);
  17.   //..
  19. }
复制代码

5.7 操作 Hash 相干 API
  1. //测试HASH相关
  2. @Test
  3. public void testHash(){
  4.   //hset
  5.   jedis.hset("maps","name","zhangsan");
  6.   //hget
  7.   jedis.hget("maps","name");
  8.   //hgetall
  9.   jedis.hgetAll("mps");
  10.   //hkeys
  11.   jedis.hkeys("maps");
  12.   //hvals
  13.   jedis.hvals("maps");
  14.   //....
  15. }
复制代码

6. SpringBoot 整合 Redis

Spring Boot Data(数据) Redis 中提供 RedisTemplate和StringRedisTemplate，此中 StringRedisTemplate 是 RedisTemplate 的子类，两个方法基本一致，不同之处重要体现在操作的数据类型不同，RedisTemplate 中的两个泛型都是 Object，意味着存储的 key 和 value 都可以是一个对象，而 StringRedisTemplate 的两个泛型都是 String，意味着 StringRedisTemplate 的 key 和 value 都只能是字符串。
留意：使用 RedisTemplate 默认是将对象序列化到 Redis 中，所以放入的对象必须实现对象序列化接口。
6.1 情况准备

  1. <dependency>
  2.   <groupId>org.springframework.boot</groupId>
  3.   <artifactId>spring-boot-starter-data-redis</artifactId>
  4. </dependency>
复制代码
  1. spring.redis.host=localhost
  2. spring.redis.port=6379
  3. spring.redis.database=0
复制代码
6.2 使用 StringRedisTemplate 和 RedisTemplate
  1. @Autowired
  2. private StringRedisTemplate stringRedisTemplate;  //对字符串支持比较友好，不能存储对象
  3. @Autowired
  4. private RedisTemplate redisTemplate;  //存储对象
  6. @Test
  7. public void testRedisTemplate(){
  8.     System.out.println(redisTemplate);
  9.     //设置redistemplate值使用对象序列化策略
  10.     redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());//指定值使用对象序列化
  11.     //redisTemplate.opsForValue().set("user",new User("21","小黑",23,new Date()));
  12.     User user = (User) redisTemplate.opsForValue().get("user");
  13.     System.out.println(user);
  14. //      Set keys = redisTemplate.keys("*");
  15. //      keys.forEach(key -> System.out.println(key));
  16.     /*Object name = redisTemplate.opsForValue().get("name");
  17.     System.out.println(name);*/
  19.     //Object xiaohei = redisTemplate.opsForValue().get("xiaohei");
  20.     //System.out.println(xiaohei);
  21.     /*redisTemplate.opsForValue().set("name","xxxx");
  22.     Object name = redisTemplate.opsForValue().get("name");
  23.     System.out.println(name);*/
  24.     /*redisTemplate.opsForList().leftPushAll("lists","xxxx","1111");
  25.     List lists = redisTemplate.opsForList().range("lists", 0, -1);
  26.     lists.forEach(list-> System.out.println(list));*/
  27. }
  30. //key的绑定操作 如果日后对某一个key的操作及其频繁，可以将这个key绑定到对应redistemplate中，日后基于绑定操作都是操作这个key
  31. //boundValueOps 用来对String值绑定key
  32. //boundListOps 用来对List值绑定key
  33. //boundSetOps 用来对Set值绑定key
  34. //boundZsetOps 用来对Zset值绑定key
  35. //boundHashOps 用来对Hash值绑定key
  37. @Test
  38. public void testBoundKey(){
  39.     BoundValueOperations<String, String> nameValueOperations = stringRedisTemplate.boundValueOps("name");
  40.     nameValueOperations.set("1");
  41.     //yuew
  42.     nameValueOperations.set("2");
  43.     String s = nameValueOperations.get();
  44.     System.out.println(s);
  46. }
  49. //hash相关操作 opsForHash
  50. @Test
  51. public void testHash(){
  52.     stringRedisTemplate.opsForHash().put("maps","name","小黑");
  53.     Object o = stringRedisTemplate.opsForHash().get("maps", "name");
  54.     System.out.println(o);
  55. }
  57. //zset相关操作 opsForZSet
  58. @Test
  59. public void testZSet(){
  60.     stringRedisTemplate.opsForZSet().add("zsets","小黑",10);
  61.     Set<String> zsets = stringRedisTemplate.opsForZSet().range("zsets", 0, -1);
  62.     zsets.forEach(value-> System.out.println(value));
  63. }
  65. //set相关操作 opsForSet
  66. @Test
  67. public void testSet(){
  68.     stringRedisTemplate.opsForSet().add("sets","xiaosan","xiaosi","xiaowu");
  69.     Set<String> sets = stringRedisTemplate.opsForSet().members("sets");
  70.     sets.forEach(value-> System.out.println(value));
  71. }
  73. //list相关的操作opsForList
  74. @Test
  75. public void testList(){
  76.     // stringRedisTemplate.opsForList().leftPushAll("lists","张三","李四","王五");
  77.     List<String> lists = stringRedisTemplate.opsForList().range("lists", 0, -1);
  78.     lists.forEach(key -> System.out.println(key));
  79. }
  82. //String相关的操作 opsForValue
  83. @Test
  84. public void testString(){
  85.     //stringRedisTemplate.opsForValue().set("166","好同学");
  86.     String s = stringRedisTemplate.opsForValue().get("166");
  87.     System.out.println(s);
  88.     Long size = stringRedisTemplate.opsForValue().size("166");
  89.     System.out.println(size);
  90. }
  93. //key相关的操作
  94. @Test
  95. public void test(){
  96.     Set<String> keys = stringRedisTemplate.keys("*");//查看所有key
  97.     Boolean name = stringRedisTemplate.hasKey("name");//判断某个key是否存在
  98.     stringRedisTemplate.delete("age");//根据指定key删除
  99.     stringRedisTemplate.rename("","");//修改key的名称
  100.     stringRedisTemplate.expire("key",10, TimeUnit.HOURS);
  101.     //设置key超时时间 参数1:设置key名 参数2:时间 参数3:时间的单位
  102.     stringRedisTemplate.move("",1);//移动key
  103. }
复制代码
7. Redis 主从复制

7.1 主从复制介绍

主从复制架构仅仅用来办理数据的冗余备份，从节点仅仅用来同步数据，无法办理 Master 节点出现故障的主动故障转移。
架构图：

7.2 搭建主从复制
  1. 1. 准备 3 台机器并修改配置
  2.   - master
  3.     port 6379
  4.     bind 0.0.0.0
  5.    
  6.   - slave1
  7.     port 6380
  8.     bind 0.0.0.0
  9.     slaveof masterip masterport
  11.   - slave2
  12.     port 6381
  13.     bind 0.0.0.0
  14.     slaveof masterip masterport
复制代码
  1. 2. 启动 3 台机器进行测试
  2.   cd /usr/redis/bin
  3.   ./redis-server /root/master/redis.conf
  4.   ./redis-server /root/slave1/redis.conf
  5.   ./redis-server /root/slave2/redis.conf
复制代码
8. Redis Sentinel 哨兵机制

8.1 Sentinel 哨兵机制介绍

Sentinel（哨兵）是 Redis 的高可用性办理方案：由一个或多个 Sentinel 实例构成的 Sentinel 系统可以监督任意多个主服务器，以及这些主服务器属下的所有从服务器，并在被监督的主服务器进入下线状态时，主动将下线主服务器属下的某个从服务器升级为新的主服务器。
简单的说哨兵机制就是带有主动故障转移功能的主从架构，但是无法办理单节点并发压力、单节点内存和磁盘物理上限的问题。
架构原理：

8.2 搭建哨兵架构
  1. 1. 在主节点上创建哨兵配置
  2.   在 Master 对应 redis.conf 同目录下新建 sentinel.conf 文件，名字绝对不能错
  4. 2. 配置哨兵，在 sentinel.conf 文件中填入内容：
  5.   sentinel monitor 被监控数据库名字（自己起名字） ip port 1
  7. 3. 启动哨兵模式进行测试
  8.   redis-sentinel  /root/sentinel/sentinel.conf
  9.        
  10.   说明：这个后面的数字 2,是指当有两个及以上的 sentinel 服务检测到 Master 宕机，才会去执行主从切换的功能
复制代码
8.3 通过 SpringBoot 操作哨兵

修改 application.properties 配置文件：
  1. # redis sentinel 配置
  2. # master书写是使用哨兵监听的那个名称
  3. spring.redis.sentinel.master=mymaster
  4. # 连接的不再是一个具体redis主机，书写的是多个哨兵节点
  5. spring.redis.sentinel.nodes=192.168.202.206:26379
复制代码
留意：如果连接过程中出现如下错误 RedisConnectionException: DENIED Redis is running in protected mode because protected mode is enabled, no bind address was specified, no authentication password is requested to clients. In this mode connections are only accepted from the loopback interface. If you want to connect from external computers to Redis you may adopt one of the following solutions: 1) Just disable protected mode sending the command 'CONFIG SET protected-mode no' from the loopback interface by connecting to Redis from the same host the server is running, however MAKE SURE Redis is not publicly accessible from internet if you do so. Use CONFIG REWRITE to make this change permanent. 2)
办理方案：在哨兵的配置文件中参加 bind 0.0.0.0 开启远程连接权限

9. Redis 集群

9.1 集群介绍

Redis 在 3.0 后开始支持 Cluster 模式，目前 Redis 的集群支持节点的主动发现，支持 slave-master 选举和容错，支持在线分片(sharding shard)等特性。reshard
集群架构图：

集群细节：

9.2 集群搭建

判断一个是集群中的节点是否可用，是集群中的所用主节点选举过程，如果半数以上的节点以为当前节点挂掉，那么当前节点就是挂掉了，所以搭建 Redis 集群时发起节点数最好为奇数，搭建集群至少需要三个主节点，三个从节点，至少需要6个节点。
  1. 1. 准备环境安装ruby以及redis集群依赖
  2.   yum install -y ruby rubygems
  3.   gem install redis-xxx.gem
复制代码

  1. 2. 在一台机器创建7个目录
复制代码
  1. 3. 每个目录复制一份配置文件
  2.   cp redis-4.0.10/redis.conf 7000/
  3.   cp redis-4.0.10/redis.conf 7001/
  4.   cp redis-4.0.10/redis.conf 7002/
  5.   cp redis-4.0.10/redis.conf 7003/
  6.   cp redis-4.0.10/redis.conf 7004/
  7.   cp redis-4.0.10/redis.conf 7005/
  8.   cp redis-4.0.10/redis.conf 7006/
复制代码
  1. 4. 修改不同目录配置文件
  2.   - port         6379 .....                                 //修改端口
  3.   - bind  0.0.0.0                                    //开启远程连接
  4.   - cluster-enabled  yes                                          //开启集群模式
  5.   - cluster-config-file  nodes-port.conf //集群节点配置文件
  6.   - cluster-node-timeout  5000                 //集群节点超时时间
  7.   - appendonly  yes                                  //开启AOF持久化
  9. 5. 指定不同目录配置文件启动七个节点
  10.   ./redis-server  /root/7000/redis.conf
  11.   ./redis-server  /root/7001/redis.conf
  12.   ./redis-server  /root/7002/redis.conf
  13.   ./redis-server  /root/7003/redis.conf
  14.   ./redis-server  /root/7004/redis.conf
  15.   ./redis-server  /root/7005/redis.conf
  16.   ./redis-server  /root/7006/redis.conf
复制代码
  1. 6. 查看进程
  2.   ps aux|grep redis
复制代码

  1. 1. 复制集群操作脚本到 bin 目录中
  2.   cp /root/redis-4.0.10/src/redis-trib.rb .
  4. 2. 创建集群
  5.   ./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
复制代码
  1. 3. 集群创建成功出现如下提示
复制代码

  1. 1. 查看集群状态 check [原始集群中任意节点] [无]
  2.   ./redis-trib.rb check 192.168.202.205:7000
  4. 2. 集群节点状态说明
  5.   - 主节点
  6.     主节点存在hash slots,且主节点的hash slots 没有交叉
  7.     主节点不能删除
  8.     一个主节点可以有多个从节点
  9.     主节点宕机时多个副本之间自动选举主节点
  11.   - 从节点
  12.     从节点没有hash slots
  13.     从节点可以删除
  14.     从节点不负责数据的写，只负责数据的同步
复制代码
  1. 1. 添加主节点 add-node [新加入节点] [原始集群中任意节点]
  2.   ./redis-trib.rb  add-node 192.168.1.158:7006  192.168.1.158:7005
  3.   注意：
  4.     1.该节点必须以集群模式启动
  5.     2.默认情况下该节点就是以master节点形式添加
复制代码
  1. 1. 添加从节点 add-node --slave [新加入节点] [集群中任意节点]
  2.   ./redis-trib.rb  add-node --slave 192.168.1.158:7006 192.168.1.158:7000
  3.   注意：当添加副本节点时没有指定主节点，redis会随机给副本节点较少的主节点添加当前副本节点
  4.        
  5. 2. 为确定的master节点添加主节点 add-node --slave --master-id master节点id [新加入节点] [集群任意节点]
  6.   ./redis-trib.rb  add-node --slave --master-id 3c3a0c74aae0b56170ccb03a76b60cfe7dc1912e 127.0.0.1:7006  127.0.0.1:7000
复制代码
  1. 1. 删除节点 del-node [集群中任意节点] [删除节点id]
  2.   ./redis-trib.rb  del-node 127.0.0.1:7002 0ca3f102ecf0c888fc7a7ce43a13e9be9f6d3dd1
  3.   注意：被删除的节点必须是从节点或没有被分配 hash slots 的节点
复制代码
  1. 1. 在线分片 reshard [集群中任意节点] [无]
  2.   ./redis-trib.rb  reshard  192.168.1.158:7000
复制代码
10. Redis 实现分布式 Session 管理

10.1 管理机制

Redis 的 Session 管理是利用 Spring 提供的 Session 管理办理方案，将一个应用 Session 交给 Redis 存储，整个应用中所有 Session 的请求都会去 Redis 中获取对应的 Session 数据。

10.2 开发 Session 管理

  1. <dependency>
  2.   <groupId>org.springframework.session</groupId>
  3.   <artifactId>spring-session-data-redis</artifactId>
  4. </dependency>
复制代码
  1. @Configuration
  2. @EnableRedisHttpSession
  3. public class RedisSessionManager {
  4.    
  5. }
复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 IT评测·应用市场-qidao123.com技术社区 (https://dis.qidao123.com/) Powered by Discuz! X3.4