python操作redis用法详解

1.简单介绍

安装redis

pip install redis

Redis是一个基于内存的高效的键值型非关系型数据库，存取效率极高，而且支持多种存储数据结构，使用也非常简单。本节中，我们就来介绍一下Python的Redis操作。

redis提供两个类Redis和StrictRedis来实现Redis的命令操作。StrictRedis实现了绝大部分官方的命令，参数也一一对应，比如set()方法就对应Redis命令的set方法。

而Redis是StrictRedis的子类，它的主要功能是用于向后兼容旧版本库里的几个方法。为了做兼容，它将方法做了改写，比如lrem()方法就将value和num参数的位置互换，这和Redis命令行的命令参数不一致。

redis连接实例是线程安全的，可以直接将redis连接实例设置为一个全局变量，直接使用。如果需要另一个Redis实例（or Redis数据库）时，就需要重新创建redis连接实例来获取一个新的连接。同理，python的redis没有实现select命令。

2.连接Redis

假设现在我们已经在本地安装了Redis并运行在6379端口。那么，可以用如下示例连接Redis并测试：

2.1 Redis方式连接

import redis   # 导入redis模块，通过python操作redis 也可以直接在redis主机的服务端操作缓存数据库redis = redis.Redis(host='localhost', port=6379, decode_responses=True)   # host是redis主机，需要redis服务端和客户端都启动 redis默认端口是6379
redis.set('name', 'junxi')  # key是"foo" value是"bar" 将键值对存入redis缓存
print(redis['name'])
print(redis.get('name'))  # 取出键name对应的值
print(type(redis.get('name')))

2.2 StrictRedis方式连接

from redis import StrictRedisredis = StrictRedis(host='localhost', port=6379, db=0, password='foobared')
redis.set('name', 'Bob')
print(redis.get('name'))

这里我们传入了Redis的地址、运行端口、使用的数据库和密码信息。在默认不传的情况下，这4个参数分别为localhost、6379、0和None。首先声明了一个StrictRedis对象，接下来调用set()方法，设置一个键值对，然后将其获取并打印。

运行结果如下：

b'Bob'

这说明我们连接成功，并可以执行set()和get()操作了。

2.3 ConnectionPool连接(推荐使用)

redis使用connection pool来管理对一个redis server的所有连接，避免每次建立、释放连接的开销。默认，每个Redis实例都会维护一个自己的连接池。
可以直接建立一个连接池，然后作为参数Redis，这样就可以实现多个Redis实例共享一个连接池

from redis import StrictRedis, ConnectionPoolpool = ConnectionPool(host='localhost', port=6379, db=0, password='foobared')
redis = StrictRedis(connection_pool=pool)

这样的连接效果是一样的。观察源码可以发现，StrictRedis内其实就是用host和port等参数又构造了一个ConnectionPool，所以直接将ConnectionPool当作参数传给StrictRedis也一样。

另外，ConnectionPool还支持通过URL来构建。URL的格式支持有如下3种：

redis://[:password]@host:port/db
rediss://[:password]@host:port/db
unix://[:password]@/path/to/socket.sock?db=db

这3种URL分别表示创建Redis TCP连接、Redis TCP+SSL连接、Redis UNIX socket连接。我们只需要构造上面任意一种URL即可，其中password部分如果有则可以写，没有则可以省略。下面再用URL连接演示一下：

url = 'redis://:foobared@localhost:6379/0'
pool = ConnectionPool.from_url(url)
redis = StrictRedis(connection_pool=pool)

这里我们使用第一种连接字符串进行连接。首先，声明一个Redis连接字符串，然后调用from_url()方法创建ConnectionPool，接着将其传给StrictRedis即可完成连接，所以使用URL的连接方式还是比较方便的。

3.字符串 strings

Python操作Redis的redis模块对字符串（string）的主要操作函数包括：SET、GET、GETSET、SETEX、SETNX、MSET、MSETNX、INCR(INCRBY,DECR,DECRBY在python中庸同一个函数incr实现)、APPEND、SETRANGE、STRLEN。函数说明如下：

set：为指定的键（key）设置值（value）， set(self, name, value, **kwargs)。
get：获取指定键（key）绑定的值（value），get(self, name)。
getset：为指定的键（key）设置新的值（value），并返回旧的值（old Value），getset(self, name, value)
setex：为指定的键（key）设置过期以秒（second）计的过期时间，setex(self, name, value, time)
setnx：键（key）不存在时，为键（key）指定值（value），setnx(self, name, value)
mset：一次性设置多个键-值(key-value)对,函数设置的键-值对（即mapping所指内容）数据要以Python字典数据类型传入，mset(self, mapping)
msetnx：键-值(key-value)对不存在时，设置键-值（key-value）对,msetnx(self, mapping)，mapping值参考6
incr：自增函数，默认步长为1，通过对步长（amount）大小以及字符的控制实现了INCRBY（amount>=1）、DECR（amount=-1）、DECRBY（amount<=-1）等函数功能，incr(self, name, amount=1)
append：为指定的字符串追加值，若不存在则直接创建，append(self, key, value)
setrange：用 value 参数覆写给定 key 所储存的字符串值，从偏移量 offset 开始，setrange(self, name, offset, value)
strlen：返回字符串的长度，当name不存在时返回0，strlen(self, name)

示例代码如下：

#!/usr/bin/python
# -*- coding:utf-8 -*-
from redis import StrictRedis, ConnectionPool
pool = redis.ConnectionPool(host='127.0.0.1', port=6379)
r = redis.StrictRedis(connection_pool=pool)
r.flushall()  # 清空Redisr.setex('name', value='liaogx', time=2)  # 设置新值，过期时间为3s
r.mset(k1 = 'v1', k2 = 'v2', k3 = 'v3')  # 批量设置新值
print(r.mget('k1', 'k2', 'k3', 'k4'))  # 批量获取新值
print(r.getset('name', 'liaogaoxiang'))  # 设置新值并获取原来的值
print(r.getrange('name', 0, 1))  # 获取子序列 0 <= x <= 1
r.setrange('name', 0, 'LIAO')  # 修改字符串内容，从指定字符串索引开始向后替换（新值太长时，则向后添加），返回值的长度
i = 0
while i < 4:print(r.get('name'))time.sleep(1)i += 1
source = 'foo'
r.set('n1', source)
r.setbit('n1', 7, 1)
'''
注：如果在Redis中有一个对应： n1 = "foo"，那么字符串foo的二进制表示为：01100110 01101111 01101111所以，如果执行 setbit('n1', 7, 1)，则就会将第7位设置为1，那么最终二进制则变成 01100111 01101111 01101111，即："goo"
'''
print(r.get('n1'))
print(r.getbit('n1', 7))  # 获取n1对应的值的二进制表示中的某位的值 （0或1）
r.set('n2', '廖高祥')
print(r.strlen('n2'))  # 返回对应的字节长度（一个汉字3个字节）
r.set('num', 1)
r.incr('num', amount=10)
r.decr('num', amount=1)
print(r.get('num'))  # 自增num对应的值，当name不存在时，则创建name＝amount，否则，则自增。
r.append('num', 111)
print(r.get('num'))  # 在redis num对应的值后面追加内容

输出结果如下：

[b'v1', b'v2', b'v3', None]
b'liaogx'
b'li'
b'LIAOgaoxiang'
b'LIAOgaoxiang'
b'LIAOgaoxiang'
b'LIAOgaoxiang'
b'goo'
1
9
b'10'
b'10111'

4.列表 list

Python操作Redis主要利用了redis模块来实现，list表操作函数主要模拟了Redis操作命令LPUSH，LRANGE，LINDEX，BLPOP，BRPOP。函数说明如下：

lpush函数实现了从向指定redis列表头部压入数据功能，lpush key value
lrange获取列表指定范围的函数，lrange key start end
lindex根据列表下标量获取列表元素值， lindex key index
blpop从列表头部取出第一个元素，返回该元素值并从列表删除（l代表left，左边）
brpop从列表尾部取出第一个元素，返回该元素值并从列表删除（l代表right，右边）
LPUSHX、RPUSHX以及其他一些Redis列表（List）函数目前版本无法实现，如有可实现方法博客代码事例将会得到更新。

示例代码如下：

#!/usr/bin/python
# -*- coding:utf-8 -*-
from redis import StrictRedis, ConnectionPool
pool = redis.ConnectionPool(host='127.0.0.1', port=6379)
r = redis.StrictRedis(connection_pool=pool)
r.flushall()  # 清空Redisr.lpush('oo', 11)  # 保存顺序为: 33,22,11
r.lpushx('oo', 00)  # 在name对应的list中添加元素，只有name已经存在时，值添加到列表的最左边
print(r.llen('oo'))  # name对应的list元素的个数r.linsert('oo', 'before', 11, 99)  # 在11之前插入值99
r.lset('oo', 1, 88)  # 对name对应的list中的某一个索引位置重新赋值
print(r.lrange('oo', 0, -1))  # 在name对应的列表分片获取数据r.lrem('oo', 88, num=1)  # 在name对应的list中删除指定的值.num=0，删除列表中所有的指定值；num=2,从前到后，删除2个；num=-2,从后向前，删除2个
print(r.lrange('oo', 0, -1))print(r.lpop('oo'))  # 在name对应的列表的左侧获取第一个元素并在列表中移除，返回值则是第一个元素
print(r.lindex('oo', 0))  # 在name对应的列表中根据索引获取列表元素
r.lpush('l1', 11)  # index为0
r.rpush('l1', 22)
r.rpush('l1', 33)
r.rpush('l1', 44)
r.rpush('l1', 55)  # index为4
r.ltrim('l1', 1, 3)  # 在name对应的列表中移除没有在[start-end]索引之间的值
print(r.lrange('l1', 0, -1))r.rpoplpush('l1', 'l1')  # 从一个列表取出最右边的元素，同时将其添加至另一个列表的最左边;src要取数据的列表的name, dst要添加数据的列表的name
print(r.lrange('l1', 0, -1))r.brpoplpush('l1', 'l1', timeout=3)  # # timeout，当src对应的列表中没有数据时，阻塞等待其有数据的超时时间（秒），0 表示永远阻塞
print(r.lrange('l1', 0, -1))print(r.blpop('l1', 3))  # 从列表头部取出第一个元素，返回该元素值并从列表删除（l代表left，左边）
print(r.lrange('l1', 0, -1))
'''# 由于redis类库中没有提供对列表元素的增量迭代，如果想要循环name对应的列表的所有元素，那么就需要：# 1、获取name对应的所有列表# 2、循环列表# 但是，如果列表非常大，那么就有可能在第一步时就将程序的内容撑爆，所有有必要自定义一个增量迭代的功能：
'''
print('自定义增量迭代：')
r.flushall()
r.lpush('l1', 11)  # index为0
r.rpush('l1', 22)
r.rpush('l1', 33)
r.rpush('l1', 44)
r.rpush('l1', 55)  # index为4def list_iter(name):list_count = r.llen(name)for index in range(list_count):yield r.lindex(name, index)for item in list_iter('l1'):print(item)

输出结果如下：

2
[b'0', b'88', b'11']
[b'0', b'11']
b'0'
b'11'
[b'22', b'33', b'44']
[b'44', b'22', b'33']
[b'33', b'44', b'22']
(b'l1', b'33')
[b'44', b'22']
自定义增量迭代：
b'11'
b'22'
b'33'
b'44'
b'55'

5.哈希 hash

Redis 数据库hash数据类型是一个string类型的key和value的映射表，适用于存储对象。redis 中每个hash可以存储键值对多达40亿。Python的redis模块实现了Redis哈希（Hash）命令行操作的几乎全部命令，包括HDEL、HEXISTS、HGET、HGETALL、HINCRBY、HKEYS、HLEN 、HMGET 、HMSET 、HSET 、HSETNX 、HVALS 、HINCRBYFLOAT等命令。函数说明如下：

hdel：删除对应哈希（Hash）表的指定键（key）的字段，hdel(self, name, key)
HEXISTS：检测哈希（Hash）表对应键（key）字段是否存在，返回布尔逻辑，hexists(self, name, key)
hget：获取哈希（Hash）指定键（key）对应的值，hget(self, name, key)
hgetall：获取哈希(Hash)表的键-值对（key-value pairs）,返回python字典类型数据，hgetall(self, name)
hincrby：为哈希表（Hash）指定键（key）对应的值（key）加上指定的整数数值（int，可为负值）hincrby(self>, name, key, amount=1)，Redis 中本操作的值被限制在 64 位(bit)有符号数字。
hkeys：返回哈希表（Hash）对应键（key）的数组（Python称之为列表List），hkeys(self, name)
hlen：获取哈希表（Hash）中键-值对（key-value pairs）个数，hlen(self, name)
hmget：获取哈希表（Hash）中一个或多个给点字段的值，不存在返回nil(Redis命令行)/None(Python)，hmget(self, name, keys)，其中keys可以为列表（list）
hmset：设置对个键-值对（key-value pairs）到哈希表（Hash）中，python输入值（mapping）为字典（dictionary）类型，hmset(self, name, mapping)
hset：为哈希表（Hash）赋值，若键（key）存在值（value）则覆盖，不存在则创建，hset(self, name, key, value)
hsetnx：为哈希表（Hash）不存值（value）的键（key）赋值，存在操作无效，对应值（value）无变化，hsetnx(self, name, key, value)
hvals：返回哈希表（Hash）对应值（value）的列表，hvals(self, name)
hincrbyfloat：为哈希表 key 中的指定字段的浮点数值加上增量 increment ，hincrbyfloat(self, name, key, amount=1.0)

示例代码如下：

#!/usr/bin/python
# -*- coding:utf-8 -*-
from redis import StrictRedis, ConnectionPool
pool = redis.ConnectionPool(host='127.0.0.1', port=6379)
r = redis.StrictRedis(connection_pool=pool)
r.flushall()  # 清空Redisr.hset('n1', 'k1', 'v1')  # hset(name, key, value),name对应的hash中设置一个键值对（不存在，则创建；否则，修改）
print(r.hget('n1', 'k1'))
r.hmset('n2', {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'})  # hmset(name, mapping),在name对应的hash中批量设置键值对
print(r.hmget('n2', 'k2'))
print(r.hgetall('n2'))  # 获取name对应hash的所有键值
print(r.hlen('n2'))  # 获取name对应的hash中键值对的个数
print(r.hkeys('n2'))  # 获取name对应的hash中所有的key的值
print(r.hvals('n2'))  # 获取name对应的hash中所有的value的值
print(r.hexists('n2', 'k4')) # 检查name对应的hash是否存在当前传入的key
r.hdel('n2', 'k3')  # 将name对应的hash中指定key的键值对删除
r.hset('n3', 'k1', 1)
r.hincrby('n3', 'k1', amount=1)  # hincrby(name, key, amount=1),自增name对应的hash中的指定key的value的值，不存在则创建key=amount
print(r.hgetall('n3'))

输出结果如下：

b'v1'
[b'v2']
{b'k1': b'v1', b'k2': b'v2', b'k3': b'v3'}
3
[b'k1', b'k2', b'k3']
[b'v1', b'v2', b'v3']
False
{b'k1': b'2'}

6.集合 set

Redis 数据库集合对象(set object)是由string类型的无重复元素的无需集合，底层编码可以是intset或者hashtable。intset编码的集合对象用整数集合最为底层实现，所有对象元素保存在整数集合中。Python的redis模块实现了 SADD、SCARD 、SDIFF 、SDIFFSTORE、SINTER 、SINTERSTORE、SISMEMBER 、SMEMBERS 、SMOVE、SPOP、SRANDMEMBER、SREM、SUNION、SUNIONSTORE操作命令的基本用法。函数说明如下：

sadd：向集合对象添加成员，sadd(self, name, value)
scard：获取集合元素个数，scard(self, name)
sdiff：返回给定多个集合对象的差集(set key1-set key2…-set keyn)，从左到右计算集合差集，sdiff(self, keys, *args)
sdiffstore：返回给定给定多个集合对象的差集并存储在目标（dest）集合中，sdiffstore(self, dest, keys, *args)
sinter：返回给定所有集合（keys, args）的交集, sinter(self, keys, args)
sinterstore：返回给定所有集合（keys, args）的交集并存储在集合(dest) 中, sinterstore(self, dest, keys, args)
sismember：判断 value元素是否是集合 name 的成员,返回布尔逻辑值True或者False，sismember(self, name, value)
smembers：返回集合中所元素值的Python集合类型数据，smembers(self, name)
smove：将元素value从集合src移动到集合 dest。若元素value在集合src中不存在，则集合dest中不会添加元素value， smove(self, src, dest, value)
spop：移除并返回集合中的一个随机元素, spop(self, name)
srandmember：返回集合中一个随机数，但是不做移除操作, srandmember(self, name)。从Redis 2.6 版本开始，在命令行下Srandmember 命令接受可选返回元素数量的参数 redis>SRANDMEMBER name count
srem：移除集合中一个元素，srem(self, name, value)，redis模块任然沿用Redis 2.4 版本以前的只接受单个元素的用法。
sunion：返回所有给定集合的并集中所有元素，sunion(self, keys, *args)
sunionstore：所有给定集合的并集存储在集合dest 中, sunionstore(self, dest, keys, *args)
sscan：迭代集合中的元素，sscan(self, name, cursor=0, match=None, count=None)

示例代码如下：

#!/usr/bin/python
# -*- coding:utf-8 -*-from redis import StrictRedis, ConnectionPool
pool = redis.ConnectionPool(host='127.0.0.1', port=6379)
r = redis.StrictRedis(connection_pool=pool)
r.flushall()  # 清空Redisr.sadd('s1', 'v1', 'v1', 'v2', 'v3')  # name对应的集合中添加元素
r.sadd('s2', 'v2', 'v4')  # name对应的集合中添加元素
print(r.scard('s1'))  # 获取name对应的集合中元素个数
print(r.sdiff('s1', 's2'))  #在第一个name对应的集合中且不在其他name对应的集合的元素集合r.sdiffstore('s3', 's1', 's2')  # 获取第一个name对应的集合中且不在其他name对应的集合，再将其新加入到dest对应的集合中
print(r.smembers('s3'))  # 获取s3对应的集合的所有成员print(r.sinter('s1', 's2'))  # 获取s1, s2对应集合的交集
r.sinterstore('s4', 's1', 's2')  # 获取s1, s2对应集合的交集，并将其存放到集合是s4中
print(r.smembers('s4'))print(r.sunion('s1', 's2'))  # 获取s1, s2对应集合的并集r.sunionstore('s5', 's1', 's2')  # 获取s1, s2对应集合的交集，并将其存放到集合是s5中
print(r.smembers('s5'))print(r.sismember('s4', 'v4'))  # 检查value是否是name对应的集合的成员r.smove('s2', 's1', 'v4')  # 将集合s2中成员v4移至集合s1中
print(r.smembers('s1'))
r.srem('s1', 'v1')  # 在name对应的集合中删除某些值print(r.spop('s1'))  # 从集合的右侧（尾部）移除一个成员，并将其返回 注意：集合是无序的，故结果随机！print(r.srandmember('s1'))  # 从name对应的集合中随机获取 numbers 个元素(Redis 2.6+)

输出结果如下：

3
{b'v3', b'v1'}
{b'v3', b'v1'}
{b'v2'}
{b'v2'}
{b'v3', b'v2', b'v4', b'v1'}
{b'v3', b'v2', b'v4', b'v1'}
False
{b'v3', b'v2', b'v4', b'v1'}
b'v2'
b'v3'

7.有序集合 sorted set

zadd 命令向有序集合添加一个或多个成员，或者更新已存在成员的分数
zcard 命令获取有序集合的成员数
zcount 命令计算在有序集合中指定区间分数的成员数
zincrby 命令有序集合中对指定成员的分数加上增量 increment
zinterstore 命令计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中
zlexcount 命令在有序集合中计算指定字典区间内成员数量
zrange 命令通过索引区间返回有序集合成指定区间内的成员
zrangebylex 命令通过字典区间返回有序集合的成员
zrangebyscore 命令通过分数返回有序集合指定区间内的成员
zrank 命令返回有序集合中指定成员的索引
zrem 命令移除有序集合中的一个或多个成员
zremrangebylex 命令移除有序集合中给定的字典区间的所有成员
zremrangebyrank 命令移除有序集合中给定的排名区间的所有成员
zremrangebyscore 命令移除有序集合中给定的分数区间的所有成员
zrevrange 命令返回有序集中指定区间内的成员，通过索引，分数从高到底
zrevrangebyscore 命令返回有序集中指定分数区间内的成员，分数从高到低排序
zrevrank 命令返回有序集合中指定成员的排名，有序集成员按分数值递减(从大到小)排序
zscore 命令返回有序集中，成员的分数值
zunionstore 命令计算给定的一个或多个有序集的并集，并存储在新的 key 中
zscan 命令迭代有序集合中的元素（包括元素成员和元素分值）

示例代码如下：

#!/usr/bin/python
# -*- coding:utf-8 -*-from redis import StrictRedis, ConnectionPool
pool = redis.ConnectionPool(host='127.0.0.1', port=6379)
r = redis.StrictRedis(connection_pool=pool)
r.flushall()  # 清空Redisr.zadd('z1', '11', 1, '22', 2, '33', 3, '44', 4, '55', 5, '66', 6, '66', 7)  # 在name对应的有序集合中添加元素
print(r.zcard('z1'))  # 获取name对应的有序集合元素的数量
print(r.zcount('z1', 1, 2))  # 获取name对应的有序集合中分数 在 [min,max] 之间的个数
r.zincrby('z1', '11', amount=5)  # 自增name对应的有序集合的 name 对应的分数
print(r.zrange('z1', 0, -1, desc=False, withscores=True))  # 值11被排序到最后;此处表示按元素的值升序排列print(r.zrank('z1', 33))  # 获取某个值在 name对应的有序集合中的排行（从 0 开始）r.zrem('z1', '66')  # 删除name对应的有序集合中值是values的成员
print(r.zrange('z1', 0, -1, desc=False, withscores=True))r.zremrangebyrank('z1', 0, 1)  # 根据排行范围删除
print(r.zrange('z1', 0, -1, desc=False, withscores=True))r.zremrangebyscore('z1', 4.5, 5.5)  # 根据分数范围删除
print(r.zrange('z1', 0, -1, desc=False, withscores=True))print(r.zscore('z1', 11))  # 获取name对应有序集合中 value 对应的分数r.zadd("zset_name", "a1", 6, "a2", 2, "a3", 5)
r.zadd('zset_name1', a1=7, b1=10, b2=5)
'''获取两个有序集合的交集并放入dest集合，如果遇到相同值不同分数，则按照aggregate进行操作aggregate的值为: SUM  MIN  MAX
'''
r.zinterstore('zset_name2', ('zset_name', 'zset_name1'), aggregate='Sum')print(r.zrange('zset_name2', 0, -1, desc=False, withscores=True))

输出结果如下：

6
2
[(b'22', 2.0), (b'33', 3.0), (b'44', 4.0), (b'55', 5.0), (b'11', 6.0), (b'66', 6.0)]
1
[(b'22', 2.0), (b'33', 3.0), (b'44', 4.0), (b'55', 5.0), (b'11', 6.0)]
[(b'44', 4.0), (b'55', 5.0), (b'11', 6.0)]
[(b'44', 4.0), (b'11', 6.0)]
6.0
[(b'a1', 13.0)]

8.RedisDump

RedisDump提供了强大的Redis数据的导入和导出功能，现在就来看下它的具体用法。

首先，确保已经安装好了RedisDump。RedisDump提供了两个可执行命令：redis-dump用于导出数据，redis-load用于导入数据。

redis-dump 导出数据

首先，可以输入如下命令查看所有可选项：

redis-dump -h

运行结果如下：

Usage: redis-dump [global options] COMMAND [command options] -u, --uri=S                      Redis URI (e.g. redis://hostname[:port])-d, --database=S                 Redis database (e.g. -d 15)-s, --sleep=S                    Sleep for S seconds after dumping (for debugging)-c, --count=S                    Chunk size (default: 10000)-f, --filter=S                   Filter selected keys (passed directly to redis' KEYS command)-O, --without_optimizations      Disable run time optimizations-V, --version                    Display version-D, --debug--nosafe

其中-u代表Redis连接字符串，-d代表数据库代号，-s代表导出之后的休眠时间，-c代表分块大小，默认是10000，-f代表导出时的过滤器，-O代表禁用运行时优化，-V用于显示版本，-D表示开启调试。

我们拿本地的Redis做测试，运行在6379端口上，密码为foobared，导出命令如下：

redis-dump -u :foobared@localhost:6379

如果没有密码的话，可以不加密码前缀，命令如下：

redis-dump -u localhost:6379

运行之后，可以将本地0至15号数据库的所有数据输出出来，例如：

{"db":0,"key":"name","ttl":-1,"type":"string","value":"James","size":5}
{"db":0,"key":"name2","ttl":-1,"type":"string","value":"Durant","size":6}
{"db":0,"key":"name3","ttl":-1,"type":"string","value":"Durant","size":6}
{"db":0,"key":"name4","ttl":-1,"type":"string","value":"HelloWorld","size":10}
{"db":0,"key":"name5","ttl":-1,"type":"string","value":"James","size":5}
{"db":0,"key":"name6","ttl":-1,"type":"string","value":"James","size":5}
{"db":0,"key":"age","ttl":-1,"type":"string","value":"1","size":1}
{"db":0,"key":"age2","ttl":-1,"type":"string","value":"-5","size":2}

每条数据都包含6个字段，其中db即数据库代号，key即键名，ttl即该键值对的有效时间，type即键值类型，value即内容，size即占用空间。

如果想要将其输出为JSON行文件，可以使用如下命令：

redis-dump -u :foobared@localhost:6379 > ./redis_data.jl

这样就可以成功将Redis的所有数据库的所有数据导出成JSON行文件了。

另外，可以使用-d参数指定某个数据库的导出，例如只导出1号数据库的内容：

redis-dump -u :foobared@localhost:6379 -d 1 > ./redis.data.jl

如果只想导出特定的内容，比如想导出以adsl开头的数据，可以加入-f参数用来过滤，命令如下：

redis-dump -u :foobared@localhost:6379 -f adsl:* > ./redis.data.jl

其中-f参数即Redis的keys命令的参数，可以写一些过滤规则。

redis-load 导入数据

同样，我们可以首先输入如下命令查看所有可选项：

redis-load -h

运行结果如下：

redis-load --helpTry: redis-load [global options] COMMAND [command options] -u, --uri=S                      Redis URI (e.g. redis://hostname[:port])-d, --database=S                 Redis database (e.g. -d 15)-s, --sleep=S                    Sleep for S seconds after dumping (for debugging)-n, --no_check_utf8-V, --version                    Display version-D, --debug--nosafe

其中-u代表Redis连接字符串，-d代表数据库代号，默认是全部，-s代表导出之后的休眠时间，-n代表不检测UTF-8编码，-V表示显示版本，-D表示开启调试。

我们可以将JSON行文件导入到Redis数据库中：

< redis_data.json redis-load -u :foobared@localhost:6379

这样就可以成功将JSON行文件导入到数据库中了。
另外，下面的命令同样可以达到同样的效果：

cat redis_data.json | redis-load -u :foobared@localhost:6379

参考博客来源（感谢分享）：
https://segmentfault.com/a/1190000016696863
https://www.jianshu.com/p/2639549bedc8
https://www.cnblogs.com/melonjiang/p/5342505.html
https://www.cnblogs.com/john-xiong/p/12089103.html