NoSql

为什么要用NoSql

1. 
   单机MySql的年代

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

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

思考一下,这种情况下:整个网站的瓶颈是什么

1、数据量如果太大、一个机器放不下了

2、数据的索引(B+Tree),一个机器内存也放不下

3、访问量(读写混合),一个服务器承受不了

只要你开始出现以上的三种情况之一,那么你就必须要晋级

1. 
   Memcached(缓存)+ MySQL+垂直拆分（读写分离）

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

   发展过程：优化数据结构和索引 ——> 文件缓存(IO) ——> Memcached(当时最热门的技术)

+%20MySQL+%E5%9E%82%E7%9B%B4%E6%8B%86%E5%88%86.png#id=c6uVg&originHeight=756&originWidth=1032&originalType=binary&status=done&style=none)

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

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

本质:数据库(读,写)

早些年 MyISAM:表锁,十分影响效率!高并发下就会出现严重的锁问题

转战 innodb:行锁

慢慢的就开始使用分库分表来解决写的压力! MySQL在哪个年代推出了表分区!这个并没有多少公司使用!

MySQL的集群,很好满足哪个年代的所有需求!

1. 
   如今的年代

2010-2020十年之间,世界已经发生了翻天覆地的变化;(定位,也是一种数据,音乐,热榜!)

MySQL等关系型数据库就不够用了!数据量很多,变化很快。

MySQL有的使用它来存储一些比较大的文件,博客,图片!数据库表很大,效率就低了!如果有一种数据库来专门处理这种数据,MySQL压力就变得十分小(研究如何处理这些问题!)大数据的IO压力下,表几乎没法更大!

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

为什么要用 NOSQL

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

这时候我们就需要使用NOSQL数据库的,NoSql可以很好的处理以上的情况

什么是NoSql

NOSQL

NOSQL= Not Only SQL(不仅仅是SQL)

关系型数据库:表格,行,列
泛指非关系型数据库的,随着web2.0互联网的诞生!传统的关系型数据库很难对付web2.0时代!尤其是超大规模的高并发的社区!暴露岀来很多难以克服的问题,NosαL在当今大数据环境下发展的十分迅速, Redis是发展最快的,而且是我们当下必须要掌握的一个技术。
很多的数据类型用户的个人信息,社交网络,地理位置。这些数据类型的存储不需要一个固定的格式!不需要多余的操作就可以横向扩展的! Map<String,Object> 使用键值对来控制。

NOSQL特点

解耦

1、方便扩展（数据之间没有关系,很好扩展！）

2、大数据量高性能（Redis一秒写8万次,读取11万,NoSqL的缓存记录级,是一种细粒度的缓存,性能会比较高！）

3、数据类型是多样型的！(不需要事先设计数据库!随取随用!如果是数据量十分大的表,很多人就无法设计了！)

4、传统 RDBMS和 NoSql

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

NoSql
-不仅仅是数据
-没有固定的查询语言
-键值对存储,列存储,文档存储,图形数据库(社交关系)
-最终一致性,
-CAP定理和BASE(异地多活)
-高性能,高可用,高可扩
-...

了解:3V+3高

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

1. 海量Volume
2. 多样Variety
3. 实时Velocity

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

1. 高并发
2. 高可拓
3. 高性能

真正在公司中的实践: NOSQL+ RDBMS一起使用才是最强的,阿里巴巴的架构演进

技术没有高低之分,就看你如何去使用!(提升内功,思维的提高!)

阿里巴巴实践分析理解数据架构演进

如果你未来相当一个架构师:没有什么是加一层解决不了的!

# 1、商品的基本信息
    名称、价格、商家信息
    关系型数据库就可以解决了!MysαL/ oracle(淘宝早年就去IOE了!-王坚:推荐文章:阿里云的这群疯子:40分钟重要!)
    淘宝内部的 MySQL不是大家用的 MySQL
# 2、商品的描述、评论(文字比较多)
    文档型数据库中, MongoDB
#3、图片
    分布式文件系统 FastDFS
    - 淘宝的 TFS
    - Google的 GFS
    - Hadoop的 HDFS
    - 阿里云的 OSS
 #4、商品的关键字(搜索）
    - 搜索引擎 solr elasticsearch
    - ISErach:多隆(多去了解一下这些技术大佬!)
#5、商品热门的波段信息
    内存数据库
    Redis tair、 Memache
#6、商品的交易,外部的支付接口
     - 三方应用

NoSql的四大分类

KV键值对:

• 新浪:Reds
• 美团: Redis+Tair
• 阿里、百度: Redis+ memcache

文档型数据库(bson格式和json一样):

• MongoDB(一般必须要掌握)
  • MongoDB是一个基于分布式文件存储的数据库,C+编写,主要用来处理大量的文档
  • MongoDB是一个个于关系型数据库和非关系型数据中中的产品! MongoDB是非关系型数据库中功能最丰富,最像关系型数据库的!

• ConthDB

列存储数据库

• HBase
• 分布式文件系统

图关系数据库

• 
  它不是存图形,放的是关系,比如:朋友圈社交网络,广告推荐!
• 
  Neo4i, Info grid

对比

Redis 入门

Redis 是什么？

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

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

区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件,并且在此基础上实现了 master- slave(主从)同步。

免费开源，是当下最热门的NoSql技术之一，也被人们称为结构化数据库。

Redis 可以用来干什么？

1、内存存储、持久化,内存中是断电即失、所以说持久化很重要（rdb、aof）

2、效率高,可以用于高速缓存

3、发布订阅系统

4、地图信息分析

5、计时器、计数器（浏览量 incr decre）

6、……

特性

1、多样的数据类型

2、持久化

3、集群

4、事务

……

需要用到的东西

官网：https://redis.io/

中文网：http://www.redis.cn/

下载地址：

注意：Windows在Github上下载（停更很久了！)

Redis推荐都是在Linux服务器上搭建的，我们是基于Linux学习！

Redis安装

Windows安装

1、下载安装包: https://github.com/dmajkic/redis/releases

2、下载完毕得到压缩包:

3、解压到自己电脑上的环境目录下的就可以的。

4、开启Redis ,双击运行服务即可。

5、使用Redis客户端连接redis

Linux安装

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

2、解压Redis的安装包！程序/opt （我用的是WSL2 自己创建的environment）

3、进入解压后的文件，可以看到我们redis的配置

reids.conf

4、基本的环境安装

这个是CentOS的

yum install gcc-c++
make
make install

而在WSL2中装的Ubuntu 20

sudo apt-get install build-essential 
sudo apt-get install gcc 
sudo apt-get install g++
make
make install

5、redis的默认安装路径/usr/local/bin

6、将redis配置文件。复制到我们当前目录下

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

上面三步由于wsl2配置暂时找不到对应的设置

8、启动redis

redis-server kconfig/redis.conf  --通过指定修改的启动
redis-cli -p 6379   -- 通过redis客户端进行连接
ping   -- 测试
ps -ef|grep redis -- redis的进程是否开启
shutdown  --  关闭redis服务
exit -- 退出

9、使用redis-cli进行连接测试！

10、查看redis的进程是否开启

测试性能

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

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

redis-benchmark命令参数！

来简单测试下：

#测试：100个并发连接100000请求
redis-benchmark-h localhost-p6379-c100-n100000

基础的知识

redis默认有16个数据库

默认使用的是第0个

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

127.0.0.1:6379>select3#切换数据库
OK
127.0.0.1:6379[3]>DBSIZE#查看DB大小
(integer)0

127.0.0.1:6379[3]> keys*#查看数据库所有的key
1)"name"

清除当前数据库 flushdb

清除全部数据库的内容FLUSHALL

127.0.0.1:6379[3]>flushdb
OK
127.0.0.1:6379[3]>keys*
(empty list or set)

Redis 是单线程的

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

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

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

1、误区1:高性能的服务器一定是多线程的？

2、误区2:多线程（CPU上下文会切换！)一定比单线程效率高！

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

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

五大数据类型

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

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 dafran # 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) -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种：

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

关于重命名RENAME和RENAMENX

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

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

1. String
2. hash：map格式
3. 列表类型list：linkedlist格式元素可重复
4. **集合类型set 元素不重复
5. 有序集合：sortedset元素不重复且排序

String（字符串）

可覆盖

基本指令：

1. 存储：set key value
2. 获取 ：get key nil（没有）
3. 删除：del key

高级用法：

追加：

# 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”

自增自减

# INCR/DECR 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”

获取key保存值的字符串长度

# `STRLEN 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`
127.0.0.1:6379> SETRANGE msg 2 hello 
(integer) 7 
127.0.0.1:6379> get msg 
“tehello”
# 替换返回 key 的旧值(old value)GETSET key value`
127.0.0.1:6379> GETSET msg test 
“hello world”

set

#`SETNX key value`  key不存在时 设置 分布式锁应用
#成功返回1
#失败返回0
127.0.0.1:6379> SETNX msg test 
(integer) 0 
127.0.0.1:6379> SETNX name sakura 
(integer) 1
#set 键值对并设置过期时间`SETEX key seconds value`
127.0.0.1:6379> setex name 10 root 
OK 
127.0.0.1:6379> get name 
(nil)

批量set键值对

#`MSET key1 value1 [key2 value2..]` 批量set键值对
127.0.0.1:6379> MSET k1 v1 k2 v2 k3 v3 OK
#仅当参数中所有的key都不存在时执行 `MSETNX key1 value1 [key2 value2..]`
#成功返回1
#失败返回0
#原子性操作,要么一起成功,要么一起失败。
127.0.0.1:6379> MSETNX k1 v1 k4 v4 
(integer) 0
#批量获取多个key保存的值`MGET key1 [key2..]`
127.0.0.1:6379> MGET k1 k2 k3 
1) “v1” 
2) “v2” 
3) “v3”

getset

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

对象：

set user:1:{name:zhja,age:15}
#user:{id}:{field}
127.0.0.1:6379> mset user:1:name zhan user:1:age 15
127.0.0.1:6379> mget user:1:name user:1:age
1) "zhan"
2) "15"

生存时间

`PSETEX key milliseconds value`
#和 SETEX 命令相似，但它以毫秒为单位设置 key 的生存时间，
`getset key value`
#如果不存在值，则返回nil，
#如果存在值，获取原来的值，并设置新的值
#先get再set

String类似的使用场景：

value除了是字符串还可以是数字，用途举例：

• 
  计数器
• 
  统计多单位的数量：uid:22532676：follow 0
• 
  粉丝数
• 
  对象存储缓存 | 命令 | 描述 | 示例 | | —- | —- | —- | | 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不存在时进行set | 127.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亿个元素)。

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

所有的List命令都是以L开头的

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

有无 “ ”都会被识别成字符，但也不一定。

---------------------------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
---------------------------Linstrt--Rinsert--------------------------
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> Linsert mylist before "world" "other"        # 在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        # 在world之前增加 new
(integer) 4
127.0.0.1:6379> Lrange mylist 0 -1
1) "hello"
2) "other"
3) "world"
4) "new"
---------------------------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)

1、添加

• 
  左部：lpush key value1[value2]
• 
  右部：rpush key value1[value2]
• 
  向已存在的列名中push值（一个或者多个）
  • LPUSHX key value
  • RPUSHX key value

2、获取

• 
  lrange key start end 获取list 起止元素==（索引从左往右 递增）==
• 
  0 -1 全部
• 
  LLEN key获取列表长度
• 
  LINDEX key index 通过索引获取列表元素
• 
  LTRIM key start end 通过下标截取指定范围内的列表

  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"

3、删除

• 
  lpop key：删除最左边的元素，并将元素返回
• 
  rpop key：删除最右边的元素，并将元素返回
• 
  RPOPLPUSH source destination 将列表的尾部(右)最后一个值弹出，并返回，然后加到另一个列表(没有可自动创建)的头部
• 
  BLPOP/BRPOP key1[key2] timout
  • 
    移出并获取列表的第一个/最后一个元素，
  • 
    如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。
  • 
    

    #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)

• 
  BRPOPLPUSH source destination timeout
  • 和RPOPLPUSH功能相同，如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。

• 
  LREM key count value 删除指定key的重复value
  • List中是允许value重复的
  • count > 0：从头部开始搜索 然后删除指定的value 至多删除count个
  • count < 0：从尾部开始搜索…
  • count = 0`：删除列表中所有的指定value。

4、插入

LINSERT key BEFORE|AFTER pivot value

5、修改

• LSET key index value 通过索引为元素设值 | 命令 | 描述 | | —- | —- | | 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 value | List中是允许value重复的
  count > 0
  ：从头部开始搜索 然后删除指定的value 至多删除count个
  count < 0
  ：从尾部开始搜索…
  count = 0
  ：删除列表中所有的指定value。 | | BLPOP/BRPOP key1[key2] timout | 移出并获取列表的第一个/最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。 | | BRPOPLPUSH source destination timeout | 和
  RPOPLPUSH
  功能相同，如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。 |

小结

• list实际上是一个链表，before Node after , left, right 都可以插入值
• 如果key不存在，则创建新的链表
• 如果key存在，新增内容
• 如果移除了所有值，空链表，也代表不存在
• 在两边插入或者改动值，效率最高！修改中间元素，效率相对较低。

应用：

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

Set（集合）

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

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

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

1、添加：

• sadd key value（可多个）

2、获取：

• smembers key 所有元素 nil（没有）
• SCARD key 获取集合的成员数
• 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] 在大量数据环境下，遍历集合中元素，每次遍历部分

3、查询

• SISMEMBER key member 查询member元素是否是集合的成员,结果是无序的
• SRANDMEMBER key [count] 随机返回集合中count个成员，count缺省值为1

4、删除：

• 
  srem key value 删除集合中的某个元素
• 
  SPOP key [count] 随机移除并返回集合中count个成员，count缺省值为1
• 
  SMOVE source destination member 将source集合的成员member移动到destination集合
• 
  SREM key member1[member2..] 移除集合中一个/多个成员

---------------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 是一个string类型的field和value的映射表，hash特别适合用于存储对象。

可以看作Map集合，key-Map ——> key- ！本质和String类型没有太大区别，还是一个简单的key-vlaue!

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

新增

• hset key field value 会覆盖
• HMSET key field1 value1 [field2 value2..] 时将多个 field-value (域-值)对设置到哈希表 key 中。
• HSETNX key field value 只有在字段 field 不存在时，设置哈希表字段的值。
• HINCRBY key field n 为哈希表 key 中的指定字段的整数值加上增量n，并返回增量后结果 一样只适用于整数型字段
• HINCRBYFLOAT key field n 为哈希表 key 中的指定字段的浮点数值加上增量 n。

查找

• HEXISTS key field 查看哈希表 key 中，指定的字段是否存在。
• HSCAN key cursor [MATCH pattern] [COUNT count] 迭代哈希表中的键值对。

获取

• 
  hget key field 获取所有给定字段的值
• 
  HMGET key field1 [field2..] 获取所有给定字段的值
• 
  HGETALL key 获取在哈希表key 的所有字段和值
• 
  HKEYS key 获取哈希表key中所有的字段
• 
  HLEN key 获取哈希表中字段的数量
• 
  HVALS key 获取哈希表中所有值

删除

• 
  hdel key field 删除字段
• 
  HDEL key field1 [field2..] 删除哈希表key中一个/多个field字段

------------------------HSET--HMSET--HSETNX----------------
127.0.0.1:6379> HSET studentx name sakura # 将studentx哈希表作为一个对象 (key-value)，设置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字段        
                HDEL studentx sex     #删除hash指定key字段！对应的value值也就消失了！
(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"

注意：

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

Zset（有序集合）

不同的是每个元素都会关联一个double类型的分数（score）。redis正是通过分数来为集合中的成员进行从小到大的排序。

score相同：按字典顺序排序

有序集合的成员是唯一的,但分数(score)却可以重复。

-------------------ZADD--ZCARD--ZCOUNT--------------
127.0.0.1:6379> ZADD myzset 1 m1 2 m2 3 m3 # 向有序集合myzset中添加成员m1 score=1 以及成员m2 score=2..
(integer) 2
127.0.0.1:6379> ZCARD myzset # 获取有序集合的成员数
(integer) 2
127.0.0.1:6379> ZCOUNT myzset 0 1 # 获取score在 [0,1]区间的成员数量
(integer) 1
127.0.0.1:6379> ZCOUNT myzset 0 -1 # 查看全部的值
(integer) 2
----------------ZINCRBY--ZSCORE--------------------------
127.0.0.1:6379> ZINCRBY myzset 5 m2 # 将成员m2的score +5
"7"
127.0.0.1:6379> ZSCORE myzset m1 # 获取成员m1的score
"1"
127.0.0.1:6379> ZSCORE myzset m2
"7"
--------------ZRANK--ZRANGE-----------------------------------
127.0.0.1:6379> ZRANK myzset m1 # 获取成员m1的索引，索引按照score排序，score相同索引值按字典顺序顺序增加
(integer) 0
127.0.0.1:6379> ZRANK myzset m2
(integer) 2
127.0.0.1:6379> ZRANGE myzset 0 1 # 获取索引在 0~1的成员
1) "m1"
2) "m3"
127.0.0.1:6379> ZRANGE myzset 0 -1 # 获取全部成员
1) "m1"
2) "m3"
3) "m2"
#testset=>{abc,add,amaze,apple,back,java,redis} score均为0
------------------ZRANGEBYLEX---------------------------------
127.0.0.1:6379> ZRANGEBYLEX testset - + # 返回所有成员
1) "abc"
2) "add"
3) "amaze"
4) "apple"
5) "back"
6) "java"
7) "redis"
127.0.0.1:6379> ZRANGEBYLEX testset - + LIMIT 0 3 # 分页 按索引显示查询结果的 0,1,2条记录
1) "abc"
2) "add"
3) "amaze"
127.0.0.1:6379> ZRANGEBYLEX testset - + LIMIT 3 3 # 显示 3,4,5条记录
1) "apple"
2) "back"
3) "java"
127.0.0.1:6379> ZRANGEBYLEX testset (- [apple # 显示 (-,apple] 区间内的成员
1) "abc"
2) "add"
3) "amaze"
4) "apple"
127.0.0.1:6379> ZRANGEBYLEX testset [apple [java # 显示 [apple,java]字典区间的成员
1) "apple"
2) "back"
3) "java"
-----------------------ZRANGEBYSCORE---------------------
127.0.0.1:6379> ZRANGEBYSCORE myzset 1 10 # 返回score在 [1,10]之间的的成员
1) "m1"
2) "m3"
3) "m2"
127.0.0.1:6379> ZRANGEBYSCORE myzset 1 5
1) "m1"
2) "m3"
127.0.0.1:6379> ZRANGEBYSCORE myzset -inf +inf     #从负无穷到正无穷
127.0.0.1:6379> zadd salary 2500 6b92d6    #添加三个用户
(integer) 1
127.0.0.1: 6379> zadd salary 5000 dafran
(integer)
127.0.0.1: 6379> zadd salary 500 zhangsan
(integer) 1
# ZRANGEBYSCORE key min max
127.0.0.1:6379> ZRANGEBYSCORE sa1ary -inf +inf    #显示全部的用户从小到大
1) "zhangsan"
2) "6b92d6"
3) "dafran"
127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf withscores #显示全部的用户并且附带成绩
1) "zhangsan"
2) "500”
3) "6b92d6"
4) "2500"
5) "dafran"
6) "5000"
127.0.0.1:6379> ZRANGEBYSCORE salary -inf 2500 withscores #显示工资小于2500员工的升序排序!
1) "zhangsan"
2) "500”
3) "6b92d6"
4) "2500"
--------------------ZLEXCOUNT-----------------------------
127.0.0.1:6379> ZLEXCOUNT testset - +
(integer) 7
127.0.0.1:6379> ZLEXCOUNT testset [apple [java
(integer) 3
------------------ZREM--ZREMRANGEBYLEX--ZREMRANGBYRANK--ZREMRANGEBYSCORE--------------------------------
127.0.0.1:6379> ZREM testset abc # 移除成员abc
(integer) 1
127.0.0.1:6379> ZREMRANGEBYLEX testset [apple [java # 移除字典区间[apple,java]中的所有成员
(integer) 3
127.0.0.1:6379> ZREMRANGEBYRANK testset 0 1 # 移除排名0~1的所有成员
(integer) 2
127.0.0.1:6379> ZREMRANGEBYSCORE myzset 0 3 # 移除score在 [0,3]的成员
(integer) 2
# testset=> {abc,add,apple,amaze,back,java,redis} score均为0
# myzset=> {(m1,1),(m2,2),(m3,3),(m4,4),(m7,7),(m9,9)}
----------------ZREVRANGE--ZREVRANGEBYSCORE--ZREVRANGEBYLEX-----------
127.0.0.1:6379> ZREVRANGE myzset 0 3 # 按score递减排序，然后按索引，返回结果的 0~3
1) "m9"
2) "m7"
3) "m4"
4) "m3"
127.0.0.1:6379> ZREVRANGE myzset 0 -1 #从大到小排序
127.0.0.1:6379> ZREVRANGE myzset 2 4 # 返回排序结果的 索引的2~4
1) "m4"
2) "m3"
3) "m2"
127.0.0.1:6379> ZREVRANGEBYSCORE myzset 6 2 # 按score递减顺序 返回集合中分数在[2,6]之间的成员
1) "m4"
2) "m3"
3) "m2"
127.0.0.1:6379> ZREVRANGEBYLEX testset [java (add # 按字典倒序 返回集合中(add,java]字典区间的成员
1) "java"
2) "back"
3) "apple"
4) "amaze"
-------------------------ZREVRANK------------------------------
127.0.0.1:6379> ZREVRANK myzset m7 # 按score递减顺序，返回成员m7索引
(integer) 1
127.0.0.1:6379> ZREVRANK myzset m2
(integer) 4
# mathscore=>{(xm,90),(xh,95),(xg,87)} 小明、小红、小刚的数学成绩
# enscore=>{(xm,70),(xh,93),(xg,90)} 小明、小红、小刚的英语成绩
-------------------ZINTERSTORE--ZUNIONSTORE-----------------------------------
127.0.0.1:6379> ZINTERSTORE sumscore 2 mathscore enscore # 将mathscore enscore进行合并 结果存放到sumscore
(integer) 3
127.0.0.1:6379> ZRANGE sumscore 0 -1 withscores # 合并后的score是之前集合中所有score的和
1) "xm"
2) "160"
3) "xg"
4) "177"
5) "xh"
6) "188"
127.0.0.1:6379> ZUNIONSTORE lowestscore 2 mathscore enscore AGGREGATE MIN # 取两个集合的成员score最小值作为结果的
(integer) 3
127.0.0.1:6379> ZRANGE lowestscore 0 -1 withscores
1) "xm"
2) "70"
3) "xg"
4) "87"
5) "xh"
6) "93"

新增

• zadd key score value（可多个）
• ZADD key score member1 [score2 member2] 向有序集合添加一个或多个成员，或者更新已存在成员的分数
• ZINCRBY key n member 有序集合中对指定成员的分数加上增量 n

获取

• 
  ZCARD key 获取有序集合的成员数
• 
  ZCOUNT key min max 计算在有序集合中指定区间score的成员数
• 
  ZSCORE key member 返回有序集中，成员的分数值
• 
  ZRANK key member 返回有序集合中指定成员的索引
• 
  ZRANGE key start end 通过索引区间返回有序集合成指定区间内的成员
• 
  ZRANGEBYLEX key min max 通过字典区间返回有序集合的成员
• 
  ZRANGEBYSCORE key min max 通过分数返回有序集合指定区间内的成员==-inf 和 +inf分别表示最小最大值，只支持开区间()==
• 
  ZLEXCOUNT key min max 在有序集合中计算指定字典区间内成员数量
• 
  ZREVRANGE key start end 返回有序集中指定区间内的成员，通过索引，分数从高到底
• 
  ZREVRANGEBYSCORRE key max min 返回有序集中指定分数区间内的成员，分数从高到低排序
• 
  ZREVRANGEBYLEX key max min 返回有序集中指定字典区间内的成员，按字典顺序倒序
• 
  ZREVRANK key member 返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序
• 
  ZINTERSTORE destination numkeys key1 [key2 ..]
  • 计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中，
  • numkeys：表示参与运算的集合数，将score相加作为结果的score

• 
  ZUNIONSTORE destination numkeys key1 [key2..]
  • 计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中

• 
  ZSCAN key cursor [MATCH pattern] [COUNT count]
  • 迭代有序集合中的元素（包括元素成员和元素分值）

移除

• 
  zrem key value 删除集合中的某个元素
• 
  ZREM key member1 [member2..] 移除有序集合中一个/多个成员
• 
  ZREMRANGEBYLEX key min max 移除有序集合中给定的字典区间的所有成员
• 
  ZREMRANGEBYRANK key start stop 移除有序集合中给定的排名区间的所有成员
• 
  ZREMRANGEBYSCORE key min max 移除有序集合中给定的分数区间的所有成员 | 命令 | 描述 | | —- | —- | | ZADD key score member1 [score2 member2] | 向有序集合添加一个或多个成员，或者更新已存在成员的分数 | | ZCARD key | 获取有序集合的成员数 | | ZCOUNT key min max | 计算在有序集合中指定区间score的成员数 | | ZINCRBY key n member | 有序集合中对指定成员的分数加上增量 n | | ZSCORE key member | 返回有序集中，成员的分数值 | | ZRANK key member | 返回有序集合中指定成员的索引 | | ZRANGE key start end | 通过索引区间返回有序集合成指定区间内的成员 | | ZRANGEBYLEX key min max | 通过字典区间返回有序集合的成员 | | ZRANGEBYSCORE key min max | 通过分数返回有序集合指定区间内的成员==-inf 和 +inf分别表示最小最大值，只支持开区间()== | | ZLEXCOUNT key min max | 在有序集合中计算指定字典区间内成员数量 | | ZREM key member1 [member2..] | 移除有序集合中一个/多个成员 | | ZREMRANGEBYLEX key min max | 移除有序集合中给定的字典区间的所有成员 | | ZREMRANGEBYRANK key start stop | 移除有序集合中给定的排名区间的所有成员 | | ZREMRANGEBYSCORE key min max | 移除有序集合中给定的分数区间的所有成员 | | ZREVRANGE key start end | 返回有序集中指定区间内的成员，通过索引，分数从高到底 | | ZREVRANGEBYSCORRE key max min | 返回有序集中指定分数区间内的成员，分数从高到低排序 | | ZREVRANGEBYLEX key max min | 返回有序集中指定字典区间内的成员，按字典顺序倒序 | | ZREVRANK key member | 返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序 | | ZINTERSTORE destination numkeys key1 [key2 ..] | 计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中，numkeys：表示参与运算的集合数，将score相加作为结果的score | | ZUNIONSTORE destination numkeys key1 [key2..] | 计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中 | | ZSCAN key cursor [MATCH pattern\\] [COUNT count] | 迭代有序集合中的元素（包括元素成员和元素分值） |

应用案例：

• set排序 存储班级成绩表 工资表排序！
• 普通消息，1.重要消息 2.带权重进行判断
• 排行榜应用实现，取Top N测试

三种特殊数据类型

geospatial（地理位置）

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

查询：http://www.jsons.cn/lngcode/

官方文档https://www.redis.net.cn/order/3685.html

----------------geoadd---------------------
#添加地理位置
#规则：南北两极无法直接添加
#一般用java程序一次导入
#有效经纬度
- 有效的经度从-180度到180度。
- 有效的纬度从-85.05112878度到85.05112878度。
#geoadd 参数 key    值（纬度、经度、名称）
#geoadd key longitud(经度) latitude(纬度) member [..]
127.0.0.1:6379> geoadd china:city 116.40 39.90 bejing
(integer) 1
127.0.0.1:6379> geoadd china:city 121.47 31.23 shanghai
(integer) 1
127.0.0.1:6379> geoadd china:city 106.
(error) ERR wrong number of arguments for 'geoadd' command
127.0.0.1:6379> geoadd china:city 106.50 29.53 chongqing 108.96 34.26 xian
(integer) 2
127.0.0.1:6379> geoadd china:city 114.13 22.54 shengzhen
(integer) 1
----------------geopos---------------------
# geopos key member [member..]获取集合中的一个/多个成员坐标
#获取集合中的一个/多个成员坐标
127.0.0.1:6379> geopos china:city bejing
1) 1) "116.39999896287918091"
   2) "39.90000009167092543"
127.0.0.1:6379> geopos china:city xian
1) 1) "108.96000176668167114"
   2) "34.25999964418929977"
----------------geodist---------------------
#geodist key member1 member2 [unit]
#返回两个给定位置之间的距离 
#unit必须是以下单位的其中一个：
- **m** 表示单位为米  默认。
- **km** 表示单位为千米。
- **mi** 表示单位为英里。
- **ft** 表示单位为英尺。
127.0.0.1:6379> geodist china:city bejing xian km
"910.0565"
127.0.0.1:6379> geodist china:city xian chongqing
"575046.9885"
127.0.0.1:6379> geodist china:city xian chongqing ft
"1886637.1015"
127.0.0.1:6379> geodist china:city xian chongqing mi
"357.3185"
127.0.0.1:6379> geodist china:city xian chongqing m
"575046.9885"
127.0.0.1:6379> geodist china:city xian chongqing 
"575046.9885"
----------------georadius---------------------
#georadius key longitude latitude radius m|km|mi|ft [WITHCOORD][WITHDIST] [WITHHASH] [COUNT count]
#以给定的经纬度为中心， 返回集合包含的位置元素当中， 与中心的距离不超过给定最大距离的所有位置元素。
#通过`georadius`就可以完成 **附近的人**功能
#withcoord:带上坐标
#withdist:带上距离，单位与半径单位相同
#COUNT n : 只显示前n个(按距离递增排序)
127.0.0.1:6379> GEORADIUS china:city 120 30 500 km withcoord withdist 
# 查询经纬度(120,30)
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"
------------GEORADIUSBYMEMBER---------------------------   
#找出位于指定元素周围的其他元素
#城市之间的定位
#GEORADIUSBYMEMBER key member radius...功能与GEORADIUS相同，
#只是中心位置不是具体的经纬度，而是使用结合中已有的成员作为中心点。
127.0.0.1:6379> georadiusbymember china:city bejing 1000 km
1) "bejing"
2) "xian"
127.0.0.1:6379> georadiusbymember china:city shanghai 400 km
1) "shanghai"
------------geohash---------------------------
#geohash key member1 [member2..]
#返回一个或多个位置元素的Geohash表示。
#使用Geohash位置52点整数编码。
#二维的经纬度转换为一维的字符串
#两字符串越近，代表距离越近
127.0.0.1:6379> geohash china:city yichang shanghai # 获取成员经纬坐标的geohash表示
1) "wmrjwbr5250"
2) "wtw6ds0y300"
127.0.0.1:6379> geohash china:city bejing
1) "wx4fbxxfke0"

底层实现原理是Zset，可以使用Zset来操作地理数据

127.0.0.1:6379> zrange china:city 0 -1
1) "chongqing"
2) "xian"
3) "shengzhen"
4) "shanghai"
5) "bejing"
127.0.0.1:6379> zrem china:city shengzhen
(integer) 1
127.0.0.1:6379> zrange china:city 0 -1
1) "chongqing"
2) "xian"
3) "shanghai"
4) "bejing"
127.0.0.1:6379>

hyperloglog（基数统计）

Redis HyperLogLog 是用来做基数统计的算法，HyperLogLog 的优点是，在输入元素的数量或者体积非常非常大时，计算基数所需的空间总是固定的、并且是很小的。

花费 12 KB 内存，就可以计算接近 2^64 个不同元素的基数。

因为 HyperLogLog 只会根据输入元素来计算基数，而不会储存输入元素本身，所以 HyperLogLog 不能像集合那样，返回输入的各个元素。

其底层使用string数据类型

0.81%错误率!统计∪V任务,可以忽略不计的

什么是基数？

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

应用场景：

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

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

指令

----------PFADD--PFCOUNT---------------------
#PFADD key element1 [elememt2..]
#添加指定元素到 HyperLogLog 中
#PFCOUNT key [key]
#返回给定 HyperLogLog 的基数估算值。有误差
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-----------------------
#`PFMERGE destkey sourcekey [sourcekey..]`
#将多个 HyperLogLog 合并为一个 HyperLogLog
#destkey  新合成
#sourcekey 合成一
#sourcekey... 合成二、.....
127.0.0.1:6379> PFMERGE myelemz myelemx myelemy # 合并myelemx和myelemy 成为myelemz
OK
127.0.0.1:6379> PFCOUNT myelemz # 查看并集数量
(integer) 17

bitmap（位图）

使用位存储，信息状态只有 0 和 1

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

• 
  一种数据结构
• 
  使用位存储，信息状态只有 0 和 1
• 
  Bitmap是一串连续的2进制数字（0或1），每一位所在的位置为偏移(offset)
• 
  在bitmap上可执行AND,OR,XOR,NOT以及其它位操作。
• 
  365 天 = 365 bit 1字节 = 8bit 46 个字节左右！
• 
  本质string

应用场景

签到统计、状态统计

------------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

Jedis

• Jedis是Redis官方推荐的Java连接开发工具。
• 要在Java开发中使用好Redis中间件，必须对Jedis熟悉才能写成漂亮的代码。

1、导入依赖

<dependencies>
    <!--Jedis-->
    <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.62</version>
    </dependency>
</dependencies>

2、编码测试:

• 
  连接数据库
  1. 修改redis.conf的配置文件

vim /usr/local/bin/myconfig/redis.conf
1

1. 
   将只绑定本地注释

bind 127.0.0.1

```bash

1. 
   保护模式改为 no

   protected-mode yes 修改
   protected-mode no

3. 允许后台运行
```bash
  daemonize no改为yes

1. 
   开放端口6379

   firewall-cmd --zone=public --add-port=6379/tcp --permanet
   1

5. 重启防火墙服务
  ```bash
systemctl restart firewalld.service
  1

 1. 阿里云服务器控制台配置安全组
   2. 重启redis-server
      ```bash
      [root@AlibabaECS bin]# redis-server myconfig/redis.conf 
      1

> 测试连接
**TestPing.java**
```java
public class TestPing {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("192.168.xx.xxx", 6379);
        String response = jedis.ping();
        System.out.println(response); // PONG
    }
}

常用Api

String

List

Set

Hash

Zset

和上面操作一样

操作事务

public class TestTX {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1",6379);
        jedis.flushDB();    //清空数据库
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("name","dafran");
        jsonObject.put("title","chi");
        //开启事务
        Transaction multi = jedis.multi();
        String result = jsonObject.toJSONString();
        //jedis.watch(result);
        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();  //关闭事务
        }
    }
}

Redis.conf详解

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

启动的时候，就通过配置文件来启动。

单位

1、配置文件unit单位对大小写不敏感，

包含

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

就是好比我们学习 Spring、Import、include

网络

bind 127.0.0.1        # 绑定的ip
protected-mode yes        # 保护模式
port 6379        #端口设置

通用 GENERAL

daemonize yes        #以守护进程的方式运行，默认是no，需要自己的开启为yes
pidfile /var/run/redis_6379.pid        #如果以后台方式运行，就需要指定一个pid文件
# 日志
# Specify the server verbosity level.
# This can be one of:
# debug (a lot of information, useful for development/testing)
# verbose (many rarely useful info, but not a mess like the debug level)
# notice (moderately verbose, what you want in production probably)        生产环境
# warning (only very important / critical messages are logged)
loglevel notice
logfile ""        # 日志输出文件名
databases 16    # 数据库的数量，默认为16个
always-show-logo yes        # 是否总是显示logo

快照 SNAPSHOTTING

持久化，在规定的时间内，执行了多少次操作，则会持久化到文件 `.rdb ` `.aof`
由于Redis是基于内存的数据库，需要将数据由内存持久化到文件中，如果没有持久化，则会断电即失。

# 如果在900s内，如果至少1个key进行修改，我们就进行持久化操作
save 900 1
save 300 10
save 60 10000
# 持久化出错，是否还继续工作
stop-writes-on-bgsave-error yes
# 是否压缩 rdb 文件，需要消耗一些cpu资源
rdbcompression yes
# 保护rdb文件的时候，进行错误的检查校验
rdbchecksum yes
# rdb 文件保存目录
dir ./