Jedis 使用教程总结

一、Redis 常用命令

1 连接操作命令

• quit：关闭连接（connection）
• auth：简单密码认证
• help cmd： 查看 cmd 帮助，例如：help quit

2 持久化

• save：将数据同步保存到磁盘
• bgsave：将数据异步保存到磁盘
• lastsave：返回上次成功将数据保存到磁盘的 Unix 时戳
• shutdown：将数据同步保存到磁盘，然后关闭服务

3 远程服务控制

• info：提供服务器的信息和统计
• monitor：实时转储收到的请求
• slaveof：改变复制策略设置
• config：在运行时配置 Redis 服务器

4 对 key 操作的命令

• exists(key)：确认一个 key 是否存在
• del(key)：删除一个 key
• type(key)：返回值的类型
• keys(pattern)：返回满足给定 pattern 的所有 key
• randomkey：随机返回 key 空间的一个
• keyrename(oldname, newname)：重命名 key
• dbsize：返回当前数据库中 key 的数目
• expire：设定一个 key 的活动时间（s）
• ttl：获得一个 key 的活动时间
• select(index)：按索引查询
• move(key, dbindex)：移动当前数据库中的 key 到 dbindex 数据库
• flushdb：删除当前选择数据库中的所有 key
• flushall：删除所有数据库中的所有 key

5 String

• set(key, value)：给数据库中名称为 key 的 string 赋予值 value
• get(key)：返回数据库中名称为 key 的 string 的 value
• getset(key, value)：给名称为 key 的 string 赋予上一次的 value
• mget(key1, key2,…, key N)：返回库中多个 string 的 value
• setnx(key, value)：添加 string，名称为 key，值为 value
• setex(key, time, value)：向库中添加 string，设定过期时间 time
• mset(key N, value N)：批量设置多个 string 的值
• msetnx(key N, value N)：如果所有名称为 key i 的 string 都不存在
• incr(key)：名称为 key 的 string 增 1 操作
• incrby(key, integer)：名称为 key 的 string 增加 integer
• decr(key)：名称为 key 的 string 减 1 操作
• decrby(key, integer)：名称为 key 的 string 减少 integer
• append(key, value)：名称为 key 的 string 的值附加 value
• substr(key, start, end)：返回名称为 key 的 string 的 value 的子串

6 List

• rpush(key, value)：在名称为 key 的 list 尾添加一个值为 value 的元素
• lpush(key, value)：在名称为 key 的 list 头添加一个值为 value 的 元素
• llen(key)：返回名称为 key 的 list 的长度
• lrange(key, start, end)：返回名称为 key 的 list 中 start 至 end 之间的元素
• ltrim(key, start, end)：截取名称为 key 的 list
• lindex(key, index)：返回名称为 key 的 list 中 index 位置的元素
• lset(key, index, value)：给名称为 key 的 list 中 index 位置的元素赋值
• lrem(key, count, value)：删除 count 个 key 的 list 中值为 value 的元素
• lpop(key)：返回并删除名称为 key 的 list 中的首元素
• rpop(key)：返回并删除名称为 key 的 list 中的尾元素
• blpop(key1, key2,… key N, timeout)：lpop 命令的 block 版本。
• brpop(key1, key2,… key N, timeout)：rpop 的 block 版本。
• rpoplpush(srckey, dstkey)：返回并删除名称为 srckey 的 list 的尾元素，并将该元素添加到名称为 dstkey 的 list 的头部

7 Set

• sadd(key, member)：向名称为 key 的 set 中添加元素 member
• srem(key, member) ：删除名称为 key 的 set 中的元素 member
• spop(key) ：随机返回并删除名称为 key 的 set 中一个元素
• smove(srckey, dstkey, member) ：移到集合元素
• scard(key) ：返回名称为 key 的 set 的基数
• sismember(key, member) ：member 是否是名称为 key 的 set 的元素
• sinter(key1, key2,…key N) ：求交集
• sinterstore(dstkey, (keys)) ：求交集并将交集保存到 dstkey 的集合
• sunion(key1, (keys)) ：求并集
• sunionstore(dstkey, (keys)) ：求并集并将并集保存到 dstkey 的集合
• sdiff(key1, (keys)) ：求差集
• sdiffstore(dstkey, (keys)) ：求差集并将差集保存到 dstkey 的集合
• smembers(key) ：返回名称为 key 的 set 的所有元素
• srandmember(key) ：随机返回名称为 key 的 set 的一个元素

8 Hash

• hset(key, field, value)：向名称为 key 的 hash 中添加元素 field
• hget(key, field)：返回名称为 key 的 hash 中 field 对应的 value
• hmget(key, (fields))：返回名称为 key 的 hash 中 field i 对应的 value
• hmset(key, (fields))：向名称为 key 的 hash 中添加元素 field
• hincrby(key, field, integer)：将名称为 key 的 hash 中 field 的 value 增加 integer
• hexists(key, field)：名称为 key 的 hash 中是否存在键为 field 的域
• hdel(key, field)：删除名称为 key 的 hash 中键为 field 的域
• hlen(key)：返回名称为 key 的 hash 中元素个数
• hkeys(key)：返回名称为 key 的 hash 中所有键
• hvals(key)：返回名称为 key 的 hash 中所有键对应的 value
• hgetall(key)：返回名称为 key 的 hash 中所有的键（field）及其对应的 value

键操作：

字符串操作：

整数和浮点数操作：

列表（List）操作：

集合（Set）操作：

哈希（Hash）操作：

有序集合（Zsort）操作：

排序操作：

二、相关实例

本例子使用 maven，需要添加如下依赖：

    redis.clients
    jedis
    2.6.0 


1
2
3
4
5
6

以下只是对数据的一些基本操作。

1、获取 Jedis 操作对象：

Jedis jedis;

@Before
public void connectionTest() {
    jedis = new Jedis("127.0.0.1", 6379);//redis的地址以及连接端口

    //开启密码验证（配置文件中为 requirepass helloworld）的时候需要执行该方法7
    //jedis.auth("helloworld");
}

1
2
3
4
5
6
7
8
9
10

2、Jedis 对 key 的操作：

@Test
public void keyTest() throws UnsupportedEncodingException {
    System.out.println(jedis.flushDB());// 清空数据
    System.out.println(jedis.echo("hello"));

    // 判断key否存在
    System.out.println(jedis.exists("foo"));

    jedis.set("key", "values");
    jedis.set("key2", "values");
    System.out.println(jedis.exists("key"));// 判断是否存在

    // 如果数据库没有任何key，返回nil，否则返回数据库中一个随机的key。
    String randomKey = jedis.randomKey();
    System.out.println("randomKey: " + randomKey);

    // 设置60秒后该key过期
    jedis.expire("key", 60);

    // key有效毫秒数
    System.out.println(jedis.pttl("key"));

    // 移除key的过期时间
    jedis.persist("key");

    // 获取key的类型, "string", "list", "set". "none" none表示key不存在
    System.out.println("type: " + jedis.type("key"));

    // 导出key的值
    byte[] bytes = jedis.dump("key");
    System.out.println(new String(bytes));

    // 将key重命名
    jedis.renamenx("key", "keytest");
    //判断是否存在
    System.out.println("key是否存在: " + jedis.exists("key"));
    //判断是否存在
    System.out.println("keytest是否存在: " + jedis.exists("keytest"));

    // 查询匹配的key
    // KEYS * 匹配数据库中所有 key 。
    // KEYS h?llo 匹配 hello ， hallo 和 hxllo 等。
    // KEYS h*llo 匹配 hllo 和 heeeeello 等。
    // KEYS h[ae]llo 匹配 hello 和 hallo ，但不匹配 hillo 。
    // 特殊符号用 \ 隔开。
    Set set = jedis.keys("k*");
    System.out.println(set);

    // 删除key
    jedis.del("key");
    System.out.println(jedis.exists("key"));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

3、Jedis 对字符串 (String) 的相关操作：

@Test
public void stringTest() {
    jedis.set("hello", "hello");
    System.out.println(jedis.get("hello"));

    // 使用append 向字符串后面添加
    jedis.append("hello", " world");
    System.out.println(jedis.get("hello"));

    // set覆盖字符串
    jedis.set("hello", "123");
    System.out.println(jedis.get("hello"));

    // 设置过期时间
    jedis.setex("hello2", 2, "world2");
    System.out.println(jedis.get("hello2"));
    try {
        Thread.sleep(3000);
    } catch (InterruptedException e) {
    }
    System.out.println(jedis.get("hello2"));

    // 一次添加多个key-value对
    jedis.mset("a", "1", "b", "2");
    // 获取a和b的value
    List valus = jedis.mget("a", "b");
    System.out.println(valus);

    // 批量删除
    jedis.del("a", "b");
    System.out.println(jedis.exists("a"));
    System.out.println(jedis.exists("b"));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

4、Jedis 对链表 (Lists) 的操作：

@Test
public void listTest() {
    String key = "mylist";
    jedis.del(key);

    // 队列添加元素
    jedis.rpush(key, "aaaa");
    jedis.rpush(key, "aaaa");
    jedis.rpush(key, "bbbb");
    jedis.rpush(key, "cccc");
    jedis.rpush(key, "cccc");

    // 队列长度
    System.out.println("lenth: " + jedis.llen(key));

    // 打印队列，从索引0开始，到倒数第1个（全部元素）
    System.out.println("all elements: " + jedis.lrange(key, 0, -1));

    // 索引为1的元素
    System.out.println("index of 1: " + jedis.lindex(key, 1));

    // 设置队列里面一个元素的值，当index超出范围时会返回一个error。
    jedis.lset(key, 1, "aa22");
    System.out.println("index of 1: " + jedis.lindex(key, 1));

    // 从队列的右边入队一个元素
    jedis.rpush(key, "-2", "-1");// 先-2，后-1入队列
    System.out.println("all elements: " + jedis.lrange(key, 0, -1));

    // 从队列的左边入队一个或多个元素
    jedis.lpush(key, "second element", "first element");// 先second
    // element，后first
    // elementF入队列
    System.out.println("all elements: " + jedis.lrange(key, 0, -1));

    // 从队列的右边出队一个元素
    System.out.println(jedis.rpop(key));
    // 从队列的左边出队一个元素
    System.out.println(jedis.lpop(key));
    System.out.println("all elements: " + jedis.lrange(key, 0, -1));

    // count > 0: 从头往尾移除值为 value 的元素，count为移除的个数。
    // count < 0: 从尾往头移除值为 value 的元素，count为移除的个数。
    // count = 0: 移除所有值为 value 的元素。
    jedis.lrem(key, 1, "cccc");
    System.out.println("all elements: " + jedis.lrange(key, 0, -1));

    //即最右边的那个元素也会被包含在内，如果start比list的尾部下标大的时候，
    //会返回一个空列表。
    //如果stop比list的实际尾部大的时候，Redis会当它是最后一个元素的下标。
    System.out.println(jedis.lrange(key, 0, 2));
    System.out.println("all elements: " + jedis.lrange(key, 0, -1));

    // 删除区间以外的元素
    System.out.println(jedis.ltrim(key, 0, 2));
    System.out.println("all elements: " + jedis.lrange(key, 0, -1));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

5、Jedis 对集合 (Sets) 的操作：

@Test
public void testSet() {
    // 清空数据
    System.out.println(jedis.flushDB());
    String key = "myset";
    String key2 = "myset2";

    // 集合添加元素
    jedis.sadd(key, "aaa", "bbb", "ccc");
    jedis.sadd(key2, "bbb", "ccc", "ddd");

    // 获取集合里面的元素数量
    System.out.println(jedis.scard(key));

    // 获得两个集合的交集，并存储在一个关键的结果集
    jedis.sinterstore("destination", key, key2);
    System.out.println(jedis.smembers("destination"));

    // 获得两个集合的并集，并存储在一个关键的结果集
    jedis.sunionstore("destination", key, key2);
    System.out.println(jedis.smembers("destination"));

    // key集合中，key2集合没有的元素，并存储在一个关键的结果集
    jedis.sdiffstore("destination", key, key2);
    System.out.println(jedis.smembers("destination"));

    // 确定某个元素是一个集合的成员
    System.out.println(jedis.sismember(key, "aaa"));

    // 从key集合里面随机获取一个元素
    System.out.println(jedis.srandmember(key));

    // aaa从key移动到key2集合
    jedis.smove(key, key2, "aaa");
    System.out.println(jedis.smembers(key));
    System.out.println(jedis.smembers(key2));

    // 删除并获取一个集合里面的元素
    System.out.println(jedis.spop(key));

    // 从集合里删除一个或多个元素
    jedis.srem(key2, "ccc", "ddd");
    System.out.println(jedis.smembers(key2));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

6、Jedis 对有序集合 (Sorted Sets) 的操作：

@Test
public void testSortSet() {
    // 清空数据
    System.out.println(jedis.flushDB());
    String key = "mysortset";

    Map scoreMembers = new HashMap();
    scoreMembers.put("aaa", 1001.0);
    scoreMembers.put("bbb", 1002.0);
    scoreMembers.put("ccc", 1003.0);

    // 添加数据
    jedis.zadd(key, 1004.0, "ddd");
    jedis.zadd(key, scoreMembers);

    // 获取一个排序的集合中的成员数量
    System.out.println(jedis.zcard(key));

    //返回的成员在指定范围内的有序集合，以0表示有序集第一个成员，
    //以1表示有序集第二个成员，以此类推。
    //负数下标，以-1表示最后一个成员，-2表示倒数第二个成员。
    Set coll = jedis.zrange(key, 0, -1);
    System.out.println(coll);

    // 返回的成员在指定范围内的逆序集合
    coll = jedis.zrevrange(key, 0, -1);
    System.out.println(coll);

    // 元素下标
    System.out.println(jedis.zscore(key, "bbb"));

    // 删除元素
    System.out.println(jedis.zrem(key, "aaa"));
    System.out.println(jedis.zrange(key, 0, -1));

    // 给定值范围内的成员数
    System.out.println(jedis.zcount(key, 1002.0, 1003.0));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

7、Jedis 对哈希 (Hashs) 的操作：

@Test
public void testHash() {
    // 清空数据
    System.out.println(jedis.flushDB());
    String key = "myhash";
    Map hash = new HashMap();
    hash.put("aaa", "11");
    hash.put("bbb", "22");
    hash.put("ccc", "33");

    // 添加数据
    jedis.hmset(key, hash);
    jedis.hset(key, "ddd", "44");

    // 获取hash的所有元素(key值)
    System.out.println(jedis.hkeys(key));

    // 获取hash中所有的key对应的value值
    System.out.println(jedis.hvals(key));

    // 获取hash里所有元素的数量
    System.out.println(jedis.hlen(key));

    // 获取hash中全部的域和值,以Map 的形式返回
    Map elements = jedis.hgetAll(key);
    System.out.println(elements);

    // 判断给定key值是否存在于哈希集中
    System.out.println(jedis.hexists(key, "bbb"));

    // 获取hash里面指定字段对应的值
    System.out.println(jedis.hmget(key, "aaa", "bbb"));

    // 获取指定的值
    System.out.println(jedis.hget(key, "aaa"));

    // 删除指定的值
    System.out.println(jedis.hdel(key, "aaa"));
    System.out.println(jedis.hgetAll(key));

    // 为key中的域 field 的值加上增量 increment
    System.out.println(jedis.hincrBy(key, "bbb", 100));
    System.out.println(jedis.hgetAll(key));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

8、Jedis 操作事务：

@Test
public void testTransaction() {
    Transaction t = jedis.multi();
    t.set("hello", "world");
    Response response = t.get("hello");

    t.zadd("foo", 1, "barowitch");
    t.zadd("foo", 0, "barinsky");
    t.zadd("foo", 0, "barikoviev");
    //返回全部相应并以有序集合的方式返回
    Response> sose = t.zrange("foo", 0, -1);
    System.out.println(response);
    System.out.println(sose);
    t.exec(); // 此行注意，不能缺少

    String foolbar = response.get(); // Response.get() 可以从响应中获取数据

    int soseSize = sose.get().size(); // sose.get() 会立即调用set方法
    System.out.println(foolbar);
    System.out.println(sose.get());
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

9、Jedis 操作管道：

@Test
public void testTransactionPipeling() {
    Pipeline p = jedis.pipelined();//开一个管道

    p.set("fool", "bar");
    p.zadd("foo", 1, "barowitch");
    p.zadd("foo", 0, "barinsky");
    p.zadd("foo", 0, "barikoviev");
    Response pipeString = p.get("fool");
    Response> sose = p.zrange("foo", 0, -1);
    System.out.println(pipeString);
    System.out.println(sose);

    p.sync();//提交

    System.out.println("==========");
    System.out.println(p.get("fool"));
    System.out.println(p.zrange("foo", 0, -1));

    int soseSize = sose.get().size();
    Set setBack = sose.get();

    System.out.println(soseSize);
    System.out.println(setBack);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26