redis

一、概念

redis是一款高性能的NOSQL系列的非关系型数据库软件

1、什么是NOSQL？

NoSQL(NoSQL = Not Only SQL(structured query languge))，意即“不仅仅是SQL”，是一项全新的数据库理念，泛指非关系型（non-relational）的数据库。(关系型数据库,如mysql,采用二维表保存数据,可以被sql操作,非关系型数据库采用map类型的kv键值对的形式)。

随着互联网web2.0网站的兴起，传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，尤其是大数据应用难题。

NOSQL和关系型数据库比较

优点：

1）、成本：nosql数据库简单易部署，基本都是开源软件，不需要像使用oracle那样花费大量成本购买使用，相比关系型数据库价格便宜。

2）、查询速度：nosql数据库将数据存储于缓存之中（redis是一个内存数据库），关系型数据库将数据存储在硬盘中，自然查询速度远不及nosql数据库。

3）、存储数据的格式：nosql的存储格式是key,value形式、文档形式、图片形式等等，所以可以存储基础类型以及对象或者是集合等各种格式，而数据库则只支持基础类型。

4）、扩展性：关系型数据库有类似join这样的多表查询机制的限制导致扩展很艰难。

缺点：

1）、维护的工具和资料有限，因为nosql是属于新的技术，不能和关系型数据库10几年的技术同日而语。

2）、不提供对sql的支持，如果不支持sql这样的工业标准，将产生一定用户的学习和使用成本。

3）、不提供关系型数据库对事务的处理。

非关系型数据库的优势

1）、性能NOSQL是基于键值对的，可以想象成表中的主键和值的对应关系，而且不需要经过SQL层的解析，所以性能非常高。

2）、可扩展性同样也是因为基于键值对，数据之间没有耦合性，所以非常容易水平扩展。

关系型数据库的优势

1）、复杂查询可以用SQL语句方便的在一个表以及多个表之间做非常复杂的数据查询。

2）、事务支持使得对于安全性能很高的数据访问要求得以实现。对于这两类数据库，对方的优势就是自己的弱势，反之亦然。

总结

关系型数据库与NoSQL数据库并非对立而是互补的关系，即通常情况下使用关系型数据库，在适合使用NoSQL的时候使用NoSQL数据库，让NoSQL数据库对关系型数据库的不足进行弥补。一般会将数据存储在关系型数据库中，在nosql数据库中备份存储关系型数据库的数据。

2、主流的NOSQL产品

1）、键值(Key-Value)存储数据库

　　相关产品： Tokyo Cabinet/Tyrant、Redis、Voldemort、Berkeley DB
　　典型应用：内容缓存，主要用于处理大量数据的高访问负载。
　　数据模型：一系列键值对
　　优势：快速查询
　　劣势：存储的数据缺少结构化

2）、列存储数据库

　　相关产品：Cassandra, HBase, Riak
　　典型应用：分布式的文件系统
　　数据模型：以列簇式存储，将同一列数据存在一起
　　优势：查找速度快，可扩展性强，更容易进行分布式扩展
　　劣势：功能相对局限

3）、文档型数据库

　　相关产品：CouchDB、MongoDB
　　典型应用：Web应用（与Key-Value类似，Value是结构化的）
　　数据模型：一系列键值对
　　优势：数据结构要求不严格
　　劣势：查询性能不高，而且缺乏统一的查询语法

4）、图形(Graph)数据库

　　相关数据库：Neo4J、InfoGrid、Infinite Graph
　　典型应用：社交网络
　　数据模型：图结构
　　优势：利用图结构相关算法。
　　劣势：需要对整个图做计算才能得出结果，不容易做分布式的集群方案。

3、什么是Redis?

Redis是用C语言开发的一个开源的高性能键值对（key-value）数据库，官方提供测试数据，50个并发执行100000个请求,读的速度是110000次/s,写的速度是81000次/s ，且Redis通过提供多种键值数据类型来适应不同场景下的存储需求，目前为止Redis支持的value数据类型如下：

1) 字符串类型 string
2) 哈希类型 map
3) 列表类型 linkedlist
4) 集合类型 set
5) 有序集合类型 sortedset

redis的应用场景

• 缓存（数据查询、短连接、新闻内容、商品内容等等）

在实际项目中，redis可用来缓存token、数据字典、树型结构的部门信息。
• 聊天室的在线好友列表
• 任务队列。（秒杀、抢购、12306等等）
• 应用排行榜
• 网站访问统计
• 数据过期处理（可以精确到毫秒）
• 分布式集群架构中的session分离

二、命令操作

windows系统中查看redis的bigkey

redis-cli.exe -h 127.0.0.1 -p 6379 -a "password" --bigkeys

redis默认密码为空，即

redis-cli.exe -h 127.0.0.1 -p 6379 -a "" --bigkeys

结果：

D:\install\Redis-x64-3.0.504>redis-cli.exe -h 127.0.0.1 -p 6379 -a "" --bigkeys

# Scanning the entire keyspace to find biggest keys as well as
# average sizes per key type.  You can use -i 0.1 to sleep 0.1 sec
# per 100 SCAN commands (not usually needed).

[00.00%] Biggest string found so far 'luoyang-server:dict:list-POLICY_TYPE' with 1401 bytes
[00.00%] Biggest string found so far 'luoyang-server:dict:list-COMPANY_NATURE' with 1710 bytes
[52.63%] Biggest string found so far 'luoyang-server:dict:list-SALARY_RANGE' with 1945 bytes

-------- summary -------

Sampled 19 keys in the keyspace!
Total key length in bytes is 855 (avg len 45.00)

Biggest string found 'luoyang-server:dict:list-SALARY_RANGE' has 1945 bytes

19 strings with 22307 bytes (100.00% of keys, avg size 1174.05)
0 lists with 0 items (00.00% of keys, avg size 0.00)
0 sets with 0 members (00.00% of keys, avg size 0.00)
0 hashs with 0 fields (00.00% of keys, avg size 0.00)
0 zsets with 0 members (00.00% of keys, avg size 0.00)

删除数据：

(1)、选择要操作的数据库，默认情况下有0到15共计16个数据库，可以使用SELECT <db_number>命令切换到指定的数据库

select 0;

(2)、根据需求使用相应的命令来删除数据。常用的删除命令包括

DEL key [key ...]：删除单个或多个键对应的值。
FLUSHDB：清空当前所在的数据库中的所有数据。
FLUSHALL：清空所有数据库中的所有数据。

1、redis的数据结构

redis存储的是：key,value格式的数据，其中key都是字符串，value有5种不同的数据结构

value的数据结构：

1) 字符串类型 string
2) 哈希类型 hash ： map格式
3) 列表类型 list ： linkedlist格式。支持重复元素
4) 集合类型 set ：不允许重复元素
5) 有序集合类型 sortedset：不允许重复元素，且元素有顺序

2、字符串类型 string

1）、存储： set key value

双击redis-cli.exe，进入如下界面：

127.0.0.1:6379> set username zhangsan
OK

java代码：

stringRedisTemplate.boundValueOps(redisPre + key).set(val);

2）、获取： get key

127.0.0.1:6379> get username
"zhangsan"

java代码：

stringRedisTemplate.boundValueOps(redisPre + key).get();

3）、删除： del key

127.0.0.1:6379> del age
(integer) 1

可以通过设置过期时间为0来删除

expire key 0

java代码：

stringRedisTemplate.delete(redisPre + key);

4）、设置过期时间

通过EXPIRE命令和PEXPIRE命令，可以给key设置生存时间（Time To Live，TTL），EXPIRE设置的时间单位为秒，PEXPIRE设置的时间单位为毫秒，在经过指定的生存时间后，Redis服务器会自动删除生存时间为0的key。

//给指定key设置生存时间（单位秒）
EXPIRE key seconds
//给指定key设置生存时间（单位毫秒）
PEXPIRE key milliseconds

java代码：

stringRedisTemplate.expire(redisPre + key, second, TimeUnit.SECONDS);

3、哈希类型

1）、存储： hset key field value

127.0.0.1:6379> hset myhash username lisi
(integer) 1
127.0.0.1:6379> hset myhash password 123
(integer) 1

2）、获取：

hget key field: 获取指定的field对应的值

127.0.0.1:6379> hget myhash username
"lisi"

hgetall key：获取所有的field和value

127.0.0.1:6379> hgetall myhash
1) "username"
2) "lisi"
3) "password"
4) "123"

3）、删除： hdel key field

127.0.0.1:6379> hdel myhash username
(integer) 1

4、列表类型 list

可以添加一个元素到列表的头部（左边）或者尾部（右边）

1）、添加

lpush key value: 将元素加入列表左边

rpush key value：将元素加入列表右边

127.0.0.1:6379> lpush myList a
(integer) 1
127.0.0.1:6379> lpush myList b
(integer) 2
127.0.0.1:6379> rpush myList c
(integer) 3

java代码：

设置list元素，从左侧添加

stringRedisTemplate.boundListOps(redisPre + key).leftPush(element);

设置list元素,从右侧添加

stringRedisTemplate.boundListOps(redisPre + key).rightPush(element);

2）、获取

lrange key start end ：范围获取

127.0.0.1:6379> lrange myList 0 -1
1) "b"
2) "a"
3) "c"

其中 0 表示列表的第一个元素， 1 表示列表的第二个元素，以此类推。你也可以使用负数下标，以 -1 表示列表的最后一个元素， -2 表示列表的倒数第二个元素，以此类推。

Java代码：

stringRedisTemplate.boundListOps(redisPre + key).range(start, end);

3）、删除

lpop key：删除列表最左边的元素，并将元素返回

java代码：

stringRedisTemplate.boundListOps(redisPre + key).leftPop();

rpop key：删除列表最右边的元素，并将元素返回

Java代码：

stringRedisTemplate.boundListOps(redisPre + key).rightPop();

获取list元素个数的Java代码：

stringRedisTemplate.boundListOps(redisPre + key).size();

列表类型的应用：

实际项目中，我们在新增用户时，会输入明文的用户名和密码，后台会将密码加密后存入数据库。如果此时有如下需求：“不能使用最近5次使用过的密码”，

此时，我们不仅要将加密后的密码存入数据库，还需要将加密后的密码存入redis的List中，此时可以如下操作：

（1）、根据key获取List所有的元素

// 获取当前用户存入redis的所有密码
List<String> list = redisService.listAll(key, 0, -1);

（2）、取最新的n个密码

Integer len = 5;
// 存储：最新的len个密码
List<String> pwdList;
// 获取最新的5个密码存入pwdList中
if (list.size() < len) {
    pwdList = list;
} else {
    pwdList = list.subList(0, len);
}

（3）、判断新的密码是否已经存在

　　　　　List<String> collect = pwdList.stream().filter(item -> {
            Boolean flag = false;
            try {
                flag = MD5Utils.getSaltverifyMD5(password, item);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return flag;
        }).collect(Collectors.toList());

（4）、如果密码已经在前n中存在，则不允许添加。如果不存在，则将将新的密码从List左侧添加，并当List中超过n个密码时，可以将超过的删除

　　　　　if (CollectionUtil.isNotEmpty(collect)) {
            return "密码不能使用最近" + len + "次修改过的密码";
        } else {
            redisService.listLeftPush(key, pasMD5);
            //删除多余的密码
            for (int i = list.size(); i >= len; i--) {
                redisService.listRightPop(key);
            }
        }

注意：必须是从List左侧添加，再从索引0获取的n个密码才是最新的密码。

5、集合类型 set

不允许重复元素

1）、存储：sadd key value

127.0.0.1:6379> sadd myset a
(integer) 1
127.0.0.1:6379> sadd myset a
(integer) 0

java代码

stringRedisTemplate.boundSetOps(redisPre + key).add(member);

如果还要设置过期时间

stringRedisTemplate.boundSetOps(redisPre + key).add(member);
stringRedisTemplate.boundSetOps(redisPre + key).expire(minute, TimeUnit.MINUTES);

2）、获取：smembers key:获取set集合中所有元素

127.0.0.1:6379> smembers myset
1) "a"

java代码：

Set members = stringRedisTemplate.boundSetOps(redisPre + key).members();

3）、删除：srem key value:删除set集合中的某个元素

127.0.0.1:6379> srem myset a
(integer) 1

java代码

stringRedisTemplate.boundSetOps(redisPre + key).remove(member);

判断set元素是否存在的Java代码：

stringRedisTemplate.boundSetOps(redisPre + key).isMember(member);

6、有序集合类型 sortedset

不允许重复元素，且元素有顺序.每个元素都会关联一个double类型的分数score。redis正是通过分数score来为集合中的成员进行从小到大的排序。

1）、存储：zadd key score value

127.0.0.1:6379> zadd mysort 60 zhangsan
(integer) 1
127.0.0.1:6379> zadd mysort 50 lisi
(integer) 1
127.0.0.1:6379> zadd mysort 80 wangwu
(integer) 1

2）、获取：

zrange key start end [withscores]

127.0.0.1:6379> zrange mysort 0 -1
1) "lisi"
2) "zhangsan"
3) "wangwu"

带分数获取

127.0.0.1:6379> zrange mysort 0 -1 withscores
1) "zhangsan"
2) "60"
3) "wangwu"
4) "80"
5) "lisi"
6) "500"

3）、删除：

zrem key value

127.0.0.1:6379> zrem mysort lisi
(integer) 1

7、通用命令

keys * : 查询所有的键
type key ： 获取键对应的value的类型
del key：删除指定的key value

如

127.0.0.1:6379> type mysort
zset
127.0.0.1:6379> type mylist
list
127.0.0.1:6379> type myhash
hash
127.0.0.1:6379> type myset
set
127.0.0.1:6379> type username
string

三、持久化

redis是一个内存数据库，当redis服务器重启，获者电脑重启，数据会丢失，我们可以将redis内存中的数据持久化保存到硬盘的文件中。

1、redis持久化机制

既然redis的数据可以保存在磁盘上，那么这个流程是什么样的呢？

要有下面五个过程：

（1）、客户端向服务端发送写操作(数据在客户端的内存中)。

（2）、数据库服务端接收到写请求的数据(数据在服务端的内存中)。

（3）、服务端调用write这个系统调用，将数据往磁盘上写(数据在系统内存的缓冲区中)。

（4）、操作系统将缓冲区中的数据转移到磁盘控制器上(数据在磁盘缓存中)。

（5）、磁盘控制器将数据写到磁盘的物理介质中(数据真正落到磁盘上)。

这5个过程是在理想条件下一个正常的保存流程，但是在大多数情况下，我们的机器等等都会有各种各样的故障，这里划分了两种情况：

（1）Redis数据库发生故障，只要在上面的第三步执行完毕，那么就可以持久化保存，剩下的两步由操作系统替我们完成。

（2）操作系统发生故障，必须上面5步都完成才可以。

2、RDB（Redis Database）

默认方式，不需要进行配置，默认就使用这种机制。

在一定的间隔时间中，检测key的变化情况，然后持久化数据。

RDB其实就是把数据以快照的形式保存在磁盘上。什么是快照呢，你可以理解成把当前时刻的数据拍成一张照片保存下来。

RDB持久化是指在指定的时间间隔内将内存中的数据集快照写入磁盘。也是默认的持久化方式，这种方式是就是将内存中数据以快照的方式写入到二进制文件中,默认的文件名为dump.rdb。

既然RDB机制是通过把某个时刻的所有数据生成一个快照来保存，那么就应该有一种触发机制，是实现这个过程。对于RDB来说，提供了三种机制：save、bgsave、自动化。我们分别来看一下

（1）、save触发（属于手动触发）

该命令会阻塞当前Redis服务器，执行save命令期间，Redis不能处理其他命令，直到RDB过程完成为止。具体流程如下：

执行完成时候如果存在老的RDB文件，就把新的替代掉旧的。我们的客户端可能都是几万或者是几十万，这种方式显然不可取。

显然该命令对于内存比较大的实例会造成长时间阻塞，这是致命的缺陷，为了解决此问题，Redis提供了第二种方式。

（2）、bgsave触发（属于手动触发）

执行该命令时，Redis会在后台异步进行快照操作，快照同时还可以响应客户端请求。具体流程如下：

具体操作是Redis进程执行fork操作创建子进程，RDB持久化过程由子进程负责，完成后自动结束。阻塞只发生在fork阶段，一般时间很短。

基本上 Redis 内部所有的RDB操作都是采用 bgsave 命令。

因为第三种方式是配置的，所以我们对前两种进行一个对比：

（3）、自动触发

自动触发是由我们的配置文件来完成的。在redis.conf配置文件中，里面有如下配置，我们可以去设置：

♣ save：这里是用来配置触发 Redis的 RDB 持久化条件，也就是什么时候将内存中的数据保存到硬盘。比如“save m n”。表示m秒内数据集存在n次修改时，自动触发bgsave。

默认如下配置：

save 900 1
save 300 10
save 60 10000

#表示900 秒内如果至少有 1 个 key 的值变化，则保存save 900 1

#表示300 秒内如果至少有 10 个 key 的值变化，则保存save 300 10

#表示60 秒内如果至少有 10000 个 key 的值变化，则保存save 60 10000

当然如果你只是用Redis的缓存功能，不需要持久化，那么你可以注释掉所有的 save 行来停用保存功能。

♣ stop-writes-on-bgsave-error ：默认值为yes。当启用了RDB且最后一次后台保存数据失败，Redis是否停止接收数据。这会让用户意识到数据没有正确持久化到磁盘上，否则没有人会注意到灾难（disaster）发生了。如果Redis重启了，那么又可以重新开始接收数据了。

stop-writes-on-bgsave-error yes

♣ rdbcompression ；默认值是yes。对于存储到磁盘中的快照，可以设置是否进行压缩存储。

rdbcompression yes

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

rdbchecksum yes

♣ dbfilename ：设置快照的文件名，默认是 dump.rdb

dbfilename dump.rdb

♣ dir：设置快照文件的存放路径，这个配置项一定是个目录，而不能是文件名。

dir ./

RDB 的优势和劣势

优势：

（1）、RDB文件紧凑，全量备份，非常适合用于进行备份和灾难恢复。

（2）、生成RDB文件的时候，redis主进程会fork()一个子进程来处理所有保存工作，主进程不需要进行任何磁盘IO操作。

（3）RDB 在恢复大数据集时的速度比 AOF 的恢复速度要快。

劣势：

RDB快照是一次全量备份，存储的是内存数据的二进制序列化形式，存储上非常紧凑。当进行快照持久化时，会开启一个子进程专门负责快照持久化，子进程会拥有父进程的内存数据，父进程修改内存子进程不会反应出来，所以在快照持久化期间修改的数据不会被保存，可能丢失数据。

（1）、编辑redis.windwos.conf文件

#   after 900 sec (15 min) if at least 1 key changed
save 900 1
#   after 300 sec (5 min) if at least 10 keys changed
save 300 10
#   after 60 sec if at least 10000 keys changed
save 60 10000

（2）、重新启动redis服务器，并指定配置文件名称(不能直接启动,在此处打开命令窗口方式启动)

redis-server.exe redis.windows.conf

3、AOF(append only file)：

全量备份总是耗时的，有时候我们提供一种更加高效的方式AOF，工作机制很简单，redis会将每一个收到的写命令都通过write函数追加到文件中。通俗的理解就是日志记录。

持久化原理：

他的原理看下面这张图：

每当有一个写命令过来时，就直接保存在我们的AOF文件中。

文件重写原理：

AOF的方式也同时带来了另一个问题。持久化文件会变的越来越大。为了压缩aof的持久化文件。redis提供了bgrewriteaof命令。将内存中的数据以命令的方式保存到临时文件中，同时会fork出一条新进程来将文件重写。

重写aof文件的操作，并没有读取旧的aof文件，而是将整个内存中的数据库内容用命令的方式重写了一个新的aof文件，这点和快照有点类似。

AOF也有三种触发机制：

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

（2）每秒同步everysec：异步操作，每秒记录如果一秒内宕机，有数据丢失。

（3）不同no：从不同步。

日志记录的方式，可以记录每一条命令的操作。可以每一次命令操作后，持久化数据(the append only file)

（1）、编辑redis.windwos.conf文件

appendonly no

# appendfsync always
appendfsync everysec
# appendfsync no

appendonly no（关闭aof） --> appendonly yes （开启aof）

# appendfsync always ：每一次操作都进行持久化
appendfsync everysec ：每隔一秒进行一次持久化
# appendfsync no ：不进行持久化

4、恢复数据

将备份文件 (dump.rdb) 移动到 redis 安装目录并启动服务即可，redis就会自动加载文件数据至内存了。Redis 服务器在载入 RDB 文件期间，会一直处于阻塞状态，直到载入工作完成为止。

四、Java客户端 Jedis

Jedis: 一款java操作redis数据库的工具.

1、使用步骤：

（1）、引入依赖

<dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.7.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.11</version>
        </dependency>

（2）、使用

//1. 获取连接
Jedis jedis = new Jedis("localhost",6379);
//2. 操作
jedis.set("username","zhangsan");
//3. 关闭连接
jedis.close();

2、Jedis操作各种redis中的数据结构

1）、字符串类型 string

public class Demo1 {
    public static void main(String[] args) {
        //1. 获取连接
        Jedis jedis = new Jedis();//如果使用空参构造，默认值 "localhost",6379端口
        //2. 操作
        //存储
        jedis.set("username","zhangsan");
        //获取
        String username = jedis.get("username");
        System.out.println(username);
        //可以使用setex()方法存储可以指定过期时间的 key value
        jedis.setex("activecode",20,"hehe");//将activecode：hehe键值对存入redis，并且20秒后自动删除该键值对
        //3. 关闭连接
        jedis.close();
    }
}

结果：

zhangsan

2）、哈希类型 hash ： map格式

public class Demo2 {
    public static void main(String[] args) {
        //1. 获取连接
        Jedis jedis = new Jedis();//如果使用空参构造，默认值 "localhost",6379端口
        //2. 操作
        // 存储hash
        jedis.hset("user","name","lisi");
        jedis.hset("user","age","23");
        jedis.hset("user","gender","female");
        // 获取hash
        String name = jedis.hget("user", "name");
        System.out.println(name);
        // 获取hash的所有map中的数据
        Map<String, String> user = jedis.hgetAll("user");
        // keyset
        Set<String> keySet = user.keySet();
        for (String key : keySet) {
            //获取value
            String value = user.get(key);
            System.out.println(key + ":" + value);
        }
        //3. 关闭连接
        jedis.close();
    }
}

结果：

lisi
gender:female
name:lisi
age:23

3）、列表类型 list

linkedlist格式。支持重复元素

public class Demo3 {
    public static void main(String[] args) {
        //1. 获取连接
        Jedis jedis = new Jedis();//如果使用空参构造，默认值 "localhost",6379端口
        //2. 操作
        // list 存储
        jedis.lpush("mylist","a","b","c");//从左边存
        jedis.rpush("mylist","a","b","c");//从右边存
        // list 范围获取
        List<String> mylist = jedis.lrange("mylist", 0, -1);
        System.out.println(mylist);
        // list 弹出
        String element1 = jedis.lpop("mylist");//c
        System.out.println(element1);
        String element2 = jedis.rpop("mylist");//c
        System.out.println(element2);
        // list 范围获取
        List<String> mylist2 = jedis.lrange("mylist", 0, -1);
        System.out.println(mylist2);
        //3. 关闭连接
        jedis.close();
    }
}

结果：

[c, b, a, a, b, c]
c
c
[b, a, a, b]

4）、集合类型 set

不允许重复元素

public class Demo4 {
    public static void main(String[] args) {
        //1. 获取连接
        Jedis jedis = new Jedis();//如果使用空参构造，默认值 "localhost",6379端口
        //2. 操作
        // set 存储
        jedis.sadd("myset","java","php","c++");
        // set 获取
        Set<String> myset = jedis.smembers("myset");
        System.out.println(myset);
        //3. 关闭连接
        jedis.close();
    }
}

结果：

[c++, java, php]

5）、有序集合类型 sortedset

不允许重复元素，且元素有顺序

public class Demo5 {
    public static void main(String[] args) {
        //1. 获取连接
        Jedis jedis = new Jedis();//如果使用空参构造，默认值 "localhost",6379端口
        //2. 操作
        // sortedset 存储
        jedis.zadd("mysortedset",3,"亚瑟");
        jedis.zadd("mysortedset",30,"后裔");
        jedis.zadd("mysortedset",55,"孙悟空");

        // sortedset 获取
        Set<String> mysortedset = jedis.zrange("mysortedset", 0, -1);

        System.out.println(mysortedset);
        //3. 关闭连接
        jedis.close();
    }
}

结果：

[亚瑟, 后裔, 孙悟空]

五、jedis连接池： JedisPool

1、使用：

（1）、创建JedisPool连接池对象

（2）、调用方法 getResource()方法获取Jedis连接

@Test
        public void test7(){
            //0.创建一个配置对象
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxTotal(50);
            config.setMaxIdle(10);
            //1.创建Jedis连接池对象
            JedisPool jedisPool = new JedisPool(config,"localhost",6379);
            //2.获取连接
            Jedis jedis = jedisPool.getResource();
            //3. 使用
            jedis.set("hehe","heihei");
            //4. 关闭 归还到连接池中
            jedis.close();;
        }

2、jedis连接池工具类使用

连接池工具类

public class JedisPoolUtils {
    private static JedisPool jedisPool;

    static{
        //读取配置文件
        InputStream is = JedisPoolUtils.class.getClassLoader().getResourceAsStream("jedis.properties");
        //创建Properties对象
        Properties pro = new Properties();
        //关联文件
        try {
            pro.load(is);
        } catch (IOException e) {
            e.printStackTrace();
        }
        //获取数据，设置到JedisPoolConfig中
        JedisPoolConfig config = new JedisPoolConfig();
        config.setMaxTotal(Integer.parseInt(pro.getProperty("maxTotal")));
        config.setMaxIdle(Integer.parseInt(pro.getProperty("maxIdle")));

        //初始化JedisPool
        jedisPool = new JedisPool(config,pro.getProperty("host"),Integer.parseInt(pro.getProperty("port")));
    }
    /**
     * 获取连接方法
     */
    public static Jedis getJedis(){
        return jedisPool.getResource();
    }
}

配置文件，放在resource目录下

host=127.0.0.1
port=6379
maxTotal=50
maxIdle=10

测试类：

@Test
        public void test8(){
            //通过连接池工具类获取
            Jedis jedis = JedisPoolUtils.getJedis();
            //3. 使用
            jedis.set("hello","world");
            //4. 关闭 归还到连接池中
            jedis.close();;
        }