Redis入门——笔记二

最新推荐文章于 2024-05-16 07:30:09 发布
最新推荐文章于 2024-05-16 07:30:09 发布
阅读量326 收藏 1
点赞数
文章标签： redis java nosql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42446156/article/details/108311157
版权

目录

二、Redis入门

 概述

Redis是什么？

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

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

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

Redis能该干什么？

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

特性

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

 Linux安装

1.下载安装包！redis-5.0.8.tar.gz

2.解压Redis的安装包！程序一般放在 /opt 目录下


3.基本环境安装

yum install gcc-c++
# 然后进入redis目录下执行
make
# 然后执行
make install


redis默认安装路径 /usr/local/bin


将redis的配置文件复制到 程序安装目录 /usr/local/bin/kconfig下


redis默认不是后台启动的，需要修改配置文件！


通过制定的配置文件启动redis服务

使用redis-cli连接指定的端口号测试，Redis的默认端口6379

查看redis进程是否开启

关闭Redis服务 shutdown

再次查看进程是否存在

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

 测试性能

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

简单测试：

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

 基础知识

redis默认有16个数据库


默认使用的第0个;

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

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

127.0.0.1:6379> config get databases # 命令行查看数据库数量databases
1) "databases"
2) "16"

127.0.0.1:6379> select 8 # 切换数据库 DB 8
OK
127.0.0.1:6379[8]> dbsize # 查看数据库大小
(integer) 0

# 不同数据库之间 数据是不能互通的，并且dbsize 是根据库中key的个数。
127.0.0.1:6379> set name sakura 
OK
127.0.0.1:6379> SELECT 8
OK
127.0.0.1:6379[8]> get name # db8中并不能获取db0中的键值对。
(nil)
127.0.0.1:6379[8]> DBSIZE
(integer) 0
127.0.0.1:6379[8]> SELECT 0
OK
127.0.0.1:6379> keys *
1) "counter:__rand_int__"
2) "mylist"
3) "name"
4) "key:__rand_int__"
5) "myset:__rand_int__"
127.0.0.1:6379> DBSIZE # size和key个数相关
(integer) 5

keys * ：查看当前数据库中所有的key。

flushdb：清空当前数据库中的键值对。

flushall：清空所有数据库的键值对。

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

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

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

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

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

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

三、五大数据类型

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

 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

关于TTL命令

Redis的key，通过TTL命令返回key的过期时间，一般来说有3种：

  • 当前key没有设置过期时间，所以会返回-1.
  • 当前key有设置过期时间，而且key已经过期，所以会返回-2.
  • 当前key有设置过期时间，且key还没有过期，故会返回key的正常剩余时间.

关于重命名RENAME和RENAMENX

  • RENAME key newkey修改 key 的名称
  • RENAMENX key newkey仅当 newkey 不存在时，将 key 改名为 newkey 。

 String(字符串)

命令描述示例
APPEND key value向指定的key的value后追加字符串127.0.0.1:6379> set msg hello OK 127.0.0.1:6379> append msg " world" (integer) 11 127.0.0.1:6379> get msg “hello world”
DECR/INCR key将指定key的value数值进行+1/-1(仅对于数字)127.0.0.1:6379> set age 20 OK 127.0.0.1:6379> incr age (integer) 21 127.0.0.1:6379> decr age (integer) 20
INCRBY/DECRBY key n按指定的步长对数值进行加减127.0.0.1:6379> INCRBY age 5 (integer) 25 127.0.0.1:6379> DECRBY age 10 (integer) 15
INCRBYFLOAT key n为数值加上浮点型数值127.0.0.1:6379> INCRBYFLOAT age 5.2 “20.2”
STRLEN key获取key保存值的字符串长度127.0.0.1:6379> get msg “hello world” 127.0.0.1:6379> STRLEN msg (integer) 11
GETRANGE key start end 按起止位置获取字符串（闭区间，起止位置都取）127.0.0.1:6379> get msg “hello world” 127.0.0.1:6379> GETRANGE msg 3 9 “lo worl”
SETRANGE key offset value 用指定的value 替换key中 offset开始的值127.0.0.1:6379> SETRANGE msg 2 hello (integer) 7 127.0.0.1:6379> get msg “tehello”
GETSET key value 将给定 key 的值设为 value ，并返回 key 的旧值(old value)。127.0.0.1:6379> GETSET msg test “hello world”
SETNX key value 仅当key不存在时进行set127.0.0.1:6379> SETNX msg test (integer) 0 127.0.0.1:6379> SETNX name sakura (integer) 1
SETEX key seconds value set 键值对并设置过期时间127.0.0.1:6379> setex name 10 root OK 127.0.0.1:6379> get name (nil)
MSET key1 value1 [key2 value2…] 批量set键值对127.0.0.1:6379> MSET k1 v1 k2 v2 k3 v3 OK
MSETNX key1 value1 [key2 value2…] 批量设置键值对，仅当参数中所有的key都不存在时执行127.0.0.1:6379> MSETNX k1 v1 k4 v4 (integer) 0
MGET key1 [key2…] 批量获取多个key保存的值127.0.0.1:6379> MGET k1 k2 k3 1) “v1” 2) “v2” 3) “v3”
PSETEX key milliseconds value和 SETEX 命令相似，但它以毫秒为单位设置 key 的生存时间，
getset key value如果不存在值，则返回nil，如果存在值，获取原来的值，并设置新的值

String类似的使用场景：value除了是字符串还可以是数字，用途举例：

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

 List(列表)

Redis列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）
一个列表最多可以包含 232 - 1 个元素 (4294967295, 每个列表超过40亿个元素)。

首先我们列表，可以经过规则定义将其变为队列、栈、双端队列等


正如图Redis中List是可以进行双端操作的，所以命令也就分为了LXXX和RLLL两类，有时候L也表示List例如LLEN

命令描述
LPUSH/RPUSH key value1[value2…] 从左边/右边向列表中PUSH值(一个或者多个)。
LRANGE key start end获取list 起止元素==（索引从左往右 递增）==
LPUSHX/RPUSHX key value向已存在的列名中push值（一个或者多个）
LINSERT key BEFORE/AFTER pivot value在指定列表元素的前/后 插入value
LLEN key查看列表长度
LINDEX key index 通过索引获取列表元素
LSET key index value 通过索引为元素设值
LPOP/RPOP key从最左边/最右边移除值 并返回
RPOPLPUSH source destination将列表的尾部(右)最后一个值弹出，并返回，然后加到另一个列表的头部
LTRIM key start end 通过下标截取指定范围内的列表
LREM key count valueList中是允许value重复的 count > 0：从头部开始搜索 然后删除指定的value 至多删除count个 count < 0：从尾部开始搜索… count = 0：删除列表中所有的指定value。
BLPOP/BRPOP key1[key2] timout移出并获取列表的第一个/最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
BRPOPLPUSH source destination timeout和RPOPLPUSH功能相同，如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
---------------------------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实际上是一个链表，before Node after , left, right 都可以插入值
  • 如果key不存在，则创建新的链表
  • 如果key存在，新增内容
  • 如果移除了所有值，空链表，也代表不存在
  • 在两边插入或者改动值，效率最高！修改中间元素，效率相对较低

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

 Set(集合)

Redis的Set是string类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据。
Redis 中 集合是通过哈希表实现的，所以添加，删除，查找的复杂度都是O(1)。
集合中最大的成员数为 232 - 1 (4294967295, 每个集合可存储40多亿个成员)。

命令描述
SADD key member1[member2…]向集合中无序增加一个/多个成员
SCARD key获取集合的成员数
SMEMBERS key返回集合中所有的成员
SISMEMBER key member查询member元素是否是集合的成员,结果是无序的
SRANDMEMBER key [count]随机返回集合中count个成员，count缺省值为1
SPOP key [count]随机移除并返回集合中count个成员，count缺省值为1
SMOVE source destination member将source集合的成员member移动到destination集合
SREM key member1[member2…]移除集合中一个/多个成员
SDIFF key1[key2…]返回所有集合的差集 key1- key2 - …
SDIFFSTORE destination key1[key2…]在SDIFF的基础上，将结果保存到集合中==(覆盖)==。不能保存到其他类型key噢！
SINTER key1 [key2…]返回所有集合的交集
SINTERSTORE destination key1[key2…] 在SINTER的基础上，存储结果到集合中。覆盖
SUNION key1 [key2…]返回所有集合的并集
SUNIONSTORE destination key1 [key2…] 在SUNION的基础上，存储结果到及和张。覆盖
SSCAN KEY [MATCH pattern] [COUNT count]在大量数据环境下，使用此命令遍历集合中元素，每次遍历部分
---------------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"

四、三种特殊数据类型

 Geospatial(地理位置)

使用经纬度定位地理坐标并用一个有序集合zset保存，所以zset命令也可以使用

命令描述
geoadd key longitud(经度) latitude(纬度) member […] 将具体经纬度的坐标存入一个有序集合
geopos key member [member…]获取集合中的一个/多个成员坐标
geodist key member1 member2 [unit]返回两个给定位置之间的距离。默认以米作为单位。
georadius key longitude latitude radius m/km/mi/ft [WITHCOORD][WITHDIST] [WITHHASH] [COUNT count]以给定的经纬度为中心， 返回集合包含的位置元素当中， 与中心的距离不超过给定最大距离的所有位置元素。
GEORADIUSBYMEMBER key member radius…功能与GEORADIUS相同，只是中心位置不是具体的经纬度，而是使用结合中已有的成员作为中心点。
geohash key member1 [member2…]返回一个或多个位置元素的Geohash表示。使用Geohash位置52点整数编码。

有效经纬度

  • 有效的经度从-180度到180度。
  • 有效的纬度从-85.05112878度到85.05112878度。

指定单位的参数 unit 必须是以下单位的其中一个：

  • m 表示单位为米。
  • km 表示单位为千米。
  • mi 表示单位为英里。
  • ft 表示单位为英尺。
-----------------geoadd--------------------
127.0.0.1:6379> geoadd china:city 111.4 30.5 yichang # 将经纬度(111.4,30.5)的地理坐标加入china:city 并命名yichang
(integer) 1
127.0.0.1:6379> geoadd china:city 121.4 31.4 shanghai # ...
(integer) 1
127.0.0.1:6379> geoadd china:city 120.2 30.2 hangzhou
(integer) 1
127.0.0.1:6379> geoadd china:city 104.1 30.6 chengdu
(integer) 1

-----------------geopos--------------------
127.0.0.1:6379> geopos china:city shanghai
1) 1) "121.40000134706497" # 经度
   2) "31.400000253193539" # 纬度
   
-----------------geodist--------------------
127.0.0.1:6379> GEODIST china:city yichang shanghai # 获取yichang和shanghai两个地理坐标的距离(单位:m)
"958793.6834"
127.0.0.1:6379> GEODIST china:city shanghai yichang km # 单位：km
"958.7937"

关于GEORADIUS的参数

通过georadius就可以完成 附近的人功能
withcoord:带上坐标
withdist:带上距离，单位与半径单位相同
COUNT n : 只显示前n个(按距离递增排序)

----------------georadius---------------------
127.0.0.1:6379> GEORADIUS china:city 120 30 500 km withcoord withdist # 查询经纬度(120,30)坐标500km半径内的成员
1) 1) "hangzhou"
   2) "29.4151"
   3) 1) "120.20000249147415"
      2) "30.199999888333501"
2) 1) "shanghai"
   2) "205.3611"
   3) 1) "121.40000134706497"
      2) "31.400000253193539"
     
------------geohash---------------------------
127.0.0.1:6379> geohash china:city yichang shanghai # 获取成员经纬坐标的geohash表示
1) "wmrjwbr5250"
2) "wtw6ds0y300"

 Hyperloglog(基数统计)

Redis HyperLogLog 是用来做基数统计的算法，HyperLogLog 的优点是，在输入元素的数量或者体积非常非常大时，计算基数所需的空间总是固定的、并且是很小的。
花费 12 KB 内存，就可以计算接近 2^64 个不同元素的基数。
因为 HyperLogLog 只会根据输入元素来计算基数，而不会储存输入元素本身，所以 HyperLogLog 不能像集合那样，返回输入的各个元素。
其底层使用string数据类型

什么是基数？

数据集中不重复的元素的个数。

应用场景

网页的访问量（UV）：一个用户多次访问，也只能算作一个人。

传统实现，存储用户的id,然后每次进行比较。当用户变多之后这种方式及其浪费空间，而我们的目的只是计数，Hyperloglog就能帮助我们利用最小的空间完成。

命令描述
PFADD key element1 [elememt2…]添加指定元素到 HyperLogLog 中
PFCOUNT key [key]返回给定 HyperLogLog 的基数估算值。
PFMERGE destkey sourcekey [sourcekey…]将多个 HyperLogLog 合并为一个 HyperLogLog
----------PFADD--PFCOUNT---------------------
127.0.0.1:6379> PFADD myelemx a b c d e f g h i j k # 添加元素
(integer) 1
127.0.0.1:6379> type myelemx # hyperloglog底层使用String
string
127.0.0.1:6379> PFCOUNT myelemx # 估算myelemx的基数
(integer) 11
127.0.0.1:6379> PFADD myelemy i j k z m c b v p q s
(integer) 1
127.0.0.1:6379> PFCOUNT myelemy
(integer) 11

----------------PFMERGE-----------------------
127.0.0.1:6379> PFMERGE myelemz myelemx myelemy # 合并myelemx和myelemy 成为myelemz
OK
127.0.0.1:6379> PFCOUNT myelemz # 估算基数
(integer) 17

虽然其底层使用String，但是get出来的值…

 BitMaps(位图)

使用位存储，信息状态只有 0 和 1
Bitmap是一串连续的2进制数字（0或1），每一位所在的位置为偏移(offset)，在bitmap上可执行AND,OR,XOR,NOT以及其它位操作。

应用场景

签到统计、状态统计

命令描述
setbit key offset value为指定key的offset位设置值
getbit key offset获取offset位的值
bitcount key [start end] 统计字符串被设置为1的bit数，也可以指定统计范围按字节
bitop operration destkey key[key…]对一个或多个保存二进制位的字符串 key 进行位元操作，并将结果保存到 destkey 上。
BITPOS key bit [start] [end] 返回字符串里面第一个被设置为1或者0的bit位。start和end只能按字节,不能按位
------------setbit--getbit--------------
127.0.0.1:6379> setbit sign 0 1 # 设置sign的第0位为 1 
(integer) 0
127.0.0.1:6379> setbit sign 2 1 # 设置sign的第2位为 1  不设置默认 是0
(integer) 0
127.0.0.1:6379> setbit sign 3 1
(integer) 0
127.0.0.1:6379> setbit sign 5 1
(integer) 0
127.0.0.1:6379> type sign
string

127.0.0.1:6379> getbit sign 2 # 获取第2位的数值
(integer) 1
127.0.0.1:6379> getbit sign 3
(integer) 1
127.0.0.1:6379> getbit sign 4 # 未设置默认是0
(integer) 0

-----------bitcount----------------------------
127.0.0.1:6379> BITCOUNT sign # 统计sign中为1的位数
(integer) 4

bitmaps的底层

这样设置以后你能get到的值是：\xA2\x80，所以bitmaps是一串从左到右的二进制串

五、事务

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

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

  • 一次性
  • 顺序性
  • 排他性

1.Redis事务没有隔离级别的概念
2.Redis单条命令是保证原子性的，但是事务不保证原子性！

  所以事务中的命令在加入时都没有被执行，直到提交时才会开始执行(Exec)一次性完成。

  操作过程：开启事务(multi) >> 命令入队 >> 执行事务(exec)

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> get k1
QUEUED
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> keys *
QUEUED
127.0.0.1:6379> exec # 事务执行
1) OK
2) OK
3) "v1"
4) OK
5) 1) "k3"
   2) "k2"
   3) "k1"

取消事务(discurd)

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)

 事务错误

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

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) # 其他命令并没有被执行

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

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" # 其他命令正常执行

 监控

悲观锁：

  • 很悲观，认为什么时候都会出现问题，无论做什么都会加锁

乐观锁：

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

使用watch key监控指定数据，相当于乐观锁加锁。

127.0.0.1:6379> set money 100 # 设置余额:100
OK
127.0.0.1:6379> set use 0 # 支出使用:0
OK
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> exec # 监视值没有被中途修改，事务正常执行
1) (integer) 80
2) (integer) 20

线程插队，修改监视值。

我们启动另外一个客户端模拟插队线程。

线程1：

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> 	# 此时事务并没有执行

模拟线程插队，线程2:

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

回到线程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"

解锁获取最新值，然后再加锁进行事务。
unwatch进行解锁。

127.0.0.1:6379> UNWATCH # 解锁
OK
127.0.0.1:6379> WATCH money
OK
127.0.0.1:6379> multi # 重新进行事务
OK
127.0.0.1:6379> DECRBY money 200
QUEUED
127.0.0.1:6379> INCRBY use 200
QUEUED
127.0.0.1:6379> exec
1) (integer) 400
2) (integer) 200

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

六、Jedis

使用Java来操作Redis，Jedis是Redis官方推荐使用的Java连接redis的客户端。

1.依赖导入:jedis、fastjson

<!--导入jredis的包-->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.2.0</version>
</dependency>
<!--fastjson-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.70</version>
</dependency>

2.连接数据库

连接远程：
开放端口6379

firewall-cmd --zone=public --add-port=6379/tcp --permanent

需要修改配置文件：
修改bind IP，默认是127.0.0.1 也就是localhost,只有本机可用。
修改为0.0.0.0 或者 本机的ip地址。

关闭保护模式
默认是yes,修改为no


然后以此配置文件启动redis-server

Java中操作Redis就需要 一个Jedis对象，创建Jedis对象，需要主机号和端口号作为参数。

其中的API与使用Redis原生的命令是一样的。

事务：

public class TestTransaction {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("192.168.167.15", 6379);
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("name", "sakura");
        jsonObject.put("msg", "hello world");
        String info = jsonObject.toJSONString();
        // 开启事务
        Transaction transaction = jedis.multi();
        try {
            transaction.set("user1", info);
            transaction.set("user2", info);
            // 执行事务
            transaction.exec();
        } catch (Exception e) {
            e.printStackTrace();
            // 如果出错则放弃事务
            transaction.discard();
        } finally {
            System.out.println(jedis.get("user1"));
            System.out.println(jedis.get("user2"));
            // 关闭连接
            jedis.close();
        }
    }
}

七、SpringBoot整合Redis

需要的依赖项,在创建项目时选择，或者手动加入。

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

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

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

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


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


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


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

先看Jedis:


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

然后再看Lettuce：

完美生效。

现在我们回到RedisAutoConfiguration

只有两个简单的Bean

  • RedisTemplate
  • StringRedisTemplate

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

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

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


这是一些基本的配置属性。

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


配置文件:(基本不用写)

spring.redis.host=127.0.0.1
spring.redis.port=6379
# 以上俩个属性都有默认值 可以省略

# 默认使用 db0
spring.redis.database=0

测试使用：

1.我们说过现在操作Redis需要用到RedisTemplate，所以需要自动注入。

@Autowired
RedisTemplate redisTemplate;

2.使用RedisTemplate

在操作Redis中数据时，需要先通过opsForxxx()方法来获取对应的Operations,然后才可以操作数据。

3.以ValueOperations（操作String）为例

@Autowired
RedisTemplate redisTemplate;

@Test
void contextLoads() {
   // 获取Redis连接对象
   RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
   // 清空数据库
   connection.flushDb();
   System.out.println(redisTemplate.keys("*"));

   ValueOperations operations = redisTemplate.opsForValue();
   // set
   operations.set("name", "sakura");
   // get
   System.out.println(operations.get("name"));
   // 事务支持开启
   redisTemplate.setEnableTransactionSupport(true);
   redisTemplate.multi();
   try {
      operations.set("msg", "hello world");
      System.out.println(operations.get("name"));
      // 事务执行
      redisTemplate.exec();
   } catch (Exception e) {
      e.printStackTrace();
      // 放弃事务
      redisTemplate.discard();
   } finally {
      // 关闭连接
      connection.close();
   }
}

此时我们回到Redis查看数据时候，惊奇发现全是乱码，可是程序中可以正常输出：

这时候就关系到存储对象的序列化问题，在网络中传输的对象也是一样需要序列化，否者就全是乱码。

我们转到看那个默认的RedisTemplate内部什么样子：


在最开始就能看到几个关于序列化的参数。

默认的序列化器是采用JDK序列化器

而默认的RedisTemplate中的所有序列化器都是使用这个序列化器


后续我们定制RedisTemplate就可以对其进行修改。

**RedisSerializer**提供了很多种序列化方案：

  • 我们可以直接调用RedisSerializer的方法来返回序列化器，然后set

  • 也可以自己new 相应的实现类，然后set


定制RedisTemplate的模板：

我们创建一个Bean加入容器，就会触发RedisTemplate上的条件注解使默认的RedisTemplate失效。

@Configuration
public class RedisConfig {

   @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        // 将template 泛型设置为 <String, Object>
        RedisTemplate<String, Object> template = new RedisTemplate();
        // 连接工厂，不必修改
        template.setConnectionFactory(redisConnectionFactory);
        /*
         * 序列化设置
         */
        // key、hash的key 采用 String序列化方式
        template.setKeySerializer(RedisSerializer.string());
        template.setHashKeySerializer(RedisSerializer.string());
        // value、hash的value 采用 Jackson 序列化方式
        template.setValueSerializer(RedisSerializer.json());
        template.setHashValueSerializer(RedisSerializer.json());
        template.afterPropertiesSet();
        
        return template;
    }
}

这样一来，只要实体类进行了序列化，我们存什么都不会有乱码的担忧了。

八、自定义Redis工具类

  使用RedisTemplate需要频繁调用.opForxxx然后才能进行对应的操作，这样使用起来代码效率低下，工作中一般不会这样使用，而是将这些常用的公共API抽取出来封装成为一个工具类，然后直接使用工具类来间接操作Redis,不但效率高并且易用。

工具类参考博客：

https://www.cnblogs.com/zeng1994/p/03303c805731afc9aa9c60dbbd32a323.html、

https://www.cnblogs.com/zhzhlong/p/11434284.html

九、Redis.conf

1.容量单位不区分大小写，G和GB有区别


2.可以使用 include 组合多个配置问题

3.网络配置


4.日志输出级别

6.日志输出文件


6.持久化规则

由于Redis是基于内存的数据库，需要将数据由内存持久化到文件中
持久化方式：

  • RDB
  • AOF


7.RDB文件相关



8.关于主从复制，稍后再提

9.Security模块中进行密码设置

10.客户端连接相关

maxclients 10000  最大客户端数量
maxmemory <bytes> 最大内存限制
maxmemory-policy noeviction # 内存达到限制值的处理策略

redis 中的默认的过期策略是== volatile-lru ==。

设置方式

config set maxmemory-policy volatile-lru

maxmemory-policy 六种方式

  • 1、volatile-lru：**只对设置了过期时间的key进行LRU（默认值）
  • 2、allkeys-lru ： 删除lru算法的key
  • 3、volatile-random：**随机删除即将过期key
  • 4、allkeys-random：**随机删除
  • 5、volatile-ttl ： 删除即将过期的
  • 6、noeviction ： 永不过期，返回错误

11.AOF相关部分

小老弟偶
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
redis分布式 —— 客户端库tinyredis1
08-03
《Redis分布式——客户端库tinyredis1详解》 在分布式系统中，Redis作为一种高性能的键值存储服务，常被用来构建高效的数据存储和缓存解决方案。本文将重点介绍一种名为tinyredis的客户端库，它是实现Redis分布式...
Redis数据库入门笔记
最新发布
07-13
Redis数据库入门笔记
redis登录常见报错
凉云半的博客
06-21 1626
redis
狂神Redis学习笔记（已更完）
weixin_54232666的博客
09-12 2005
Redis的学习笔记 看狂神的课程做的笔记
B站【狂神说Java笔记】-JVM快速入门篇
2401_84103327的博客
05-16 944
小编精心为大家准备了一手资料以上Java高级架构资料、源码、笔记、视频。Dubbo、Redis、设计模式、Netty、zookeeper、Spring cloud、分布式、高并发等架构技术【附】架构书籍BAT面试的20道高频数据库问题解析Java面试宝典Netty实战算法BATJ面试要点及Java架构师进阶资料本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取8.方法区。
Redis学习笔记(超详细，看完必会)
qq_44860722的博客
07-15 2517
当系统的并发量比较高的时候，请求会直接落在Mysql上，在中间插入了缓存Redis，所有的请求先到Redis中查，如果查到了直接返回，请求就不会落在Mysql上，减轻了Mysql的压力。一个恶意的请求，假如有3000万个请求，要查询数据id=-1的，Redis缓存中查不到数据，然后去Mysql中查，Mysql中也查不到，那么3000万个请求全落在Mysql，永远起不来服务（恶意请求，永远查不到数据）。在Redis中查不到，就去查Mysql，查Mysql结果为空，也将他添加到Redis缓存中，添加空值。...
Redis学习-狂神教程
qq_42277704的博客
08-14 177
根据狂神的redis教程学习做的笔记
redis初级入门笔记
04-06
作为初级入门，我们首先需要了解 Redis 的基本概念和核心特性。 **1. Redis 概述** Redis（Remote Dictionary Server）是一个开源的、基于内存的数据结构存储系统，可以作为数据库、缓存和消息中间件使用。它的数据...
Redis全套学习笔记
05-25
2. Redis 数据类型： - **字符串(String)**：基本的键值对，支持设置、获取、追加、长度计算、原子递增/递减等操作。 - **列表(List)**：双端队列，允许在两端插入和删除元素，支持范围查询，可用于消息队列。 - ...
redis入门学习笔记
08-28
redis入门学习笔记化运维，非常不错，适合新手的，建议下载
狂神说Redis笔记.pdf
08-09
狂神Redis课堂笔记，Redis is an open source (BSD licensed), in-memory data structure store, used as a database, cache, and message broker. 翻译为：Redis是一个开源的内存中的数据结构存储系统，它可以用作：数据库、缓存和消息中间件。 官网：https://redis.io Redis是用C语言开发的一个开源的高性能键值对(key-value)数据库，官方提供的数据是可以达到100000+的QPS（每秒内查询次数）。它存储的value类型比较丰富，也被称为结构化的NoSql数据库。 NoSql（Not Only SQL），不仅仅是SQL，泛指非关系型数据库。NoSql数据库并不是要取代关系型数据库，而是关系型数据库的补充。 关系型数据库(RDBMS)： Mysql Oracle DB2 SQLServer 非关系型数据库(NoSql)： Redis Mongo db MemCached
狂神docker笔记（超详细）.rar
06-14
狂神docker教学视频笔记，截图标注很全（本人增加了很多额外的标注），帮助更好理解，敲了很久，实在不易。上传来帮助大家学习，一方面攒点积分！
redis.clients.jedis.exceptions.JedisDataException: ERR unknown command 'SENTINEL'
小马哥(新博客地址 http://maruifu.cn )
05-30 2万+
Exception in thread "Thread-3" redis.clients.jedis.exceptions.JedisDataException: ERR unknown command 'SENTINEL' at redis.clients.jedis.Protocol.processError(Protocol.java:118) at redis.clients
最全狂神Docker笔记，包含bug解决方式
博客
05-01 1125
更便捷的升级和扩缩容使用了 Docker之后，我们部署应用就和搭积木一样。项目打包为一个镜像，扩展服务器A！服务器B更简单的系统运维在容器化之后，我们的开发，测试环境都是高度一致的更高效的计算资源利用Docker是内核级别的虚拟化，可以在一个物理机上可以运行很多的容器实例！服务器的性能可以被压榨到极致。docker的理念是将应用和环境打包成一个镜像！
狂神说-Redis（宝塔下的Linux）
shenxinde的博客
03-22 3361
一、Nosql概述 1、为什么使用Nosql 1.1、单机MySQL的时代 90年代,一个网站的访问量一般不会太大，单个数据库完全够用。那个时候，更多的去使用静态网页 Html ~ 服务器根本没有太大的压力。 这种情况下，整个网站的瓶颈是什么： 1.数据量如果太大，一个机器放不下 2.数据的索引（B+ Tree）,一个机器内存也存放不下 3.访问量变大后（读写混合），一个服务器承受不了。 1.2、Memcached(缓存) + Mysql + 垂直拆分（读写分离） 主要解决读的问题
B站【狂神说Java笔记】-数组
2401_83817843的博客
03-28 1050
千千万万要记得：多刷题！！多刷题！！之前算法是我的硬伤，后面硬啃了好长一段时间才补回来，算法才是程序员的灵魂！！！！篇幅有限，以下只能截图分享部分的资源！！（1）多线程（这里以多线程为代表，其实整理了一本JAVA核心架构笔记集）（2）刷的算法题（还有左神的算法笔记）（3）面经+真题解析+对应的相关笔记（很全面）（4）视频学习（部分）ps：当你觉得学不进或者累了的时候，视频是个不错的选择在这里，最后只一句话：祝大家offer拿到手软！！
spring 狂神说的详细笔记
热门推荐
xiangminlu的博客
04-22 3万+
最近在学习java框架，发现狂神说的视频挺好的，通俗易懂，还有笔记，整理过来，以便随时复习回顾。 狂神说spring5 视频链接： B站教学视频 spring5 系列笔记： 狂神说Spring01： 概述及IOC理论推导 狂神说Spring02： 快速上手Spring 狂神说Spring03： 依赖注入（DI） 狂神说Spring04： 自动装配 狂神说Spring05： ...
Redis全面深入学习笔记(强烈推荐).docx
09-17
"Redis全面深入学习笔记，涵盖了从下载、编译Redis源码到启动、停止Redis服务的详细步骤，适合对Redis感兴趣的学习者。笔记强调了如何在Linux环境中进行操作，包括更改Redis的默认端口和配置为后台运行模式。此外，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值