1 概述

1.1 NoSQL数据库

1.1.1 NoSQL数据库概述

NoSQL(NoSQL = Not Only SQL )，意即“不仅仅是SQL”，泛指非关系型的数据库。

NoSQL 不依赖业务逻辑方式存储，而以简单的key-value模式存储。因此大大的增加了数据库的扩展能力。

  • 不遵循SQL标准。

  • 不支持ACID。

  • 远超于SQL的性能。

1.1.2 NoSQL适用场景

NoSQL适用的场景有：

  • 对数据高并发的读写

  • 海量数据的读写

  • 对数据高可扩展性的

不适用的场景有：

  • 需要事务支持

  • 基于sql的结构化查询存储，处理复杂的关系,需要即席查询。

1.1.3 常见的NoSQL数据库

Memcache

  • 很早出现的NoSql数据库

  • 数据都在内存中，一般不持久化

  • 支持简单的key-value模式，支持类型单一

  • 一般是作为缓存数据库辅助持久化的数据库

Redis

  • 几乎覆盖了Memcached的绝大部分功能

  • 数据都在内存中，支持持久化，主要用作备份恢复

  • 除了支持简单的key-value模式，还支持多种数据结构的存储，比如 list、set、hash、zset等。

  • 一般是作为缓存数据库辅助持久化的数据库‘

MongoDB

  • 高性能、开源、模式自由(schema free)的文档型数据库

  • 数据都在内存中， 如果内存不足，把不常用的数据保存到硬盘

  • 虽然是key-value模式，但是对value（尤其是json）提供了丰富的查询功能

  • 支持二进制数据及大型对象

  • 可以根据数据的特点替代RDBMS ，成为独立的数据库。或者配合RDBMS，存储特定的数据。

1.2 行式数据库和列式数据库

1.2.1 概述

列如如下表：

行式数据库存储为：【张三，北京，20】，【李四，上海，45】，【王五，哈尔滨，30】

列式数据库存储为：【张三，李四，王五】，【北京，上海，哈尔滨】，【20，45，30】

可以发现，若要查id为3的人员信息，行式数据库较为快，若要查年龄的平均值，则列式数据库较为快

1.2.2 常见的列式数据库

Hbase：

HBase是Hadoop项目中的数据库。它用于需要对大量的数据进行随机、实时的读写操作的场景中。HBase的目标就是处理数据量非常庞大的表，可以用普通的计算机处理超过10亿行数据，还可处理有数百万列元素的数据表。

Cassandra：

Apache Cassandra是一款免费的开源NoSQL数据库，其设计目的在于管理由大量商用服务器构建起来的庞大集群上的海量数据集(数据量通常达到PB级别)。在众多显著特性当中，Cassandra最为卓越的长处是对写入及读取操作进行规模调整，而且其不强调主集群的设计思路能够以相对直观的方式简化各集群的创建与扩展流程。

1.3 Redis概述和安装

1.3.1 Redis概述

Redis是一个开源的key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括

  • string(字符串)

  • list(链表)

  • set(集合)

  • zset(sorted set --有序集合)

  • hash（哈希类型）

这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，Redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是Redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件。并且在此基础上实现了master-slave(主从)同步。

1.3.2 Redis安装

redis安装地址

下载：

wget https://download.redis.io/releases/redis-6.2.1.tar.gz

解压：

tar -xzvf redis-6.2.1.tar.gz

由于redis需要c语言编译环境，这里安装gcc

yum install gcc
​
# 测试
gcc --version

在redis-6.2.1目录下进行编译，打包

make        # 若报无.h文件则执行 make distclean
make install

安装目录默认为：/usr/local/bin

  • redis-benchmark:性能测试工具，可以在自己本子运行，看看自己本子性能如何

  • redis-check-aof：修复有问题的AOF文件

  • redis-check-dump：修复有问题的dump.rdb文件

  • redis-sentinel：Redis集群使用

  • redis-server：Redis服务器启动命令

  • redis-cli：客户端，操作入口

前台启动redis

# 前台启动
redis-server

后台启动redis:

  1. 修改redis.conf

# 原来
daemonize no
# 修改后
daemonize yes

  1. 启动redis

redis-server /etc/redis.conf

1.4 redis相关知识介绍

默认16个数据库，类似数组下标从0开始，初始默认使用0号库

切换数据库使用

select [index]

Redis是单线程+多路IO复用技术

多路复用是指使用一个线程来检查多个文件描述符（Socket）的就绪状态，比如调用select和poll函数，传入多个文件描述符，如果有一个文件描述符就绪，则返回，否则阻塞直到超时。得到就绪状态后进行真正的操作可以在同一个线程里执行，也可以启动线程执行（比如使用线程池）

与Memcache三点不同: 支持多数据类型，支持持久化，单线程+多路IO复用

2 常见的数据类型

2.1 Key

keys 查看当前库所有key (匹配：keys 1)

exists key判断某个key是否存在

type key 查看你的key是什么类型

del key 删除指定的key数据

unlink key 根据value选择非阻塞删除

expire key 10 10秒钟：为给定的key设置过期时间

ttl key查看还有多少秒过期，-1表示永不过期，-2表示已过期

select命令切换数据库

dbsize查看当前数据库的key的数量

flushdb清空当前库

flushall通杀全部库

del 和 unlink 区别：

unlink仅将keys从keyspace元数据中删除，真正的删除会在后续异步操作。

2.2 String

2.2.1 介绍

String是Redis最基本的类型，你可以理解成与Memcached一模一样的类型，一个key对应一个value。String类型是二进制安全的。意味着Redis的string可以包含任何数据。比如jpg图片或者序列化的对象。

String类型是Redis最基本的数据类型，一个Redis中字符串value最多可以是512M

2.2.2 基本操作

set <key> <value> [EX|PX]添加键值对

当数据库中key不存在时，可以将key-value添加数据库

当数据库中key存在时，可以将key-value添加数据库，覆盖掉原先的值

EX、PX设置超时时间，EX是秒级，PX是毫秒级

append <key> <value>将给定的value 追加到原值的末尾

strlen <key>获得值的长度

setnx <key> <value>只有在 key 不存在时设置 key 的值

set和setnx的区别

setnx在当key存在时不能操作，set当key存在时会覆盖原先的值

incr <key>将 key 中储存的数字值增1，只能对数字值操作，如果为空，新增值为1

decr <key>将 key 中储存的数字值减1，只能对数字值操作，如果为空，新增值为-1

incrby/decrby <key> <步长>将 key 中储存的数字值增减。自定义步长。

incr和decr是原子操作

所谓原子操作是指不会被线程调度机制打断的操作；

这种操作一旦开始，就一直运行到结束，中间不会有任何 context switch （切换到另一个线程）。

（1）在单线程中， 能够在单条指令中完成的操作都可以认为是"原子操作"，因为中断只能发生于指令之间。

（2）在多线程中，不能被其它进程（线程）打断的操作就叫原子操作。

Redis单命令的原子性主要得益于Redis的单线程。

mset <key1> <value1> <key2> <value2> .....同时设置一个或多个 key-value对

mget <key1> <key2> <key3> .....同时获取一个或多个 value

msetnx <key1> <value1> <key2> <value2> .....同时设置一个或多个 key-value 对，当且仅当所有给定 key 都不存在。

msetnx操作有原子性，有一个失败则都失败

getrange <key> <起始位置> <结束位置>获得值的范围，类似java中的substring

getrange是全闭区间，列如lucymay -> [0,3] -> lucy

setrange <key> <起始位置> <value>用 value 覆写key所储存的字符串值，从起始位置开始

setex <key> <过期时间> <value>设置键值的同时，设置过期时间，单位秒。

getset <key> <value>以新换旧，设置了新值同时获得旧值。

2.2.3 数据结构

String的数据结构为简单动态字符串(Simple Dynamic String,缩写SDS)。是可以修改的字符串，内部结构实现上类似于Java的ArrayList，采用预分配冗余空间的方式来减少内存的频繁分配.

如图中所示，内部为当前字符串实际分配的空间capacity一般要高于实际字符串长度len。当字符串长度小于1M时，扩容都是加倍现有的空间，如果超过1M，扩容时一次只会多扩1M的空间。需要注意的是字符串最大长度为512M。

2.3 List

2.3.1 简介

Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）。

它的底层实际是个双向链表，对两端的操作性能很高，通过索引下标的操作中间的节点性能会较差。

2.3.2 常用命令

lpush/rpush <key> <value1> <value2> <value3> ....从左边/右边插入一个或多个值。

lpop/rpop <key>从左边/右边吐出一个值

当值都取出来后，键就不存在了

rpoplpush <key1> <key2>从key1列表右边吐出一个值，插到key2列表左边。

lrange <key> <start> <stop>按照索引下标获得元素(从左到右)

lindex <key> <index>按照索引下标获得元素(从左到右)

llen <key>获得列表长度

linsert <key> [before|after] <value> <newvalue>在value的前面/后面插入newvalue插入值

若有多个值相同只会执行一次

lrem <key> <n> <value>从左边删除n个value(从左到右)

lset <key> <index> <value>将列表key下标为index的值替换成value

2.3.3 数据结构

List的数据结构为快速链表quickList。

首先在列表元素较少的情况下会使用一块连续的内存存储，这个结构是ziplist，也即是压缩列表。它将所有的元素紧挨着一起存储，分配的是一块连续的内存。当数据量比较多的时候才会改成quicklist。

因为普通的链表需要的附加指针空间太大，会比较浪费空间。比如这个列表里存的只是int类型的数据，结构上还需要两个额外的指针prev和next。

Redis将链表和ziplist结合起来组成了quicklist。也就是将多个ziplist使用双向指针串起来使用。这样既满足了快速的插入删除性能，又不会出现太大的空间冗余。

2.4 Set

2.4.1 简介

Redis set对外提供的功能与list类似是一个列表的功能，特殊之处在于set是可以自动排重的，当你需要存储一个列表数据，又不希望出现重复数据时，set是一个很好的选择，并且set提供了判断某个成员是否在一个set集合内的重要接口，这个也是list所不能提供的。

Redis的Set是string类型的无序集合。它底层其实是一个value为null的hash表，所以添加，删除，查找的复杂度都是O(1)。

一个算法，随着数据的增加，执行时间的长短，如果是O(1)，数据增加，查找数据的时间不变

2.4.2 常用命令

sadd <key><value1><value2> .....将一个或多个 member 元素加入到集合 key 中，已经存在的 member 元素将被忽略

smembers <key>取出该集合的所有值。

sismember <key> <value>判断集合key是否为含有该value值，有1，没有0

scard<key>返回该集合的元素个数。

srem <key> <value1> <value2> ....删除集合中的某个元素。

spop <key>随机从该集合中吐出一个值。

srandmember <key> <n>随机从该集合中取出n个值。不会从集合中删除 。

smove <source> <destination> <value>把集合中一个值从一个集合移动到另一个集合

sinter <key1> <key2>返回两个集合的交集元素。

sunion <key1> <key2>返回两个集合的并集元素。

sdiff <key1> <key2>返回两个集合的差集元素(key1中的，不包含key2中的)

2.4.3 数据结构

Set数据结构是dict字典，字典是用哈希表实现的。

Java中HashSet的内部实现使用的是HashMap，只不过所有的value都指向同一个对象。Redis的set结构也是一样，它的内部也使用hash结构，所有的value都指向同一个内部值。

2.5 Hash

2.5.1 简介

Redis hash 是一个键值对集合，是一个string类型的field和value的映射表，hash特别适合用于存储对象。类似Java里面的Map<String,Object>

2.5.2 常用命令

hset <key> <field> <value>给key集合中的 field键赋值value

hget <key1> <field>从key1集合field取出 value

hmset <key1> <field1> <value1> <field2> <value2>...批量设置hash的值

hexists <key1> <field>查看哈希表 key 中，给定域 field 是否存在。

hkeys <key>列出该hash集合的所有field

hvals <key>列出该hash集合的所有value

hincrby <key> <field> <increment>为哈希表 key 中的域 field 的值加上增量 1 -1

hsetnx <key> <field> <value>将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在 .

2.5.3 数据结构

Hash类型对应的数据结构是两种：ziplist（压缩列表），hashtable（哈希表）。当field-value长度较短且个数较少时，使用ziplist，否则使用hashtable。

2.6 Zset

2.6.1 简介

Redis有序集合zset与普通集合set非常相似，是一个没有重复元素的字符串集合。

不同之处是有序集合的每个成员都关联了一个评分（score）,这个评分（score）被用来按照从最低分到最高分的方式排序集合中的成员。集合的成员是唯一的，但是评分可以是重复了 。

因为元素是有序的, 所以你也可以很快的根据评分（score）或者次序（position）来获取一个范围的元素。

访问有序集合的中间元素也是非常快的,因此你能够使用有序集合作为一个没有重复成员的智能列表。

2.6.2 常用命令

zadd <key> <score1> <value1> <score2> <value2>…将一个或多个 member 元素及其 score 值加入到有序集 key 当中。

zrange <key><start><stop> [WITHSCORES]返回有序集 key 中，下标在start,stop之间的元素带WITHSCORES，可以让分数一起和值返回到结果集。

zrangebyscore key min max [withscores] [limit offset count]返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。

zrevrangebyscore key max min [withscores] [limit offset count]同上，改为从大到小排列。

zincrby <key> <increment> <value> 为元素的score加上增量

zrem <key> <value>删除该集合下，指定值的元素

zcount <key> <min> <max>统计该集合，分数区间内的元素个数

zrank <key> <value>返回该值在集合中的排名，从0开始。

2.6.3 数据结构

SortedSet(zset)是Redis提供的一个非常特别的数据结构，一方面它等价于Java的数据结构Map<String, Double>，可以给每一个元素value赋予一个权重score，另一方面它又类似于TreeSet，内部的元素会按照权重score进行排序，可以得到每个元素的名次，还可以通过score的范围来获取元素的列表。

zset底层使用了两个数据结构

（1）hash，hash的作用就是关联元素value和权重score，保障元素value的唯一性，可以通过元素value找到相应的score值。

（2）跳跃表，跳跃表的目的在于给元素value排序，根据score的范围获取元素列表。

3 常用配置文件

3.1 UNIT单位

# Note on units: when memory size is needed, it is possible to specify
# it in the usual form of 1k 5GB 4M and so forth:
#
# 1k => 1000 bytes
# 1kb => 1024 bytes
# 1m => 1000000 bytes
# 1mb => 1024*1024 bytes
# 1g => 1000000000 bytes
# 1gb => 1024*1024*1024 bytes
#
# units are case insensitive so 1GB 1Gb 1gB are all the same.

配置大小单位,开头定义了一些基本的度量单位，只支持bytes，不支持bit，对大小写不敏感

3.2 INCLUDES包含

################################## INCLUDES ###################################
​
# Include one or more other config files here.  This is useful if you
# have a standard template that goes to all Redis servers but also need
# to customize a few per-server settings.  Include files can include
# other files, so use this wisely.
#
# Note that option "include" won't be rewritten by command "CONFIG REWRITE"
# from admin or Redis Sentinel. Since Redis always uses the last processed
# line as value of a configuration directive, you'd better put includes
# at the beginning of this file to avoid overwriting config change at runtime.
#
# If instead you are interested in using includes to override configuration
# options, it is better to use include as the last line.
#
# include /path/to/local.conf
# include /path/to/other.conf
​

类似jsp中的include，多实例的情况可以把公用的配置文件提取出来

3.3 网络相关配置

3.3.1 bind

bind 127.0.0.1 -::1

默认情况bind=127.0.0.1只能接受本机的访问请求

不写的情况下，无限制接受任何ip地址的访问

生产环境肯定要写你应用服务器的地址；服务器是需要远程访问的，所以需要将其注释掉

3.3.2 protected-mode

protected-mode yes

如果开启了protected-mode，那么在没有设定bind ip且没有设密码的情况下，Redis只允许接受本机的响应

3.3.3 port

port 6379

端口号，默认 6379

3.3.4 tcp-backlog

tcp-backlog 511

设置tcp的backlog，backlog其实是一个连接队列，backlog队列总和=未完成三次握手队列 + 已经完成三次握手队列。

在高并发环境下你需要一个高backlog值来避免慢客户端连接问题。

注意Linux内核会将这个值减小到/proc/sys/net/core/somaxconn的值（128），所以需要确认增大/proc/sys/net/core/somaxconn和/proc/sys/net/ipv4/tcp_max_syn_backlog（128）两个值来达到想要的效果

3.3.5 timeout

timeout 0

一个空闲的客户端维持多少秒会关闭，0表示关闭该功能。即永不关闭。

3.3.6 tcp-keepalive

tcp-keepalive 300

对访问客户端的一种心跳检测，每个隔秒检测一次。若检测时客户端无响应，则会释放连接

单位为秒，如果设置为0，则不会进行Keepalive检测，建议设置成60

3.4 GENERAL 通用

3.4.1 daemonize

daemonize yes

是否为后台进程，设置为yes为守护进程，后台启动

3.4.2 pidfile

pidfile /var/run/redis_6379.pid

存放pid文件的位置，每个实例会产生一个不同的pid文件（即保存进程号）

3.4.3 loglevel

loglevel notice

指定日志记录级别，Redis总共支持四个级别：debug、verbose、notice、warning，默认为notice

  • debug，类似java的debug

  • verbose，类似java的info

  • notice，生产中使用

  • warning，只显示警告和一些重要信息

3.4.4 logfile

logfile ""

设置日志文件存放位置

3.4.5 databases

databases 16

设定库的数量 默认16，默认数据库为0，可以使用SELECT <dbid>命令在连接上指定数据库id

3.5 SECURITY安全

# requirepass foobared

访问密码的查看、设置和取消

在命令中设置密码，只是临时的。重启redis服务器，密码就还原了。

永久设置，需要再配置文件中进行设置。

命令行：

config get requirepass # 查看密码
config set requirepass "123456"	# 设置密码
auth 123456 # 登录

3.6 LIMITS限制

3.6.1 maxclients

# maxclients 10000

  • 设置redis同时可以与多少个客户端进行连接。

  • 默认情况下为10000个客户端。

  • 如果达到了此限制，redis则会拒绝新的连接请求，并且向这些连接请求方发出“max number of clients reached”以作回应。

3.6.2 maxmemory

# maxmemory <bytes>

  • 建议必须设置，否则，将内存占满，造成服务器宕机

  • 设置redis可以使用的内存量。一旦到达内存使用上限，redis将会试图移除内部数据，移除规则可以通过maxmemory-policy来指定。

  • 如果redis无法根据移除规则来移除内存中的数据，或者设置了“不允许移除”，那么redis则会针对那些需要申请内存的指令返回错误信息，比如SET、LPUSH等。

  • 但是对于无内存申请的指令，仍然会正常响应，比如GET等。如果你的redis是主redis（说明你的redis有从redis），那么在设置内存使用上限时，需要在系统中留出一些内存空间给同步队列缓存，只有在你设置的是“不移除”的情况下，才不用考虑这个因素。

3.6.3 axmemory-policy

# maxmemory-policy noeviction

  • volatile-lru：使用LRU算法移除key，只对设置了过期时间的键；（最近最少使用）

  • allkeys-lru：在所有集合key中，使用LRU算法移除key

  • volatile-random：在过期集合中移除随机的key，只对设置了过期时间的键

  • allkeys-random：在所有集合key中，移除随机的key

  • volatile-ttl：移除那些TTL值最小的key，即那些最近要过期的key

  • noeviction：不进行移除。针对写操作，只是返回错误信息

3.6.4 maxmemory-samples

# maxmemory-samples 5

  • 设置样本数量，LRU算法和最小TTL算法都并非是精确的算法，而是估算值，所以你可以设置样本的大小，redis默认会检查这么多个key并选择其中LRU的那个。

  • 一般设置3到7的数字，数值越小样本越不准确，但性能消耗越小。

3.7 SNAPSHOTTING快照

3.7.1 save

格式：save 秒钟 写操作次数

RDB是整个内存的压缩过的Snapshot，RDB的数据结构，可以配置复合的快照触发条件，

默认是1分钟内改了1万次，或5分钟内改了10次，或15分钟内改了1次。

# You can set these explicitly by uncommenting the three following lines.
#
# save 3600 1
# save 300 100
# save 60 10000

3.7.2 stop-writes-on-bgsave-error

# However if you have setup your proper monitoring of the Redis server
# and persistence, you may want to disable this feature so that Redis will
# continue to work as usual even if there are problems with disk,
# permissions, and so forth.
stop-writes-on-bgsave-error yes

当Redis无法写入磁盘的话，直接关掉Redis的写操作。推荐yes.

3.7.3 rdbcompression

# Compress string objects using LZF when dump .rdb databases?
# By default compression is enabled as it's almost always a win.
# If you want to save some CPU in the saving child set it to 'no' but
# the dataset will likely be bigger if you have compressible values or keys.
rdbcompression yes

对于存储到磁盘中的快照，可以设置是否进行压缩存储。如果是的话，redis会采用LZF算法进行压缩。

如果你不想消耗CPU来进行压缩的话，可以设置为关闭此功能。推荐yes.

3.7.4 rdbchecksum

# RDB files created with checksum disabled have a checksum of zero that will
# tell the loading code to skip the check.
rdbchecksum yes

在存储快照后，还可以让redis使用CRC64算法来进行数据校验，

但是这样做会增加大约10%的性能消耗，如果希望获取到最大的性能提升，可以关闭此功能

推荐yes.

4 发布和订阅

4.1 什么是发布和订阅

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

Redis 客户端可以订阅任意数量的频道。

4.2 Redis发布和订阅

客户端可以订阅频道

当给这个频道发布消息后，消息就会发送给订阅的客户端

4.3 发布订阅命令行实现

打开一个客户端订阅channel1

SUBSCRIBE channel1

打开另一个客户端，给channel1发布消息hello

publish channel1 hello

打开第一个客户端可以看到发送的消息

发布的消息没有持久化，如果在订阅的客户端收不到hello，只能收到订阅后发布的消息

5 其他数据类型

5.1 Bitmaps

5.1.1 简介

现代计算机用二进制（位） 作为信息的基础单位， 1个字节等于8位， 例如“abc”字符串是由3个字节组成， 但实际在计算机存储时将其用二进制表示， “abc”分别对应的ASCII码分别是97、 98、 99， 对应的二进制分别是01100001、 01100010和01100011，如下图

合理地使用操作位能够有效地提高内存使用率和开发效率。

Redis提供了Bitmaps这个“数据类型”可以实现对位的操作：

  • Bitmaps本身不是一种数据类型， 实际上它就是字符串（key-value） ， 但是它可以对字符串的位进行操作。

  • Bitmaps单独提供了一套命令， 所以在Redis中使用Bitmaps和使用字符串的方法不太相同。 可以把Bitmaps想象成一个以位为单位的数组， 数组的每个单元只能存储0和1， 数组的下标在Bitmaps中叫做偏移量

5.1.2 命令

setbit <key> <offset> <value>设置Bitmaps中某个偏移量的值（0或1）

getbit <key> <offset>获取Bitmaps中某个偏移量的值

bitcount <key> [start end]统计字符串被设置为1的bit数。一般情况下，给定的整个字符串都会被进行计数，通过指定额外的 start 或 end 参数，可以让计数只在特定的位上进行。start、end 是指bit组的字节的下标数，二者皆包含。

bitop and(or/not/xor) <destkey> [key…]bitop是一个复合操作， 它可以做多个Bitmaps的and（交集） 、 or（并集） 、 not（非） 、 xor（异或） 操作并将结果保存在destkey中。

5.2 HyperLogLog

5.2.1 简介

在工作当中，我们经常会遇到与统计相关的功能需求，比如统计网站PV（PageView页面访问量）,可以使用Redis的incr、incrby轻松实现。

但像UV（UniqueVisitor，独立访客）、独立IP数、搜索记录数等需要去重和计数的问题如何解决？这种求集合中不重复元素个数的问题称为基数问题。

解决基数问题有很多种方案：

  • 数据存储在MySQL表中，使用distinct count计算不重复个数

  • 使用Redis提供的hash、set、bitmaps等数据结构来处理

以上的方案结果精确，但随着数据不断增加，导致占用空间越来越大，对于非常大的数据集是不切实际的。

Redis HyperLogLog 是用来做基数统计的算法，HyperLogLog 的优点是，在输入元素的数量或者体积非常非常大时，计算基数所需的空间总是固定的、并且是很小的。在 Redis 里面，每个 HyperLogLog 键只需要花费 12 KB 内存，就可以计算接近 2^64 个不同元素的基数。这和计算基数时，元素越多耗费内存就越多的集合形成鲜明对比。

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

5.2.2 命令

pfadd <key> <element> [element ...] 添加指定元素到 HyperLogLog 中

pfcount<key> [key ...]计算HLL的近似基数

pfmerge <destkey> <sourcekey> [sourcekey ...]将一个或多个HLL合并后的结果存储在另一个HLL中

5.3 Geospatial

5.3.1 简介

Redis 3.2 中增加了对GEO类型的支持。GEO，Geographic，地理信息的缩写。该类型，就是元素的2维坐标，在地图上就是经纬度。redis基于该类型，提供了经纬度设置，查询，范围查询，距离查询，经纬度Hash等常见操作。

5.3.2 命令

geoadd <key> <longitude> <latitude> <member> [longitude latitude member...] 添加地理位置（经度，纬度，名称）

两极无法直接添加，一般会下载城市数据，直接通过 Java 程序一次性导入。

有效的经度从 -180 度到 180 度。有效的纬度从 -85.05112878 度到 85.05112878 度。当坐标位置超出指定范围时，该命令将会返回一个错误。

已经添加的数据，是无法再次往里面添加的。

geopos <key> <member> [member...]获得指定地区的坐标值

geodist <key> <member1> <member2> [m|km|ft|mi] 获取两个位置之间的直线距离

georadius <key> <longitude> <latitude> <radius> <m|km|ft|mi>以给定的经纬度为中心，找出某一半径内的元素

6 Redis_Jedis

6.1 引入相关jar包

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.2.0</version>
</dependency>
public class JedisDemo1 {
    private static final Jedis jedis =
            new Jedis("IP地址", 端口号);
​
    static {
        jedis.auth("密码");
    }
​
    @Test
    public void demo1(){
        jedis.set("k1", "v1");                      // 设置键值对
        System.out.println(jedis.get("k1"));        // 获取键对应的值
        System.out.println(jedis.ttl("k1"));    // 查看过期时间
        System.out.println(jedis.exists("k1"));   // 查看键对应的值是否存在
        jedis.expire("k1", 300);        // 设置超时时间
        jedis.mset("k2", "v2", "k3", "v3"); // 批量设置键值对
        System.out.println(jedis.mget("k1", "k2", "k3"));   // 批量获取值
    }
​
    @Test
    public void demo2(){
        jedis.lpush("key1", "lucy", "mary", "jack");    // list添加
        List<String> key1 = jedis.lrange("key1", 0, -1);    // 获取list
        System.out.println(key1);
    }
​
    @Test
    public void demo3(){
        jedis.sadd("name1", "value1", "value2", "value3");  // set添加
        Set<String> name1 = jedis.smembers("name1");    // 获取set
        System.out.println(name1);
    }
​
    @Test
    public void demo4(){
        jedis.hset("user", "age", "20");
        jedis.hset("user", "name", "zhangsan");
        Map<String, String> user = jedis.hgetAll("user");
        System.out.println(user);
    }
​
    @Test
    public void demo5(){
        jedis.zadd("key3", 100, "zhangsan");
        jedis.zadd("key3", 200, "lisi");
        List<String> key3 = jedis.zrange("key3", 0, -1);
        System.out.println(key3);
    }
}

6.2 例子-手机验证码生成

1、输入手机号，点击发送后随机生成6位数字码，2分钟有效

2、输入验证码，点击验证，返回成功或失败

3、每个手机号每天只能输入3次

public class RedisUtil {
    private static final Jedis jedis =
            new Jedis("ip", 端口号);
​
    static {
        jedis.auth("密码");
    }
​
    public static Boolean confirm(String tel, String confirm){
        String codeKey = "VerifyCode" + tel + ":code";
        String s = jedis.get(codeKey);
        if (s != null && s.equals(confirm)) {
​
            return true;
        }
        return false;
    }
​
    public static int stockConfirm(String tel, String confirm){
        String countKey = "VerifyCode" + tel + ":count";
        String codeKey = "VerifyCode" + tel + ":code";
        String count = jedis.get(codeKey);
        if (count == null) {
            jedis.setex(countKey, (int) DateUtil.getSecond(), "1");
        } else if (Integer.parseInt(count) <= 2) {
            jedis.incr(countKey);
        } else {
            return -1;
        }
        jedis.setex(codeKey, 120, confirm);
        return 1;
    }
}
public class RandomUtil {
    static Random random = new Random();
​
    public static String getCode(){
        StringBuilder code = new StringBuilder();
        for (int i = 0; i < 6; i++) {
            code.append(random.nextInt(10));
        }
        System.out.println("生成的验证码：" + code);
        return code.toString();
    }
}
public class DateUtil {
    public static long getSecond(){
        LocalDateTime midnight = LocalDateTime.now().plusDays(1).withHour(0).withMinute(0).withSecond(0).withNano(0);
        return ChronoUnit.SECONDS.between(LocalDateTime.now(),midnight);
    }
}
public class PhoneCode {
    public static void main(String[] args) {
        System.out.println("请输入手机号");
        Scanner scanner = new Scanner(System.in);
        String s = scanner.nextLine();
        RedisUtil.stockConfirm(s, RandomUtil.getCode());
        System.out.println("请输入验证码");
        String s1 = scanner.nextLine();
        System.out.println("是否相等：" + RedisUtil.confirm(s, s1));
​
    }
}

7 SpringBoot整合redis

7.1.1 导入依赖

<!--连接池-->
<dependency>    
    <groupId>com.alibaba</groupId>    
    <artifactId>druid-spring-boot-starter</artifactId>    
<version>1.2.8</version></dependency>
​
<!--redis-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

7.1.2 配置文件

#Redis服务器地址
spring.redis.host=ip地址
#Redis服务器连接端口
spring.redis.port=端口号
spring.redis.password=密码
#Redis数据库索引（默认为0）
spring.redis.database= 0
#连接超时时间（毫秒）
spring.redis.timeout=1800000
#连接池最大连接数（使用负值表示没有限制）
spring.redis.lettuce.pool.max-active=20
#最大阻塞等待时间(负数表示没限制)
spring.redis.lettuce.pool.max-wait=-1
#连接池中的最大空闲连接
spring.redis.lettuce.pool.max-idle=5
#连接池中的最小空闲连接
spring.redis.lettuce.pool.min-idle=0

7.1.3 添加redis配置类

@EnableCaching
@Configuration
public class RedisConfig extends CachingConfigurerSupport {
​
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setConnectionFactory(factory);
        //key序列化方式
        template.setKeySerializer(redisSerializer);
        //value序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //value hashmap序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        return template;
    }
​
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        //解决查询缓存转换异常的问题
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 配置序列化（解决乱码的问题）,过期时间600秒
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(600))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                .disableCachingNullValues();
        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }
}

7.1.4 测试

@RestController
@RequestMapping("/redisTest")
public class RedisTestController {
    @Autowired
    private RedisTemplate redisTemplate;
​
    @GetMapping
    public String testRedis() {
        //设置值到redis
        redisTemplate.opsForValue().set("name","lucy");
        //从redis获取值
        String name = (String)redisTemplate.opsForValue().get("name");
        return name;
    }
}

8 Redis事物

8.1 Redis事物定义

Redis事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。

Redis事务的主要作用就是串联多个命令防止别的命令插队。

8.2 Multi、Exec、discard

从输入Multi命令开始，输入的命令都会依次进入命令队列中，但不会执行，直到输入Exec后，Redis会将之前的命令队列中的命令依次执行。

组队的过程中可以通过discard来放弃组队。

  • 组队成功，提交成功

  • 组队阶段报错，提交失败

  • 组队成功，提交有成功有失败情况

8.3 事物的错误处理

组队中某个命令出现了报告错误，执行时整个的所有队列都会被取消。

如果执行阶段某个命令报出了错误，则只有报错的命令不会被执行，而其他的命令都会执行，不会回滚。

8.4 事物冲突的问题

8.4.1 悲观锁

悲观锁(Pessimistic Lock), 顾名思义，就是很悲观，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会block直到它拿到锁。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。

8.4.2 乐观锁

乐观锁(Optimistic Lock), 顾名思义，就是很乐观，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号等机制。乐观锁适用于多读的应用类型，这样可以提高吞吐量。Redis就是利用这种check-and-set机制实现事务的。

8.4.3 Redis实现

WATCH key [key ...]

在执行multi之前，先执行watch key1 [key2],可以监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断。

unwatch

取消 WATCH 命令对所有 key 的监视。

如果在执行 WATCH 命令之后，EXEC 命令或DISCARD 命令先被执行了的话，那么就不需要再执行UNWATCH 了。

8.5 Redis事物特性

  • 单独的隔离操作 ：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。

  • 没有隔离级别的概念 ：队列中的命令没有提交之前都不会实际被执行，因为事务提交前任何指令都不会被实际执行

  • 不保证原子性 ：事务中如果有一条命令执行失败，其后的命令仍然会被执行，没有回滚

8.6 ab模拟测试

yum install httpd-tools
ab -n 2000 -c 200 -k -p ~/postfile -T application/x-www-form-urlencoded http://ip地址:端口号/Seckill/doseckill

8.7 库存遗留问题

乐观锁会造成库存遗留问题

例如2000人同时抢到的库存500的商品，其中一个人修改后，由于版本号修改后，剩余1999人全部更新失败

Redis不能实施悲观锁

解决：使用Lua脚本语言

Lua 是一个小巧的脚本语言，Lua脚本可以很容易的被C/C++ 代码调用，也可以反过来调用C/C++的函数，Lua并没有提供强大的库，一个完整的Lua解释器不过200k，所以Lua不适合作为开发独立应用程序的语言，而是作为嵌入式脚本语言。很多应用程序、游戏使用LUA作为自己的嵌入式脚本语言，以此来实现可配置性、可扩展性。

将复杂的或者多步的redis操作，写为一个脚本，一次提交给redis执行，减少反复连接redis的次数。提升性能。LUA脚本是类似redis事务，有一定的原子性，不会被其他命令插队，可以完成一些redis事务性的操作。

但是注意redis的lua脚本功能，只有在Redis 2.6以上的版本才可以使用。redis 2.6版本以后，通过lua脚本解决争抢问题，实际上是redis 利用其单线程的特性，用任务队列的方式解决多任务并发问题。