windows连接redis软件 连接redis工具

阅读全文大概得花3个小时时间

Redis入门

概述

Redis是什么

Redis：REmote DIctionary Server

是完全开源免费的，用C语言编写的，遵循BSD协议，是一个高性能的（Key/Value）分布式内存数据库，基于内存运行，并支持持久化的NoSQL数据库，是当前最热门的NoSQL数据库之一，也被人们称之为数据结构服务器

Redis与其他key-value缓存产品有以下三个特点

• Redis支持数据的持久化，可以将内存中的数据保持在磁盘中，重启的时候可以再次加载进行使用。
• Redis不仅仅支持简单的key-value类型的数据，同时还提供list、setzset、hash等数据结构的存储。
• Redis支持数据的备份，即master-slave模式的数据备份。

Redis能干嘛

内存存储和持久化：redis支持异步将内存中的数据写到磁盘上，同时不影响继续服务

取最新N个数据的操作，如：可以将最细腻的10条评论的ID放在Redis的List集合里面

发布、订阅消息系统

地图信息分析

定时器、计数器

……

特性

数据类型、基本操作和配置

持久化和复制。RDB、AOF

事务的控制

……

常用网站

https://redis.io/官网

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

windows安装

下载地址：https://github.com/dmajkic/redis/downloads

解压到自己的电脑的环境目录即可

双击redis-server.exe启动即可

通过客户端去访问redis-cli

# 基本的set设值
127.0.0.1:6379> set key wyx
OK
# 取出存储的值
127.0.0.1:6379> get key
"wyx"

重要提示

由于企业里面做Redis开发，99%都是Linux半的运用和安装，几乎不会涉及到windows版，所以重点是下面的Linux版的安装和使用。

Linux安装

下载地址 http://download.redis.io/releases/redis-5.0.7.tar.gz

安装步骤

1. 下载获得redis-5.0.7.tar.gz后将它放到我们Linux的目录下 /opt。
2. /opt 目录下，解压命令： tar -zxvf redis-5.0.7.tar.gz
3. 解压完成后出现文件夹：redis-5.0.7
4. 进入目录cd redis-5.0.7
5. 在redis-5.0.7目录下执行make命令，若出现问题，解决问题后再进行make。

可能出现的错误：
1.gcc安装（gcc是linux下的一个编译程序，是c程序的编译工具，redis基于C语言）
  解决方法：yum install gcc-c++
  测试：gcc-v

2. 如果make完成后继续执行make install 出现下面这种情况就是已经安装成功。



3. 查看默认安装目录：usr/local/bin

/usr 这是一个非常重要的目录，类似于windows下的Program Files，存放用户的程序。

1. 创建配置文件夹 拷贝配置文件（备用）

cd /usr/local/bin
mkdir myredis
cp /opt/redis.conf /usr/local/bin/myredis

修改配置文件设置redis为守护进程（后台运行）。

daemonize设置yes或者no区别

• daemonize：yse

• redis采用的是单线程模式。当redis.conf中选项daemonize设置成yes时，代表开启守护进程模式。在该模式下redis会在后台运行，并将进程pid号写入至redis.conf选项pidfile设置的文件中，此时redis将一直运行，除非手动kill该进程。

• daemonize：no

• 当daemonize选项设置成no时，当前界面将进入redis的命令行界面，exit强制退出或者关闭连接工具（putty，xshell）都会导致redis进程退出。

1. 启动redis，并使用redis-cli连接

# 启动redis服务 用我们的配置文件
[root@VM-0-6-centos bin]# redis-server wconfig/redis.conf
29271:C 09 Mar 2021 21:52:54.068 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
29271:C 09 Mar 2021 21:52:54.068 # Redis version=5.0.7, bits=64, commit=00000000, modified=0, pid=29271, just started
29271:C 09 Mar 2021 21:52:54.068 # Configuration loaded
# 启动连接工具redis-cli测试
[root@VM-0-6-centos bin]# redis-cli
127.0.0.1:6379> ping
PONG
# 关闭redis，推出连接
127.0.0.1:6379> shutdown
not connected> exit
[root@VM-0-6-centos bin]#

基本Redis常识

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

# 查看redis.conf配置文件，里面有默认配置

databases 16

# By default Redis shows an ASCII art logo only when started to log to the
# standard output and if the standard output is a TTY. Basically this means
# that normally a logo is displayed only in interactive sessions.

select命令切换数据库

127.0.0.1:6379> select 1
OK
127.0.0.1:6379[1]> 

# 不同的库可以存不用的数据

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

127.0.0.1:6379[1]> set wyx nb
OK
127.0.0.1:6379[1]> dbsize
(integer) 1
127.0.0.1:6379[1]> keys *
1) "wyx"
127.0.0.1:6379[1]> select 0
OK
127.0.0.1:6379> keys * # 查看全部的key
1) "k1"
127.0.0.1:6379> dbsize
(integer) 1

flushdb：清空当前库

flushall：清空全部的库

127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> dbsize
(integer) 0
127.0.0.1:6379> select 1
OK
127.0.0.1:6379[1]> dbsize
(integer) 1
127.0.0.1:6379[1]> flushall
OK

为什么redis是单线程？

基于常识，做缓存用的Redis很快！官方表示，因为redis是基于内存的操作，CPU不是Redis的瓶颈，Redis的瓶颈最有可能是机器内存的大小或者网络带宽。既然单线程容易实现，而且CPU不会成为瓶颈，那就顺理成章的采用了单线程的方案乐！

Redis采用的是基于内存的单进程单线程模型的KV数据库，由C语言编写，官方提供的数据时可以达到100000+的QPS（每秒内查询次数）。这个数据不比采用单进程多线程的同样基于内存的KV数据库Memcached差！

Redis为什么那么快

• 以前一直有个误区，认为i：高性能服务器一定是多线程来实现的
  原因很简单因为误区二导致的：多线程一定比单线程效率高，其实不然！
• redis核心就是 如果我的数据全在内存里，我单线程的去操作 就是效率最高的，因为多线程的本质就是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）。

String（字符串类型）

String是redis最基本的类型，你可以理解成Memcached一摸一样的类型，一个key对应一个value。

String类型是二进制安全的，意思是redis的string可以包含任何数据，比如jpg图片或者序列化的对象。

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

Hash（哈希，类似Java中的Map）

Redis hash是一个键值对集合

Redis hash是一个String类型的field和value的映射表，hash特别适合用于存储对象

类似Java里面的Map<String,Object>

List（列表）

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

它的底层实际是个链表！

Set（集合）

Redis的Set是String类型的无序集合，他是通过HashTable实现的！

Zset（sorted set：有序集合）

Redis zset和set一样，也是String类型元素的集合，且不允许重复的成员。

不同的是每个元素都会关联一个double类型的分数。

Redis正是通过分数来为集合中的成员进行从小到大的排序，zset的成员也是唯一的，但是分数（Score）去可以重复。

Redis键（key）

# keys * 查看所有的key
127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> set name wyx
OK
127.0.0.1:6379> keys *
1) "name"
# exists key 的名字，判断某个key是否存在
127.0.0.1:6379> exists name
(integer) 1
127.0.0.1:6379> exists name1
(integer) 0
# move key db 将这个key移动到其他数据库。这个库就没有了
127.0.0.1:6379> move name 1
(integer) 1
127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> select 1
OK
127.0.0.1:6379[1]> keys *
1) "name"
127.0.0.1:6379[1]> select 0
OK
# expare key 设置key的 生存时间 ，秒当key过期时（生存时间为0），它会被自动删除。
# ttl key 查看还有多少秒国企，-1表示永不过期，-2表示已过期
127.0.0.1:6379> set name kjvgkvh
OK
127.0.0.1:6379> expire name 10
(integer) 1
127.0.0.1:6379> ttl name
(integer) 7
127.0.0.1:6379> ttl name
(integer) 6
127.0.0.1:6379> ttl name
(integer) 5
127.0.0.1:6379> ttl name
(integer) 4
127.0.0.1:6379> ttl name
(integer) 2
127.0.0.1:6379> ttl name
(integer) -2
127.0.0.1:6379> keys *
(empty list or set)
# type 查看key是什么类型
127.0.0.1:6379> set name kjvgkvh
OK
127.0.0.1:6379> get name
"kjvgkvh"
127.0.0.1:6379> type name
string

字符串String

单值单value

常用命令说明：

#======================================================
# set、get、del、append、strlen
#======================================================
127.0.0.1:6379> set key1 value1
OK
127.0.0.1:6379> get key1
"value1"
127.0.0.1:6379> keys *
1) "key1"
127.0.0.1:6379> del key1
(integer) 1
127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> exists key1
(integer) 0
127.0.0.1:6379> append key1 "hello"
(integer) 5
127.0.0.1:6379> append key1 "wyx"
(integer) 8
127.0.0.1:6379> get key1
"hellowyx"
127.0.0.1:6379> strlen key1
(integer) 8
#======================================================
# incr、decr      一定要是数字才能进行加减，+1和-1。
# incrby、decrby  命令将key中存储的数字加上指定的增量值
#======================================================
127.0.0.1:6379> set views 0
OK
127.0.0.1:6379> type views
string
127.0.0.1:6379> incr views
(integer) 1
127.0.0.1:6379> incr views
(integer) 2
127.0.0.1:6379> decr views
(integer) 1
127.0.0.1:6379> incrby views 10
(integer) 11
127.0.0.1:6379> decrby views 10
(integer) 1
#======================================================
# range [范围]
# getrange 获取指定区间范围内的值。类似between...and的关系，从零到负一表示全部
#======================================================
127.0.0.1:6379> set key2 abcd123456
OK
127.0.0.1:6379> getrange key2 0 -1
"abcd123456"
127.0.0.1:6379> getrange key2 0 2
"abc"
127.0.0.1:6379> get key2
"abcd123456"
127.0.0.1:6379> getrange key2 0 1
"ab"
#======================================================
# setrange 设置指定区间范围内的值，格式是setrange key值 索引 具体值
#======================================================
127.0.0.1:6379> setrange key3 0 1
(integer) 1
127.0.0.1:6379> get key3
"1"
127.0.0.1:6379> setrange key2 1 asddas
(integer) 10
127.0.0.1:6379> get key2
"aasddas456"
#======================================================
# setex(set with expire)
# setnx(set if not exist)
#======================================================
127.0.0.1:6379> setex key3 60 expaire # 设置过期时间
OK
127.0.0.1:6379> get key3
"expaire"
127.0.0.1:6379> ttl key3
(integer) 50
127.0.0.1:6379> setnx key4 redis #如果不存在就设置，成功返回1
(integer) 1
127.0.0.1:6379> setnx key4 mysql # 如果存在不设置，失败返回0
(integer) 0
127.0.0.1:6379> get key4
"redis"
#======================================================
# mset  mset 命令用于同时设置一个或多个key-value对
# mget  mget 命令返回所有（一个或者多个）给定key的值。
#       如果给定的key里面，有某个key不存在，那么这个key返回特殊值nil。
# msetnx 当所有key都成功设置，返回1.
#        如果所有给定的key都设置失败（至少有一个已经存在），那么返回0.原子操作
#======================================================

127.0.0.1:6379> mset k10 v10 k11 v11 k12 v12
OK
127.0.0.1:6379> keys *
1) "k10"
2) "key1"
3) "key2"
4) "views"
5) "k12"
6) "k11"
7) "key4"
127.0.0.1:6379> mget k10 k11 k12 k13
1) "v10"
2) "v11"
3) "v12"
4) (nil)
127.0.0.1:6379> msetnx k10 v10 k15 v15
(integer) 0
127.0.0.1:6379> get k15
(nil)
#======================================================
# getset （先get再set）
#======================================================
127.0.0.1:6379> getset db mongodb
(nil)
127.0.0.1:6379> get db
"mongodb"
127.0.0.1:6379> getset db redis
"mongodb"
127.0.0.1:6379> get db
"redis"

String数据结构是简单的key-value类型，value其实不仅可以是String，也可以是数字。

常规key-value缓存应用：

常规计数：粉丝数，点赞数。

列表List

单值多value

#======================================================
# lpush：将一个或多个值插入到列表头部（左）
# rpush：将一个或多个值插入到列表尾部（右）
# lrange：返回列表中指定区间的元素，区间一偏移量START 和END指定。
# 其中 0 表示列表的第一个元素，1表示列表的第二个元素，以此类推。
# 你也可以使用负数下标，以 -1 表示列表的最后一个元素，-2表示列表的倒数第二个元素，以次类推。
#======================================================
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> lrange list 0 1
1) "two"
2) "one"
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "one"
127.0.0.1:6379> rpush list "three"
(integer) 3
127.0.0.1:6379> lrange list 0 -1
1) "two"
2) "one"
3) "three"
#======================================================
# lpop 命令用于移除并返回列表的第一个元素。当列表key不存在时，返回nil。
# rpop 移除列表的最后一个元素，返回值为移除的元素
#======================================================
127.0.0.1:6379> lpop list
"two"
127.0.0.1:6379> rpop list
"three"
127.0.0.1:6379> lrange list 0 -1
1) "one"
#======================================================
# lindex，按照索引下标获得元素（-1代表最后一个，0代表是第一个）
#======================================================
127.0.0.1:6379> lindex list 1
(nil)
127.0.0.1:6379> lindex list 0
"one"
127.0.0.1:6379> lindex list -1
"one"
#======================================================
# llen用于返回列表的长度
#======================================================
127.0.0.1:6379> flushdb
OK
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> llen list
(integer) 3
#======================================================
# lrem key 根据参数COUNT的值，移除列表中与参数VALUE相等的元素
#======================================================
127.0.0.1:6379> lrem list 1 "two"
(integer) 1
127.0.0.1:6379> lrange list 0 -1
1) "three"
2) "one"
#======================================================
# Ltrim key 对一个列表进行修建（trim），就是说，让列表只保留指定区间内的元素，不在指定区间之内的元素都将被删除
#======================================================
127.0.0.1:6379> rpush mylist "hello"
(integer) 1
127.0.0.1:6379> rpush mylist "hello"
(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
OK
127.0.0.1:6379> lrange mylist 0 -1
1) "hello"
2) "hello2"
#======================================================
# rpoplpush 移除列表的最后一个元素，并将该元素添加到另一个列表并返回
#======================================================
127.0.0.1:6379> rpush mylist "hello"
(integer) 3
127.0.0.1:6379> rpush mylist "foo"
(integer) 4
127.0.0.1:6379> rpush mylist "bar"
(integer) 5
127.0.0.1:6379> rpoplpush mylist myotherlist
"bar"
127.0.0.1:6379> lrange mylist 0 -1
1) "hello"
2) "hello2"
3) "hello"
4) "foo"
127.0.0.1:6379> lrange myotherlist 0 -1
1) "bar"
#======================================================
# lset key index value 将列表key下表为index的元素的值设置为value
#======================================================
127.0.0.1:6379> exists list
(integer) 1
127.0.0.1:6379> del list
(integer) 1
127.0.0.1:6379> exists list 
(integer) 0
127.0.0.1:6379> lpush list value1
(integer) 1
127.0.0.1:6379> lrange list 0 0
1) "value1"
127.0.0.1:6379> lset list 0 "new"
OK
127.0.0.1:6379> lrange list 0 0
1) "new"
127.0.0.1:6379> lset list 1 "new" # index超出范围报错
(error) ERR index out of range
#======================================================
# linsert key before/after pivot value 用于在列表的元素前或者后插入元素。
# 将值value插入到列表key当中，位于pivot之前或之后
#======================================================
127.0.0.1:6379> del mylist
(integer) 1
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" "there"
(integer) 3
127.0.0.1:6379> lrange mylist 0 -1
1) "hello"
2) "there"
3) "world"

性能总结

• 他是一个字符串链表，left，right都可以插入添加
• 如果键不存在，创建新的链表
• 如果键已存在，新增内容
• 如果值全移除，对应的键也就消失了
• 链表的操作无论是头和尾效率都极高，但假如是对中间元素进行操作，效率就很惨淡了。

list就是链表，有数据结构知识的人都可以理解其结构。使用list结构，我们可以轻松实现最新消息排行等功能。list的另一个应用就是消息队列，可以利用list的push操作，将任务存在list中，然后工作线程再用pop操作将任务取出进行执行。redis还提供了操作list中某一端的api，你可以直接查询，删除list中某一段的元素。

redis的list是每个子元素都是String类型的双向链表，可以通过push和pop操作从列表的头部或者尾部添加或者删除元素，这样list既可以作为栈，也可以作为队列。

集合Set

单值多value

#======================================================
# sadd将一个或多个成员元素加入到集合中，不能重复
# smembers 返回集合中的所有成员
# sismember 命令判断成员元素是否是集合的成员
#======================================================
127.0.0.1:6379> sadd myset "hello"
(integer) 1
127.0.0.1:6379> sadd myset "wyx"
(integer) 1
127.0.0.1:6379> sadd myset "wyx"
(integer) 0
127.0.0.1:6379> smembers myset
1) "wyx"
2) "hello"
127.0.0.1:6379> sismember myset hello
(integer) 1
127.0.0.1:6379> sismember myset world
(integer) 0
#======================================================
# scard，获取集合里面的元素个数
#======================================================
127.0.0.1:6379> scard myset
(integer) 2
#======================================================
# srem key value 用于移除集合中的一个或多个成员元素
#======================================================
127.0.0.1:6379> srem myset "wyxx"
(integer) 0
127.0.0.1:6379> smembers myset
1) "wyx"
2) "hello"
127.0.0.1:6379> srem myset "wyx"
(integer) 1
#======================================================
# srandmember key命令用于返回集合中的一个随机元素
#======================================================
127.0.0.1:6379> smembers myset
1) "hello"
127.0.0.1:6379> sadd myset wyx cyz zsh lel
(integer) 4
127.0.0.1:6379> smembers myset
1) "zsh"
2) "wyx"
3) "cyz"
4) "hello"
5) "lel"
127.0.0.1:6379> srandmember myset
"lel"
127.0.0.1:6379> srandmember myset
"zsh"
127.0.0.1:6379> srandmember myset
"zsh"
127.0.0.1:6379> srandmember myset
"cyz"
127.0.0.1:6379> srandmember myset 2
1) "zsh"
2) "lel"
127.0.0.1:6379> srandmember myset 2
1) "zsh"
2) "hello"
#======================================================
# spop key 用于移除集合中的指定key的一个或多个随机元素
#======================================================
127.0.0.1:6379> spop myset
"wyx"
127.0.0.1:6379> spop myset 2
1) "zsh"
2) "cyz"
127.0.0.1:6379> sadd myset hello world wyx 
(integer) 2
127.0.0.1:6379> smembers myset
1) "world"
2) "hello"
3) "wyx"
4) "lel"
#======================================================
# smoce source destination member
# 将指定成员member 元素从source集合移动到destination集合。
#======================================================
127.0.0.1:6379> sadd myset2 set2
(integer) 1
127.0.0.1:6379> smove myset myset2 wyx
(integer) 1
127.0.0.1:6379> smembers myset
1) "world"
2) "hello"
3) "lel"
127.0.0.1:6379> smembers myset2
1) "wyx"
2) "set2"
127.0.0.1:6379> flushdb
OK
#======================================================
# - 数字集合类
#   - 差集：sdiff
#   - 交集：sinter
#   - 并集：sunion
#======================================================
127.0.0.1:6379> keys *
(empty list or set)
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 key1 d
(integer) 1
127.0.0.1:6379> srem key1 d
(integer) 1
127.0.0.1:6379> smembers key1
1) "c"
2) "b"
3) "a"
127.0.0.1:6379> sadd key2 d
(integer) 1
127.0.0.1:6379> sadd key2 c
(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) "c"
2) "e"
3) "a"
4) "b"
5) "d"

在微博应用中，可以将一个用户所有的关注人存在一个集合中，将其所有粉丝存在一个集合。redis还为集合提供了求交集、并集、差集等操作，可以非常方便地实现如共同关注、共同喜好、二度好友等功能，对上面的所有集合操作，你可以使用不同的命令选择将结果返回客户端还是存集到一个新的集合中。

哈希Hash

kv模式不变，但v是一个键值对

#======================================================
# hset、hget 命令用于为哈希表中的字段赋值
# hmset、hmget 同时将多个field-value对设置到哈希表中。会覆盖哈希表已存在的字段
# hgetall 用于返回哈希表中，所有的字段和值
# hdel   用于删除哈希表key中的一个或多个指定字段
#======================================================
127.0.0.1:6379> hset myhash field1 "wyx"
(integer) 1
127.0.0.1:6379> hget myhash field1
"wyx"
127.0.0.1:6379> hmset myhash field1 "hello" field2 "world"
OK
127.0.0.1:6379> hget myhash field1
"hello"
127.0.0.1:6379> hget myhash field2
"world"
127.0.0.1:6379> hgetall myhash
1) "field1"
2) "hello"
3) "field2"
4) "world"
127.0.0.1:6379> hdel myhash field1
(integer) 1
#======================================================
# hlen 获取哈希表中字段的数量。
#======================================================
127.0.0.1:6379> hlen myhash
(integer) 1
127.0.0.1:6379> hmset myhash field1 "Hello" field2 "world"
OK
127.0.0.1:6379> hlen myhash
(integer) 2
#======================================================
# hexists 查看哈希表中的指定字段是否存在。
#======================================================
127.0.0.1:6379> hexists myhash field1
(integer) 1
127.0.0.1:6379> hexists myhash field3
(integer) 0
#======================================================
# hkeys 获取哈希表中的所有域（field）。
# hvals 返回哈希表中所有域的值。
#======================================================
127.0.0.1:6379> hkeys myhash
1) "field2"
2) "field1"
127.0.0.1:6379> hvals myhash
1) "world"
2) "Hello"
#======================================================
# hincrby 为哈希表中的字段加上指定增量值。
#======================================================
127.0.0.1:6379> hset myhash field 5
(integer) 1
127.0.0.1:6379> hincrby myhash field 1
(integer) 6
127.0.0.1:6379> hincrby myhash field -1
(integer) 5
127.0.0.1:6379> hincrby myhash field -10
(integer) -5
#======================================================
# hsetnx 为哈希表中不存在的字段赋值
#======================================================
127.0.0.1:6379> hsetnx myhash field1 "hello"
(integer) 0
127.0.0.1:6379> hdel myhash field1
(integer) 1
127.0.0.1:6379> hsetnx myhash field1 "hello"
(integer) 1
127.0.0.1:6379> hget myhash field1
"hello"

Redis hash是一个String类型的field和value的映射表，hash特别适合用于存储对象。存储部分变更的数据，如用户信息等。

有序集合Zset

在set基础上，加一个score值。之前set是k1 v1 v2 v3，现在zset是k1 score1 v1 score2 v2

#======================================================
# zadd  将一个或多个成员元素及其分数值加入到有序集合当中
# zrange 返回有序集中，指定区间内的成员
#======================================================
127.0.0.1:6379> zadd myset 1 one
(integer) 1
127.0.0.1:6379> flushdb
OK
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"
#======================================================
# zrangebyscore 返回有序集合中指定分数区间的成员列表。有序集成员按分数递增（从小到大）次序排列。
#======================================================
127.0.0.1:6379> zadd salary 2500xiaoming
(error) ERR wrong number of arguments for 'zadd' command
127.0.0.1:6379> zadd salary 2500 xiaoming
(integer) 1
127.0.0.1:6379> zadd salary 5000 xiaohong
(integer) 1
127.0.0.1:6379> zadd salary 500 wyx
(integer) 1
127.0.0.1:6379> zrange salary
(error) ERR wrong number of arguments for 'zrange' command
127.0.0.1:6379> zrange salary 0 -1
1) "wyx"
2) "xiaoming"
3) "xiaohong"
127.0.0.1:6379> zrangebyscore salary -inf +inf
1) "wyx"
2) "xiaoming"
3) "xiaohong"
127.0.0.1:6379> zrangebyscore salary -inf +inf withscores
1) "wyx"
2) "500"
3) "xiaoming"
4) "2500"
5) "xiaohong"
6) "5000"
127.0.0.1:6379> zrevrange salary 0 -1 withscore
(error) ERR syntax error
127.0.0.1:6379> zrevrange salary 0 -1 withscores
1) "xiaohong"
2) "5000"
3) "xiaoming"
4) "2500"
5) "wyx"
6) "500"
127.0.0.1:6379> zrangebyscore salary -inf 2500 withscores
1) "wyx"
2) "500"
3) "xiaoming"
4) "2500"
#======================================================
# zrem 移除有序集中的一个或多个成员
#======================================================
127.0.0.1:6379> zrem salary 0 -1
(integer) 0
127.0.0.1:6379> zrange salary 0 -1
1) "wyx"
2) "xiaoming"
3) "xiaohong"
127.0.0.1:6379> zrem salary wyx
(integer) 1
127.0.0.1:6379> zrange salary 0 -1
1) "xiaoming"
2) "xiaohong"
#======================================================
# zcard  命令用于计算集合中元素的数量
#======================================================
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 hello 3 wyx
(integer) 1
#======================================================
# zcount 计算有序集合中指定分数区间的成员数量
#======================================================
127.0.0.1:6379> zcount myset 1 3
(integer) 5
127.0.0.1:6379> zcount myset 1 2
(integer) 3
127.0.0.1:6379> zrange myset 1 2
1) "hello"
2) "two"
127.0.0.1:6379> zrange myset 0 -1
1) "one"
2) "hello"
3) "two"
4) "three"
5) "wyx"
127.0.0.1:6379> flushdb
OK
#======================================================
# zrank 返回有序集中指定成员的排名，其中有序集成员按分数值递增（从小到大顺序排列）
#======================================================
127.0.0.1:6379> zadd salary 2500 xiaoming
(integer) 1
127.0.0.1:6379> zadd salary 5000 xiaohong
(integer) 1
127.0.0.1:6379> zadd salary 500 wyx
(integer) 1
127.0.0.1:6379> zrange salary 0 -1 withscores
1) "wyx"
2) "500"
3) "xiaoming"
4) "2500"
5) "xiaohong"
6) "5000"
127.0.0.1:6379> zrank salary wyx
(integer) 0
127.0.0.1:6379> zrank salary xiaoming
(integer) 1
#======================================================
# zrevrank 返回有序集中成员的排名。其中有序集成员按分数值递减（从大到小）排序。
#======================================================
127.0.0.1:6379> zrevrank salary wyx
(integer) 2
127.0.0.1:6379> zrevrank salary xiaohong
(integer) 0

和set相比，sorted set增加了一个权重参数score，使得集合中的元素能够按score进行有序排列，比如一个存储全班同学成绩的sorted set，其集合value可以是同学的学号，而score就可以是其考试得分，这样在数据插入集合的时候，就已经进行了天然排序。可以用sorted set来做带权重的队列，比如普通消息的score为1，重要消息的score为2，然后工作线程可以选择按score的倒叙来获取工作任务。让重要的任务优先执行。

三种特殊数据类型

GEO地理位置

简介

reids的geo特性在redis3.2版本中推出的，这个功能可以将用户的地理位置信息存储起来，并对这些信息进行操作。来实现诸如附近位置、摇一摇这类赖于地理位置信息的功能。geo的数据类型为zset。

geo的数据结构共有六个常用命令：geoadd、geopos、geodist、georadius、georadiusbymember、geohash

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

geoadd

语法：geoadd key longitude latitude member [longitude latitude member …]

功能：将给定的空间元素（经度、纬度、名字）添加到指定的键里面。可以添加多个。这些数据会以有序集合的形式被存储在键里面，从而使得georadius合georadiusbymember这样的命令可以在之后通过位置查询取得这些元素。

geoadd命令一标准的x，y格式接收参数，所以用户必须先输入精度，然后再输入维度。geoadd能够记录的坐标是有限的：非常接近两级的区域无法被索引。有效的经度介于-180到180之间，有效的维度介于-85.05112878到85.05112878之间，当用户尝试输入一个超出范围的经度或者纬度时，geoadd命令将返回一个错误。

127.0.0.1:6379> geoadd china 116.46 39.92 beijing
(integer) 1
127.0.0.1:6379> geoadd china 121.48 31.22 shanghai
(integer) 1
127.0.0.1:6379> geoadd china 113.65 34.76 henan
(integer) 1
127.0.0.1:6379> geoadd china 113.65 34.76 wuhan
(integer) 1

geopos

语法：geopos key member [member …]

从key里返回所有指定元素的位置（经纬度）

127.0.0.1:6379> geopos china beijing
1) 1) "116.45999997854232788"
   2) "39.9199990416181052"
127.0.0.1:6379> geopos china henan
1) 1) "113.64999979734420776"
   2) "34.75999874008049773"
127.0.0.1:6379> geopos china wuhan
1) 1) "113.64999979734420776"
   2) "34.75999874008049773"

geodist

语法：geodist key member1 member2 [unit]

返回两个给定位置之间的距离，如果两个位置之间的其中一个不存在，那么命令返回空值。

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

m表示单位是米

km表示单位是千米

mi表示单位是英里

ft表示单位是英尺

如果用户没有显示地指定单位参数，那么geodist默认使用mi作为单位。

geodist命令在计算距离时会假设地球为完美的球形，在极限情况下，这一假设最大会造成0.5%的误差。

127.0.0.1:6379> geodist china beijing henan m
"625316.6996"
127.0.0.1:6379> geodist china beijing wuhan  m
"625316.6996"
127.0.0.1:6379> geodist china beijing wuhan  km
"625.3167"

georadius

语法：georadius key longitude latitude radius m|km|ft|mi [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count] [ASC|DESC]

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

127.0.0.1:6379> georadius china 110 15 1000 km 
(empty list or set)
127.0.0.1:6379> georadius china 110 15 2000 km 
(empty list or set)
127.0.0.1:6379> georadius china 110 15 3000 km 
1) "shanghai"
2) "henan"
3) "wuhan"
4) "beijing"
127.0.0.1:6379> georadius china 110 15 3000 km withcoord 
1) 1) "shanghai"
   2) 1) "121.48000091314315796"
      2) "31.21999956478423854"
2) 1) "henan"
   2) 1) "113.64999979734420776"
      2) "34.75999874008049773"
3) 1) "wuhan"
   2) 1) "113.64999979734420776"
      2) "34.75999874008049773"
4) 1) "beijing"
   2) 1) "116.45999997854232788"
      2) "39.9199990416181052"
127.0.0.1:6379> georadius china 110 15 3000 km withcoord withdisit
(error) ERR syntax error
127.0.0.1:6379> georadius china 110 15 3000 km withcoord withdist
1) 1) "shanghai"
   2) "2149.1794"
   3) 1) "121.48000091314315796"
      2) "31.21999956478423854"
2) 1) "henan"
   2) "2227.9756"
   3) 1) "113.64999979734420776"
      2) "34.75999874008049773"
3) 1) "wuhan"
   2) "2227.9756"
   3) 1) "113.64999979734420776"
      2) "34.75999874008049773"
4) 1) "beijing"
   2) "2842.0670"
   3) 1) "116.45999997854232788"
      2) "39.9199990416181052"

georadiusbymember

语法：georadiusbymember key member radius m|km|ft|mi [WITHCOORD] [WITHDIST] [WITHHASH] [COUNT count] [ASC|DESC] [STORE key] [STO

找出位于指定范围内的元素，中心点是由给定的位置与元素决定的。与georadius 区别是这个可以指定位置的名称，不用写经纬度。

127.0.0.1:6379> georadiusbymember china beijing 1000 km
1) "henan"
2) "wuhan"
3) "beijing"
127.0.0.1:6379> georadiusbymember china beijing 400 km
1) "beijing"

geohash

语法：geohash key member [member …]

redis 使用geohash将二维码经纬度转换为一维字符串，字符串越长表示位置越精确，两个字符串越相似表示距离越近。

127.0.0.1:6379> geohash china beijing
1) "wx4g455wfe0"
127.0.0.1:6379> geohash china shanghai wuhan
1) "wtw3s77j9j0"
2) "ww0vdpv7sv0"
127.0.0.1:6379>

zrem

geo没有提供删除成员的命令，但是因为geo的底层实现是zset，所以可以借用zrem命令实现对地理位置信息的删除。

127.0.0.1:6379> zrange china 0 -1
1) "shanghai"
2) "henan"
3) "wuhan"
4) "beijing"
127.0.0.1:6379> zrange china 0 -1 withscores
1) "shanghai"
2) "4054757652758722"
3) "henan"
4) "4064942540089391"
5) "wuhan"
6) "4064942540089391"
7) "beijing"
8) "4069886062674726"
127.0.0.1:6379> zrem china beijing
(integer) 1
127.0.0.1:6379> zrem china henan
(integer) 1
127.0.0.1:6379> zrange china 0 -1
1) "shanghai"
2) "wuhan"

HyperLogLog

简介

Redis在2.8.9版本添加了HyperLogLog结构。

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

在redis里面，每个HyperLogLog键只需要花费12kb内存，就可以计算接近2^64各不同元素的技术。这和计算基数时，元素越多耗费内存越多的集合形成鲜明对比。

HyperLogLog则是一种算法，它提供了不精确的去重计数方案。

举个例子：加入我要统计网页的UV（浏览用户数量，一天来自同一个用户的多次访问只能算一次），传统的解决方案是使用set来保存用户id，然后统计set中的元素数量来获取页面UV。但是这种方案只能承载少量的用户，一旦用户数量大起来就需要消耗大量的空间来存储用户id。我的目的是统计用户数量而不是保存用户，这简直是个吃力不讨好的方案！而是用redis的HyperLogLog最多需要12k就可以统计大量的用户数，尽管它大概有0.81%的错误率，但对于统计UV这种不需要很精确地数据是可以忽略不记的。

什么是基数？

比如数据集{1，3，5，7，5，7，8}，那么这个数据集的基数集为{1，3，5，7，8}，基数（不重复的元素）为5。基数估计就是在误差可接受的范围内，快速计算基数。

基本命令

命令	描述
pfadd key element [element …]	添加指定元素到HyperLogLog中
pfcount key [key …]	返回给定HyperLogLog的基数估算值
pfmerge destkey sourcekey [sourcekey …]	将多个HyperLogLog合并为一个HyperLogLog，并集计算

测试

127.0.0.1:6379> pfadd mykey a b c d e f g h i j
(integer) 1
127.0.0.1:6379> pfcount mykey
(integer) 10
127.0.0.1:6379> pfadd mykey2 i j z x c v b n m
(integer) 1
127.0.0.1:6379> pfmerge mykey3 mykey mykey2
OK
127.0.0.1:6379> pfcount mykey3
(integer) 15

BitMap

简介

在开发中，可能会遇到这种情况：需要统计用的某些信息，如活跃或不活跃，登陆或者不登陆；又如需要记录用户一年的打卡情况，打卡了是1，没有打卡是0，如果使用普通的key/value存储，则需要记录365条记录，如果用户量很大，需要的空间也会很大，所以redis提供了Bitmap位图这种数据结构，BiteMap就是通过操作二进制来进行记录，几位0和1；如果要记录365填的打卡情况，使用Bitmap表示的形式大概如下：01010001111000111…………，这样有什么好处呢？当然就是节约内存了，365天相当于365bit，又1字节=8bit，所以相当于使用46个字节即可。

BitMap就是通过一个bit位来表示某个元素对应的值或者状态，其中的key就是对应元素本身，实际上底层也是通过对字符串的操作来实现的。redis从2.2版本之后新增了setbit，getbit，bitcount等几个bitmap相关命令。

setbit设置操作

命令	描述
setbit key offset value	设置key的第offset位为value（1或0）
getbit key offset	获取key的第offset位设置的值，未设置过默认返回0
bitcount key [start end]	统计操作统计key start到end上位为1的个数。这里的start和end单位是字节（8bit）

测试

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 1
(integer) 0
127.0.0.1:6379> bitcount sign
(integer) 3
127.0.0.1:6379> bitcount sign 0 2  #代表第一个字节到第三个字节直接 10011000 00000000 00000000
(integer) 3
127.0.0.1:6379> bitcount sign 0 1  #代表第一个字节到第二个字节直接 10011000 00000000
(integer) 3
127.0.0.1:6379> bitcount sign 0 0  #代表第一个字节到第一个字节直接 10011000
(integer) 3
127.0.0.1:6379> bitcount sign 1 1  #代表第二个字节到第二个字节直接 00000000
(integer) 0
127.0.0.1:6379> bitcount sign 1 2
(integer) 0

Redis.conf

熟悉基本配置

位置

redis的配置文件位于redis安装目录下，名为redis.conf

config get *

我们一般情况下，会单独拷贝出来一份进行操作。来保证初始文件的安全。

units 单位

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

INCLUDES 包含

和spring配置文件类似，可以通过includes包含，redis.conf可以作为总文件，可以包含其他文件！

NETWORK 网络配置

bind 127.0.0.1        #绑定ip
protected-mode yes    #保护模式
port 6379             #默认端口

GENERAL 通用

daemonize yes          #默认情况下，redis不作为守护进程运行。需要开启的话，改为yes
supervised no          #可通过upstart和systemd管理redis守护进程。
pidfile /var/run/redis_6379.pid    #以后台进程方式运行redis，则需要指定pid文件
loglevel notice        #日志级别。可选项有：
					   #debug （记录大量日志信息，是用于开发、测试阶段）；
					   #verbose（较多日志信息）
					   #notice（适量日志信息，适用于生产环境）；
					   #warning（仅有部分重要、关键信息才会被记录）。
logfile ""             #日志文件的位置，当指定为空字符串时，为标准输出
databases 16           #设置数据库的数目。默认的数据库是DB 0
always-show-logo yes   #是否总是显示logo

SNAPSHOPTING 快照

#900秒（15分钟）内至少1个key值改变（则进行数据库保存--持久化）
save 900 1
#300秒（5分钟）内至少10个key值改变（则进行数据库保存--持久化）
save 300 10
#60秒（1分钟）内至少10000个key值改变（则进行数据库保存--持久化）
save 60 10000

stop-writes-on-bgsave-error yes #持久化出现错误后，是否依然继续进行工作。

rdbcompression yes  #使用压缩rdb文件 yes：压缩，但需要一些cpu的消耗。no：不压缩，需要更多的磁盘空间

rdbchecksum yes #是否检验rdb文件，更有利于文件的容错性，但是在保存rdb文件的时候，会有大概10%的性能损耗。

dbfilename dump.rdb #dbfilenamerdb 文件名称

dir ./  #dir 数据目录，数据库的写入会在这个目录。rdb、aof文件也会在这个目录

REPLICATION 复制

SECURITY 安全

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

# 设置密码（可选）
# requirepass foobared  
# 设置和禁用危险命令 ，下面这个命令是禁用了redis中CONFIG命令（可选）
# rename-command CONFIG ""
# 设置了危险命令flushdb 为很长的无规律字符串 b840fc02d524045429941cc15f59e41cb7be6c52
# rename-command CONFIG b840fc02d524045429941cc15f59e41cb7be6c52

也可以在客户端修改密码（临时配置），不过在重启redis后临时配置失效

#启动redis
#链接客户端

#获得和设置密码
127.0.0.1:6379> config get requirepass
1) "requirepass"
2) ""
127.0.0.1:6379> config set requirepass "123456"
OK
#测试ping，发现需要登陆验证
127.0.0.1:6379> ping
(error) NOAUTH Authentication required.
127.0.0.1:6379> auth 123456
OK
127.0.0.1:6379> ping
PONG
# 这个修改的密码重启redis失效

限制

maxclients 10000     #设置能连上redis的最大科幻段连接量

maxmemory <bytes>    #redis配置的最大内存容量

maxmemory-policy noeviction #maxmemory-policy  内存到达上限的处理策略
							#volatile-lru:利用LRU算法移除设置过过期时间的key
							#volatile-random：随机一处设置过过期时间的key，
							#volatile-ttl：移除即将过期的key，根据最近过期时间来删除（辅以TTL）
							#allkeys-lru：利用LRU算法移除任何key，
							#allkeys-random：随机一处任何key
							#noevication：不移除任何key，只是返回一个写错误。

append only模式

appendonly no   #是否yiappend only模式作为持久化方式，默认使用的是rdb方式持久化，这种方式在许多应用中已经足够用了

appendfilename “appendonly.aof”  #appendfilename AOF 文件名称

appendfsync everysec  #appendfsync aof持久化策略的配置
					  #no表示不执行fsync，由于操作系统保证数据同步到磁盘。速度最快。
					  #always表示每次写入都执行fsync，以保证数据同步到磁盘。
					  #everysec表示每秒执行一次fsync，可能导致丢失这1s数据。

常见配置介绍

1、reids默认不是以守护进程的方式运行，可以通过该配置项修改，使用yes启用守护进程

daemonize no

2、当redis一守护进程方式运行时，redis默认会把pid写入到 /var/run/redis.pid文件，可以通过pidfile指定

pidfile /var/run/redis.pid

3、指定redis监听端口，默认端口为6379，作者在自己的一篇博客中解释了为什么选用6379作为默认端口，因为6379在手机按键上MERZ对应的号码，而MERZ取自意大利歌女Alessia Merz的名字

port 6379

4、绑定的主机地址

bind 127.0.0.1

5、当客户端闲置多长时间后关闭连接，如果指定为0，表示关闭该功能

timeout 300

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

loglevel verbose

7、日志记录方式，默认为标准输出，如果配置redis为守护进程方式运行，而这里有配置为日志记录方式为标准输出，则日志将会发送给 /dev/null

logfile stdout

8、设置数据的数量，默认数据库为0，可以使用select命令再连接上指定数据库id

database 16

9、指定在多长时间内，有多少此更新操作，就将数据同步到数据文件，可以多个条件配合

save

redis默认配置文件中提供了三个条件：

save 900 1

save 30010

save 60 10000

分别表示900秒（15分钟）内有一个（全是更改key的数量）更改，300秒（5分钟）内有10个更改以及60秒内有10000个更改

10、指定存储至本地数据库时是否压缩数据，默认为yes，redis采用LZF压缩，如果为了节省cpu时间，可以关闭该选项，但会导致数据库文件变得巨大

rdbcompression yes

11、指定本地数据库文件名，默认为dump.rdb

dbfilename dump.rdb

12、指定本地数据库存放目录

dir ./

13、设置当本机为slav服务时，设置master服务的ip地址及端口，在redis启动时，它会自动从master进行数据同步

slaveof

14、dangmaster服务设置了密码保护时，slav服务连接master的密码

masterauth

15、设置redis连接密码，如果配置了连接密码，客户端在连接redis时需要通过auth命令提供密码，默认关闭

requirepass foobared

16、设置同一时间最大客户端连接数，默认无限制，redis可以同时打开的客户端连接数为rdis进程可以打开的最大文件描述符数，如果设置maxclients 0，表示不做限制。当客户端连接数到达限制时，redis会关闭新的连接并向客户端返回max number of clients reached 错误信息

maxclients 128

17、指定redis最大内存限制，redis在启动时会把数据加载到内存中，达到最大内存后，redis会先尝试清除已到期或即将到期的key，当此方法处理后，仍然到达最大内存设置，将无法再进行写操作，但仍然可以进行读取操作。redis新的vm机制，会把key存放内存，value会存放在swap区

maxmemory

18、指定是否在每次更新后进行日志记录，redis在默认情况下是异步的把数据写入磁盘，如果不开启，可能会在断电时导致一段时间内的数据丢失。因为redis本身同步数据文件是按上面save条件来同步的，所以有的数据会在一段时间内只存在于内存中。默认为no

appendonly no

19、指定更新日志文件名，默认为appendonly.aof

appendfilename appendonly.aof

20、指定更新日志条件，总共有三个可选值

no：表示等操作系统进行数据缓存同步到磁盘（快）

alwys：表示每次更新操作后进行手动调用fsync()将数据写到磁盘（慢、安全）

everysec：表示每秒同步一次（折中，默认值）

appendfsync everysec

21、指定是否启用虚拟内存机制，默认值为no，简单的介绍一下，vm机制将数据分页存放，由redis将访问量较少的也即冷数据swap到磁盘上，访问多的页面由磁盘自动换出到内存中

vm-enabled no

22、虚拟机内存文件路径，默认值为/tmp/redis.swap，不可多个redis实例共享

vm-swap-file /tmp/redis.swap

23、将所有大于vm-max-memory的数据存入虚拟内存，无论vm-maxmemory设置多小，所有索引数据都是内存存储的（redis的索引数据 就是key），也就是说，当vm-max-memory设置为0时，其实是所有value都存放在磁盘中。默认值为0

vm-max-memory 0

24、redis swap文件分成了很多的page，一个对象可以保存在多个page上面，但一个page尚不能被多个对象共享，vm-page-size是要根据储存的数据大小来决定，作者建议如果存储很多小对象，page大小最好设置为32或者64byte，如果存储很大的对象，则可以使用更大的page，如果不确定，就使用默认值

vm-page-size 32

25、设置swap文件中的page数量，由于页面（已中表示页面空闲或使用的bitmap）是在放在内存的，在磁盘上每8个pages将消耗1byte的内存。

vm-page 134247728

26、设置访问swap文件的线程数，最好不要超过机器的核数，如果设置为0，那么所有对swap文件的操作都是串行的，可能会造成比较长时间的延迟。默认值为4

vm-max-threads 4

27、设置在向客户端应答时，是否把较小的包合并为一个包发送，默认为开启

glueoutputbuf yes

28、指定在超过一定的数量或者最大的元素超过某一临界值时，采用一种特殊的哈希算法

hash-max-zipmap-entries 64

hash-max-zipmap-value 512

29、指定是否激活重置哈希，默认为开启

activerhashing yes

30、指定包含其他的配置文件，可以在同一主机上多个redis实例之间使用同一份配置文件，而同时多个实例又拥有自己的特定配置文件

include /path/to/local.conf

redis的持久化

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

RDB（Redis DataBase）

什么是RDB

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

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

Fork

Fork的作用是复制一个与当前进程一样的进程。新进程的所有数据（变量，环境变量，程序计数器等）数值都和原进程一致，但是是一个全新的进程，并作为原进程的子进程。

RDB保存的是dump.rdp文件

配置文件及SNAPSHOTTING

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

• save 60 10000 1分钟10000个key
• save 300 10 5分钟 10个key修改
• save 900 1 15分钟1个key修改

如果想禁用RDB持久化的策略，只要不设置任何save指令，或者给save传入一个空字符串参数也可以。

若要修改完立马生效，可以手动使用save命令！立马生效！

其余命令解析

Stop-writes-no-bgsave-error：如果配置为no，表示你不在乎数据不一致或者有其他的手段发现和控制机制，默认为yes。

rdbcompression：对于存储到磁盘中的快照，可以设置是否进行压缩。如果是的话，redis会采用LZF算法进行压缩，如果你不想消耗cpu来进行压缩的话，可以设置为关闭此功能。

rdbchecksum：在存储快照后，还可以让redis使用CRC64算法来进行数据校验，但是这样做会增大约10%的性能消耗，如果希望获取到最大的性能提升，可以关闭此功能。默认为yes。

如何触发RDB快照

1、配置文件中默认的快照配置，建议多用一台机子作为备份，复制一份dump.rdb

2、命令save或者bgsave

• save时只管保存，其他的不管，全部阻塞
• bgsave，redis会在后台异步进行快照操作，快照同时还可以响应客户端请求。可以通过lastsave命令获取最后一次成功执行快照的时间。

3、执行flushall命令，也会产生dump.rdb文件，但里面是空的，无意义！

4、退出的时候也会产生dump.rdb文件！

如何恢复

1、将备份文件(dump.rdb)移动到redis安装目录冰启动服务器即可

2、CONFIG GET dir 获取目录

127.0.0.1:6379> config get dir
1) "dir"
2) "/usr/local/bin"

优点和缺点

优点：

1、适合大规模的数据恢复

2、对数据完整性和一致性要求不高

缺点：

1、在一定间隔时间做一次备份，所以如果redis意外down掉的话，就会丢失最后一次快照的所有修改

2、Fork的时候，内存中的数据被克隆了一份，大致2倍的膨胀性需要考虑。

小结

AOF（Append Only File）

是什么

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

AOF保存的是appendonly.aof文件

配置

appendonly no   #是否以append only模式作为持久化方式，默认使用的是rdb方式持久化，这种方式在许多应用已经足够

# The name of the append only file (default: "appendonly.aof")
appendfilename "appendonly.aof"

appendfsync everysec #appendfsync aof持久化策略的配置
					 #no 表示不执行fsync，由操作系统保证数据同步到磁盘，速度最快
					 #alaways 表示每次写入都执行fsync，以保证数据同步到磁盘
					 #everysec 表示每秒执行一次fsync，可能会导致丢失这1s数据。 默认策略

no-appendfsync-on-rewrite no #重写时是否可以运用Appendfsync，用默认no即可，保证数据安全性

auto-aof-rewrite-percentage 100  #设置重写的基准值
auto-aof-rewrite-min-size 64mb   #设置重写的基准值

aof-load-truncated yes  #恢复时候忽略最后一条可能出问题的指令，默认yes
aof-use-rdb-preamble yes

AOF启动/修复/恢复

正常恢复：

• 启动：设置Yes，修改默认的appendonly no，改为yes
• 将有数据的aof文件复制一份保存到对应目录 （config get dir）
• 恢复：重启redis然后重新加载

异常恢复：

• 启动：设置yes
• 故意破坏appendonly.aof文件！
• 修复：redis-check-aof --fix appendonly.aof进行修复
• 恢复：重启redis然后重新加载

Rewrite

是什么：

AOF采用文件追加方式，文件会越来越大，为避免出现此种情况，新增了重写机制，当AOF文件的大小超过所设定的阈值时，redis就会启动AOF文件的内容压缩，只保留可以恢复数据的最小指令集，可以使用命令bgrewriteaof！

重写原理：

AOF文件持续增长而过大时，会fork出一条新进程来将文件重写（也是先写临时文件最后再rename），遍历新进程的内存中数据，每条记录有一条的set语句。重写aof文件的操作，并没有读取接的aof文件，这点和快照有点类似！

触发机制：

redis会记录上次重写时的AOF大小，默认配置是当AOF文件大小是上次rewrite后大小的已被且文件大于64m的触发

优点和缺点

优点：

1、每修改同步：appendfsync always 同步持久化，每次发生数据变更会被立即记录到磁盘，性能比较差但数据完整性比较好

2、每秒同步：appendfsync everysec 异步操作，每秒记录，如果一秒内当即，有数据丢失

3、不同步：appendfsync no 从不同步

缺点：

1、相同数据集的数据而言，aof文件要远大于rdb文件，恢复速度慢于rdb。

2、AOF运行效率要鳗鱼rdb，每秒同步策略较好，不同步效率和rdb相同。

小总结

总结

1、RDB 持久化方式能够在指定的时间间隔内对你的数据进行快照存储

2、AOF 持久化方式记录每次对服务器写的操作，当服务器重启的时候会重新执行这些命令来恢复原始的数据，AOF命令以Redis 协议追加保存每次写的操作到文件末尾，Redis还能对AOF文件进行后台重写，使得AOF文件的体积不至于过大。

3、只做缓存，如果你只希望你的数据在服务器运行的时候存在，你也可以不使用任何持久化

4、同时开启两种持久化方式

• 在这种情况下，当redis重启的时候会优先载入AOF文件来恢复原始的数据，因为在通常情况下AOF文件保存的数据集要比RDB文件保存的数据集要完整。
• RDB 的数据不实时，同时使用两者时服务器重启也只会找AOF文件，那要不要只使用AOF呢？作者建议不要，因为RDB更适合用于备份数据库（AOF在不断变化不好备份），快速重启，而且不会有AOF可能潜在的Bug，留着作为一个万一的手段。

5、性能建议

• 因为RDB文件只用作后备用途，建议只在Slave上持久化RDB文件，而且只要15分钟备份一次就够了，只保留 save 900 1 这条规则。
• 如果Enable AOF ，好处是在最恶劣情况下也只会丢失不超过两秒数据，启动脚本较简单只load自己的AOF文件就可以了，代价一是带来了持续的IO，二是AOF rewrite 的最后将 rewrite 过程中产生的新数据写到新文件造成的阻塞几乎是不可避免的。只要硬盘许可，应该尽量减少AOF rewrite的频率，AOF重写的基础大小默认值64M太小了，可以设到5G以上，默认超过原大小100%大小重写可以改到适当的数值。
• 如果不Enable AOF ，仅靠 Master-Slave Repllcation 实现高可用性也可以，能省掉一大笔IO，也减少了rewrite时带来的系统波动。代价是如果Master/Slave 同时倒掉，会丢失十几分钟的数据，启动脚本也要比较两个 Master/Slave 中的 RDB文件，载入较新的那个，微博就是这种架构。

Redis事务

理论

Redis事务的概念：

Redis事务的本质一组命令的集合。事务支持一次执行多个命令，一个事务中所有命令都会被序列化。在事务执行过程，会按照顺序串行化执行队列中的命令，其他客户端提交的命令请求不会插入到事务执行命令序列中。

总结说：redis事务就是一次性、顺序性、排他性的执行一个队列中的一系列命令。

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

批量操作在发生EXEC命令前被放入队列缓存，并不会被实际执行！

Redis不保证原子性：

Redis中，单条命令时原子执行的，但事务不保证原子性，且没有回滚。事务中任意命令执行失败，其余的命令仍会被执行。

Redis事物的三个阶段：

• 开始事务；
• 命令入队
• 执行事务

Redis事务相关命令：

watch key1 key2 ... #监视一或多个key,如果在事务执行之前，被监视的key被其他命令改动，则事务被打断 （ 类似乐观锁 ）
multi # 标记一个事务块的开始（ queued ）
exec # 执行所有事务块的命令 （ 一旦执行exec后，之前加的监控锁都会被取消掉 ）
discard # 取消事务，放弃事务块中的所有命令
unwatch # 取消watch对所有key的监控

实践

正常执行

放弃事务

若在事务队列中存在命令性错误（类似于Java编译性错误），则执行exec命令时，所有命令都不会执行

若在事务队列中存在语法性错误（类似于java的1/0的运行时异常），则执行exec命令时，其他正确命令会被执行，错误命令抛出异常

watch 监控

悲观锁：

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

乐观锁：

乐观锁（optimistic Lock），顾名思义，就是很乐观，每次去拿数据的时候都任务别人不会修改，所以不会上所。但是在更新的时候会判断一下在此期间别人又没有去更新这个数据，可以使用版本号等级制，乐观锁适用于多读的应用类型，这样的可以提高吞吐量，乐观锁策略：提交版本必须大于记录当前版本才能执行更新。

测试：

1、初始化行用卡可用余额和支出

127.0.0.1:6379> set balance 100
OK
127.0.0.1:6379> set debt 0
OK

2、使用watch检测balance，事务期间balance数据未变动，事务执行成功

127.0.0.1:6379> multi
OK
127.0.0.1:6379> decrby balance 20
QUEUED
127.0.0.1:6379> incrby debt 20
QUEUED
127.0.0.1:6379> exec
1) (integer) 80
2) (integer) 20

3、使用watch检测balance，事务期间balance数据变动，事务执行失败！

127.0.0.1:6379> set balance 100
OK
127.0.0.1:6379> set dept 0
OK
127.0.0.1:6379> watch balance
OK
127.0.0.1:6379> multi   #执行完毕后，执行窗口二代码
OK
127.0.0.1:6379> decrby balance 20
QUEUED
127.0.0.1:6379> incrby dept 20
QUEUED
127.0.0.1:6379> exec  #修改失败
(nil)


# 窗口二
127.0.0.1:6379> get balance
"100"
127.0.0.1:6379> set balance 200
OK



#窗口一:出现问题后放弃监视，然后从来！
127.0.0.1:6379> unwatch
OK
127.0.0.1:6379> watch balance
OK
127.0.0.1:6379> multi
OK
127.0.0.1:6379> decrby balance 20
QUEUED
127.0.0.1:6379> incrby dept 20
QUEUED
127.0.0.1:6379> exec
1) (integer) 180
2) (integer) 20

说明：

一旦职系那个exec开启事务的执行后，无论事务使用执行是否成功，watch对变量的监控都将被取消。故当事务执行失败后，需要新执行watch命令对变量进行监控，并开启新的事务进行操作。

小结

watch指令类似于乐观锁，在事务提交时，如果watch监控的多个key中任何key的值已经被其他客户端更改，则使用exec执行事务时，事务队列将不会被执行，同时返回Nullmulti-bulk应答已通知调用者事务执行失败。

Redis发布订阅

是什么

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

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

订阅/发布消息图：

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

命令

这些命令被广泛用于构建即时通信应用，比如网络聊天室（chatroom）和实时广播、实时提醒等。

测试

以下实例演示了发布订阅是如何工作的。在我们实例中我们创建了订阅频道名为redisChat；

127.0.0.1:6379> subscribe redisChat
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "redisChat"
3) (integer) 1

现在，我们先重新开启个redis客户端，然后在同一个频道redisChat发布两次信息，订阅者就能接收到消息。

127.0.0.1:6379> publish redisChat "hello,Redis"
(integer) 1
127.0.0.1:6379> publish redisChat "hello,wyx"
(integer) 1


#订阅者的客户端会显示如下信息
1) "message"
2) "redisChat"
3) "hello,Redis"
1) "message"
2) "redisChat"
3) "hello,wyx"

原理

Redis是使用C实现的、通过分析Redis源码里的pubsub.c文件，了解发布和订阅的底层实现，籍此加深对redis的理解。

Redis通过publish、subscribe和psubscribe等命令实现发布和订阅功能。

通过subscribe命令订阅某频道后，redis-server里维护了一个字典，字典的键就是一个个channel，而字典的值则是一个链表，链表中保存了所订阅这个channel的客户端。subscribe命令的关键，就是将客户端添加到给定channel的订阅链表中。

通过 PUBLISH 命令向订阅者发送消息，redis-server 会使用给定的频道作为键，在它所维护的 channel字典中查找记录了订阅这个频道的所有客户端的链表，遍历这个链表，将消息发布给所有订阅者。

Pub/Sub 从字面上理解就是发布（Publish）与订阅（Subscribe），在Redis中，你可以设定对某一个key值进行消息发布及消息订阅，当一个key值上进行了消息发布后，所有订阅它的客户端都会收到相应的消息。这一功能最明显的用法就是用作实时消息系统，比如普通的即时聊天，群聊等功能。

使用场景

Pub/Sub构建实时消息系统

Redis的Pub/Sub系统可以构建实时的消息系统，比如很多用Pub/Sub构建的实时聊天系统的例子

Redis主从复制

概念

主从复制，是指将一台redis服务器的数据，复制到其他的redis服务器。前者称为主节点（master/leader），后者成为从节点（slave/follower）；数据的复制时单向的，只能由主节点到从节点。Master以写为主，Salve以读为主。

默认情况下，每台redis服务器都是主节点；且一个主节点可以有多个从节点（或者没有从节点），但一个从节点只能有一个主节点。

主从复制的作用主要包括：

1、数据冗余：主从复制实现了数据的热备份，是持久化之外的一种数据冗余方式。

2、故障恢复：当主节点出现问题时，可以由从节点提供服务，实现快速的故障恢复；实际上是一种服务的冗余。

3、负载均衡：在主从复制的基础上，配合督学分离，可以有主节点提供写服务，由从节点提供读服务（即写redis数据时应用连接主节点，读redis数据时应用连接从节点），翻单服务器负载；尤其是在写少读多的场景下，通过多个从节点分担读负载，可以大大提高redis服务器的并发量。

4、高可用基石：除了上述作用以外，主从复制还是哨兵和集群能够实施的基础，因此说主从复制是redis高可用的基础。

一般来说，要将redis运用于工程项目中，只使用一台redis是万万不能的，原因如下：

1、从结构上，单个redis服务器会发生单点故障，并且一台服务器需要处理所有的请求负载，压力较大；

2、从容梁上，单个redis服务器内存容量有限，就算一台redis服务器内存容量为256G，也不能将所有的内存用作Redis存储内存，一般来说，单台Redis最大使用内存不应该超过20G。

电商网站上的商品，一般都是一次上传，无数次浏览的，说专业点也就是“多读少写”。

对于这种长江，哦我们可以使用如下这种架构：

环境配置

基本环境

配从库不配主库，从库配置：

slaveof 主库ip 主库端口  #配置主从
Info replication #查看信息

每次于master断开之后，都需要重新连接，除非你配置redis.conf文件！

修改配置文件！

准备工作：我们配置主从复制，只扫需要三个redis服务，一主二从！配置三个客户端！

拷贝多个redis.conf文件

2、指定端口6379，依次类推

3、开启daemonize yes 后台运行

4、Pid文件名字pidfile /var/run/redis_6379.pid，依此类推

5、Log文件名字logfile "6379.log"，依此类推

6、Dump.rdb名字dbfilename dump6379.rdb，依此类推

上述配置完毕后，3个服务通过3个不同的配置文件开启，我们的准备换就就ok了！

一主二从

一主二仆

1、环境初始化，启动客户端redis-cli -p -端口号连接redis服务。

默认三个都是master主节点。info replication查看redis服务信息

2、配置为一个Master 两个Slave

主节点配置

测试一：主机挂了，查看从机信息，主机恢复，再次查看信息

• 主机挂，从机还是为从机，从机中主机信息显示为down（下线）
• 主机恢复，原来的主机还是主机，下面有两个从机，从机还是从机，显示主机up。

测试二：从机挂了，查看主机信息，从机回复，查看从机信息

• 从机挂，主机里面就没有这个从机的信息了。
• 从机恢复，从机变为自己的主机。

层层链路

上一个Slave可以是下一个Slave的Master，Slave同样可以接受其他slaves的连接和同步请求，那么改slave作为链条中下一个master，可以有效减轻master的写压力（只需要写入后面一个从机）

谋朝篡位

一主二从的情况下，如果主机端了，从机可以使用命令slaveof no one将自己改为主机！这个时候其余的从机（手动）连接到这个节点。对一个从属服务器执行执行命令Slaveof no one 将使这个从属服务器关闭复制功能，并从从属服务器转变回主服务器，原来同步所得的数据集不会被丢弃。

主机再回来，就成了光杆司令，从机为了正常使用跑到了新的主机上！

复制原理

Slave启动成功连接到master后会发送一个sync命令

Master接到命令后，启动后台的存盘进程，同时收集所有接收到的用于修改数据集，在后台进程执行完毕之后，master将传送整个数据文件到salve，并完成一次完全同步。

全量复制：而slave服务在接收到数据库文件数据后，将其存盘并加载到内存中。

增量复制：master继续将新的所有的收集到的修改命令一次传给slave，完成同步

但是只要是重新连接master，一次完全同步（全量复制）将被自动执行

哨兵模式

概述

主从切换技术的方法是：当主服务器宕机后，需要手动把一台从服务器切换为主服务器，这就需要人工干预，费时费力，还会造成一段时间内服务不可用。这不是一种推荐的方式，更多时候，我们优先考虑哨兵模式。Redis从2.8开始正是提供了Sentinel（哨兵）架构来解决这个问题。

谋朝篡位的自动版，能够后台监控主机是否故障，如果故障了根据投票数自动将从库转换为主库。

哨兵模式是一种特殊的模式，首先redis提供了哨兵的命令，哨兵是一个独立的进程，作为进程，他会独立运行。其原理是 哨兵通过发送命令，等待redis服务器相应，从而监控运行的多个redis实例。

这里的哨兵有两个作用

• 通过发送命令，让redis服务器返回监控其运行状态，包括主服务器和从服务器。
• 当烧饼检测到master宕机，会自动将slave切换成master，然后通过发布订阅模式通知其他的从服务器，修改配置文件，当他们切换主机。

然而一个哨兵进程对redis服务器进行监控，可能会出现问题，为此，我们可以使用多个哨兵进行监控。各个哨兵之间还会进行监控，这样就形成了多哨兵模式。

假设主服务器宕机，哨兵1先检测到这个结果，系统并不会马上进行failover过程，仅仅是哨兵1主观的认为主服务器不可用，这个现象称为主观下线。当后面的哨兵也检测到主服务器不可用，并且数量达到一定值时，那么烧饼之间就会进行一次投票，投票的结果由一个哨兵发起，进行failover【故障转移】操作。切换成功后，就会通过发布订阅模式，让各个哨兵把自己监控的服务器实现切换主机，这个过程称为客观下线。

配置测试

1、调整结构，6379主机 80、81从机

2、自定义/myredis目录下新建sentinel.conf文件，名字千万不要写错

3、配置哨兵，填写内容

• sentinel monitor 被监控的主机名字 被监控主机ip 端口 1
• 上面最后一个数字1，表示主机挂掉后slave投票看让谁接替成为主机，得票数多成为主机

4、启动哨兵

• Redis-sentinel /myredis/sentinel.conf
• 上述目录依照各自的实际情况配置，可能目录不同

5、正常主从演示

6、原有的Master挂了

7、投票重选

8、重新主从继续开工，info replication 查看

9、问题：如果之前的master重启回来，会不会双master冲突？ 之前的回来只能做小弟

哨兵模式的优缺点

优点

1. 哨兵集群模式是基于主从模式的，所有主从的优点，哨兵模式同样具有。
2. 主从可以切换，故障可以转移，系统可用性更好。
3. 哨兵模式时主从模式的升级，系统更健壮，可用性更高。

缺点

1. redis较难支持在线扩容，在集群容量到达上限时在线扩容会变得更复杂。
2. 实现哨兵模式的配置也不简单，甚至可以说有些繁琐。

哨兵配置说明

# Example sentinel.conf
# 哨兵sentinel实例运行的端口 默认26379
port 26379
# 哨兵sentinel的工作目录
dir /tmp
# 哨兵sentinel监控的redis主节点的 ip port
# master-name 可以自己命名的主节点名字 只能由字母A-z、数字0-9 、这三个字符".-_"组成。
# quorum 配置多少个sentinel哨兵统一认为master主节点失联 那么这时客观上认为主节点失联了
# sentinel monitor <master-name> <ip> <redis-port> <quorum>
sentinel monitor mymaster 127.0.0.1 6379 2
# 当在Redis实例中开启了requirepass foobared 授权密码 这样所有连接Redis实例的客户端都要提供密码
# 设置哨兵sentinel 连接主从的密码 注意必须为主从设置一样的验证密码
# sentinel auth-pass <master-name> <password>
sentinel auth-pass mymaster MySUPER--secret-0123passw0rd
# 指定多少毫秒之后 主节点没有应答哨兵sentinel 此时 哨兵主观上认为主节点下线 默认30秒
# sentinel down-after-milliseconds <master-name> <milliseconds>
sentinel down-after-milliseconds mymaster 30000
# 这个配置项指定了在发生failover主备切换时最多可以有多少个slave同时对新的master进行 同步，这个数字越小，完成failover所需的时间就越长，但是如果这个数字越大，就意味着越 多的slave因为replication而不可用。可以通过将这个值设为 1 来保证每次只有一个slave 处于不能处理命令请求的状态。
# sentinel parallel-syncs <master-name> <numslaves>
sentinel parallel-syncs mymaster 1
# 故障转移的超时时间 failover-timeout 可以用在以下这些方面：
#1. 同一个sentinel对同一个master两次failover之间的间隔时间。
#2. 当一个slave从一个错误的master那里同步数据开始计算时间。直到slave被纠正为向正确的master那里同步数据时。
#3.当想要取消一个正在进行的failover所需要的时间。
#4.当进行failover时，配置所有slaves指向新的master所需的最大时间。不过，即使过了这个超时，slaves依然会被正确配置为指向master，但是就不按parallel-syncs所配置的规则来了
# 默认三分钟
# sentinel failover-timeout <master-name> <milliseconds>
sentinel failover-timeout mymaster 180000
# SCRIPTS EXECUTION
#配置当某一事件发生时所需要执行的脚本，可以通过脚本来通知管理员，例如当系统运行不正常时发邮件通知相关人员。
#对于脚本的运行结果有以下规则：
#若脚本执行后返回1，那么该脚本稍后将会被再次执行，重复次数目前默认为10
#若脚本执行后返回2，或者比2更高的一个返回值，脚本将不会重复执行。
#如果脚本在执行过程中由于收到系统中断信号被终止了，则同返回值为1时的行为相同。
#一个脚本的最大执行时间为60s，如果超过这个时间，脚本将会被一个SIGKILL信号终止，之后重新执
行。
#通知型脚本:当sentinel有任何警告级别的事件发生时（比如说redis实例的主观失效和客观失效等等），将会去调用这个脚本，这时这个脚本应该通过邮件，SMS等方式去通知系统管理员关于系统不正常运行的信息。调用该脚本时，将传给脚本两个参数，一个是事件的类型，一个是事件的描述。如果sentinel.conf配置文件中配置了这个脚本路径，那么必须保证这个脚本存在于这个路径，并且是可执行的，否则sentinel无法正常启动成功。
#通知脚本
# sentinel notification-script <master-name> <script-path>
sentinel notification-script mymaster /var/redis/notify.sh
# 客户端重新配置主节点参数脚本
# 当一个master由于failover而发生改变时，这个脚本将会被调用，通知相关的客户端关于master地址已经发生改变的信息。
# 以下参数将会在调用脚本时传给脚本:
# <master-name> <role> <state> <from-ip> <from-port> <to-ip> <to-port>
# 目前<state>总是“failover”,
# <role>是“leader”或者“observer”中的一个。
# 参数 from-ip, from-port, to-ip, to-port是用来和旧的master和新的master(即旧的slave)通信的
# 这个脚本应该是通用的，能被多次调用，不是针对性的。
# sentinel client-reconfig-script <master-name> <script-path>
sentinel client-reconfig-script mymaster /var/redis/reconfig.sh

缓存穿透和雪崩

redis缓存的使用，极大的提升了应用程序的性能和效率，特别是数据查询方面。但同时，他也带来了一些问题。其中，最要害的问题，就是数据的一致性问题，从严格意义上讲，这个问题无解。如果对于数据的一致性要求很高，那么就不能使用缓存。

另外的一些典型问题就是，缓存穿透、缓存雪崩和缓存击穿。目前，业界也都有比较流行的解决方案。

缓存穿透

概念

缓存穿透的概念很简单，用户想要查询一个数据，发现redis内存数据库没有，也就是缓存没有几种，于是向持久层数据库查询。发现也没有，于是本次查询失败，当用户很多的时候，缓存都没有命中， 于是都去请求了持久层数据库。这会给持久层数据库造成很大的压力，这时候就相当于出现了缓存穿透

解决方案

布隆过滤器

布隆过滤器是一种数据结构，对所有可能查询的参数以hash形式存储，在控制层先进行校验，不符合则丢弃，从而避免了对底层存储系统的查询压力；

缓存空对象

当存储层不命中后，即使返回的空对象也将其缓存起来，同时会设置一个过期时间，之后再访问这个数据将会从缓存中获取，保护了后端数据源；

但是这种方法会存在两个问题：

1、如果空值能够被缓存起来，这就意味着缓存需要更多的空间存储更多的键，因为这当中可能会有很多的空值的键；

2、即使对空值

设置了过期时间，还是会存在缓存层和存储层的数据会有一段时间窗口的不一致，这对于需要保持一致性的业务会有影响。

缓存击穿

概述

这里需要注意和缓存穿透的区别，缓存击穿，是指一个key非常热点，在不停的扛着大并发，大并发集中对着一个点进行访问，当这个key在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库，就像在一个屏障上凿开了一个洞。

当某个key在过期的瞬间，有大量的请求并发访问，这类数据一般是热点数据，由于缓存过期，会同时访问数据库来查询最新数据，并且回写缓存，会导致数据库瞬间压力过大。

解决方案

设置热点数据永不过期

从缓存层面来看，没有设置过期时间，所以不会出现热点key过期后产生的问题。

加互斥锁

分布式锁：使用分布式锁，保证对于每个key同时只有一个线程去查询后端事务，其他线程没有获得分布式锁的权限，因此只需要等待即可。这种方式将高并发的压力转移到了分布式锁，因此对分布式锁的考验很大。

缓存雪崩

概念

缓存雪崩，是指在某一时间段，缓存集中过期失效。

产生雪崩的原因之一，比如在写文本的时候，马上就要到双十二零点，很快就会迎来一波抢购，这波商品时间比较集中的放入了缓存，假设缓存一个小时，那么到了凌晨一点钟的时候，这批商品的缓存就都过期了。而对于这批商品的访问查询，都落到了数据库上，对于数据库而言，就会产生周期性的压力波峰。于是所有的请求都会达到存储层，存储层的调用量会爆增，造成存储层也会挂掉的情况。

其中集中过期，倒也不是非常致命，比较致命的缓存雪崩，是缓存服务器某个节点宕机或者断网。因为自然形成的缓存雪崩，一定是在某个时间段集中创建缓存，这个时候，数据库也是可以顶住压力的。无非就是对数据库产生周期性的压力而已。而缓存服务节点的宕机，对数据库服务器造成的压力是不可预知的，很有可能瞬间就把数据库压垮。

解决方案

redis高可用

这个思想的含义是，既然redis有可能挂掉，那我多增设几台redis，这样一台挂掉之后其他的还可以继续工作，其实就是搭建的集群。

限流降级

这个解决方案的思想时，在缓存失效后，通过加锁或者队列来控制都数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存，其他线程等待。

数据预热

数据预热的含义就是在正式部署之前，我先把可能的数据预先访问一遍，这样部分可能大量访问的数据就会加载到缓存中。在即将发生大并发前手动触发加载缓存不同的key，设置不同的过期时间，让缓存失效的时间点尽量均匀。

Jedis

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

测试连通

1、新建一个普通的maven项目

2、导入redis的依赖！

<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.2.0</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.58</version>
</dependency>

3、编写测试代码

public class Ping {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1",6379);
        System.out.println("连接成功");
        //查看服务是否运行
        System.out.println("服务正在运行: "+jedis.ping());
    }
}

4、启动redis服务（本地）

5、启动代码测试

连接成功
服务正在运行: PONG

常用API

public class TestPassword {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);

        //验证密码，如果没有设置密码这段代码省略
//        jedis.auth("password");

        jedis.connect(); //连接
        jedis.disconnect(); //断开连接

        jedis.flushAll(); //清空所有的key
    }
}

对key操作的命令

import redis.clients.jedis.Jedis;

import java.util.Set;

public class TestKey {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);

        System.out.println("清空数据："+jedis.flushDB());
        System.out.println("判断某个键是否存在："+jedis.exists("username"));
        System.out.println("新增<'username','kuangshen'>的键值对："+jedis.set("username", "kuangshen"));
        System.out.println("新增<'password','password'>的键值对："+jedis.set("password", "password"));
        System.out.print("系统中所有的键如下：");
        Set<String> keys = jedis.keys("*");
        System.out.println(keys);
        System.out.println("删除键password:"+jedis.del("password"));
        System.out.println("判断键password是否存在："+jedis.exists("password"));
        System.out.println("查看键username所存储的值的类型："+jedis.type("username"));
        System.out.println("随机返回key空间的一个："+jedis.randomKey());
        System.out.println("重命名key："+jedis.rename("username","name"));
        System.out.println("取出改后的name："+jedis.get("name"));
        System.out.println("按索引查询："+jedis.select(0));
        System.out.println("删除当前选择数据库中的所有key："+jedis.flushDB());
        System.out.println("返回当前数据库中key的数目："+jedis.dbSize());
        System.out.println("删除所有数据库中的所有key："+jedis.flushAll());
    }
}

对String操作的命令

import redis.clients.jedis.Jedis;

import java.util.concurrent.TimeUnit;

public class TestString {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);

        jedis.flushDB();
        System.out.println("===========增加数据===========");
        System.out.println(jedis.set("key1","value1"));
        System.out.println(jedis.set("key2","value2"));
        System.out.println(jedis.set("key3", "value3"));
        System.out.println("删除键key2:"+jedis.del("key2"));
        System.out.println("获取键key2:"+jedis.get("key2"));
        System.out.println("修改key1:"+jedis.set("key1", "value1Changed"));
        System.out.println("获取key1的值："+jedis.get("key1"));
        System.out.println("在key3后面加入值："+jedis.append("key3", "End"));
        System.out.println("key3的值："+jedis.get("key3"));
        System.out.println("增加多个键值对："+jedis.mset("key01","value01","key02","value02","key03","value03"));
        System.out.println("获取多个键值对："+jedis.mget("key01","key02","key03"));
        System.out.println("获取多个键值对："+jedis.mget("key01","key02","key03","key04"));
        System.out.println("删除多个键值对："+jedis.del("key01","key02"));
        System.out.println("获取多个键值对："+jedis.mget("key01","key02","key03"));

        jedis.flushDB();
        System.out.println("===========新增键值对防止覆盖原先值==============");
        System.out.println(jedis.setnx("key1", "value1"));
        System.out.println(jedis.setnx("key2", "value2"));
        System.out.println(jedis.setnx("key2", "value2-new"));
        System.out.println(jedis.get("key1"));
        System.out.println(jedis.get("key2"));

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

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

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

对List操作命令

public class TestList {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        jedis.flushDB();
        System.out.println("===========添加一个list===========");
        jedis.lpush("collections", "ArrayList", "Vector", "Stack", "HashMap", "WeakHashMap", "LinkedHashMap");
        jedis.lpush("collections", "HashSet");
        jedis.lpush("collections", "TreeSet");
        jedis.lpush("collections", "TreeMap");
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));//-1代表倒数第一个元素，-2代表倒数第二个元素,end为-1表示查询全部
        System.out.println("collections区间0-3的元素："+jedis.lrange("collections",0,3));
        System.out.println("===============================");
        // 删除列表指定的值 ，第二个参数为删除的个数（有重复时），后add进去的值先被删，类似于出栈
        System.out.println("删除指定元素个数："+jedis.lrem("collections", 2, "HashMap"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("删除下表0-3区间之外的元素："+jedis.ltrim("collections", 0, 3));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("collections列表出栈（左端）："+jedis.lpop("collections"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("collections添加元素，从列表右端，与lpush相对应："+jedis.rpush("collections", "EnumMap"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("collections列表出栈（右端）："+jedis.rpop("collections"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("修改collections指定下标1的内容："+jedis.lset("collections", 1, "LinkedArrayList"));
        System.out.println("collections的内容："+jedis.lrange("collections", 0, -1));
        System.out.println("===============================");
        System.out.println("collections的长度："+jedis.llen("collections"));
        System.out.println("获取collections下标为2的元素："+jedis.lindex("collections", 2));
        System.out.println("===============================");
        jedis.lpush("sortedList", "3","6","2","0","7","4");
        System.out.println("sortedList排序前："+jedis.lrange("sortedList", 0, -1));
        System.out.println(jedis.sort("sortedList"));
        System.out.println("sortedList排序后："+jedis.lrange("sortedList", 0, -1));
    }
}

对set的操作命令

public class TestSet {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        jedis.flushDB();
        System.out.println("============向集合中添加元素（不重复）============");
        System.out.println(jedis.sadd("eleSet", "e1","e2","e4","e3","e0","e8","e7","e5"));
        System.out.println(jedis.sadd("eleSet", "e6"));
        System.out.println(jedis.sadd("eleSet", "e6"));
        System.out.println("eleSet的所有元素为："+jedis.smembers("eleSet"));
        System.out.println("删除一个元素e0："+jedis.srem("eleSet", "e0"));
        System.out.println("eleSet的所有元素为："+jedis.smembers("eleSet"));
        System.out.println("删除两个元素e7和e6："+jedis.srem("eleSet", "e7","e6"));
        System.out.println("eleSet的所有元素为："+jedis.smembers("eleSet"));
        System.out.println("随机的移除集合中的一个元素："+jedis.spop("eleSet"));
        System.out.println("随机的移除集合中的一个元素："+jedis.spop("eleSet"));
        System.out.println("eleSet的所有元素为："+jedis.smembers("eleSet"));
        System.out.println("eleSet中包含元素的个数："+jedis.scard("eleSet"));
        System.out.println("e3是否在eleSet中："+jedis.sismember("eleSet", "e3"));
        System.out.println("e1是否在eleSet中："+jedis.sismember("eleSet", "e1"));
        System.out.println("e1是否在eleSet中："+jedis.sismember("eleSet", "e5"));
        System.out.println("=================================");
        System.out.println(jedis.sadd("eleSet1", "e1","e2","e4","e3","e0","e8","e7","e5"));
        System.out.println(jedis.sadd("eleSet2", "e1","e2","e4","e3","e0","e8"));
        System.out.println("将eleSet1中删除e1并存入eleSet3中："+jedis.smove("eleSet1", "eleSet3", "e1"));//移到集合元素
        System.out.println("将eleSet1中删除e2并存入eleSet3中："+jedis.smove("eleSet1", "eleSet3", "e2"));
        System.out.println("eleSet1中的元素："+jedis.smembers("eleSet1"));
        System.out.println("eleSet3中的元素："+jedis.smembers("eleSet3"));
        System.out.println("============集合运算=================");
        System.out.println("eleSet1中的元素："+jedis.smembers("eleSet1"));
        System.out.println("eleSet2中的元素："+jedis.smembers("eleSet2"));
        System.out.println("eleSet1和eleSet2的交集:"+jedis.sinter("eleSet1","eleSet2"));
        System.out.println("eleSet1和eleSet2的并集:"+jedis.sunion("eleSet1","eleSet2"));
        System.out.println("eleSet1和eleSet2的差集:"+jedis.sdiff("eleSet1","eleSet2"));//eleSet1中有，eleSet2中没有
        jedis.sinterstore("eleSet4","eleSet1","eleSet2");//求交集并将交集保存到dstkey的集合
        System.out.println("eleSet4中的元素："+jedis.smembers("eleSet4"));
    }
}

对Hash的操作命令

public class TestHash {
    public static void main(String[] args) {
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        jedis.flushDB();
        Map<String,String> map = new HashMap<String,String>();
        map.put("key1","value1");
        map.put("key2","value2");
        map.put("key3","value3");
        map.put("key4","value4");
        //添加名称为hash（key）的hash元素
        jedis.hmset("hash",map);
        //向名称为hash的hash中添加key为key5，value为value5元素
        jedis.hset("hash", "key5", "value5");
        System.out.println("散列hash的所有键值对为："+jedis.hgetAll("hash"));//return Map<String,String>
        System.out.println("散列hash的所有键为："+jedis.hkeys("hash"));//return Set<String>
        System.out.println("散列hash的所有值为："+jedis.hvals("hash"));//return List<String>
        System.out.println("将key6保存的值加上一个整数，如果key6不存在则添加key6："+jedis.hincrBy("hash", "key6", 6));
        System.out.println("散列hash的所有键值对为："+jedis.hgetAll("hash"));
        System.out.println("将key6保存的值加上一个整数，如果key6不存在则添加key6："+jedis.hincrBy("hash", "key6", 3));
        System.out.println("散列hash的所有键值对为："+jedis.hgetAll("hash"));
        System.out.println("删除一个或者多个键值对："+jedis.hdel("hash", "key2"));
        System.out.println("散列hash的所有键值对为："+jedis.hgetAll("hash"));
        System.out.println("散列hash中键值对的个数："+jedis.hlen("hash"));
        System.out.println("判断hash中是否存在key2："+jedis.hexists("hash","key2"));
        System.out.println("判断hash中是否存在key3："+jedis.hexists("hash","key3"));
        System.out.println("获取hash中的值："+jedis.hmget("hash","key3"));
        System.out.println("获取hash中的值："+jedis.hmget("hash","key3","key4"));
    }
}

事务

基本操作

import com.alibaba.fastjson.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;

public class TestMulti {
    public static void main(String[] args) {
        //创建客户端连接服务端，redis服务端需要被开启
        Jedis jedis = new Jedis("127.0.0.1", 6379);
        jedis.flushDB();

        JSONObject jsonObject = new JSONObject();
        jsonObject.put("hello", "world");
        jsonObject.put("name", "java");
        //开启事务
        Transaction multi = jedis.multi();
        String result = jsonObject.toJSONString();
        try{
            //向redis存入一条数据
            multi.set("json", result);
            //再存入一条数据
            multi.set("json2", result);
            //这里引发了异常，用0作为被除数
            int i = 100/0;
            //如果没有引发异常，执行进入队列的命令
            multi.exec();
        }catch(Exception e){
            e.printStackTrace();
            //如果出现异常，回滚
            multi.discard();
        }finally{
            System.out.println(jedis.get("json"));
            System.out.println(jedis.get("json2"));
            //最终关闭客户端
            jedis.close();
        }
    }
}

StringBoot整合

基础使用

概述

在springboot中一般使用RedisTemplate提供的方法来操作redis。那么使用SpringBoot整合redis需要哪些步骤。

1、JedisPoolConfig（这个是配置连接池）

2、RedisConnectionFactory这个是配置连接信息，这里的RedisConnectionFactory是一个接口，我们需要使用它的实现类，在SpringBoot- Redis 方案中提供了以下四种工厂模型：

• JredisConnectionFactory
• JedisConnectionFactory
• LettuceConnectionFactory
• SrpConnectionFactory

3、RedisTemplate基本操作

导入依赖

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

yml配置

spring:
    redis:
      host: 127.0.0.1
      port: 6379
      password: 
      jedis:
        pool:
          max-active: 8
          max-wait: -1ms
          max-idle: 500
          min-idle: 0
      lettuce:
        shutdown-timeout: 0ms

测试

@SpringBootTest
class SpringbootRedisApplicationTests {

    @Autowired
    private RedisTemplate<String,String> redisTemplate;

    @Test
    void contextLoads() {
        redisTemplate.opsForValue().set("myKey","myValue");
        System.out.println(redisTemplate.opsForValue().get("myKey"));
    }

}

封装工具类

1、仙剑SpringBoot项目

2、导入redis的启动器

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

3、配置redis，可以查看RedisProperties分析

spring.redis.host=127.0.0.1
spring.redis.port=6379

4、分析RedisAutoConfiguration自动配置类

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {

	@Bean
	@ConditionalOnMissingBean(name = "redisTemplate")
	@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
	public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
		RedisTemplate<Object, Object> template = new RedisTemplate<>();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

	@Bean
	@ConditionalOnMissingBean
	@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
	public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
		StringRedisTemplate template = new StringRedisTemplate();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

}

这个源码可以看出，SpringBoot自动帮我们在容器中生成了一个RedisTemplate和一个StringRedisTemplate。

但是，这个RedisTemplate的泛型是<Object,Object>，写代码不方便，需要写好多类型转换代码；我们需要一个泛型为<String,Object>形式的RedisTemplate。并且，这个RedisTemplate没有设置数据存在Redis时，key及value的序列化方式。

看到@ConditionalOnMissingBean注解后，就知道如果Sping容器有了RedisTemplate对象了，这个自动配置的RedisTemplate不会被实例化。因此我们可以直接自己写配置类，配置RedisTemplate。

5、既然自动配置不好用，就重新配置一个RedisTemplate

@Configuration
public class RedisConfig {

  @Bean
  @SuppressWarnings("all")
  public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
      RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
      template.setConnectionFactory(factory);
      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);
      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;
  }


}

6、写一个Redis工具类（直接用RedisTemplate操作Redis，需要很多行代码，因此直接封装好一个RedisUtils，这样写代码更方便点。这个RedisUtils交给Spring容器实例化，使用时直接注入。）