redis基础

2021-06-17

">Nosql概述

为什么要用Nosql

单机MySQL的年代

90年代，一个基本的网站访问量一般不会太大，单个数据库完全足够！

那个时候，更多的去使用静态网页 Html ~ 服务器根本没有太大的压力！

思考一下，这种情况下：整个网站的瓶颈是什么？

数据量如果太大，一个机器放不下了！
数据的索引（B+tree），一个机器内存也放不下
访问量（读写混合），一个服务器承受不了~

如果你开始出现以上的三种情况之一，那么你就必须要晋级！

Memcached（缓存）+MySQL+垂直拆分

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

发展过程：优化数据结构和索引–》文件缓存（IO）–》Memcached（当时最热门的技术！）

分库分表+水平拆分+MySQL集群

技术和业务在发展的同时，对人的要求也越来越高！

如今最近的年代

为什么要用NoSQL！

用户的个人信息，社交网络，地理位置。用户自己产生的数据，用户日志等等爆发式增长！

这时候我们就需要使用NoSQL数据库的，NoSQL可以很好的处理以上的情况！

什么是NoSQL

NoSQL = non-relational（非关系型数据库），随着web2.0互联网的诞生！传统的关系型数据库很难对付web2.0时代！尤其是超大规模的高并发的社区！暴露出来很多难以克服的问题，NoSQL在当今大数据环境下发展的十分迅速。Redis是发展最快的，而且是我们当下必须要掌握的一个技术！

NoSQL特点

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

传统的EDBMS和NoSQL

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

NoSQL
- 不仅仅是数据
- 没有固定的查询语言
- 键值对存储，列存储，文档存储，图形数据库（社交关系）
- 最终一致性
- CAP定理和BASE（异地多活）初级架构师！
- 高性能，高可用，高可扩
- ....

了解：3V+3高

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

海量Volume
多样Variety
实时Velocity

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

高并发
高可扩（随时水平拆分）
高性能（保证用户体验和性能）

真实的公司中的时间：NoSQL+RDBMS一起使用才是最强的，阿里巴巴的架构

阿里巴巴演进分析

大型互联网应用问题：

数据类型太多了！
数据源繁多，经常重构！
数据要改造，大面积改造！

解决问题：

UDSL热点缓存设计

NoSQL的四大分类

KV键值对：

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

文档型数据库（bson格式和json一样）：

MongoDB（一般必须要掌握）
- MongoDB是一个基于分布式的文件存储的数据库，C++编写，主要用来处理大量的文档！
- MongoDB是一个介于关系型数据库和非关系型数据库中间的产品！MongoDB是非关系型数据库中功能最丰富，最像关系型数据库的！
ConthDB

列存储数据库

HBase
分布式文件系统

图形关系数据库

它不是存图形，放的是关系，比如：朋友圈社交网络，广告推荐！
Neo4j，Graph

Redis入门

概述

Redis是什么？

Redis（Remote Dictionary Server），即远程字典服务！

是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。免费和开源！是放下最热门的NoSQL技术之一！也被人们称之为结构化数据库！

Redis能干嘛？

内存存储、持久化，内存中是断电即失、所以说持久化很重要（rdb、aof）
效率高，可以用于高速缓存
发布订阅系统
地图信息分析
计时器、计数器（浏览量！）
…

特性

多样的数据类型
持久化
集群
事务

Windows安装

下载安装包
下载完毕得到压缩包
解压到自己电脑上的环境目录下的就可以的！
开启 redis，运行服务即可！

Windows下使用确实简单，但是Redis推荐我们使用Linux去开发使用！

Linux安装

下载安装包！redis-6.2.1.tar.gz
解压Redis的安装包！程序 /opt
进入解压后的文件，可以看到 redis 的配置文件

基本的环境安装

yum install gcc-c++

make

make install #确认

redis 的默认安装路径usr/local/bin
将 redis 配置文件复制到我们当前目录下，可以创建一个配置文件夹如wangconfig
redis 默认不是后台启动的，修改自定义配置redis文件
1
daemonize yes //守护进程模式启动
启动 redis 服务！
1
redis-server wangconfig/redis.conf

使用Redis客户端进行连接

1
2
3

redis-cli -p 6379
#查看所有的key
keys *

查看redis的进程是否开启

[root@touchingwang ~]# ps -ef|grep redis
root     20985     1  0 14:47 ?        00:00:00 redis-server 127.0.0.1:6379
root     21058 15176  0 14:48 pts/0    00:00:00 redis-cli -p 6379
root     21263 21221  0 14:51 pts/1    00:00:00 grep --color=auto redis

如何关闭redis服务呢？

1 2	127.0.0.1:6379> shutdown not connected> exit

再次查看进程是否存在

1 2	[root@touchingwang ~]# ps -ef\|grep redis root 21323 21221 0 14:53 pts/1 00:00:00 grep --color=auto redis

后面我们会使用单机多redis启动集群测试！

测试性能

redis-benchmark是一个压力测试工具！

官方自带的性能测试工具！

我们来简单测试下：

# 测试：100个并发连接	100000请求
redis-benchmark -h localhost -p 6379 -c 100 -n 100000
# -h 远程号
# -p 端口号
# -c 指定并发连接数
# -n 指定请求数

如何查看这些分析呢！

#测试的每一个请求格式都如下
====== MSET (10 keys) ======                                                   
  100000 requests completed in 1.42 seconds	#对我们的10万个请求进行写入测试
  100 parallel clients #100个并发客户端
  3 bytes payload #每次写入3个字节
  keep alive: 1	#只有一台服务器来处理这些请求，单机性能
  host configuration "save": 3600 1 300 100 60 10000
  host configuration "appendonly": no
  multi-thread: no

Latency by percentile distribution:# 按百分比分布的延迟
0.000% <= 0.343 milliseconds (cumulative count 2)
50.000% <= 0.735 milliseconds (cumulative count 51031)
75.000% <= 0.959 milliseconds (cumulative count 75002)
87.500% <= 1.255 milliseconds (cumulative count 87689)
93.750% <= 1.471 milliseconds (cumulative count 93861)
96.875% <= 1.679 milliseconds (cumulative count 96876)
98.438% <= 1.927 milliseconds (cumulative count 98438)
99.219% <= 2.175 milliseconds (cumulative count 99232)
99.609% <= 2.439 milliseconds (cumulative count 99616)
99.805% <= 2.655 milliseconds (cumulative count 99806)
99.902% <= 22.735 milliseconds (cumulative count 99903)
99.951% <= 23.823 milliseconds (cumulative count 99952)
99.976% <= 24.367 milliseconds (cumulative count 99976)
99.988% <= 24.623 milliseconds (cumulative count 99988)
99.994% <= 24.879 milliseconds (cumulative count 99994)
99.997% <= 24.943 milliseconds (cumulative count 99997)
99.998% <= 24.991 milliseconds (cumulative count 99999)
99.999% <= 25.007 milliseconds (cumulative count 100000)
100.000% <= 25.007 milliseconds (cumulative count 100000)
# 所有请求在25.007毫秒内处理完成
Cumulative distribution of latencies: # 延迟的累积分布
0.000% <= 0.103 milliseconds (cumulative count 0)
0.039% <= 0.407 milliseconds (cumulative count 39)
0.375% <= 0.503 milliseconds (cumulative count 375)
2.434% <= 0.607 milliseconds (cumulative count 2434)
40.337% <= 0.703 milliseconds (cumulative count 40337)
64.008% <= 0.807 milliseconds (cumulative count 64008)
72.043% <= 0.903 milliseconds (cumulative count 72043)
77.357% <= 1.007 milliseconds (cumulative count 77357)
82.076% <= 1.103 milliseconds (cumulative count 82076)
86.227% <= 1.207 milliseconds (cumulative count 86227)
89.055% <= 1.303 milliseconds (cumulative count 89055)
91.997% <= 1.407 milliseconds (cumulative count 91997)
94.650% <= 1.503 milliseconds (cumulative count 94650)
96.189% <= 1.607 milliseconds (cumulative count 96189)
97.076% <= 1.703 milliseconds (cumulative count 97076)
97.797% <= 1.807 milliseconds (cumulative count 97797)
98.324% <= 1.903 milliseconds (cumulative count 98324)
98.767% <= 2.007 milliseconds (cumulative count 98767)
99.088% <= 2.103 milliseconds (cumulative count 99088)
99.888% <= 3.103 milliseconds (cumulative count 99888)
99.900% <= 4.103 milliseconds (cumulative count 99900)
99.920% <= 23.103 milliseconds (cumulative count 99920)
99.964% <= 24.111 milliseconds (cumulative count 99964)
100.000% <= 25.103 milliseconds (cumulative count 100000)

Summary:
  throughput summary: 70422.54 requests per second #每秒进行70422.54次请求
  latency summary (msec):
          avg       min       p50       p95       p99       max
        0.892     0.336     0.735     1.519     2.071    25.007

基础的知识

redis 默认有16个数据库，可以在redis.conf中看到databases 16

可以使用 select 进行切换数据库

127.0.0.1:6379> select 3
OK
127.0.0.1:6379[3]> dbsize
(integer) 0
keys * #查看数据库所有的key

清空当前数据库flushdb

清空全部数据库的内容flushall

思考：为什么 redis 是6379？（了解一下即可！）

redis 是单线程的！

明白Redis是很快的，官方表示，Redis是基于内存操作的，CPU不是Redis性能瓶颈，Redis的瓶颈是根据机器的内存和网络带宽，既然可以使用单线程来实现，就使用单线程了！所以就使用了单线程！

Redis 是C 语言写道，官方提供的数据为 100000+ 是QPS，完全不比同样是使用 key-value 的Mamecache差！

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

先去CPU》内存》硬盘的速度要有所了解！

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

五大数据类型

Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。它支持多种类型的数据结构，如字符串（strings），散列（hashes），列表（lists），集合（sets），有序集合（sorted sets）与范围查询， bitmaps， hyperloglogs 和地理空间（geospatial）索引半径查询。 Redis 内置了复制（replication），LUA脚本（Lua scripting）， LRU驱动事件（LRU eviction），事务（transactions）和不同级别的磁盘持久化（persistence），并通过 Redis哨兵（Sentinel）和自动分区（Cluster）提供高可用性（high availability）。

我们现在讲解的命令大家一定要全部记住，后面我们使用SpringBoot。Redis，所有的方法就是这些命令！单点登录

Redis-Key

keys *	#查看所有的key
EXIST name #判断当前的key是否存在
move name 1 #移除当前的key
EXPIRE name 10 #设置key的过期时间，单位是秒
ttl name #查看当前key的剩余时间
type name #查看当前key的类型

后面如果遇到不会的命令，可以去官网查看帮助文档

String（字符串）

90%的Java程序员 redis 只会使用一个String类型！

set key1 v1 #设置值
get key1 #获得值
keys * #获得所有的key
EXISTS key1 #判断某一个key是否存在
APPEND key1 #追加字符串，如果当前key不存在，就相当于setkey
get key1
STRING key1	#获取字符串的长度
####################################################
#步长 i++
127.0.0.1:6379> set views 0 #初始浏览量为0
OK
127.0.0.1:6379> incr views #自增1
(integer) 1
127.0.0.1:6379> incr views
(integer) 2
127.0.0.1:6379> get views
"2"
127.0.0.1:6379> decr views #自减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
#####################################################
#字符串范围 range
127.0.0.1:6379> GETRANGE key1 0 4 #截取字符串[0-3]
"v1sss"
127.0.0.1:6379> GETRANGE key1 0 -1 #获取全部的字符串和get key一样
"v1ssshelloworld"
#####################################################
127.0.0.1:6379> set key2 abcdefg
OK
127.0.0.1:6379> SETRANGE key2 1 xx #替换指定位置开始的字符串！
(integer) 7
127.0.0.1:6379> get key2
"axxdefg"
#####################################################
# setex (set with expire) #设置过期时间
# setnx (set if not exist) #不存在再设置（在分布式锁中会常常使用！）
setex key3 30 hello #设置key3的值为hello，30秒后过期
setnx mykey redis #如果mykey不存在，创建mykey
stenx mykey mogodb #如果mykey存在，创建失败！
#####################################################
mset
mget
127.0.0.1:6379> mset k1 v1 k2 v1 k3 v3 #同时设置多个值
OK
127.0.0.1:6379> keys *
1) "k3"
2) "k1"
3) "k2"
127.0.0.1:6379> mget k1 k2 k3 #同时获取多个值
1) "v1"
2) "v1"
3) "v3"
127.0.0.1:6379> msetnx k1 v1 k4 v4 #msetnx 是一个原子性的操作，要么一起成功，要么一起失败
(integer) 0
127.0.0.1:6379> keys *
1) "k3"
2) "k1"
3) "k2"
127.0.0.1:6379> get k4
(nil)

# 对象
set user:1{name:zhangsan,age:3} #设置一个user:1对象 值为json字符来保存一个对象！

# 这里的key是一个巧妙的设计：user：{id}：{field}，如此设计在Redis中是完全OK了！
127.0.0.1:6379> mset user:1:name zhangsan user:1:age 2
OK
127.0.0.1:6379> mget user:1:name user:1:age
1) "zhangsan"
2) "2"

##############################################################
getset # 先get在set
127.0.0.1:6379> getset db redis #如果不存在值，则返回 nil
(nil)
127.0.0.1:6379> getset db mogodb #如果存在值，获取原来的值，并设置新的值
"redis"
127.0.0.1:6379> get db
"mogodb"

数据结构是相同的！

String类似的使用常见：value除了是我们的字符串还可以是我们的数字！

计数器
统计多单位的数量 uid:829797897:follow 0
粉丝数
对象缓存存储

List

基本的数据类型，列表

在redis里面，我们可以把list玩成，栈，队列，阻塞队列！

所有的list命令都是用l开头的

###################################################
127.0.0.1:6379> LPUSH list one #将一个值或者多个值，插入到列表头部
(integer) 1
127.0.0.1:6379> LPUSH list two
(integer) 2
127.0.0.1:6379> LPUSH list three
(integer) 3
127.0.0.1:6379> LRANGE list 0 -1 #获取list中的值
1) "three"
2) "two"
3) "one"
127.0.0.1:6379> LRANGE list 0 1 #通过区间获取具体的值
1) "three"
2) "two"
127.0.0.1:6379> RPUSH list four #将一个值或者多个值，插入到列表尾部（右）
(integer) 4
127.0.0.1:6379> LRANGE list 0 -1
1) "three"
2) "two"
3) "one"
4) "four"

###################################################
LPOP
RPOP

127.0.0.1:6379> LPOP list #移除列表的第一个元素
"three"
127.0.0.1:6379> LRANGE list 0 -1
1) "two"
2) "one"
3) "four"
127.0.0.1:6379> RPOP list #移除list的最后一个元素
"four"
127.0.0.1:6379> LRANGE list 0 -1
1) "two"
2) "one"

###################################################
Lindex

127.0.0.1:6379> LRANGE list 0 -1
1) "two"
2) "one"
127.0.0.1:6379> LINDEX list 0 #通过下标获得list中的某一个值！
"two"
127.0.0.1:6379> LINDEX list 1
"one"

###################################################
Llen

127.0.0.1:6379> LRANGE list 0 -1
1) "four"
2) "three"
3) "two"
4) "one"
127.0.0.1:6379> LLEN list #返回列表的长度
(integer) 4

###################################################
移除指定的值！
取关 uid

127.0.0.1:6379> LRANGE list 0 -1
1) "four"
2) "four"
3) "three"
4) "two"
5) "one"
127.0.0.1:6379> lrem list 1 one #移除list集合中指定个数的value，精确匹配
(integer) 1
127.0.0.1:6379> lrem list 2 four
(integer) 2
127.0.0.1:6379> LRANGE list 0 -1
1) "three"
2) "two"

###################################################
trim 修剪：list 截断

127.0.0.1:6379> RPUSH mylist hello
(integer) 1
127.0.0.1:6379> RPUSH mylist hello1
(integer) 2
127.0.0.1:6379> RPUSH mylist hello2
(integer) 3
127.0.0.1:6379> RPUSH mylist hello3
(integer) 4
127.0.0.1:6379> LTRIM mylist 1 2 #通过下标截取指定的长度，这个list已经被改变了，截断了只剩下截取的元素！
OK
127.0.0.1:6379> LRANGE mylist 0 -1
1) "hello1"
2) "hello2"

###################################################
rpoplpush #移除列表的最后一个元素，将他移动到新的列表中！

127.0.0.1:6379> rpush mylist hello
(integer) 1
127.0.0.1:6379> rpush mylist hello1
(integer) 2
127.0.0.1:6379> rpush mylist hello12
(integer) 3
127.0.0.1:6379> rpoplpush mylist myotherlist #移除列表的最后一个元素，将他移动到新的列表中！
"hello12"
127.0.0.1:6379> LRANGE mylist 0 -1 #查看原来的列表
1) "hello"
2) "hello1"
127.0.0.1:6379> keys *
1) "mylist"
2) "myotherlist"
127.0.0.1:6379> LRANGE myotherlist 0 -1 #查看目标列表中，确实存在该值
1) "hello12"

###################################################
lset #将列表中只当下标的值替换为另外一个值，更新操作

127.0.0.1:6379> EXISTS list #判断这个列表是否存在
(integer) 0
127.0.0.1:6379> lset list 0 item #如果不存在列表我们去更新就会报错
(error) ERR no such key
127.0.0.1:6379> lpush list vvlue1
(integer) 1
127.0.0.1:6379> LRANGE list 0 0
1) "vvlue1"
127.0.0.1:6379> lset list 0 item #如果存在，更新当前下标的值
OK
127.0.0.1:6379> LRANGE list 0 0
1) "item"
127.0.0.1:6379> lset list 1 other #如果不存在，则会报错！
(error) ERR index out of range

###################################################
linsert #将某个具体的value插入到列表中某个元素的前面或者后面

127.0.0.1:6379> RPUSH mylist hello
(integer) 1
127.0.0.1:6379> RPUSH mylist world
(integer) 2
127.0.0.1:6379> LRANGE mylist 0 -1
1) "hello"
2) "world"
127.0.0.1:6379> LINSERT mylist before "world" "other"
(integer) 3
127.0.0.1:6379> LRANGE mylist 0 -1
1) "hello"
2) "other"
3) "world"
127.0.0.1:6379> LINSERT mylist after world new
(integer) 4
127.0.0.1:6379> LRANGE mylist 0 -1
1) "hello"
2) "other"
3) "world"
4) "new"

小结

它实际上是一个链表，before Node after，left，right都可以插入值
如果key不存在，创建新的链表
如果key存在，新增乃荣
弱国移除了所有值，空链表，也代表不存在！
在两边插入或者改动值，效率最高！中间元素，相对来说效率会低一点~

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

Set（集合）

set中的值是不能重复的！

#####################################################
127.0.0.1:6379> sadd myset "hello" #set集合中添加元素
(integer) 1
127.0.0.1:6379> sadd myset "world"
(integer) 1
127.0.0.1:6379> sadd myset "touchingwang"
(integer) 1
127.0.0.1:6379> SMEMBERS myset #查看指定set的所有值
1) "hello"
2) "touchingwang"
3) "world"
127.0.0.1:6379> SISMEMBER myset "hello" #判断某一个值是不是在set集合中！
(integer) 1
127.0.0.1:6379> SISMEMBER myset "worlds"
(integer) 0

#####################################################
127.0.0.1:6379> SCARD myset #获取set集合中的内容元素个数！
(integer) 3

#####################################################
127.0.0.1:6379> SREM myset hello #移除set集合中的指定元素
(integer) 1

#####################################################
set 无序不重复集合。抽随机！

127.0.0.1:6379> SMEMBERS myset
1) "touchingwang"
2) "world"
127.0.0.1:6379> SRANDMEMBER myset #随机抽选出一个元素
"touchingwang"
127.0.0.1:6379> SRANDMEMBER myset
"touchingwang"
127.0.0.1:6379> SRANDMEMBER myset
"world"
127.0.0.1:6379> SRANDMEMBER myset 2 #随机抽选出指定个数的元素

#####################################################
删除指定的key，随机删除key！

127.0.0.1:6379> spop myset #随机删除一些set集合中的元素！
"world"
127.0.0.1:6379> SMEMBERS myset
1) "touchingwang"

#####################################################
将一个指定的值移动到另外一个set集合中
127.0.0.1:6379> sadd myset "hello"
(integer) 1
127.0.0.1:6379> sadd myset "world"
(integer) 1
127.0.0.1:6379> sadd myset "touchingwang"
(integer) 1
127.0.0.1:6379> SMOVE myset myset2 touchingwang
(integer) 1
127.0.0.1:6379> SMEMBERS myset
1) "hello"
2) "world"
127.0.0.1:6379> SMEMBERS myset2
1) "touchingwang"

#####################################################
微博，B站，共同关注！（并集）
数字集合类：
 - 差集
 - 交集
 - 并集
 127.0.0.1:6379> sadd key1 a
(integer) 1
127.0.0.1:6379> sadd key1 b
(integer) 1
127.0.0.1:6379> sadd key1 c
(integer) 1
127.0.0.1:6379> sadd key2 c
(integer) 1
127.0.0.1:6379> sadd key2 d
(integer) 1
127.0.0.1:6379> sadd key2 e
(integer) 1
127.0.0.1:6379> SDIFF key1 key2 #差集
1) "a"
2) "b"
127.0.0.1:6379> SINTER key1 key2 #交集 共同好友就可以这样实现
1) "c"
127.0.0.1:6379> SUNION key1 key2 #并集
1) "d"
2) "b"
3) "c"
4) "a"
5) "e"

微博，A用户将所有关注的人放到一个set集合中！将它的粉丝也放在一个集合中！

共同关注，共同爱好，二度好友，推荐好友！（六度分割理论）

Hash（哈希）

Map集合，key-map！这时候这个值是一个mao集合！本质和String类型没有太大区别，还是一个简单的key-value！

set myhash field touchingwang

127.0.0.1:6379> hset myhash field kuangshen #set一个具体key-value
(integer) 1
127.0.0.1:6379> HGET myhash field #获取一个字段值
"kuangshen"
127.0.0.1:6379> hmset myhash field hello field2 world #set多个key-value
OK
127.0.0.1:6379> HMGET myhash field field2 #获取多个字段值
1) "hello"
2) "world"
127.0.0.1:6379> HGETALL myhash #获取全部的数据
1) "field"
2) "hello"
3) "field2"
4) "world"
127.0.0.1:6379> HDEL myhash field #删除hash指定的key字段，对应的value值也就消失了！
(integer) 1
127.0.0.1:6379> HGETALL myhash
1) "field2"
2) "world"

#####################################################################
hlen

127.0.0.1:6379> HGETALL myhash
1) "field2"
2) "zhangsan"
3) "field1"
4) "hello"
5) "field"
6) "world"
127.0.0.1:6379> hlen myhash #获取hash表的字段数量
(integer) 3

#####################################################################
127.0.0.1:6379> HEXISTS myhash field1 #判断hash中指定字段是否存在！
(integer) 1
127.0.0.1:6379> HEXISTS myhash field3
(integer) 0

#####################################################################
#只获取所有field
#只获取所有value
127.0.0.1:6379> hkeys myhash #只获取所有field
1) "field2"
2) "field1"
3) "field"
127.0.0.1:6379> hvals myhash #只获取所有value
1) "zhangsan"
2) "hello"
3) "world"

#####################################################################
incr decr

127.0.0.1:6379> hset myhash field3 5 #指定增量！
(integer) 1
127.0.0.1:6379> HINCRBY myhash field3 1
(integer) 6
127.0.0.1:6379> HINCRBY myhash field3 -1
(integer) 5
127.0.0.1:6379> hsetnx myhash field4 hello #如果不存在则可以设置
(integer) 1
127.0.0.1:6379> hsetnx myhash field4 world #如果存在则不能设置
(integer) 0

hash变更的数据 user name age，尤其是用户信息之类的，经常变动的信息！hash更适合于对象的存储。String更适合字符串存储！

hset user:1 name kuangshen

Zset（有序集合）

在set的基础上，增加了一个值，set k1 v1 zset k1 score v1

127.0.0.1:6379> zadd myset 1 one #添加一个值
(integer) 1
127.0.0.1:6379> zadd myset 2 two 3 three #添加多个值
(integer) 2
127.0.0.1:6379> ZRANGE myset 0 -1
1) "one"
2) "two"
3) "three"

#####################################################
排序如何实现

127.0.0.1:6379> zadd salary 2500 xiaohong #添加三个用户
(integer) 1
127.0.0.1:6379> zadd salary 5000 zhangsan
(integer) 1
127.0.0.1:6379> zadd salary 500 kuangshen
(integer) 1
127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf #显示全部的用户 从小到大！
1) "kuangshen"
2) "xiaohong"
3) "zhangsan"
127.0.0.1:6379> ZREVRANGE salary 0 -1 #从大到小进行排序
1) "zhangsan"
2) "kuangshen"
127.0.0.1:6379> ZRANGEBYSCORE salary 0 -1
(empty array)
127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf withscores #显示全部的用户兵器附带成绩
1) "kuangshen"
2) "500"
3) "xiaohong"
4) "2500"
5) "zhangsan"
6) "5000"
127.0.0.1:6379> ZRANGEBYSCORE salary -inf 2500 withscores #显示工资小于2500员工的升序排序！
1) "kuangshen"
2) "500"
3) "xiaohong"
4) "2500"

#####################################################
# 移除rem中的元素

127.0.0.1:6379> zrange salary 0 -1
1) "kuangshen"
2) "zhangsan"
3) "xiaohong"
127.0.0.1:6379> zrem salary xiaohong #移除有序集合中的指定元素
(integer) 1
127.0.0.1:6379> zrange salary 0 -1
1) "kuangshen"
2) "zhangsan"
127.0.0.1:6379> ZCARD salary #获取有序集合中的个数
(integer) 2

#####################################################
127.0.0.1:6379> zadd myset 1 hello
(integer) 1
127.0.0.1:6379> zadd myset 2 world 3 kuangshen
(integer) 2
127.0.0.1:6379> ZCOUNT myset 1 3 #获取指定区间的成员数量
(integer) 3
127.0.0.1:6379> ZCOUNT myset 1 2
(integer) 2

其余的一些API，通过我们的学习，剩下的如果工作中有需要，这个时候你可以去查查看官方文档！

案例思路：set 排序存储班级成绩表，工资表排序！

普通消息，1，重要消息，2，带权重进行判断！

排行榜应用实现，取Top N

三种特殊数据类型

geospatial地理位置

朋友的定位，附近的人，打车举例计算?

Redis的Geo在Redis3.2版本就推出了！这个功能可以推算地理位置的信息，两地之间的距离，方圆几里的人！

只有六个命令

getadd

# getadd 添加地理位置
# 规则：两级无法直接添加，我们一般会下载城市数据，直接通过java程序一次性导入
# 参数 key 值（经度、纬度、地名）
127.0.0.1:6379> geoadd china:city 116.40 39.90 beijin
(integer) 1
127.0.0.1:6379> geoadd china:city 120.47 31.23 shanghai
(integer) 1
127.0.0.1:6379> geoadd china:city 106.50 29.53 chongqi 114.05 22.52 shenzhen
(integer) 2
127.0.0.1:6379> geoadd china:city 120.16 30.24 hangzhou 108.96 34.26 xian
(integer) 2

geopos

获得当前定位：一定是一个坐标镇！

127.0.0.1:6379> GEOPOS china:city chongqi #获取指定的城市的经度，纬度！
1) 1) "106.49999767541885376"
   2) "29.52999957900659211"
127.0.0.1:6379> GEOPOS china:city xian
1) 1) "108.96000176668167114"
   2) "34.25999964418929977"

geodist

两人之间的距离

单位：

m：表示单位为米
km：表示单位为千米
mi：表示单位为英里
ft：表示单位为英尺

127.0.0.1:6379> GEODIST china:city beijin shanghai
"1031922.7612"
127.0.0.1:6379> GEODIST china:city beijin shanghai km #查看北京到上海的直线距离
"1031.9228"
1) 1) "chongqi"
   2) "341.9374"
   3) 1) "106.49999767541885376"
      2) "29.52999957900659211"

georadius 以给定的经度为中心，找出某一半径内的元素

找附近的人？（获得所有附近的人的地址，定位！）通过半径来查询！

获得指定数量的人，200

127.0.0.1:6379> GEORADIUS china:city 110 30 500 km withdist withcoord [count 1]
				#以110，30这个经纬度为中心，寻找方圆500km的城市
				#withdist显示到中间距离的位置
				#withcoord显示他人的定位信息
				#count 2筛选出指定的结果

georadiusbymember

# 找出位于指定元素周围的其他元素！
127.0.0.1:6379> GEORADIUSBYMEMBER china:city beijin 1000 km
1) "beijin"
2) "xian"
127.0.0.1:6379> GEORADIUSBYMEMBER china:city shanghai 400 km
1) "hangzhou"
2) "shanghai"

geohash命令 - 返回一个或多个位置的geohash表示

该命令将返回11个字符的geohash字符串！

1
2
3

127.0.0.1:6379> GEOHASH china:city beijin chongqi
1) "wx4fbxxfke0"
2) "wm5xzrybty0"

GEO 底层的实现原理其实就是Zset！我们可以使用Zset命令来操作geo！

127.0.0.1:6379> ZRANGE china:city 0 -1 #查看地图中全部的元素
1) "chongqi"
2) "xian"
3) "shenzhen"
4) "hangzhou"
5) "shanghai"
6) "beijin"
127.0.0.1:6379> zrem china:city beijin #移除指定元素
(integer) 1
127.0.0.1:6379> ZRANGE china:city 0 -1
1) "chongqi"
2) "xian"
3) "shenzhen"
4) "hangzhou"
5) "shanghai"

Hyperloglog

什么是基数？

A{1，3，5，7，8，7} B{1，3，5，7，8}

基数（不重复的元素） A为5，可以接收误差！

简介

Redis2.8.9版本就更新了Hyperloglog数据结构！

Redis Hyperloglog 基数统计的算法！

优点：占用的内存是固定的，2^64 不同的元素的技术，只需要费 12KB内存！如果要从内存角度来比较的话 Hyperloglog 首选

网页的UV（一个人访问一个网站多次，但是还是算作一个人！）

传统的方式，set 保存用户的 id，然后就可以统计 set 中的元素数量作为标准判断！

这个方式如果保存大量的用户id，就会比较麻烦！我们的目的是为了技术，而不是保存用户id；

0.81%错误率！统计UV任务，可以忽略不计的！

测试使用

127.0.0.1:6379> PFADD mykey a b c d e f g h i j #创建第一组元素 mykey
(integer) 1
127.0.0.1:6379> PFCOUNT mykey #统计 mykey 元素的基数数量
(integer) 10
127.0.0.1:6379> PFADD mykey2 i j z x c v b n m #创建第一组元素 mykey2
(integer) 1
127.0.0.1:6379> PFCOUNT mykey
(integer) 10
127.0.0.1:6379> PFCOUNT mykey2
(integer) 9
127.0.0.1:6379> PFMERGE mykey3 mykey mykey2 #合并两组 mykey mykey2 => mykey3 并集
OK
127.0.0.1:6379> PFCOUNT mykey3 #查看并集的数量！
(integer) 15

如果允许容错，那么一定可以使用 Hyperloglog！

如果不允许容错，就使用 set 或者自己的数据类型即可！

Bitmaps

位存储

统计用户信息，活跃，不活跃！登录、未登录！打卡，365打卡！两个状态的，都可以使用Bitemaps！

Bitmaps 位图，数据结构！都是操作二进制位来进行记录，就只有0和1两个状态！

使用bitmap 来记录周一到周日的打卡!

周一：1 周二：0 周三：0 周四：1……

127.0.0.1:6379> setbit sign 0 1
(integer) 0
127.0.0.1:6379> setbit sign 1 0
(integer) 0
127.0.0.1:6379> setbit sign 2 0
(integer) 0
127.0.0.1:6379> setbit sign 3 1
(integer) 0
127.0.0.1:6379> setbit sign 4 1
(integer) 0
127.0.0.1:6379> setbit sign 5 0
(integer) 0
127.0.0.1:6379> setbit sign 6 0
(integer) 0
127.0.0.1:6379> getbit sign 3 #查看某一天是否打卡！
(integer) 1
127.0.0.1:6379> getbit sign 6
(integer) 0
127.0.0.1:6379> BITCOUNT sign #统计操作，统计打卡的天数！
(integer) 3

事务

Redis事务本质：一组命令的集合！一个事务中的所有命令都会被序列化，在事务执行过程中，会按照顺序执行！

一次性、顺序性、排他性！执行一系列的命令！

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

==Redis事务没有隔离级别的概念==

所有的命令在事务中，并没有直接被执行！只有发起执行命令的时候才会执行！Exec

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

redis 的事务：

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

正常执行事务！

127.0.0.1:6379> multi #开启事务
OK
# 命令入队
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> get k2
QUEUED
127.0.0.1:6379(TX)> set k3 v3
QUEUED
127.0.0.1:6379(TX)> exec #执行事务
1) OK
2) OK
3) "v2"
4) OK

放弃事务!

127.0.0.1:6379> MULTI #开启事务
OK
127.0.0.1:6379(TX)> set k1 v1
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> set k4 v4
QUEUED
127.0.0.1:6379(TX)> DISCARD #取消事务
OK
127.0.0.1:6379> get k4 #事务队列中的命令都不会被执行！
(nil)

编译型异常（代码有问题！），事务中所有的命令都不会被执行！

127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> getset k3 #错误的命令
(error) ERR wrong number of arguments for 'getset' command
127.0.0.1:6379(TX)> set k5 v5
QUEUED
127.0.0.1:6379(TX)> exec #执行事务报错！
(error) EXECABORT Transaction discarded because of previous errors.
127.0.0.1:6379> get k5 #所有的命令都不会被执行！
(nil)

运行时异常（1/0），如果事务队列中存在语法性错误，那么执行命令的时候，其他命令可以正常执行的

127.0.0.1:6379> set k1 "v1"
OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> incr k1 #会执行的时候失败！
QUEUED
127.0.0.1:6379(TX)> set k2 v2
QUEUED
127.0.0.1:6379(TX)> set k3 v3
QUEUED
127.0.0.1:6379(TX)> get k3
QUEUED
127.0.0.1:6379(TX)> exec
1) (error) ERR value is not an integer or out of range #虽然第一条命令报错了，但是依旧正常执行成功了！
2) OK
3) OK
4) "v3"
127.0.0.1:6379> get k2
"v2"
127.0.0.1:6379> get k3
"v3"

监控！

悲观锁：

很悲观，什么时候都不会出问题，无论做什么都会加锁！

乐观锁：

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

redis 测监视测试

127.0.0.1:6379> set money 100
OK
127.0.0.1:6379> set out 0
OK
127.0.0.1:6379> WATCH money #监视 money 对象
OK
127.0.0.1:6379> MULTI #事务正常结束，数据期间没有发生变动，这个时候就正常执行成功！
OK
127.0.0.1:6379(TX)> DECRBY money 20
QUEUED
127.0.0.1:6379(TX)> INCRBY out 20
QUEUED
127.0.0.1:6379(TX)> exec
1) (integer) 80
2) (integer) 20

测试多线程修改值，使用watch 可以当作redis的乐观锁操作！

127.0.0.1:6379> watch money
OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> DECRBY money 10
QUEUED
127.0.0.1:6379(TX)> INCRBY out 10
QUEUED
127.0.0.1:6379(TX)> exec #执行之前，另外一个线程，修改了我们的值，这个时候，就会导致事务执行失败！
(nil)
127.0.0.1:6379> unwatch #如果发现事务执行失败，就先解锁
OK
127.0.0.1:6379> watch money #获取最新的值，再次监视，select version
OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379(TX)> DECRBY money 10
QUEUED
127.0.0.1:6379(TX)> INCRBY out 10
QUEUED
127.0.0.1:6379(TX)> exec #比对监视的值是否发生了变化，如果没有变化，那么可以执行成功，如果变化就执失败！
1) (integer) 990
2) (integer) 30

Jedis

我们要使用Java来操作 Redis

什么是jedis 是Redis官方推荐的java连接开发工具！使用 java 操作 Redis 中间件！

如果你要使用java操作redis，那么一定要对jedis十分的熟悉！

测试

1、导入对应的依赖

<!--导入jedis的包-->
<dependencies>
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>3.6.0</version>
    </dependency>
    <!--fastjson-->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.76</version>
    </dependency>
</dependencies>

2、编码测试：

连接数据库
操作命令
断开连接！

package com.wang;

import redis.clients.jedis.Jedis;

public class TestPing {
    public static void main(String[] args) {
        //1/ new Jedis 对象即可
        Jedis jedis = new Jedis("**.**.**.**", 6379);
        jedis.auth("**");
        //jedis 所有的命令就是我们之前学习的所有指令！所以之前的指令学习很重要！
        System.out.println(jedis.ping());
    }
}

远程连接可能会出现的问题

开启安全组策略6379，bing注释只留一个，受保护的设置为no，防火墙关掉，重启
设置requirepass密码，登录查看是否修改成功

常用的API

对一些常用命令的操作

public class TestPing {
    public static void main(String[] args) {
        //1. new Jedis 对象即可
        Jedis jedis = new Jedis("**.**.**.**", 6379);
        jedis.auth("**");
        //jedis 所有的命令就是我们之前学习的所有指令！所以之前的指令学习很重要！
        System.out.println(jedis.ping());

        System.out.println("清空数据库："+jedis.flushDB());
        System.out.println("判断某个键是否存在："+jedis.exists("k1"));
        System.out.println("新增k1,v1键值对："+jedis.set("k1","v1"));
        System.out.println("新增k2,v2键值对："+jedis.set("k2","v2"));
        System.out.println("获得k1键的值："+jedis.get("k1"));
        System.out.println("系统中所有的键如下：");
        Set<String> keys = jedis.keys("*");
        System.out.println(keys);

        System.out.println("删除键k2："+jedis.del("k2"));
        System.out.println("判断键k2是否存在："+jedis.exists("k2"));
        System.out.println("查看键 k1 所存储的数据类型："+jedis.type("k1"));
        System.out.println("随机返回 key 空间的一个："+jedis.randomKey());
        System.out.println("重命名 key ："+jedis.rename("k1","newk1"));
        System.out.println("取出改后的 newk1 ："+jedis.get("newk1"));
        System.out.println("按索引查询："+jedis.select(0));
        System.out.println("删除当前选择数据库中的所有键："+jedis.flushDB());
        System.out.println("返回当前数据库中 key 的数量："+jedis.dbSize());
        System.out.println("删除所有数据库中的所有 key ："+jedis.flushAll());
    }
}

对 String 操作的命令

public class TestPing {
    public static void main(String[] args) {
        //1. new Jedis 对象即可
        Jedis jedis = new Jedis("**.**.**.**", 6379);
        jedis.auth("**");
        //jedis 所有的命令就是我们之前学习的所有指令！所以之前的指令学习很重要！
        System.out.println(jedis.ping());

        jedis.flushDB();
        System.out.println("=========增加数据========");
        System.out.println(jedis.set("k1","v1"));
        System.out.println(jedis.set("k2","v2"));
        System.out.println(jedis.set("k3","v3"));
        System.out.println("删除键k2："+jedis.del("k2"));
        System.out.println("获取键k2："+jedis.del("k2"));
        System.out.println("修改k1："+jedis.set("k1","v1changed"));
        System.out.println("获取k1的值："+jedis.get("k1"));
        System.out.println("在k3后面加入值："+jedis.append("k3","End"));
        System.out.println("获取k3的值："+jedis.get("k3"));
        System.out.println("增加多个键值对："+jedis.mset("k01","v01","k02","v02","k03","v03"));
        System.out.println("获取多个键值对："+jedis.mget("k01","k02","k03"));
        System.out.println("删除多个键值对："+jedis.del("k01","k02"));
        System.out.println("获取多个键值对："+jedis.mget("k01","k02","k03"));

        jedis.flushDB();
        System.out.println("=========增加键值对防止覆盖原先值========");
        System.out.println(jedis.setnx("k1","v1"));
        System.out.println(jedis.setnx("k1","v2"));
        System.out.println(jedis.setnx("k1","v2-new"));
        System.out.println(jedis.get("k1"));
        System.out.println(jedis.get("k2"));

        System.out.println("=========增加键值对并设置有效时间========");
        System.out.println(jedis.setex("k3",2,"v3"));
        System.out.println(jedis.get("k3"));
        try {
            TimeUnit.SECONDS.sleep(3);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println(jedis.get("k3"));

        System.out.println("=========获取原值，更新为新值========");
        System.out.println(jedis.getSet("k2","k2GetSet"));
        System.out.println(jedis.get("k2"));

        System.out.println("获得k2的值的字符串："+jedis.getrange("k2",2,4));
    }
}

对 List 操作的命令

对 Set操作的命令

对 Hash操作的命令

对 Zset操作的命令

所有的API命令就是我们对应的上面学习的指令，一个都没有变化！

事务

Jedis jedis = new Jedis("**.**.**.**", 6379);
jedis.auth("**");

JSONObject jsonObject = new JSONObject();
jsonObject.put("hello","world");
jsonObject.put("name","touchingWang");

jedis.flushDB();
//开始事务
Transaction multi = jedis.multi();
String result = jsonObject.toJSONString();

try {
    multi.set("user1",result);
    multi.set("user2",result);
    int i = 1/0;//代码抛出异常，事务执行失败

    multi.exec(); //执行事务
} catch (Exception e) {
    multi.discard(); //放弃事务
    e.printStackTrace();
} finally {
    System.out.println(jedis.get("user1"));
    System.out.println(jedis.get("user2"));
    jedis.close(); //关闭连接
}

jedis.close();

SpringBoot整合

SpringBoot 操作数据：Spring-data jdbc monodb redis！

SpringData 也是和 SpringBoot齐名的项目！

说明：在Springboot2.x之后，原来使用的jedis被替换为了lettuce？

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

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

整合测试一下

1、导入依赖

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

2、配置连接

1
2
3

# 配置redis
spring.redis.host=127.0.0.1
spring.redis.port=6379

3、测试

@SpringBootTest
class Redis02SpringbootApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {

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

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

        //RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
        //connection.flushDb();
        //connection.flushAll();
        redisTemplate.opsForValue().set("mykey","touchingWang");
        System.out.println(redisTemplate.opsForValue().get("mykey"));
    }
}

所有的对象，都需要序列化

默认的序列化方式是JDK序列，我们可能会使用json来序列化！

关于对象的保存：在企业中，所有的 pojo 都会序列化！我们来编写一个自己的RedisTemplate

@Configuration
public class RedisConfig {

    //编写我们自己的 redisTemplate
    @Bean
//    @SuppressWarnings("all")
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory){
        //我们为了自己开发方便，一般直接使用<String, Object>
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);

        //序列化配置
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer =
                new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,ObjectMapper.DefaultTyping.NON_FINAL);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        //hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        //value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }

}

所有的redis操作，其实对于java开发人员来说，更重要的是去理解redis的思想和每一种数据结构的用户和作用场景！

redis系列来自b站up主狂神说Java https://www.bilibili.com/video/BV1S54y1R7SB