Redis笔记

最新推荐文章于 2024-07-27 13:31:57 发布

北航_Curry

最新推荐文章于 2024-07-27 13:31:57 发布

阅读量1.2k

点赞数

分类专栏： javaEE框架文章标签： java redis

本文链接：https://blog.csdn.net/qq_40643699/article/details/121362802

版权

javaEE框架专栏收录该内容

18 篇文章 2 订阅

订阅专栏

一、数据库发展概述

1、单机Mysql时代

90年代,一个网站的访问量一般不会太大，单个数据库完全够用。随着用户增多，网站出现以下问题

数据量增加到一定程度，单机数据库就放不下了
数据的索引（B+ Tree）,一个机器内存也存放不下
访问量变大后（读写混合），一台服务器承受不住。

2、Memcached(缓存) + Mysql + 垂直拆分（读写分离）

网站80%的情况都是在读，每次都要去查询数据库的话就十分的麻烦！所以说我们希望减轻数据库的压力，我们可以使用缓存来保证效率！

优化过程经历了以下几个过程：

1、优化数据库的数据结构和索引(难度大)

2、文件缓存，通过IO流获取比每次都访问数据库效率略高，但是流量爆炸式增长时候，IO流也承受不了

3、MemCache,当时最热门的技术，通过在数据库和数据库访问层之间加上一层缓存，第一次访问时查询数据库，将结果保存到缓存，后续的查询先检查缓存，若有直接拿去使用，效率显著提升。

3、分库分表 + 水平拆分 + Mysql集群

在这里插入图片描述

4、如今最近的年代

如今信息量井喷式增长，各种各样的数据出现（用户定位数据，图片数据等），大数据的背景下关系型数据库（RDBMS）无法满足大量数据要求。Nosql数据库就能轻松解决这些问题。

目前一个基本的互联网项目

在这里插入图片描述

为什么要用NoSQL ？

用户的个人信息，社交网络，地理位置。用户自己产生的数据，用户日志等等爆发式增长！
这时候我们就需要使用NoSQL数据库的，Nosql可以很好的处理以上的情况！

二、什么是NoSQL

NoSQL = Not Only SQL（不仅仅是SQL）Not Only Structured Query Language

关系型数据库：列+行，同一个表下数据的结构是一样的。

非关系型数据库：数据存储没有固定的格式，并且可以进行横向扩展（因为很多信息的存储不需要一个固定的格式）。

NoSQL泛指非关系型数据库，随着web2.0互联网的诞生，传统的关系型数据库很难对付web2.0时代！尤其是超大规模的高并发的社区，暴露出来很多难以克服的问题，NoSQL在当今大数据环境下发展的十分迅速，Redis是发展最快的。

NoSQL的特点

方便扩展（数据之间没有关系，很好扩展！）
大数据量高性能（Redis一秒可以写8万次，读11万次，NoSQL的缓存记录级，是一种细粒度的缓存，性能会比较高！）
数据类型是多样型的！（不需要事先设计数据库，随取随用）

传统的关系型数据库和非关系型数据库NoSQL的区别

传统的 RDBMS(关系型数据库)
- 结构化组织（行、列）
- SQL
- 数据和关系都存在单独的表中 row col
- 操作，数据定义语言
- 严格的一致性
- 基础的事务
- ...

Nosql
- 不仅仅是数据
- 没有固定的查询语言
- 键值对存储，列存储，文档存储，图形数据库（社交关系）
- 最终一致性
- CAP定理和BASE
- 高性能，高可用，高扩展
- ...

3v + 3高

大数据时代的3V ：主要是描述问题的

海量Velume
多样Variety
实时Velocity

大数据时代的3高：主要是对程序的要求

高并发
高可扩
高性能

真正在公司中的实践：NoSQL + RDBMS（关系型数据库）一起使用才是最强的。

Nosql的四大分类

1、KV键值对

美团：Redis + Tair
新浪：Redis
阿里、百度：Redis + Memcache

2、文档型数据库（bson数据格式）

MongoDB(掌握)：基于分布式文件存储的数据库。C++编写，用于处理大量文档。MongoDB是RDBMS和NoSQL的中间产品。MongoDB是非关系型数据库中功能最丰富的，NoSQL中最像关系型数据库的数据库。

3、列存储数据库

4、图关系数据库

三、Redis概述

中文官网：https://redis.cn/

Redis是什么？

Redis（Remote Dictionary Server )，即远程字典服务。

是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。

与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。

Redis能该干什么？

内存存储、持久化，内存是断电即失的，所以需要持久化（RDB、AOF）
高效率、用于高速缓冲
发布订阅系统
地图信息分析
计时器、计数器(eg：浏览量)
......

Redis特性

多样的数据类型

持久化

集群

事务

四、使用redis

windows（不建议用windows开发）

windows版本

开启redis-server.exe（服务器）
启动redis-cli.exe（客户端）

linux

1、使用Xftp，把Redis的压缩包移到阿里云的/home/han_home下，这个目录是放下载各种环境的压缩包

2、把压缩包再移动到/opt目录，解压

[root@iZ2zeehdhym7ngf0fl3lpzZ home]# cd han_home
[root@iZ2zeehdhym7ngf0fl3lpzZ han_home]# ls
redis-6.0.6.tar.gz
[root@iZ2zeehdhym7ngf0fl3lpzZ han_home]# mv redis-6.0.6.tar.gz /opt 
[root@iZ2zeehdhym7ngf0fl3lpzZ han_home]# cd /opt
[root@iZ2zeehdhym7ngf0fl3lpzZ opt]# ls
redis-6.0.6.tar.gz
[root@iZ2zeehdhym7ngf0fl3lpzZ opt]# tar -zxvf redis-6.0.6.tar.gz

解压完成后：

[root@iZ2zeehdhym7ngf0fl3lpzZ opt]# ls
redis-6.0.6  redis-6.0.6.tar.gz

3、进入解压后的redis-6.0.6文件，安装redis

再依次执行以下几个命令：(执行make报错可以去狂神评论下找)

[root@iZ2zeehdhym7ngf0fl3lpzZ redis-6.0.6]# yum install gcc-c++
[root@iZ2zeehdhym7ngf0fl3lpzZ redis-6.0.6]# make

这时候，redis已经安装完成了！

这里默认把redis安装到/usr/local/bin目录里：（redis-cli和redis-server）

4、将redis配置文件copy到当前目录下

[root@iZ2zeehdhym7ngf0fl3lpzZ /]# cd /usr/local/bin
[root@iZ2zeehdhym7ngf0fl3lpzZ bin]# ls
chardetect  cloud-init      easy_install      easy_install-3.8  jsondiff   jsonpointer  redis-benchmark  redis-check-rdb  redis-sentinel
cloud-id    cloud-init-per  easy_install-3.6  han_redis_config  jsonpatch  jsonschema   redis-check-aof  redis-cli        redis-server
[root@iZ2zeehdhym7ngf0fl3lpzZ bin]# cp /opt/redis-6.0.6/redis.conf han_redis_config
[root@iZ2zeehdhym7ngf0fl3lpzZ bin]# cd han_redis_config
[root@iZ2zeehdhym7ngf0fl3lpzZ han_redis_config]# ls
redis.conf

之后我们就使用这个配置文件进行启动redis（保证了原来的配置文件不被修改）

5、修改redis配置

redis默认不是后台启动的，修改redis配置文件，让其后台启动

[root@iZ2zeehdhym7ngf0fl3lpzZ han_redis_config]# vim redis.conf
# 进入这个配置文件

可以搜一下vim怎么修改、保存退出等等指令

将这里原来的no改为yes

6、启动redis

通过指定的配置文件启动redis-server，通过指定端口号启动redis-cli

显示pong就表示成功！！

7、说明

在这个下面就可以写redis 的命令了

同时，我们双击上面这个标签，就可以重新开启一个新的窗口编写linux命令

8、查看进程是否有redis-server和redis-cli

9、如何退出redis

五、测试redis性能

redis-benchmark：Redis官方提供的性能测试工具，参数选项如下：

简单测试：

# 测试：100个并发连接 100000请求
redis-benchmark -h localhost -p 6379 -c 100 -n 100000

六、基础知识

redis默认有16个数据库，我们默认使用的是第一个（下图来自redis.conf）

16个数据库为：DB 0~DB 15

默认使用DB 0 ，可以使用select n切换到DB n
选择使用第二个数据库
dbsize可以查看当前数据库的大小，与key数量相关。

get、set、查看所有的key、清空当前数据库

set key value 插入键值对
get key 获取value
keys * 查看数据库所有的key

flushdb 清空当前数据库
flushall 清空0-15全部数据库

Redis是单线程的，Redis是基于内存操作的

所以Redis的性能瓶颈不是CPU,而是机器内存和网络带宽。

那么为什么Redis的速度如此快呢，性能这么高呢？QPS达到10W+

Redis为什么单线程还这么快？

误区1：高性能的服务器一定是多线程的？
误区2：多线程（CPU上下文会切换！）一定比单线程效率高！

核心：

Redis是将所有的数据放在内存中的，所以说使用单线程去操作效率就是最高的，多线程（CPU上下文会切换：耗时的操作！），对于内存系统来说，如果没有上下文切换效率就是最高的，多次读写都是在一个CPU上的，在内存存储数据情况下，单线程就是最佳的方案。

七、redis五大数据类型

Redis是一个开源（BSD许可），内存存储的数据结构服务器，可用作数据库，高速缓存和消息队列代理。它支持字符串、哈希表、列表、集合、有序集合，位图，hyperloglogs等数据类型。内置复制、Lua脚本、LRU收回、事务以及不同级别磁盘持久化功能，同时通过Redis Sentinel提供高可用，通过Redis Cluster提供自动分区。

redis命令学习：https://www.redis.net.cn/order/

Redis-key基本命令：

在redis中无论什么数据类型，在数据库中都是以key-value形式保存，通过进行对Redis-key的操作，来完成对数据库中数据的操作。

下面学习的命令：

exists key：判断键是否存在
del key：删除键值对
move key db：将键值对移动到指定数据库
expire key second：设置键值对的过期时间
type key：查看value的数据类型

127.0.0.1:6379> keys * # 查看当前数据库所有key
(empty list or set)
127.0.0.1:6379> set name qinjiang # set key
OK
127.0.0.1:6379> set age 20
OK
127.0.0.1:6379> keys *
1) "age"
2) "name"
127.0.0.1:6379> move age 1 # 将键值对移动到指定数据库
(integer) 1
127.0.0.1:6379> EXISTS age # 判断键是否存在
(integer) 0 # 不存在
127.0.0.1:6379> EXISTS name
(integer) 1 # 存在
127.0.0.1:6379> SELECT 1
OK
127.0.0.1:6379[1]> keys *
1) "age"
127.0.0.1:6379[1]> del age # 删除键值对
(integer) 1 # 删除个数


127.0.0.1:6379> set age 20
OK
127.0.0.1:6379> EXPIRE age 15 # 设置键值对的过期时间

(integer) 1 # 设置成功 开始计数
127.0.0.1:6379> ttl age # 查看key的过期剩余时间
(integer) 13
127.0.0.1:6379> ttl age
(integer) 11
127.0.0.1:6379> ttl age
(integer) 9
127.0.0.1:6379> ttl age
(integer) -2 # -2 表示key过期，-1表示key未设置过期时间

127.0.0.1:6379> get age # 过期的key 会被自动delete
(nil)
127.0.0.1:6379> keys *
1) "name"

127.0.0.1:6379> type name # 查看value的数据类型
string

string类型：

############################################################
127 .0.0.1:6379> set name lisen  # 设置值
127 .0.0.1:6379> get lisen # 获得值
127 .0.0.1:6379> keys * # 获得所有的key
127 .0.0.1:6379> EXISTS lisen  # 判断某一个key是否存在
(integer) 1
#追加字符串，如果当前key不存在，就相当于setkey
127 .0.0.1:6379> APPEND lisen "hehe"  # 9就是name的值的长度
(integer) 9
127 .0.0.1:6379> get lisen
"lisenhehe"
127 .0.0.1:6379> STRLEN key1  # 获取字符串的长度！
(integer) 9
############################################################
# i++
# 步长 i+=
127 .0.0.1:6379> set views 0 # 初始浏览量为 0
OK
127 .0.0.1:6379> get views
"0"
127 .0.0.1:6379> incr views  # 自增 1 浏览量变为 1
(integer) 1
127 .0.0.1:6379> incr views
(integer) 2
127 .0.0.1:6379> get viewsg
"2"
127 .0.0.1:6379> decr views  # 自减 1 浏览量-1
(integer) 1
127 .0.0.1:6379> decr views
(integer) 0
127 .0.0.1:6379> decr views
(integer) -1
127 .0.0.1:6379> get views
"-1"
127 .0.0.1:6379> INCRBY views 10 # 可以设置步长，指定增量！
(integer) 9
127 .0.0.1:6379> INCRBY views 10
(integer) 19
127 .0.0.1:6379> DECRBY views 5
(integer) 14
############################################################

127.0.0.1:6379[13]> set key1 hello,lisen # 设置 key1 的值
OK
127.0.0.1:6379[13]> GETRANGE key1 0 3  # 截取字符串 [0,3]
"hell"
127.0.0.1:6379[13]> GETRANGE key1 0 -1 # 获取全部的字符串 和 get key是一样的
"hello,lisen"
# 127.0.0.1:6379[13]> SETRANGE key1 1 xx #替换指定位置开始的字符串！写多少长度的就换多少长度的
127.0.0.1:6379[13]> SETRANGE key1 0 l
(integer) 11
127.0.0.1:6379[13]> get key1
"lello,lisen"
127.0.0.1:6379[13]> SETRANGE key1 0 lllllll
(integer) 11
127.0.0.1:6379[13]> get key1
"lllllllisen"

List类型：

---------------------------LPUSH---RPUSH---LRANGE--------------------------------

127.0.0.1:6379> LPUSH mylist k1 # LPUSH mylist=>{1}
(integer) 1
127.0.0.1:6379> LPUSH mylist k2 # LPUSH mylist=>{2,1}
(integer) 2
127.0.0.1:6379> RPUSH mylist k3 # RPUSH mylist=>{2,1,3}
(integer) 3
127.0.0.1:6379> get mylist # 普通的get是无法获取list值的
(error) WRONGTYPE Operation against a key holding the wrong kind of value
127.0.0.1:6379> LRANGE mylist 0 4 # LRANGE 获取起止位置范围内的元素
1) "k2"
2) "k1"
3) "k3"
127.0.0.1:6379> LRANGE mylist 0 2
1) "k2"
2) "k1"
3) "k3"
127.0.0.1:6379> LRANGE mylist 0 1
1) "k2"
2) "k1"
127.0.0.1:6379> LRANGE mylist 0 -1 # 获取全部元素
1) "k2"
2) "k1"
3) "k3"

---------------------------LPUSHX---RPUSHX-----------------------------------

127.0.0.1:6379> LPUSHX list v1 # list不存在 LPUSHX失败
(integer) 0
127.0.0.1:6379> LPUSHX list v1 v2  
(integer) 0
127.0.0.1:6379> LPUSHX mylist k4 k5 # 向mylist中 左边 PUSH k4 k5
(integer) 5
127.0.0.1:6379> LRANGE mylist 0 -1
1) "k5"
2) "k4"
3) "k2"
4) "k1"
5) "k3"

---------------------------LINSERT--LLEN--LINDEX--LSET----------------------------

127.0.0.1:6379> LINSERT mylist after k2 ins_key1 # 在k2元素后 插入ins_key1
(integer) 6
127.0.0.1:6379> LRANGE mylist 0 -1
1) "k5"
2) "k4"
3) "k2"
4) "ins_key1"
5) "k1"
6) "k3"
127.0.0.1:6379> LLEN mylist # 查看mylist的长度
(integer) 6
127.0.0.1:6379> LINDEX mylist 3 # 获取下标为3的元素
"ins_key1"
127.0.0.1:6379> LINDEX mylist 0
"k5"
127.0.0.1:6379> LSET mylist 3 k6 # 将下标3的元素 set值为k6
OK
127.0.0.1:6379> LRANGE mylist 0 -1
1) "k5"
2) "k4"
3) "k2"
4) "k6"
5) "k1"
6) "k3"

---------------------------LPOP--RPOP--------------------------

127.0.0.1:6379> LPOP mylist # 左侧(头部)弹出
"k5"
127.0.0.1:6379> RPOP mylist # 右侧(尾部)弹出
"k3"

---------------------------RPOPLPUSH--------------------------

127.0.0.1:6379> LRANGE mylist 0 -1
1) "k4"
2) "k2"
3) "k6"
4) "k1"
127.0.0.1:6379> RPOPLPUSH mylist newlist # 将mylist的最后一个值(k1)弹出，加入到newlist的头部
"k1"
127.0.0.1:6379> LRANGE newlist 0 -1
1) "k1"
127.0.0.1:6379> LRANGE mylist 0 -1
1) "k4"
2) "k2"
3) "k6"

---------------------------LTRIM--------------------------

127.0.0.1:6379> LTRIM mylist 0 1 # 截取mylist中的 0~1部分
OK
127.0.0.1:6379> LRANGE mylist 0 -1
1) "k4"
2) "k2"

# 初始 mylist: k2,k2,k2,k2,k2,k2,k4,k2,k2,k2,k2
---------------------------LREM--------------------------

127.0.0.1:6379> LREM mylist 3 k2 # 从头部开始搜索 至多删除3个 k2
(integer) 3
# 删除后：mylist: k2,k2,k2,k4,k2,k2,k2,k2

127.0.0.1:6379> LREM mylist -2 k2 #从尾部开始搜索 至多删除2个 k2
(integer) 2
# 删除后：mylist: k2,k2,k2,k4,k2,k2


---------------------------BLPOP--BRPOP--------------------------

mylist: k2,k2,k2,k4,k2,k2
newlist: k1

127.0.0.1:6379> BLPOP newlist mylist 30 # 从newlist中弹出第一个值，mylist作为候选
1) "newlist" # 弹出
2) "k1"
127.0.0.1:6379> BLPOP newlist mylist 30
1) "mylist" # 由于newlist空了 从mylist中弹出
2) "k2"
127.0.0.1:6379> BLPOP newlist 30
(30.10s) # 超时了

127.0.0.1:6379> BLPOP newlist 30 # 我们连接另一个客户端向newlist中push了test, 阻塞被解决。
1) "newlist"
2) "test"
(12.54s)

小结：

list的 left, right 都可以插入值

如果key不存在，则创建新的链表
如果key存在，新增内容
如果移除了所有值，空链表，也代表不存在
在两边插入或者改动值，效率最高！修改中间元素，效率相对较低

应用：

消息排队！消息队列（Lpush Rpop）,栈（Lpush Lpop）

set类型：

Redis的Set是string类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据。

Redis 中集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。

集合中最大的成员数为 2^32 - 1 (4294967295, 每个集合可存储40多亿个成员)。

---------------SADD--SCARD--SMEMBERS--SISMEMBER--------------------

127.0.0.1:6379> SADD myset m1 m2 m3 m4 # 向myset中增加成员 m1~m4
(integer) 4
127.0.0.1:6379> SCARD myset # 获取集合的成员数目
(integer) 4
127.0.0.1:6379> smembers myset # 获取集合中所有成员
1) "m4"
2) "m3"
3) "m2"
4) "m1"
127.0.0.1:6379> SISMEMBER myset m5 # 查询m5是否是myset的成员
(integer) 0 # 不是，返回0
127.0.0.1:6379> SISMEMBER myset m2
(integer) 1 # 是，返回1
127.0.0.1:6379> SISMEMBER myset m3
(integer) 1

---------------------SRANDMEMBER--SPOP----------------------------------

127.0.0.1:6379> SRANDMEMBER myset 3 # 随机返回3个成员
1) "m2"
2) "m3"
3) "m4"
127.0.0.1:6379> SRANDMEMBER myset # 随机返回1个成员
"m3"
127.0.0.1:6379> SPOP myset 2 # 随机移除并返回2个成员
1) "m1"
2) "m4"
# 将set还原到{m1,m2,m3,m4}

---------------------SMOVE--SREM----------------------------------------

127.0.0.1:6379> SMOVE myset newset m3 # 将myset中m3成员移动到newset集合
(integer) 1
127.0.0.1:6379> SMEMBERS myset
1) "m4"
2) "m2"
3) "m1"
127.0.0.1:6379> SMEMBERS newset
1) "m3"
127.0.0.1:6379> SREM newset m3 # 从newset中移除m3元素
(integer) 1
127.0.0.1:6379> SMEMBERS newset
(empty list or set)

# 下面开始是多集合操作,多集合操作中若只有一个参数默认和自身进行运算
# setx=>{m1,m2,m4,m6}, sety=>{m2,m5,m6}, setz=>{m1,m3,m6}

-----------------------------SDIFF------------------------------------

127.0.0.1:6379> SDIFF setx sety setz # 等价于setx-sety-setz
1) "m4"
127.0.0.1:6379> SDIFF setx sety # setx - sety
1) "m4"
2) "m1"
127.0.0.1:6379> SDIFF sety setx # sety - setx
1) "m5"


-------------------------SINTER---------------------------------------
# 共同关注（交集）

127.0.0.1:6379> SINTER setx sety setz # 求 setx、sety、setx的交集
1) "m6"
127.0.0.1:6379> SINTER setx sety # 求setx sety的交集
1) "m2"
2) "m6"

-------------------------SUNION---------------------------------------

127.0.0.1:6379> SUNION setx sety setz # setx sety setz的并集
1) "m4"
2) "m6"
3) "m3"
4) "m2"
5) "m1"
6) "m5"
127.0.0.1:6379> SUNION setx sety # setx sety 并集
1) "m4"
2) "m6"
3) "m2"
4) "m1"
5) "m5"

Hash（哈希）

Redis hash ,可以看成Map集合，是一个string类型的field和value的映射表，hash特别适合用于存储对象。

Set就是一种简化的Hash,只变动key,而value使用默认值填充。可以将一个Hash表作为一个对象进行存储，表中存放对象的信息。

------------------------HSET--HMSET--HSETNX----------------
127.0.0.1:6379> HSET studentx name sakura # 将studentx哈希表作为一个对象，设置name为sakura
(integer) 1
127.0.0.1:6379> HSET studentx name gyc # 重复设置field进行覆盖，并返回0
(integer) 0
127.0.0.1:6379> HSET studentx age 20 # 设置studentx的age为20
(integer) 1
127.0.0.1:6379> HMSET studentx sex 1 tel 15623667886 # 设置sex为1，tel为15623667886
OK
127.0.0.1:6379> HSETNX studentx name gyc # HSETNX 设置已存在的field
(integer) 0 # 失败
127.0.0.1:6379> HSETNX studentx email 12345@qq.com
(integer) 1 # 成功

----------------------HEXISTS--------------------------------
127.0.0.1:6379> HEXISTS studentx name # name字段在studentx中是否存在
(integer) 1 # 存在
127.0.0.1:6379> HEXISTS studentx addr
(integer) 0 # 不存在

-------------------HGET--HMGET--HGETALL-----------
127.0.0.1:6379> HGET studentx name # 获取studentx中name字段的value
"gyc"
127.0.0.1:6379> HMGET studentx name age tel # 获取studentx中name、age、tel字段的value
1) "gyc"
2) "20"
3) "15623667886"
127.0.0.1:6379> HGETALL studentx # 获取studentx中所有的field及其value
 1) "name"
 2) "gyc"
 3) "age"
 4) "20"
 5) "sex"
 6) "1"
 7) "tel"
 8) "15623667886"
 9) "email"
10) "12345@qq.com"


--------------------HKEYS--HLEN--HVALS--------------
127.0.0.1:6379> HKEYS studentx # 查看studentx中所有的field
1) "name"
2) "age"
3) "sex"
4) "tel"
5) "email"
127.0.0.1:6379> HLEN studentx # 查看studentx中的字段数量
(integer) 5
127.0.0.1:6379> HVALS studentx # 查看studentx中所有的value
1) "gyc"
2) "20"
3) "1"
4) "15623667886"
5) "12345@qq.com"

-------------------------HDEL--------------------------
127.0.0.1:6379> HDEL studentx sex tel # 删除studentx 中的sex、tel字段
(integer) 2
127.0.0.1:6379> HKEYS studentx
1) "name"
2) "age"
3) "email"

-------------HINCRBY--HINCRBYFLOAT------------------------
127.0.0.1:6379> HINCRBY studentx age 1 # studentx的age字段数值+1
(integer) 21
127.0.0.1:6379> HINCRBY studentx name 1 # 非整数字型字段不可用
(error) ERR hash value is not an integer
127.0.0.1:6379> HINCRBYFLOAT studentx weight 0.6 # weight字段增加0.6
"90.8"

Zset（有序集合）

八、三种特殊数据类型

Geospatial(地理位置)

Hyperloglog(基数统计)

BitMaps(位图)

九、事务

Redis的单条命令是保证原子性的，但是redis事务不能保证原子性

Redis事务本质：一组命令的集合。

----------------- 队列 set set set 执行 -------------------

事务中每条命令都会被序列化，执行过程中按顺序执行，不允许其他命令进行干扰。

一次性
顺序性
排他性
Redis事务没有隔离级别的概念
Redis单条命令是保证原子性的，但是事务不保证原子性！

Redis事务操作过程：

开启事务（multi）
命令入队
执行事务（exec）

redis里的事务有点像批处理，先“multi”开启事务，再依次把命令入队列，最后“exec”时依次一次性执行结束事务

放弃事务-discard：

127.0.0.1:6379> multi
OK
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> DISCARD # 放弃事务
OK
127.0.0.1:6379> EXEC 
(error) ERR EXEC without MULTI # 当前未开启事务
127.0.0.1:6379> get k1 # 被放弃事务中命令并未执行
(nil)

事务出现错误时：

1、代码语法错误（编译时异常）所有的命令都不执行

127.0.0.1:6379> multi
OK
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> error k1 # 这是一条语法错误命令
(error) ERR unknown command `error`, with args beginning with: `k1`, # 会报错但是不影响后续命令入队 
127.0.0.1:6379> get k2
QUEUED
127.0.0.1:6379> EXEC
(error) EXECABORT Transaction discarded because of previous errors. # 执行报错
127.0.0.1:6379> get k1 
(nil) # 其他命令并没有被执行

2、代码逻辑错误 (运行时异常) **其他命令可以正常执行 ** >>> 所以不保证事务原子性

127.0.0.1:6379> multi
OK
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> INCR k1 # 这条命令逻辑错误（对字符串进行增量）
QUEUED
127.0.0.1:6379> get k2
QUEUED
127.0.0.1:6379> exec
1) OK
2) OK
3) (error) ERR value is not an integer or out of range # 运行时报错
4) "v2" # 其他命令正常执行

# 虽然中间有一条命令报错了，但是后面的指令依旧正常执行成功了。
# 所以说Redis单条指令保证原子性，但是Redis事务不能保证原子性。

十、redis实现乐观锁

乐观锁：

很乐观，认为什么时候都不会出现问题，所以不会上锁！更新数据的时候去判断一下，在此期间是否有人修改过这个数据
获取version
更新的时候比较version

1.初始值

127.0.0.1:6379> set money 100 # 设置余额:100
OK
127.0.0.1:6379> set use 0 # 支出使用:0
OK

2. 线程1

watch 给 money上锁（监控money）

127.0.0.1:6379> watch money # money上锁
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> DECRBY money 20
QUEUED
127.0.0.1:6379> INCRBY use 20
QUEUED
127.0.0.1:6379> 	# 此时事务还没有执行

3.此时开启另外一个会话窗口（模拟第二个线程）

127.0.0.1:6379> INCRBY money 500 # 修改了线程一中监视的money
(integer) 600

4.回到线程1的会话窗口

127.0.0.1:6379> EXEC # 执行之前，另一个线程修改了我们的值，这个时候就会导致事务执行失败
(nil) # 没有结果，说明事务执行失败

127.0.0.1:6379> get money # 线程2 修改生效
"600"
127.0.0.1:6379> get use # 线程1事务执行失败，数值没有被修改
"0"

注意：每次提交执行exec后都会自动释放锁，不管是否成功
unwatch进行解锁。

watch相当于上锁，通过这种方式使得redis实现乐观锁 ！！！！

Jedis

什么是Jedis？

Jedis是 Redis 官方推荐的 java连接开发工具！ 使用Java 操作Redis 中间件！如果你要使用java操作redis，那么一定要对Jedis 十分的熟悉！

1、新建maven项目（com.han.redis），导入Jedis和fsatJson依赖

2、连接本地redis

首先要保证本地的redis-server和redis-cli开启！

这里就不测试连接阿里云上的redis了。

使用Jedis类的对象连接（从Jedis源码看出，有一个通过主机host和端口号连接的构造器）
redis的所有指令都在Jedis类源码的方法里

ping pong！连接成功！！

用Jedis演示redis事务

十一、SpringBoot整合redis

workspace/redis_springboot

1、新建springboot项目,记着把NoSQL中的Redis选上

springboot 2.x后，原来使用的 Jedis 被 lettuce 替换。

jedis：采用的直连，多个线程操作的话，是不安全的。如果要避免不安全，使用jedis pool连接池！更像BIO模式

lettuce：采用netty，实例可以在多个线程中共享，不存在线程不安全的情况！可以减少线程数据了，更像NIO模式

2、配置redis

我们在学习SpringBoot自动配置的原理时，整合一个组件并进行配置一定会有一个自动配置类xxxAutoConfiguration,并且在spring.factories中也一定能找到这个类的完全限定名。Redis也不例外。

那么就一定还存在一个RedisProperties类

之前我们说SpringBoot2.x后默认使用Lettuce来替换Jedis，现在我们就能来验证了。

先看Jedis:

@ConditionalOnClass注解中有两个类是默认不存在的，所以Jedis是无法生效的

然后再看Lettuce：

现在我们回到RedisAutoConfiguratio

只有两个简单的Bean

RedisTemplate
StringRedisTemplate

当看到xxTemplate时可以对比RestTemplat、SqlSessionTemplate,通过使用这些Template来间接操作组件。那么这俩也不会例外。分别用于操作Redis和Redis中的String数据类型。

在RedisTemplate上也有一个条件注解，说明我们是可以对其进行定制化的

说完这些，我们需要知道如何编写配置文件然后连接Redis，就需要阅读RedisProperties

还有一些连接池相关的配置。注意使用时一定使用Lettuce的连接池。

3、使用redis

可以看出，redisTemplate下面有操作不同redis类型数据的方法，每一个下面都有操作对应的数据类型的redis指令
（其中opsForValue()是操作String类型的）

@SpringBootTest
class Redis02SpringbootApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {

        // redisTemplate 操作不同的数据类型，api和我们的指令是一样的
        // opsForValue 操作字符串 类似String
        // opsForList 操作List 类似List
        // opsForHah

        // 除了基本的操作，我们常用的方法都可以直接通过redisTemplate操作，比如事务和基本的CRUD

        // 获取连接对象
        //RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
        //connection.flushDb();
        //connection.flushAll();

        redisTemplate.opsForValue().set("mykey","kuangshen");
        System.out.println(redisTemplate.opsForValue().get("mykey"));
    }
}

@SpringBootTest
class RedisSpringbootApplicationTests {
	@Autowired
	private RedisTemplate redisTemplate;

	@Test
	void contextLoads() throws JsonProcessingException {
		User user = new User("han", 23);
		String jsonUser = new ObjectMapper().writeValueAsString(user);//将user变成json字符串
		redisTemplate.opsForValue().set("user1", jsonUser);//不能将user对象直接传入
		System.out.println(redisTemplate.opsForValue().get("user1"));
	}
}

控制台输出：{"name":"han","age":23}

参考这个链接： ObjectMapper详解

十二、redis持久化

面试和工作，持久化都是重点！
Redis 是内存数据库，如果不将内存中的数据库状态保存到磁盘，那么一旦服务器进程退出，服务器中的数据库状态也会消失。所以 Redis 提供了持久化功能！

1、RDB（Redis Data Base）这是redis默认的持久化方式

在指定的时间间隔内将内存中的数据集快照写入磁盘，也就是行话讲的Snapshot快照，它恢复时是将快照文件直接读到内存里。

Redis会单独创建（fork）一个子进程来进行持久化，会先将数据写入到一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化好的文件。整个过程中，主进程是不进行任何IO操作的。这就确保了极高的性能。如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那RDB方式要比AOF方式更加的高效。RDB的缺点是最后一次持久化后的数据可能丢失。我们默认的就是RDB，一般情况下不需要修改这个配置！

RDB文件是 dump.rdb

2、AOF（append only file）

将我们的所有命令都记录下来，history，恢复的时候就把这个文件全部在执行一遍！

AOF方式默认是不开启的，需要去配置文件配置

以日志的形式来记录每个写操作，将Redis执行过的所有指令记录下来（读操作不记录），只许追加文件但不可以改写文件，redis启动之初会读取该文件重新构建数据，换言之，redis重启的话就根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作

十三、redis发布订阅

Redis 发布订阅(pub/sub)是一种消息通信模式：发送者(pub)发送消息，订阅者(sub)接收消息。

订阅/发布消息图：

下图展示了频道 channel1 ，以及订阅这个频道的三个客户端 —— client2 、 client5 和 client1 之间的关系：

当有新消息通过 PUBLISH 命令发送给频道 channel1 时，这个消息就会被发送给订阅它的三个客户端：

在这里插入图片描述

会话1：

--------------消息发布端-------------------
127.0.0.1:6379> PUBLISH sakura "hello world" # 发布消息到sakura频道
(integer) 1
127.0.0.1:6379> PUBLISH sakura "hello i am sakura" # 发布消息
(integer) 1

-----------------查看活跃的频道------------
127.0.0.1:6379> PUBSUB channels
1) "sakura"

会话2：

------------订阅端----------------------
127.0.0.1:6379> SUBSCRIBE sakura # 订阅sakura频道
Reading messages... (press Ctrl-C to quit) # 等待接收消息
1) "subscribe" # 订阅成功的消息
2) "sakura"
3) (integer) 1
1) "message" # 接收到来自sakura频道的消息 "hello world"
2) "sakura"
3) "hello world"
1) "message" # 接收到来自sakura频道的消息 "hello i am sakura"
2) "sakura"
3) "hello i am sakura"

应用：

消息订阅：公众号订阅，微博关注等等（其实更多是使用消息队列来进行实现）
多人在线聊天室。

稍微复杂的场景，我们就会使用消息中间件MQ处理。

十四、主从复制

主从复制，是指将一台Redis服务器的数据，复制到其他的Redis服务器。前者称为主节点（Master/Leader）,后者称为从节点（Slave/Follower），数据的复制是单向的！只能由主节点复制到从节点（主节点以写为主、从节点以读为主）。

默认情况下，每台Redis服务器都是主节点，一个主节点可以有0个或者多个从节点，但每个从节点只能由一个主节点。

作用：

数据冗余：主从复制实现了数据的热备份，是持久化之外的一种数据冗余的方式。
故障恢复：当主节点故障时，从节点可以暂时替代主节点提供服务，是一种服务冗余的方式
负载均衡：在主从复制的基础上，配合读写分离，由主节点进行写操作，从节点进行读操作，分担服务器的负载；尤其是在读多写少的场景下，通过多个从节点分担负载，提高并发量。
高可用基石：主从复制还是哨兵和集群能够实施的基础。

为什么使用集群

单台服务器难以负载大量的请求
单台服务器故障率高，系统崩坏概率大
单台服务器内存容量有限。

北航_Curry

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Redis笔记

一、数据库发展概述1、单机Mysql时代90年代,一个网站的访问量一般不会太大，单个数据库完全够用。随着用户增多，网站出现以下问题数据量增加到一定程度，单机数据库就放不下了数据的索引（B+ Tree）,一个机器内存也存放不下访问量变大后（读写混合），一台服务器承受不住。2、Memcached(缓存) + Mysql + 垂直拆分（读写分离）网站80%的情况都是在读，每次都要去查询数据库的话就十分的麻烦！所以说我们希望减轻数据库的压力，我们可以使用缓存来保证效率！...
复制链接

扫一扫

专栏目录