Redis 6
1.NoSQL数据库简介
1.技术发展
技术的分类:
- 解决功能性的问题：Java、Jsp、RDBMS、Tomcat、HTML、Linux、JDBC、SVN
- 解决扩展性的问题：Struts、Spring、SpringMVC、Hibernate、Mybatis
- 解决性能的问题：NoSQL、Java线程、Hadoop、Nginx、MQ、ElasticSearch
Web1.0时代
Web1.0的时代，数据访问量很有限，用一夫当关的高性能的单点服务器可以解决大部分问题。
Web2.0时代
随着Web2.0的时代的到来，用户访问量大幅度提升，同时产生了大量的用户数据。加上后来的智能移动设备的普及，所有的互联网平台都面临了巨大的性能挑战。
解决CPU及内存压力
解决IO压力
2.NoSQL数据库
-
NoSQL数据库概述
NoSQL(NoSQL = Not Only SQL )，意即“不仅仅是SQL”，泛指非关系型的数据库。
NoSQL 不依赖业务逻辑方式存储，而以简单的key-value模式存储。因此大大的增加了数据库的扩展能力。
- 不遵循SQL标准。
- 不支持ACID。
- 远超于SQL的性能。
-
NoSQL适用场景
- 对数据高并发的读写
- 海量数据的读写
- 对数据高可扩展性的
-
NoSQL不适用场景
- 需要事务支持
- 基于sql的结构化查询存储，处理复杂的关系,需要即席查询。
- （用不着sql的和用了sql也不行的情况，请考虑用NoSql）
-
Memcache
-
Redis
-
MongoDB
3.行式存储数据库（大数据时代）
-
行式数据库
-
列式数据库
4.图关系型数据库
主要应用：社会关系，公共交通网络，地图及网络拓谱(n*(n-1)/2)
5.DB-Engines 数据库排名
数据来源：DB-Engines Ranking - popularity ranking of database management systems
2.Redis概述安装
1.Redis安装
-
准备工作：下载安装最新版的gcc编译器
安装C 语言的编译环境 yum install centos-release-scl scl-utils-build yum install -y devtoolset-8-toolchain scl enable devtoolset-8 bash 测试 gcc版本 gcc --version -
解压redis-6.2.1.tar.gz
-
解压完成后进入目录,再次执行make命令
-
跳过make test 继续执行: make install
-
安装目录：/usr/local/bin
查看默认安装目录： redis-benchmark:性能测试工具，可以在自己本子运行，看看自己本子性能如何 redis-check-aof：修复有问题的AOF文件，rdb和aof后面讲 redis-check-dump：修复有问题的dump.rdb文件 redis-sentinel：Redis集群使用 redis-server：Redis服务器启动命令 redis-cli：客户端，操作入口 -
前台启动（不推荐）
redis-server -
后台启动（推荐）
- 备份redis.conf
- 后台启动设置daemonize no改成yes
redis-server /opt/module/redis-6.2.1/Myredis.conf- 2.2.5.4.用客户端访问：redis-cli
- Redis关闭
- 单实例关闭：
redis-cli shutdown - 也可以进入终端后再关闭
shutdown
- 单实例关闭：
2.Redis介绍相关知识
Redis是单线程+多路IO复用技术
多路复用是指使用一个线程来检查多个文件描述符（Socket）的就绪状态，比如调用select和poll函数，传入多个文件描述符，如果有一个文件描述符就绪，则返回，否则阻塞直到超时。得到就绪状态后进行真正的操作可以在同一个线程里执行，也可以启动线程执行（比如使用线程池）
串行 vs 多线程+锁（memcached） vs 单线程+多路IO复用(Redis)
与Memcache三点不同: 支持多数据类型，支持持久化，单线程+多路IO复用）
3.常用五大数据类型
1.Redis键(key)
keys * 查看当前库所有key (匹配：keys *1)
exists key 判断某个key是否存在
type key 查看你的key是什么类型
del key 删除指定的key数据
unlink key 根据value选择非阻塞删除,仅将keys从keyspace元数据中删除，真正的删除会在后续异步操作。
expire key 10 10秒钟：为给定的key设置过期时间
ttl key 查看还有多少秒过期，-1表示永不过期，-2表示已过期
select 命令切换数据库
dbsize 查看当前数据库的key的数量
flushdb 清空当前库
flushall 通杀全部库
2.Redis字符串(String)
-
简介
- String是Redis最基本的类型，你可以理解成与Memcached一模一样的类型，一个key对应一个value。
- String类型是二进制安全的。意味着Redis的string可以包含任何数据。比如jpg图片或者序列化的对象。
- String类型是Redis最基本的数据类型，一个Redis中字符串value最多可以是512M
-
常用命令
set <key><value> 添加键值对 *NX： 当数据库中key不存在时，可以将key-value添加数据库 *XX： 当数据库中key存在时，可以将key-value添加数据库，与NX参数互斥 *EX： key的超时秒数 *PX： key的超时毫秒数，与EX互斥 get <key> 查询对应键值 append <key> <value> 将给定的<value> 追加到原值的末尾 strlen <key> 获得值的长度 setnx <key> <value> 只有在 key 不存在时 设置 key 的值 incr <key> 将 key 中储存的数字值增1 只能对数字值操作，如果为空，新增值为1 decr <key> 将 key 中储存的数字值减1 只能对数字值操作，如果为空，新增值为-1 incrby / decrby <key><步长> 将 key 中储存的数字值增减。自定义步长。原子性
所谓原子操作是指不会被线程调度机制打断的操作；
这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch （切换到另一个线程）。
- 在单线程中， 能够在单条指令中完成的操作都可以认为是"原子操作"，因为中断只能发生于指令之间。
- 在多线程中，不能被其它进程（线程）打断的操作就叫原子操作。
Redis单命令的原子性主要得益于Redis的单线程。
mset <key1><value1><key2><value2> ..... 同时设置一个或多个 key-value对 mget <key1><key2><key3> ..... 同时获取一个或多个 value msetnx <key1><value1><key2><value2> ..... 同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在。原子性，有一个失败则都失败
getrange <key><起始位置><结束位置> 获得值的范围，类似java中的substring，前包，后包 setrange <key><起始位置><value> 用 <value> 覆写<key>所储存的字符串值，从<起始位置>开始(索引从0开始)。 setex <key><过期时间><value> 设置键值的同时，设置过期时间，单位秒。 getset <key><value> 以新换旧，设置了新值同时获得旧值。 -
数据结构
String的数据结构为简单动态字符串(Simple Dynamic String,缩写SDS)。是可以修改的字符串，内部结构实现上类似于Java的ArrayList，采用预分配冗余空间的方式来减少内存的频繁分配.
如图中所示，内部为当前字符串实际分配的空间capacity一般要高于实际字符串长度len。当字符串长度小于1M时，扩容都是加倍现有的空间，如果超过1M，扩容时一次只会多扩1M的空间。需要注意的是字符串最大长度为512M。
3.Redis列表(List)
-
简介
单键多值
Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）。
它的底层实际是个双向链表，对两端的操作性能很高，通过索引下标的操作中间的节点性能会较差。
-
常用命令
lpush/rpush <key><value1><value2><value3> .... 从左边/右边插入一个或多个值。 lpop/rpop <key> 从左边/右边吐出一个值。值在键在，值光键亡。 rpoplpush <key1><key2> 从<key1>列表右边吐出一个值，插到<key2>列表左边。 lrange <key><start><stop> 按照索引下标获得元素(从左到右) lrange mylist 0 -1 0左边第一个，-1右边第一个，（0-1表示获取所有） lindex <key><index> 按照索引下标获得元素(从左到右) llen <key> 获得列表长度 linsert <key> before <value><newvalue> 在<value>的后面插入<newvalue>插入值 lrem <key><n><value> 从左边删除n个value(从左到右) lset<key><index><value> 将列表key下标为index的值替换成value -
数据结构
List的数据结构为快速链表quickList。
首先在列表元素较少的情况下会使用一块连续的内存存储，这个结构是ziplist，也即是压缩列表。
它将所有的元素紧挨着一起存储，分配的是一块连续的内存。
当数据量比较多的时候才会改成quicklist。
因为普通的链表需要的附加指针空间太大，会比较浪费空间。比如这个列表里存的只是int类型的数据，结构上还需要两个额外的指针prev和next。
Redis将链表和ziplist结合起来组成了quicklist。也就是将多个ziplist使用双向指针串起来使用。这样既满足了快速的插入删除性能，又不会出现太大的空间冗余。
Redis集合(Set)
-
简介
Redis set对外提供的功能与list类似是一个列表的功能，特殊之处在于set是可以自动排重的，当你需要存储一个列表数据，又不希望出现重复数据时，set是一个很好的选择，并且set提供了判断某个成员是否在一个set集合内的重要接口，这个也是list所不能提供的。
Redis的Set是string类型的无序集合。它底层其实是一个value为null的hash表，所以添加，删除，查找的复杂度都是O(1)。
一个算法，随着数据的增加，执行时间的长短，如果是O(1)，数据增加，查找数据的时间不变
-
常用命令
sadd <key><value1><value2> ..... 将一个或多个 member 元素加入到集合 key 中，已经存在的 member 元素将被忽略 smembers <key> 取出该集合的所有值。 sismember <key><value> 判断集合<key>是否为含有该<value>值，有1，没有0 scard<key> 返回该集合的元素个数。 srem <key><value1><value2> .... 删除集合中的某个元素。 spop <key> 随机从该集合中吐出一个值。 srandmember <key><n> 随机从该集合中取出n个值。不会从集合中删除 。 smove <source><destination> value把集合中一个值从一个集合移动到另一个集合 sinter <key1><key2> 返回两个集合的交集元素。 sunion <key1><key2> 返回两个集合的并集元素。 sdiff <key1><key2> 返回两个集合的差集元素(key1中的，不包含key2中的) -
数据结构
Set数据结构是dict字典，字典是用哈希表实现的。
Java中HashSet的内部实现使用的是HashMap，只不过所有的value都指向同一个对象。Redis的set结构也是一样，它的内部也使用hash结构，所有的value都指向同一个内部值。
Redis哈希(Hash)
-
简介
Redis hash 是一个键值对集合。
Redis hash是一个string类型的field和value的映射表，hash特别适合用于存储对象。
类似Java里面的Map<String,Object>
用户ID为查找的key，存储的value用户对象包含姓名，年龄，生日等信息，如果用普通的key/value结构来存储
主要有以下2种存储方式：
-
常用命令
hset <key><field><value> 给<key>集合中的 <field>键赋值<value> hget <key1><field> 从<key1>集合<field>取出 value hmset <key1><field1><value1><field2><value2>... 批量设置hash的值 hexists<key1><field> 查看哈希表 key 中，给定域 field 是否存在。 hkeys <key> 列出该hash集合的所有field hvals <key> 列出该hash集合的所有value hincrby <key><field><increment> 为哈希表 key 中的域 field 的值加上增量 1 -1 hsetnx <key><field><value> 将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在 . -
数据结构
Hash类型对应的数据结构是两种：ziplist（压缩列表），hashtable（哈希表）。当field-value长度较短且个数较少时，使用ziplist，否则使用hashtable。
Redis有序集合Zset(sorted set)
-
简介
Redis有序集合zset与普通集合set非常相似，是一个没有重复元素的字符串集合。
不同之处是有序集合的每个成员都关联了一个评分（score）,这个评分（score）被用来按照从最低分到最高分的方式排序集合中的成员。集合的成员是唯一的，但是评分可以是重复了 。
因为元素是有序的, 所以你也可以很快的根据评分（score）或者次序（position）来获取一个范围的元素。
访问有序集合的中间元素也是非常快的,因此你能够使用有序集合作为一个没有重复成员的智能列表。
-
常用命令
zadd <key><score1><value1><score2><value2>… 将一个或多个 member 元素及其 score 值加入到有序集 key 当中。 zrange <key><start><stop> [WITHSCORES] 返回有序集 key 中，下标在<start><stop>之间的元素 带WITHSCORES，可以让分数一起和值返回到结果集。 zrangebyscore key minmax [withscores] [limit offset count] 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。 zrevrangebyscore key maxmin [withscores] [limit offset count] 同上，改为从大到小排列。 zincrby <key><increment><value> 为元素的score加上增量 zrem <key><value> 删除该集合下，指定值的元素 zcount <key><min><max> 统计该集合，分数区间内的元素个数 zrank <key><value> 返回该值在集合中的排名，从0开始。 -
数据结构
SortedSet(zset)是Redis提供的一个非常特别的数据结构，一方面它等价于Java的数据结构Map<String, Double>，可以给每一个元素value赋予一个权重score，另一方面它又类似于TreeSet，内部的元素会按照权重score进行排序，可以得到每个元素的名次，还可以通过score的范围来获取元素的列表。
zset底层使用了两个数据结构:
- hash，hash的作用就是关联元素value和权重score，保障元素value的唯一性，可以通过元素value找到相应的score值。
- 跳跃表，跳跃表的目的在于给元素value排序，根据score的范围获取元素列表。
-
跳跃表（跳表）
-
简介
有序集合在生活中比较常见，例如根据成绩对学生排名，根据得分对玩家排名等。对于有序集合的底层实现，可以用数组、平衡树、链表等。数组不便元素的插入、删除；平衡树或红黑树虽然效率高但结构复杂；链表查询需要遍历所有效率低。Redis采用的是跳跃表。跳跃表效率堪比红黑树，实现远比红黑树简单。
-
实例
对比有序链表和跳跃表，从链表中查询出51
-
有序链表
要查找值为51的元素，需要从第一个元素开始依次查找、比较才能找到。共需要6次比较。
-
跳跃表
从第2层开始，1节点比51节点小，向后比较。
21节点比51节点小，继续向后比较，后面就是NULL了，所以从21节点向下到第1层
在第1层，41节点比51节点小，继续向后，61节点比51节点大，所以从41向下
在第0层，51节点为要查找的节点，节点被找到，共查找4次。
-
-
4.Redis配置文件介绍
###Units单位###
配置大小单位,开头定义了一些基本的度量单位，只支持bytes，不支持bit
大小写不敏感
###INCLUDES包含###
类似jsp中的include，多实例的情况可以把公用的配置文件提取出来
###网络相关配置 ###
-
bind
默认情况bind=127.0.0.1只能接受本机的访问请求
不写的情况下，无限制接受任何ip地址的访问
生产环境肯定要写你应用服务器的地址；服务器是需要远程访问的，所以需要将其注释掉
如果开启了protected-mode，那么在没有设定bind ip且没有设密码的情况下，Redis只允许接受本机的响应
-
protected-mode
将本机访问保护模式设置no
-
Port
端口号，默认 6379
-
tcp-backlog
设置tcp的backlog，backlog其实是一个连接队列，backlog队列总和=未完成三次握手队列 + 已经完成三次握手队列。
在高并发环境下你需要一个高backlog值来避免慢客户端连接问题。
注意Linux内核会将这个值减小到/proc/sys/net/core/somaxconn的值（128），所以需要确认增大/proc/sys/net/core/somaxconn和/proc/sys/net/ipv4/tcp_max_syn_backlog（128）两个值来达到想要的效果
-
timeout
一个空闲的客户端维持多少秒会关闭，0表示关闭该功能。即永不关闭。
-
tcp-keepalive
对访问客户端的一种心跳检测，每个n秒检测一次。
单位为秒，如果设置为0，则不会进行Keepalive检测，建议设置成60
###GENERAL通用###
-
daemonize
是否为后台进程，设置为yes
守护进程，后台启动
-
pidfile
存放pid文件的位置，每个实例会产生一个不同的pid文件
-
loglevel
指定日志记录级别，Redis总共支持四个级别：debug、verbose、notice、warning，默认为****notice****
四个级别根据使用阶段来选择，生产环境选择notice 或者warning
-
logfile
日志文件名称
-
databases 16
设定库的数量 默认16，默认数据库为0，可以使用SELECT 命令在连接上指定数据库id
###SECURITY安全###
-
设置密码
访问密码的查看、设置和取消
在命令中设置密码，只是临时的。重启redis服务器，密码就还原了。
永久设置，需要再配置文件中进行设置。
#### LIMITS限制 ###
-
maxclients
- 设置redis同时可以与多少个客户端进行连接。
- 默认情况下为10000个客户端。
- 如果达到了此限制，redis则会拒绝新的连接请求，并且向这些连接请求方发出“max number of clients reached”以作回应。
-
maxmemory
- 建议****必须设置****，否则，将内存占满，造成服务器宕机
- 设置redis可以使用的内存量。一旦到达内存使用上限，redis将会试图移除内部数据，移除规则可以通过maxmemory-policy来指定。
- 如果redis无法根据移除规则来移除内存中的数据，或者设置了“不允许移除”，那么redis则会针对那些需要申请内存的指令返回错误信息，比如SET、LPUSH等。
- 但是对于无内存申请的指令，仍然会正常响应，比如GET等。如果你的redis是主redis（说明你的redis有从redis），那么在设置内存使用上限时，需要在系统中留出一些内存空间给同步队列缓存，只有在你设置的是“不移除”的情况下，才不用考虑这个因素。
-
maxmemory-policy
- volatile-lru：使用LRU算法移除key，只对设置了过期时间的键；（最近最少使用）
- allkeys-lru：在所有集合key中，使用LRU算法移除key
- volatile-random：在过期集合中移除随机的key，只对设置了过期时间的键
- allkeys-random：在所有集合key中，移除随机的key
- volatile-ttl：移除那些TTL值最小的key，即那些最近要过期的key
- noeviction：不进行移除。针对写操作，只是返回错误信息
-
maxmemory-samples
- 设置样本数量，LRU算法和最小TTL算法都并非是精确的算法，而是估算值，所以你可以设置样本的大小，redis默认会检查这么多个key并选择其中LRU的那个。
- 一般设置3到7的数字，数值越小样本越不准确，但性能消耗越小。
5.Redis的发布和订阅
-
什么是发布和订阅
Redis 发布订阅 (pub/sub) 是一种消息通信模式：发送者 (pub) 发送消息，订阅者 (sub) 接收消息。
Redis 客户端可以订阅任意数量的频道。
-
Redis的发布和订阅
-
客户端可以订阅频道如下图
-
当给这个频道发布消息后，消息就会发送给订阅的客户端
-
-
发布订阅命令行实现
-
打开一个客户端订阅channel1
SUBSCRIBE channel1
-
打开另一个客户端，给channel1发布消息hello
publish channel1 hello
返回的1是订阅者数量
-
打开第一个客户端可以看到发送的消息
注：发布的消息没有持久化，如果在订阅的客户端收不到hello，只能收到订阅后发布的消息
-
6.Redis新数据类型
Bitmaps
-
简介
现代计算机用二进制（位） 作为信息的基础单位， 1个字节等于8位， 例如“abc”字符串是由3个字节组成， 但实际在计算机存储时将其用二进制表示， “abc”分别对应的ASCII码分别是97、 98、 99， 对应的二进制分别是01100001、 01100010和01100011，如下图
合理地使用操作位能够有效地提高内存使用率和开发效率。
Redis提供了Bitmaps这个“数据类型”可以实现对位的操作：
- Bitmaps本身不是一种数据类型， 实际上它就是字符串（key-value） ， 但是它可以对字符串的位进行操作。
- Bitmaps单独提供了一套命令， 所以在Redis中使用Bitmaps和使用字符串的方法不太相同。 可以把Bitmaps想象成一个以位为单位的数组， 数组的每个单元只能存储0和1， 数组的下标在Bitmaps中叫做偏移量。
-
命令
setbit<key><offset><value> 设置Bitmaps中某个偏移量的值（0或1） getbit<key><offset> 获取Bitmaps中某个偏移量的值 bitcount<key>[start end] 统计字符串从start字节到end字节比特值为1的数量 bitop and(or/not/xor) <destkey> [key…] bitop是一个复合操作， 它可以做多个Bitmaps的and（交集） 、 or（并集） 、 not（非） 、 xor（异或） 操作并将结果保存在destkey中 -
Bitmaps与set对比
假设网站有1亿用户， 每天独立访问的用户有5千万， 如果每天用集合类型和Bitmaps分别存储活跃用户可以得到表
set和Bitmaps存储一天活跃用户对比 数据类型 每个用户id占用空间 需要存储的用户量 全部内存量 集合类型 64位 50000000 64位*50000000 = 400MB Bitmaps 1位 100000000 1位*100000000 = 12.5MB 很明显， 这种情况下使用Bitmaps能节省很多的内存空间， 尤其是随着时间推移节省的内存还是非常可观的
set和Bitmaps存储独立用户空间对比 数据类型 一天 一个月 一年 集合类型 400MB 12GB 144GB Bitmaps 12.5MB 375MB 4.5GB 但Bitmaps并不是万金油， 假如该网站每天的独立访问用户很少， 例如只有10万（大量的僵尸用户） ， 那么两者的对比如下表所示， 很显然， 这时候使用Bitmaps就不太合适了， 因为基本上大部分位都是0。
set和Bitmaps存储一天活跃用户对比（独立用户比较少） 数据类型 每个userid占用空间 需要存储的用户量 全部内存量 集合类型 64位 100000 64位*100000 = 800KB Bitmaps 1位 100000000 1位*100000000 = 12.5MB
HyperLogLog
-
简介
Redis HyperLogLog 是用来做基数统计的算法，HyperLogLog 的优点是，在输入元素的数量或者体积非常非常大时，计算基数所需的空间总是固定的、并且是很小的。
比如数据集 {1, 3, 5, 7, 5, 7, 8}， 那么这个数据集的基数集为 {1, 3, 5 ,7, 8}, 基数(不重复元素)为5。 基数估计就是在误差可接受的范围内，快速计算基数。
-
命令
pfadd <key>< element> [element ...] 添加指定元素到 HyperLogLog 中 pfcount<key> [key ...] 计算HLL的近似基数，可以计算多个HLL，比如用HLL存储每天的UV，计算一周的UV可以使用7天的UV合并计算即可 pfmerge<destkey><sourcekey> [sourcekey ...] 将一个或多个HLL合并后的结果存
Geospatial
-
简介
Redis 3.2 中增加了对GEO类型的支持。GEO，Geographic，地理信息的缩写。该类型，就是元素的2维坐标，在地图上就是经纬度。redis基于该类型，提供了经纬度设置，查询，范围查询，距离查询，经纬度Hash等常见操作。
-
命令
geoadd<key>< longitude><latitude><member> [longitude latitude member...] 添加地理位置（经度，纬度，名称） geopos <key> <member> [member...] 获得指定地区的坐标值 geodist <key> <member1> <member2> [m|km|ft|mi ] 获取两个位置之间的直线距离 georadius <key> <longitude> <latitude> radius [m|km|ft|mi] 以给定的经纬度为中心，找出某一半径内的元素
7.Redis_Jedis_测试
Jedis所需要的jar包
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.2.0</version>
</dependency>
连接Redis注意事项
禁用Linux的防火墙：Linux(CentOS7)里执行命令
systemctl stop/disable firewalld.service
redis.conf中注释掉bind 127.0.0.1 ,然后 protected-mode no
Jedis常用操作
-
创建测试程序
public class JedisDemo1 { public static void main(String[] args) { // 创建Jedis对象 Jedis jedis = new Jedis("10.2.37.60", 6379); String ping = jedis.ping(); System.out.println(ping); jedis.close(); } } -
测试相关数据类型
-
Jedis-API:Key
// 操作key @Test public void demo1() { // 创建Jedis对象 Jedis jedis = new Jedis("10.2.37.60", 6379); // 添加数据 jedis.set("name", "kevin"); // 获取数据 String name = jedis.get("name"); System.out.println(name); System.out.println("================="); // 设置多个key-value jedis.mset("k1","v1", "k2", "v2"); // 获取多个key-value List<String> mget = jedis.mget("k1", "k2"); for (String s : mget) { System.out.println(s); } System.out.println("================="); Set<String> keys = jedis.keys("*"); for (String key : keys) { System.out.println(key); } jedis.close(); } -
Jedis-API: List
// 操作list @Test public void demo2() { // 创建Jedis对象 Jedis jedis = new Jedis("10.2.37.60", 6379); // 添加数据 jedis.lpush("key1", "lucy", "mary", "jack", "kevin"); // 获取数据 List<String> key1 = jedis.lrange("key1", 0, -1); for (String s : key1) { System.out.println(s); } jedis.close(); } -
Jedis-API: set
// 操作set @Test public void demo3() { // 创建Jedis对象 Jedis jedis = new Jedis("10.2.37.60", 6379); // 添加数据 jedis.sadd("names", "lucy", "jack"); // 获取数据 Set<String> name = jedis.smembers("names"); for (String s : name) { System.out.println(s); } jedis.close(); } -
Jedis-API: hash
// 操作hash @Test public void demo4() { // 创建Jedis对象 Jedis jedis = new Jedis("10.2.37.60", 6379); // 添加数据 jedis.hset("user", "age", "20"); // 获取数据 String age = jedis.hget("user", "age"); System.out.println(age); jedis.close(); } -
Jedis-API: zset
// 操作zset @Test public void demo5() { // 创建Jedis对象 Jedis jedis = new Jedis("10.2.37.60", 6379); // 添加数据 jedis.zadd("china", 100d, "上海"); // 获取数据 Set<String> china = jedis.zrange("china", 0, -1); for (String s : china) { System.out.println(s); } jedis.close(); }
-
8.Redis_Jedis_实例
完成一个手机验证码功能
要求：
- 输入手机号，点击发送后随机生成6位数字码，2分钟有效
- 输入验证码，点击验证，返回成功或失败
- 每个手机号每天只能输入3次
public class PhoneCode {
public static void main(String[] args) {
// 模拟验证码的发送
if (verifyCode("12345678912")) {
Scanner scanner = new Scanner(System.in);
System.out.print("请输入验证码:");
String code = scanner.next();
// 验证手机号验证码是否匹配
getRedisCode("12345678912", code);
}
}
// 生成6位数字的验证码
public static String getCode() {
Random random = new Random();
StringBuilder code = new StringBuilder();
for (int i = 0; i < 6; i++) {
int rand = random.nextInt(10);
code.append(rand);
}
return code.toString();
}
// 让每个手机每天只能发送三次，验证码放到redis中，设置过期时间
public static boolean verifyCode(String phone) {
Jedis jedis = new Jedis("10.2.37.60");
// 拼接key
// 手机发送key的次数
String countKey = "VerifyCode" + phone + ":count";
// 验证码key
String codeKey = "VerifyCode" + phone + ":code";
// 让每个手机每天只能发送三次
String count = jedis.get(countKey);
if (count == null) {
jedis.setex(countKey, 24*60*60, "1");
} else if (Integer.parseInt(count) <= 2) {
// 次数+1
jedis.incr(countKey);
} else {
// 发送短信次数为3
System.out.println("今天发送的次数已经超过三次！");
jedis.close();
return false;
}
// 发送的验证码放到redis
jedis.setex(codeKey, 2*60, getCode());
jedis.close();
return true;
}
// 验证码校验
public static void getRedisCode(String phone, String code) {
Jedis jedis = new Jedis("10.2.37.60");
// 验证码key
String codeKey = "VerifyCode" + phone + ":code";
String redisCode = jedis.get(codeKey);
if (redisCode.equals(code)) {
System.out.println("成功！");
} else {
System.out.println("失败！");
}
jedis.close();
}
}
9.Redis与Spring Boot整合
整合步骤
-
引入redis相关依赖
<!-- redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <!-- spring2.X集成redis所需common-pool2--> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-pool2</artifactId> </dependency> -
application.yml配置redis配置
spring: # Redis配置 redis: # Redis服务器地址 host: 10.2.37.60 # Redis服务器连接端口 port: 6379 # Redis数据库索引（默认为0） database: 0 # 连接超时时间（毫秒） connect-timeout: 180000 lettuce: pool: # 连接池最大连接数（使用负值表示没有限制） max-active: 20 # 最大阻塞等待时间(负数表示没限制) max-wait: -1 # 连接池中的最大空闲连接 max-idle: 5 # 连接池中的最小空闲连接 min-idle: 0 -
添加redis配置类
@EnableCaching @Configuration public class RedisConfig extends CachingConfigurerSupport { @Bean public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) { RedisTemplate<String, Object> template = new RedisTemplate<>(); RedisSerializer<String> redisSerializer = new StringRedisSerializer(); Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class); ObjectMapper om = new ObjectMapper(); om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL); jackson2JsonRedisSerializer.setObjectMapper(om); template.setConnectionFactory(factory); // key序列化方式 template.setKeySerializer(redisSerializer); // value序列化 template.setValueSerializer(jackson2JsonRedisSerializer); // value hashmap序列化 template.setHashValueSerializer(jackson2JsonRedisSerializer); return template; } @Bean public CacheManager cacheManager(RedisConnectionFactory factory) { RedisSerializer<String> redisSerializer = new StringRedisSerializer(); Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class); // 解决查询缓存转换异常的问题 ObjectMapper om = new ObjectMapper(); om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL); jackson2JsonRedisSerializer.setObjectMapper(om); // 配置序列化（解决乱码的问题）,过期时间600秒 RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig() .entryTtl(Duration.ofSeconds(600)) .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer)) .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer)) .disableCachingNullValues(); RedisCacheManager cacheManager = RedisCacheManager.builder(factory) .cacheDefaults(config) .build(); return cacheManager; } } -
RedisTestController中添加测试方法
@RestController @RequestMapping("/redis") public class RedisController { private final RedisTemplate redisTemplate; public RedisController(RedisTemplate redisTemplate) { this.redisTemplate = redisTemplate; } @RequestMapping public String testRedis() { // 设置值到redis redisTemplate.opsForValue().set("name", "kevin"); // 从redis中获取值 String name = (String) redisTemplate.opsForValue().get("name"); return name; } }
10.Redis_事务_锁机制_秒杀
Redis的事务定义
Redis事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。
Redis事务的主要作用就是串联多个命令防止别的命令插队。
Multi、Exec、discard
从输入Multi命令开始，输入的命令都会依次进入命令队列中，但不会执行，直到输入Exec后，Redis会将之前的命令队列中的命令依次执行。
组队的过程中可以通过discard来放弃组队。
事务的错误处理
组队中某个命令出现了报告错误，执行时整个的所有队列都会被取消。
如果执行阶段某个命令报出了错误，则只有报错的命令不会被执行，而其他的命令都会执行，不会回滚。
事务冲突的问题
-
例子
一个请求想给金额减8000
一个请求想给金额减5000
一个请求想给金额减1000
-
悲观锁
悲观锁(Pessimistic Lock), 顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。
-
乐观锁
乐观锁(Optimistic Lock), 顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量。Redis就是利用这种check-and-set机制实现事务的。
-
WATCH key [key …]
在执行multi之前，先执行watch key1 [key2],可以监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断。
-
unwatch
取消 WATCH 命令对所有 key 的监视。
如果在执行 WATCH 命令之后，EXEC 命令或DISCARD 命令先被执行了的话，那么就不需要再执行UNWATCH 了。
-
Redis事务三特性
-
单独的隔离操作
事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。
-
没有隔离级别的概念
队列中的命令没有提交之前都不会实际被执行，因为事务提交前任何指令都不会被实际执行
-
不保证原子性
事务中如果有一条命令执行失败，其后的命令仍然会被执行，没有回滚
-
11.Redis持久化之RDB
总体介绍
Redis 提供了2个不同形式的持久化方式:
- RDB（Redis DataBase）
- AOF（Append Of File）
RDB（Redis DataBase）
-
官网介绍
-
作用
在指定的时间间隔内将内存中的数据集快照写入磁盘， 也就是行话讲的Snapshot快照，它恢复时是将快照文件直接读到内存里
-
备份是如何执行的
Redis会单独创建（fork）一个子进程来进行持久化，会先将数据写入到 一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文件。 整个过程中，主进程是不进行任何IO操作的，这就确保了极高的性能 如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那RDB方式要比AOF方式更加的高效。RDB的缺点是最后一次持久化后的数据可能丢失。
-
Fork
- Fork的作用是复制一个与当前进程一样的进程。新进程的所有数据（变量、环境变量、程序计数器等） 数值都和原进程一致，但是是一个全新的进程，并作为原进程的子进程
- 在Linux程序中，fork()会产生一个和父进程完全相同的子进程，但子进程在此后多会exec系统调用，出于效率考虑，Linux中引入了“写时复制技术”
- 一般情况父进程和子进程会共用同一段物理内存，只有进程空间的各段的内容要发生变化时，才会将父进程的内容复制一份给子进程。
-
RDB持久化流程
-
dump.rdb文件
在redis.conf中配置文件名称，默认为dump.rdb
-
配置位置
rdb文件的保存路径，也可以修改。默认为Redis启动时命令行所在的目录下
dir “/myredis/”
-
触发RDB快照；保存策略
-
配置文件中默认的快照配置
-
命令save VS bgsave
save ：save时只管保存，其它不管，全部阻塞。手动保存。不建议。
bgsave：Redis会在后台异步进行快照操作， 快照同时还可以响应客户端请求。
可以通过lastsave 命令获取最后一次成功执行快照的时间
-
flushall命令
执行flushall命令，也会产生dump.rdb文件，但里面是空的，无意义
-
Save
格式：save 秒钟 写操作次数
RDB是整个内存的压缩过的Snapshot，RDB的数据结构，可以配置复合的快照触发条件，
默认是1分钟内改了1万次，或5分钟内改了10次，或15分钟内改了1次。
禁用
不设置save指令，或者给save传入空字符串
-
stop-writes-on-bgsave-error
当Redis无法写入磁盘的话，直接关掉Redis的写操作。推荐yes.
-
rdbcompression 压缩文件
对于存储到磁盘中的快照，可以设置是否进行压缩存储。如果是的话，redis会采用LZF算法进行压缩。
如果你不想消耗CPU来进行压缩的话，可以设置为关闭此功能。推荐yes.
-
rdbchecksum 检查完整性
在存储快照后，还可以让redis使用CRC64算法来进行数据校验，
但是这样做会增加大约10%的性能消耗，如果希望获取到最大的性能提升，可以关闭此功能
推荐yes.
-
rdb的备份
先通过config get dir 查询rdb文件的目录
将*.rdb的文件拷贝到别的地方
rdb的恢复
- u 关闭Redis
- u 先把备份的文件拷贝到工作目录下 cp dump2.rdb dump.rdb
- 启动Redis, 备份数据会直接加载
-
-
优势
- 适合大规模的数据恢复
- 对数据完整性和一致性要求不高更适合使用
- 节省磁盘空间
- 恢复速度快
-
劣势
- Fork的时候，内存中的数据被克隆了一份，大致2倍的膨胀性需要考虑
- 虽然Redis在fork时使用了写时拷贝技术,但是如果数据庞大时还是比较消耗性能。
- 在备份周期在一定间隔时间做一次备份，所以如果Redis意外down掉的话，就会丢失最后一次快照后的所有修改。
-
停止
动态停止RDB：redis-cli config set save “”#save后给空值，表示禁用保存策略
-
小总结
12.Redis持久化之AOF
AOF（Append Only File）
-
介绍
以日志的形式来记录每个写操作（增量保存），将Redis执行过的所有写指令记录下来(读操作不记录)， 只许追加文件但不可以改写文件，redis启动之初会读取该文件重新构建数据，换言之，redis 重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作
-
AOF持久化流程
- 客户端的请求写命令会被append追加到AOF缓冲区内；
- AOF缓冲区根据AOF持久化策略[always,everysec,no]将操作sync同步到磁盘的AOF文件中；
- AOF文件大小超过重写策略或手动重写时，会对AOF文件rewrite重写，压缩AOF文件容量；
- Redis服务重启时，会重新load加载AOF文件中的写操作达到数据恢复的目的；
-
AOF默认不开启
可以在redis.conf中配置文件名称，默认为 appendonly.aof
AOF文件的保存路径，同RDB的路径一致。
-
AOF和RDB同时开启，redis听谁的？
AOF和RDB同时开启，系统默认取AOF的数据（数据不会存在丢失）
-
AOF启动/修复/恢复
- AOF的备份机制和性能虽然和RDB不同, 但是备份和恢复的操作同RDB一样，都是拷贝备份文件，需要恢复时再拷贝到Redis工作目录下，启动系统即加载。
- 正常恢复
- 修改默认的appendonly no，改为yes
- 将有数据的aof文件复制一份保存到对应目录(查看目录：config get dir)
- 恢复：重启redis然后重新加载
- 异常恢复
- 修改默认的appendonly no，改为yes
- 如遇到AOF文件损坏，通过/usr/local/bin/redis-check-aof–fix appendonly.aof进行恢复
- 备份被写坏的AOF文件
- 恢复：重启redis，然后重新加载
-
AOF同步频率设置
appendfsync always始终同步，每次Redis的写入都会立刻记入日志；性能较差但数据完整性比较好
appendfsync everysec每秒同步，每秒记入日志一次，如果宕机，本秒的数据可能丢失。
appendfsync noredis不主动进行同步，把同步时机交给操作系统。
-
Rewrite压缩
-
介绍
AOF采用文件追加方式，文件会越来越大为避免出现此种情况，新增了重写机制, 当AOF文件的大小超过所设定的阈值时，Redis就会启动AOF文件的内容压缩， 只保留可以恢复数据的最小指令集.可以使用命令bgrewriteaof
-
重写原理，如何实现重写
AOF文件持续增长而过大时，会fork出一条新进程来将文件重写(也是先写临时文件最后再rename)，redis4.0版本后的重写，是指上就是把rdb 的快照，以二级制的形式附在新的aof头部，作为已有的历史数据，替换掉原来的流水账操作。
no-appendfsync-on-rewrite：
- 如果 no-appendfsync-on-rewrite=yes ,不写入aof文件只写入缓存，用户请求不会阻塞，但是在这段时间如果宕机会丢失这段时间的缓存数据。（降低数据安全性，提高性能）
- 如果 no-appendfsync-on-rewrite=no, 还是会把数据往磁盘里刷，但是遇到重写操作，可能会发生阻塞。（数据安全，但是性能降低）
触发机制，何时重写
- Redis会记录上次重写时的AOF大小，默认配置是当AOF文件大小是上次rewrite后大小的一倍且文件大于64M时触发
- 重写虽然可以节约大量磁盘空间，减少恢复时间。但是每次重写还是有一定的负担的，因此设定Redis要满足一定条件才会进行重写。
- **auto-aof-rewrite-percentage：**设置重写的基准值，文件达到100%时开始重写（文件是原来重写后文件的2倍时触发）
- **auto-aof-rewrite-min-size：**设置重写的基准值，最小文件64MB。达到这个值开始重写。
-
重写流程
- bgrewriteaof触发重写，判断是否当前有bgsave或bgrewriteaof在运行，如果有，则等待该命令结束后再继续执行。
- 主进程fork出子进程执行重写操作，保证主进程不会阻塞。
- 子进程遍历redis内存中数据到临时文件，客户端的写请求同时写入aof_buf缓冲区和aof_rewrite_buf重写缓冲区保证原AOF文件完整以及新AOF文件生成期间的新的数据修改动作不会丢失。
-
- 子进程写完新的AOF文件后，向主进程发信号，父进程更新统计信息。
- 主进程把aof_rewrite_buf中的数据写入到新的AOF文件。
- 使用新的AOF文件覆盖旧的AOF文件，完成AOF重写。
-
-
优势
- 备份机制更稳健，丢失数据概率更低。
- 可读的日志文本，通过操作AOF稳健，可以处理误操作。
-
劣势
- 比起RDB占用更多的磁盘空间。
- 恢复备份速度要慢。
- 每次读写都同步的话，有一定的性能压力。
- 存在个别Bug，造成恢复不能。
-
小总结
总结(Which one)
- 官方推荐两个都启用。
- 如果对数据不敏感，可以选单独用RDB。
- 不建议单独用 AOF，因为可能会出现Bug。
- 如果只是做纯内存缓存，可以都不用。
13.Redis_主从复制
介绍
主机数据更新后根据配置和策略， 自动同步到备机的master/slaver机制，Master以写为主，Slave以读为主
作用
- 读写分离，性能扩展
- 容灾快速恢复
怎么玩？
-
开启daemonize yes
-
新建redis6379.conf，填写以下内容
include /opt/module/myredis/Myredis.conf pidfile /var/run/redis_6379.pid port 6379 dbfilename dump6379.rdb appendfilename appendonly6381.aof -
新建redis6380.conf，填写以下内容
include /opt/module/myredis/Myredis.conf pidfile /var/run/redis_6380.pid port 6380 dbfilename dump6380.rdb appendfilename appendonly6380.aof -
新建redis6381.conf，填写以下内容
include /opt/module/myredis/Myredis.conf pidfile /var/run/redis_6381.pid port 6381 dbfilename dump6381.rdb appendfilename appendonly6381.aof -
启动三台redis服务器
[root@master myredis]# redis-server ./redis6379.conf [root@master myredis]# redis-server ./redis6380.conf [root@master myredis]# redis-server ./redis6381.conf -
查看系统进程，看看三台服务器是否启动
[root@master myredis]# ps -ef | grep redis root 36969 1 0 19:46 ? 00:00:00 redis-server *:6379 root 36975 1 0 19:46 ? 00:00:00 redis-server *:6380 root 36981 1 0 19:46 ? 00:00:00 redis-server *:6381 -
查看三台主机运行情况
info replication打印主从复制的相关信息
-
配从(库)不配主(库)
slaveof <ip> <port>成为某个实例的从服务器
常用3招
-
一主二仆
- slave1、slave2是从头开始复制
- 从机不可以写
- 主机shutdown后从机原地待命
-
薪火相传
上一个Slave可以是下一个slave的Master，Slave同样可以接收其他 slaves的连接和同步请求，那么该slave作为了链条中下一个的master, 可以有效减轻master的写压力,去中心化降低风险。
slaveof <ip> <port>
-
反客为主
当一个master宕机后，后面的slave可以立刻升为master，其后面的slave不用做任何修改。
用
slaveof no one将从机变为主机。
复制原理
-
Slave启动成功连接到master后会发送一个sync命令
-
Master接到命令启动后台的存盘进程，同时收集所有接收到的用于修改数据集命令， 在后台进程执行完毕之后，master将传送整个数据文件到slave,以完成一次完全同步
-
全量复制：而slave服务在接收到数据库文件数据后，将其存盘并加载到内存中。
-
增量复制：Master继续将新的所有收集到的修改命令依次传给slave,完成同步
但是只要是重新连接master,一次完全同步（全量复制)将被自动执行
哨兵模式(sentinel)
-
介绍
反客为主的自动版，能够后台监控主机是否故障，如果故障了根据投票数自动将从库转换为主库
-
怎么玩？
-
调整为一主二仆模式，6379带着6380、6381
-
自定义的/myredis目录下新建sentinel.conf文件，名字绝不能错
-
配置哨兵,填写内容
sentinel monitor mymaster 127.0.0.1 6379 1其中mymaster为监控对象起的服务器名称， 1 为至少有多少个哨兵同意迁移的数量。
-
启动哨兵
/usr/local/binredis做压测可以用自带的redis-benchmark工具
执行
redis-sentinel /opt/module/myredis/sentinel.conf
-
当主机挂掉，从机选举中产生新的主机
(大概10秒左右可以看到哨兵窗口日志，切换了新的主机)
哪个从机会被选举为主机呢？根据优先级别：slave-priority
原主机重启后会变为从机。
-
复制延时
由于所有的写操作都是先在Master上操作，然后同步更新到Slave上，所以从Master同步到Slave机器有一定的延迟，当系统很繁忙的时候，延迟问题会更加严重，Slave机器数量的增加也会使这个问题更加严重。
-
故障恢复
优先级在redis.conf中默认：slave-priority 100，值越小优先级越高
偏移量是指获得原主机数据最全的
每个redis实例启动后都会随机生成一个40位的runid
-
主从复制
private static JedisSentinelPool jedisSentinelPool=null; public static Jedis getJedisFromSentinel(){ if(jedisSentinelPool==null){ Set<String> sentinelSet=new HashSet<>(); sentinelSet.add("192.168.11.103:26379"); JedisPoolConfig jedisPoolConfig =new JedisPoolConfig(); jedisPoolConfig.setMaxTotal(10); //最大可用连接数 jedisPoolConfig.setMaxIdle(5); //最大闲置连接数 jedisPoolConfig.setMinIdle(5); //最小闲置连接数 jedisPoolConfig.setBlockWhenExhausted(true); //连接耗尽是否等待 jedisPoolConfig.setMaxWaitMillis(2000); //等待时间 jedisPoolConfig.setTestOnBorrow(true); //取连接的时候进行一下测试 ping pong jedisSentinelPool=new JedisSentinelPool("mymaster",sentinelSet,jedisPoolConfig); return jedisSentinelPool.getResource(); }else{ return jedisSentinelPool.getResource(); } }
-
14.Redis集群
问题
容量不够，redis如何进行扩容？
并发写操作， redis如何分摊？
另外，主从模式，薪火相传模式，主机宕机，导致ip地址发生变化，应用程序中配置需要修改对应的主机地址、端口等信息。
之前通过代理主机来解决，但是redis3.0中提供了解决方案。就是无中心化集群配置。
什么是集群
Redis 集群实现了对Redis的水平扩容，即启动N个redis节点，将整个数据库分布存储在这N个节点中，每个节点存储总数据的1/N。
Redis 集群通过分区（partition）来提供一定程度的可用性（availability）： 即使集群中有一部分节点失效或者无法进行通讯， 集群也可以继续处理命令请求。
搭建
-
将rdb,aof文件都删除掉。
-
制作6个实例，6379,6380,6381,6389,6390,6391
-
配置基本信息
开启daemonize yes Pid文件名字 指定端口 Log文件名字 Dump.rdb名字 Appendonly 关掉或者换名字 -
redis cluster配置修改
cluster-enabled yes 打开集群模式 cluster-config-file nodes-6379.conf 设定节点配置文件名 cluster-node-timeout 15000 设定节点失联时间，超过该时间（毫秒），集群自动进行主从切换。include /home/bigdata/redis.conf port 6379 pidfile "/var/run/redis_6379.pid" dbfilename "dump6379.rdb" dir "/home/bigdata/redis_cluster" logfile "/home/bigdata/redis_cluster/redis_err_6379.log" cluster-enabled yes cluster-config-file nodes-6379.conf cluster-node-timeout 15000 -
修改好redis6379.conf文件，拷贝多个redis.conf文件
-
使用查找替换修改另外5个文件
:%s/6379/6380 -
启动6个redis服务
-
将六个节点合成一个集群
组合之前，请确保所有redis实例启动后，nodes-xxxx.conf文件都生成正常。
-
合体
cd /opt/module/redis-6.2.1/src/ redis-cli --cluster create --cluster-replicas 1 10.2.37.60:6379 10.2.37.60:6380 10.2.37.60:6381 10.2.37.60:6389 10.2.37.60:6390 10.2.37.60:6391此处不要用127.0.0.1， 请用真实IP地址
–replicas 1 采用最简单的方式配置集群，一台主机，一台从机，正好三组。
-
普通方式登录
可能直接进入读主机，存储数据时，会出现MOVED重定向操作。所以，应该以集群方式登录。
-
-c 采用集群策略连接，设置数据会自动切换到相应的写主机
-
通过 cluster nodes 命令查看集群信息
-
redis cluster 如何分配这六个节点?
一个集群至少要有三个主节点。
选项 --cluster-replicas 1 表示我们希望为集群中的每个主节点创建一个从节点。
分配原则尽量保证每个主数据库运行在不同的IP地址，每个从库和主库不在一个IP地址上。
什么是slots
[OK] All nodes agree about slots configuration.
>>> Check for open slots...
>>> Check slots coverage...
[OK] All 16384 slots covered.
一个 Redis 集群包含 16384 个插槽（hash slot）， 数据库中的每个键都属于这 16384 个插槽的其中一个，
集群使用公式 CRC16(key) % 16384 来计算键 key 属于哪个槽， 其中 CRC16(key) 语句用于计算键 key 的 CRC16 校验和 。
集群中的每个节点负责处理一部分插槽。 举个例子， 如果一个集群可以有主节点， 其中：
节点 A 负责处理 0 号至 5460 号插槽。
节点 B 负责处理 5461 号至 10922 号插槽。
节点 C 负责处理 10923 号至 16383 号插槽。
在集群中录入值
在redis-cli每次录入、查询键值，redis都会计算出该key应该送往的插槽，如果不是该客户端对应服务器的插槽，redis会报错，并告知应前往的redis实例地址和端口。
redis-cli客户端提供了 –c 参数实现自动重定向。
如 redis-cli -c –p 6379 登入后，再录入、查询键值对可以自动重定向。
不在一个slot下的键值，是不能使用mget,mset等多键操作。
可以通过{}来定义组的概念，从而使key中{}内相同内容的键值对放到一个slot中去。
查询集群中的值
CLUSTER GETKEYSINSLOT <slot> <count> 返回 count 个 slot 槽中的键。
故障恢复
如果主节点下线？从节点能否自动升为主节点？注意：15秒超时
主节点恢复后，主从关系会如何？主节点回来变成从机。
如果所有某一段插槽的主从节点都宕掉，redis服务是否还能继续?
如果某一段插槽的主从都挂掉，而cluster-require-full-coverage 为yes ，那么 ，整个集群都挂掉
如果某一段插槽的主从都挂掉，而cluster-require-full-coverage 为no ，那么，该插槽数据全都不能使用，也无法存储。
redis.conf中的参数 cluster-require-full-coverage
集群的Jedis开发
即使连接的不是主机，集群会自动切换主机存储。主机写，从机读。
无中心化主从集群。无论从哪台主机写的数据，其他主机上都能读到数据。
public class RedisClusterDemo {
public static void main(String[] args) {
// 创建对象
HostAndPort hostAndPort = new HostAndPort("10.2.37.60", 6379);
JedisCluster jedisCluster = new JedisCluster(hostAndPort);
// 写入数据
jedisCluster.set("k1", "v1");
// 读出数据
String k1 = jedisCluster.get("k1");
System.out.println(k1);
// 关闭连接
jedisCluster.close();
}
}
Redis 集群提供了以下好处
- 实现扩容
- 分摊压力
- 无中心配置相对简单
Redis 集群的不足
- 多键操作是不被支持的
- 多键的Redis事务是不被支持的。lua脚本不被支持
- 由于集群方案出现较晚，很多公司已经采用了其他的集群方案，而代理或者客户端分片的方案想要迁移至redis cluster，需要整体迁移而不是逐步过渡，复杂度较大。
15.Redis应用问题解决
缓存
这里讲Redis缓存。Redis利用计算机的外存内存（非CPU内存）作为存储介质，提高数据读写性能。
当然，Redis也有其他高性能技术，还在学习中。
缓存失效
常见的Redis失效有三个名词：击穿、穿透、雪崩。
共同点：Redis缓存失效，没有命中数据（数据为空或者Redis异常）。
不同点：最终返回响应不同。
缓存击穿
Redis没有命中数据，持久层命中数据，并返回有效数据。
并且将持久层命中的数据缓存到Redis。
缓存穿透
Redis没有命中数据，持久层没有命中数据，并返回空数据。
缓存雪崩
Redis没有命中数据，持久层异常，并返回异常数据（信息）。
方案
每种情况都有各自的方案，但是，
最终都是围绕Redis缓存失效的问题展开。
这里，笼统做一下梳理：
| 序号 | 方案 |
|---|---|
| 1 | 高可用（集群方式部署缓存） |
| 2 | 限流降级（缓存失效后，通过加锁或队列控制持久层数据库读写数量） |
| 3 | 数据预加载（先加载部分数据） |
| 4 | 设置不同的过期时间 |
| 5 | 热点数据永远不过期 |
小结
缓存失效：击穿、穿透、雪崩。
共同点：Redis缓存失效，没有命中数据（数据为空或者Redis异常）。
不同点：最终返回响应不同。
针对Redis缓存失效，常用的方案：预加载、限流、熔断等。
15.分布式锁
问题描述
随着业务发展的需要，原单体单机部署的系统被演化成分布式集群系统后，由于分布式系统多线程、多进程并且分布在不同机器上，这将使原单机部署情况下的并发控制锁策略失效，单纯的Java API并不能提供分布式锁的能力。为了解决这个问题就需要一种跨JVM的互斥机制来控制共享资源的访问，这就是分布式锁要解决的问题！
分布式锁主流的实现方案：
- 基于数据库实现分布式锁
- 基于缓存（Redis等）
- 基于Zookeeper
每一种分布式锁解决方案都有各自的优缺点：
- 性能：redis最高
- 可靠性：zookeeper最高
这里，我们就基于redis实现分布式锁。
解决方案：使用redis实现分布式锁
- 多个客户端同时获取锁（setnx）
- 获取成功，执行业务逻辑{从db获取数据，放入缓存}，执行完成释放锁（del）
- 其他客户端等待重试
编写代码
Redis: set num 0
@GetMapping("testLock")
public void testLock(){
//1获取锁，setne
Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", "111");
//2获取锁成功、查询num的值
if(lock){
Object value = redisTemplate.opsForValue().get("num");
//2.1判断num为空return
if(StringUtils.isEmpty(value)){
return;
}
//2.2有值就转成成int
int num = Integer.parseInt(value+"");
//2.3把redis的num加1
redisTemplate.opsForValue().set("num", ++num);
//2.4释放锁，del
redisTemplate.delete("lock");
}else{
//3获取锁失败、每隔0.1秒再获取
try {
Thread.sleep(100);
testLock();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
重启，服务集群，通过网关压力测试：
查看redis中num的值：
优化之设置锁的过期时间
设置过期时间有两种方式：
- 首先想到通过expire设置过期时间（缺乏原子性：如果在setnx和expire之间出现异常，锁也无法释放）
- 在set时指定过期时间（推荐）
设置过期时间：
优化之UUID防误删
优化之LUA脚本保证删除的原子性
@GetMapping("testLockLua")
public void testLockLua() {
//1 声明一个uuid ,将做为一个value 放入我们的key所对应的值中
String uuid = UUID.randomUUID().toString();
//2 定义一个锁：lua 脚本可以使用同一把锁，来实现删除！
String skuId = "25"; // 访问skuId 为25号的商品 100008348542
String locKey = "lock:" + skuId; // 锁住的是每个商品的数据
// 3 获取锁
Boolean lock = redisTemplate.opsForValue().setIfAbsent(locKey, uuid, 3, TimeUnit.SECONDS);
// 第一种： lock 与过期时间中间不写任何的代码。
// redisTemplate.expire("lock",10, TimeUnit.SECONDS);//设置过期时间
// 如果true
if (lock) {
// 执行的业务逻辑开始
// 获取缓存中的num 数据
Object value = redisTemplate.opsForValue().get("num");
// 如果是空直接返回
if (StringUtils.isEmpty(value)) {
return;
}
// 不是空 如果说在这出现了异常！ 那么delete 就删除失败！ 也就是说锁永远存在！
int num = Integer.parseInt(value + "");
// 使num 每次+1 放入缓存
redisTemplate.opsForValue().set("num", String.valueOf(++num));
/*使用lua脚本来锁*/
// 定义lua 脚本
String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
// 使用redis执行lua执行
DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
redisScript.setScriptText(script);
// 设置一下返回值类型 为Long
// 因为删除判断的时候，返回的0,给其封装为数据类型。如果不封装那么默认返回String 类型，
// 那么返回字符串与0 会有发生错误。
redisScript.setResultType(Long.class);
// 第一个要是script 脚本 ，第二个需要判断的key，第三个就是key所对应的值。
redisTemplate.execute(redisScript, Arrays.asList(locKey), uuid);
} else {
// 其他线程等待
try {
// 睡眠
Thread.sleep(1000);
// 睡醒了之后，调用方法。
testLockLua();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
Lua 脚本详解：
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZmJjrdGW-1653533279183)(Redis 6.assets/image-20220526104427501.png)]](https://i-blog.csdnimg.cn/blog_migrate/ca8de11cac9c1ed8dc7970e22476f2c8.png)
总结
-
加锁
// 1. 从redis中获取锁,set k1 v1 px 20000 nx String uuid = UUID.randomUUID().toString(); Boolean lock = this.redisTemplate.opsForValue() .setIfAbsent("lock", uuid, 2, TimeUnit.SECONDS); -
使用lua释放锁
// 2. 释放锁 del String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end"; // 设置lua脚本返回的数据类型 DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>(); // 设置lua脚本返回类型为Long redisScript.setResultType(Long.class); redisScript.setScriptText(script); redisTemplate.execute(redisScript, Arrays.asList("lock"),uuid); -
重试
Thread.sleep(500); testLock();为了确保分布式锁可用，我们至少要确保锁的实现同时满足以下四个条件：
- 互斥性。在任意时刻，只有一个客户端能持有锁。
- 不会发生死锁。即使有一个客户端在持有锁的期间崩溃而没有主动解锁，也能保证后续其他客户端能加锁。
- 解铃还须系铃人。加锁和解锁必须是同一个客户端，客户端自己不能把别人加的锁给解了。
- 加锁和解锁必须具有原子性。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
