redis接口手册

Posted lemon

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了redis接口手册相关的知识，希望对你有一定的参考价值。

redis接口手册

String类型数据结构

set(String key, Object value)

使用:set("name","tom")
结果:get("name")  输出结果为tom

setExpire(String key, Object value, long expireTime, TimeUnit timeUnit)

使用:setExpire("name","tom",10, TimeUnit.SECONDS)
结果:get("name")  由于设置的是10秒失效，十秒之内查询有结果，十秒之后返回为null

setOffset(String key, Object value, long offset)

value 参数覆写(overwrite)给定 key 所储存的字符串值，从偏移量 offset 开始

使用:setOffset("key","hello world")
setOffset("key","redis", 6)
结果:get("key")  输出结果为hello redis

setIfAbsent(String key, Object value)

设置value时先判断该值原来是否存在

使用:setIfAbsent("multi1","multi1")//multi1之前已经存在
setIfAbsent("multi111","multi111")//multi111之前不存在
结果:false
true

multiSet(Map< String, Object> map)

为多个键分别设置它们的值

使用：Map<String,String> maps = new HashMap<String, String>();
        maps.put("multi1","multi1");
        maps.put("multi2","multi2");
        maps.put("multi3","multi3");
        multiSet(maps);
        List<String> keys = new ArrayList<String>();
        keys.add("multi1");
        keys.add("multi2");
        keys.add("multi3");
        System.out.println(multiGet(keys));
结果：[multi1, multi2, multi3]

multiSetIfAbsent(Map<String, Object> map)

为多个键分别设置它们的值，如果存在则返回false，不存在返回true

使用：Map<String,String> maps = new HashMap<String, String>();
        maps.put("multi11","multi11");
        maps.put("multi22","multi22");
        maps.put("multi33","multi33");
        Map<String,String> maps2 = new HashMap<String, String>();
        maps2.put("multi1","multi1");
        maps2.put("multi2","multi2");
        maps2.put("multi3","multi3");
        System.out.println(multiSetIfAbsent(maps));
        System.out.println(multiSetIfAbsent(maps2));
结果：true
false

get(String key)

获取key对应的值

使用：set("key","hello world");
        System.out.println(get("key"));
结果：hello world

getAndSet(String key, String value)

设置键的字符串值并返回其旧值

使用：set("getSetTest","test");
        System.out.println(getAndSet("getSetTest","test2"));
结果：test

List< Object> multiGet(Collection< String> collection)

为多个键分别取出它们的值

使用：Map<String,String> maps = new HashMap<String, String>();
        maps.put("multi1","multi1");
        maps.put("multi2","multi2");
        maps.put("multi3","multi3");
        multiSet(maps);
        List<String> keys = new ArrayList<String>();
        keys.add("multi1");
        keys.add("multi2");
        keys.add("multi3");
        System.out.println(multiGet(keys));
结果：[multi1, multi2, multi3]

increment(String key, long value)

支持整数

使用：increment("increlong",1);
        System.out.println(get("increlong"));
结果：2

increment(String key, double value)

支持浮点数

使用：increment("increlong",1.2);
        System.out.println(get("increlong"));
结果：2.2

append(String key, String value)

如果key已经存在并且是一个字符串，则该命令将该值追加到字符串的末尾。如果键不存在，则它被创建并设置为空字符串，因此APPEND在这种特殊情况下将类似于SET。

使用：append("appendTest","Hello");
        System.out.println(get("appendTest"));
        append("appendTest","world");
        System.out.println(get("appendTest"));
结果：Hello
        Helloworld

sub(String key, long start, long end)

截取key所对应的value字符串

使用：appendTest对应的value为Helloworld
System.out.println(sub("appendTest",0,5));
结果：Hellow
使用：System.out.println(sub("appendTest",0,-1));
结果：Helloworld
使用：System.out.println(sub("appendTest",-3,-1));
结果：rld

size(String key)

返回key所对应的value值得长度

使用：set("key","hello world");
    System.out.println(size("key"));
结果：11

setBit(String key, long offset, boolean value)

对 key 所储存的字符串值，设置或清除指定偏移量上的位(bit)
key键对应的值value对应的ascii码,在offset的位置(从左向右数)变为value

使用：set("bitTest","a");
        // ‘a‘ 的ASCII码是 97。转换为二进制是：01100001
        // ‘b‘ 的ASCII码是 98  转换为二进制是：01100010
        // ‘c‘ 的ASCII码是 99  转换为二进制是：01100011
        //因为二进制只有0和1，在setbit中true为1，false为0，因此我要变为‘b‘的话第六位设置为1，第七位设置为0
        setBit("bitTest",6, true);
        setBit("bitTest",7, false);
        System.out.println(get("bitTest"));
结果：b

getBit(String key, long offset)

获取键对应值的ascii码的在offset处位值

使用：System.out.println(getBit("bitTest",7));
结果：false

Hash数据结构

hdelete(String key, Object... hashKeys)

删除给定的哈希hashKeys

使用：System.out.println(hdelete("redisHash","name"));
        System.out.println(entries("redisHash"));
结果：1
{class=6, age=28.1}

hasKey(String key, Object hashKey)

确定哈希hashKey是否存在

使用：System.out.println(hasKey("redisHash","age"));
        System.out.println(hasKey("redisHash","ttt"));
结果：true
false

hget(String key, Object hashKey)

从键中的哈希获取给定hashKey的值

使用：System.out.println(hget("redisHash","age"));
结果：26

hmultiGet(String key, Collection< Object> hashKeys)

从哈希中获取给定hashKey的值

使用：List<Object> kes = new ArrayList<Object>();
        kes.add("name");
        kes.add("age");
        System.out.println(hmultiGet("redisHash",kes));
结果：[jack, 28.1]

hincrement(String key, Object hashKey, long value)

通过给定的delta增加散列hashKey的值（整型）

使用：System.out.println(hget("redisHash","age"));
    System.out.println(hincrement("redisHash","age",1));
结果：26
27

hincrement(String key, Object hashKey, double value)

通过给定的delta增加散列hashKey的值（浮点数）

使用：System.out.println(hget("redisHash","age"));
    System.out.println(hincrement("redisHash","age",1.1));
结果：27
28.1

hkeys(String key)

获取key所对应的散列表的key

使用：System.out.println(hkeys("redisHash1"));
//redisHash1所对应的散列表为{class=1, name=jack, age=27}
结果：[name, class, age]

hsize(String key)

获取key所对应的散列表的大小个数

使用：System.out.println(hsize("redisHash1"));
//redisHash1所对应的散列表为{class=1, name=jack, age=27}
结果：3

putAll(String key, Map<Object, Object> map)

使用m中提供的多个散列字段设置到key对应的散列表中

使用：Map<String,Object> testMap = new HashMap();
        testMap.put("name","jack");
        testMap.put("age",27);
        testMap.put("class","1");
       putAll("redisHash1",testMap);
        System.out.println(entries("redisHash1"));
结果：{class=1, name=jack, age=27}

put(String key, Object hashKey, Object value)

设置散列hashKey的值

使用：put("redisHash","name","tom");
        put("redisHash","age",26);
        put("redisHash","class","6");
System.out.println(entries("redisHash"));
结果：{age=26, class=6, name=tom}

putIfAbsent(String key, Object hashKey, Object value)

仅当hashKey不存在时才设置散列hashKey的值。

使用：System.out.println(putIfAbsent("redisHash","age",30));
System.out.println(putIfAbsent("redisHash","kkk","kkk"));
结果：false
true

values(String key)

获取整个哈希存储的值根据密钥

使用：System.out.println(values("redisHash"));
结果：[tom, 26, 6]

entries(String key)

获取整个哈希存储根据密钥

使用：System.out.println(entries("redisHash"));
结果：{age=26, class=6, name=tom}

hscan(String key, ScanOptions options)

使用Cursor在key的hash中迭代，相当于迭代器。

使用：Cursor<Map.Entry<Object, Object>> curosr = hscan("redisHash", ScanOptions.ScanOptions.NONE);
        while(curosr.hasNext()){
            Map.Entry<Object, Object> entry = curosr.next();
            System.out.println(entry.getKey()+":"+entry.getValue());
        }
结果：age:28.1
class:6
kkk:kkk

List数据结构

lrange(String key, long start, long end)

返回存储在键中的列表的指定元素。偏移开始和停止是基于零的索引，其中0是列表的第一个元素（列表的头部），1是下一个元素

使用：System.out.println(lrange("list",0,-1));
结果:[c#, c++, python, java, c#, c#]

trim(String key, long start, long end)

裁剪现有列表，使其只包含指定的指定范围的元素，起始和停止都是基于0的索引

使用：System.out.println(lrange("list",0,-1));
trim("list",1,-1);//裁剪第一个元素
System.out.println(lrange("list",0,-1));
结果:[c#, c++, python, java, c#, c#]
[c++, python, java, c#, c#]

lsize(String key)

返回存储在键中的列表的长度。如果键不存在，则将其解释为空列表，并返回0。当key存储的值不是列表时返回错误。

使用：System.out.println(lsize("list"));
结果:6

leftPush(String key, Object value)

将所有指定的值插入存储在键的列表的头部。如果键不存在，则在执行推送操作之前将其创建为空列表。（从左边插入）

使用：leftPush("list","java");
        leftPush("list","python");
        leftPush("list","c++");
结果:返回的结果为推送操作后的列表的长度

leftPushAll(String key, Object... values)

批量把一个数组插入到列表中

使用：String[] stringarrays = new String[]{"1","2","3"};
        leftPushAll("listarray",stringarrays);
        System.out.println(lrange("listarray",0,-1));
结果:[3, 2, 1]

leftPushAll(String key, Collection< Object> values)

批量把一个集合插入到列表中

使用：List<Object> strings = new ArrayList<Object>();
        strings.add("1");
        strings.add("2");
        strings.add("3");
        leftPushAll("listcollection4", strings);
        System.out.println(lrange("listcollection4",0,-1));
结果:[3, 2, 1]

leftPushIfPresent(String key, Object value)

只有存在key对应的列表才能将这个value值插入到key所对应的列表中

使用：System.out.println(leftPushIfPresent("leftPushIfPresent","aa"));
        System.out.println(leftPushIfPresent("leftPushIfPresent","bb"));
==========分割线===========
System.out.println(leftPush("leftPushIfPresent","aa"));
        System.out.println(leftPushIfPresent("leftPushIfPresent","bb"));
结果:
0
0
==========分割线===========
1
2

leftPush(String key, Object pivot, Object value)

把value值放到key对应列表中pivot值的左面，如果pivot值存在的话

使用：leftPush("list","java","oc");
        System.out.print(lrange("list",0,-1));
结果：[c++, python, oc, java, c#, c#]

rightPush(String key, Object value)

将所有指定的值插入存储在键的列表的头部。如果键不存在，则在执行推送操作之前将其创建为空列表。（从右边插入）

使用：rightPush("listRight","java");
        rightPush("listRight","python");
        rightPush("listRight","c++");
结果:
1
2
3

rightPushAll(String key, Object... values)

使用：String[] stringarrays = new String[]{"1","2","3"};
        rightPushAll("listarrayright",stringarrays);
        System.out.println(lrange("listarrayright",0,-1));
结果:[1, 2, 3]

rightPushAll(String key, Collection< Object> values)

使用：List<Object> strings = new ArrayList<Object>();
        strings.add("1");
        strings.add("2");
        strings.add("3");
        rightPushAll("listcollectionright", strings);
        System.out.println(lrange("listcollectionright",0,-1));
结果:[1, 2, 3]

rightPushIfPresent(String key, Object value)

只有存在key对应的列表才能将这个value值插入到key所对应的列表中

使用：System.out.println(rightPushIfPresent("rightPushIfPresent","aa"));
        System.out.println(rightPushIfPresent("rightPushIfPresent","bb"));
        System.out.println("==========分割线===========");
        System.out.println(rightPush("rightPushIfPresent","aa"));
        System.out.println(rightPushIfPresent("rightPushIfPresent","bb"));
结果:0
0
==========分割线===========
1
2

rightPush(String key, Object pivot, Object value)

把value值放到key对应列表中pivot值的右面，如果pivot值存在的话

使用：System.out.println(lrange("listRight",0,-1));
        rightPush("listRight","python","oc");
        System.out.println(lrange("listRight",0,-1));
结果:[java, python, c++]
[java, python, oc, c++]

lset(String key, long index, Object value)

在列表中index的位置设置value值

使用：System.out.println(lrange("listRight",0,-1));
        lset("listRight",1,"setValue");
        System.out.println(lrange("listRight",0,-1));
结果:[java, python, oc, c++]
[java, setValue, oc, c++]

remove(String key, long count, Object value)

从存储在键中的列表中删除等于值的元素的第一个计数事件。
计数参数以下列方式影响操作：
count> 0：删除等于从头到尾移动的值的元素。
count <0：删除等于从尾到头移动的值的元素。
count = 0：删除等于value的所有元素。

使用：System.out.println(lrange("listRight",0,-1));
        remove("listRight",1,"setValue");//将删除列表中存储的列表中第一次次出现的“setValue”。
        System.out.println(lrange("listRight",0,-1));
结果:[java, setValue, oc, c++]
[java, oc, c++]

index(String key, long index)

根据下表获取列表中的值，下标是从0开始的

使用：System.out.println(lrange("listRight",0,-1));
System.out.println(index("listRight",2));
结果:[java, oc, c++]
c++

leftPop(String key)

弹出最左边的元素，弹出之后该值在列表中将不复存在

使用：System.out.println(lrange("list",0,-1));
        System.out.println(leftPop("list"));
        System.out.println(lrange("list",0,-1));
结果:
[c++, python, oc, java, c#, c#]
c++
[python, oc, java, c#, c#]

leftPop(String key, long timeout, TimeUnit timeUnit)

移出并获取列表的第一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。

使用：用法与 leftPop(String key);一样

rightPop(String key)

弹出最右边的元素，弹出之后该值在列表中将不复存在

使用： System.out.println(lrange("list",0,-1));
        System.out.println(rightPop("list"));
        System.out.println(lrange("list",0,-1));
结果:[python, oc, java, c#, c#]
c#
[python, oc, java, c#]

rightPop(String key, long timeout, TimeUnit timeUnit)

移出并获取列表的最后一个元素， 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。

使用：用法与 rightPop(String key);一样

rightPopAndLeftPush(String sourceKey, String destinationKey)

用于移除列表的最后一个元素，并将该元素添加到另一个列表并返回。

使用：System.out.println(lrange("list",0,-1));
rightPopAndLeftPush("list","rightPopAndLeftPush");
    System.out.println(lrange("list",0,-1));
    System.out.println(lrange("rightPopAndLeftPush",0,-1));
结果:[oc, java,c#]
[oc, java]
[c#]

rightPopAndLeftPush(String sourceKey, String destinationKey, long timeout, TimeUnit timeUnit)

用于移除列表的最后一个元素，并将该元素添加到另一个列表并返回，如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止。

使用：用法与rightPopAndLeftPush(K sourceKey, K destinationKey)一样

Set数据结构

add(String key, Object... values)

无序集合中添加元素，返回添加个数
也可以直接在add里面添加多个值 如：add("setTest","aaa","bbb")

使用：String[] strarrays = new String[]{"strarr1","sgtarr2"};
        System.out.println(add("setTest", strarrays));
结果：2

sremove(String key, Object... values)

移除集合中一个或多个成员

使用：String[] strarrays = new String[]{"strarr1","sgtarr2"};
System.out.println(sremove("setTest",strarrays));
结果：2

pop(String key)

移除并返回集合中的一个随机元素

使用：System.out.println(pop("setTest"));
System.out.println(members("setTest"));
结果：bbb
[aaa, ccc]

move(String key, Object value, String destKey)

将 member 元素从 source 集合移动到 destination 集合

使用：move("setTest","aaa","setTest2");
        System.out.println(members("setTest"));
        System.out.println(members("setTest2"));
结果：[ccc]
[aaa]

ssize(String key)

无序集合的大小长度

使用：System.out.println(ssize("setTest"));
结果：1

isMember(String key, Object value)

判断 member 元素是否是集合 key 的成员

使用：System.out.println(isMember("setTest","ccc"));
        System.out.println(isMember("setTest","asd"));
结果：true
false

intersect(String key, String otherKey)

key对应的无序集合与otherKey对应的无序集合求交集

使用：System.out.println(members("setTest"));
        System.out.println(members("setTest2"));
        System.out.println(intersect("setTest","setTest2"));
结果：[aaa, ccc]
[aaa]
[aaa]

intersect(String key, Collection< String> otherKeys)

key对应的无序集合与多个otherKey对应的无序集合求交集

使用：System.out.println(members("setTest"));
        System.out.println(members("setTest2"));
        System.out.println(members("setTest3"));
        List<String> strlist = new ArrayList<String>();
        strlist.add("setTest2");
        strlist.add("setTest3");
        System.out.println(intersect("setTest",strlist));
结果：[aaa, ccc]
[aaa]
[ccc, aaa]
[aaa]

sintersectAndStore(String key, String otherKey, String destKey)

key无序集合与otherkey无序集合的交集存储到destKey无序集合中

使用：System.out.println("setTest:" + members("setTest"));
System.out.println("setTest2:" + members("setTest2"));
System.out.println(sintersectAndStore("setTest","setTest2","destKey1"));
System.out.println(members("destKey1"));
结果：setTest:[ddd, bbb, aaa, ccc]
setTest2:[ccc, aaa]
2
[aaa, ccc]

sintersectAndStore(String key, Collection< String> otherKeys, String destKey)

key对应的无序集合与多个otherKey对应的无序集合求交集存储到destKey无序集合中

使用：System.out.println("setTest:" + members("setTest"));
        System.out.println("setTest2:" + members("setTest2"));
        System.out.println("setTest3:" + members("setTest3"));
        List<String> strlist = new ArrayList<String>();
        strlist.add("setTest2");
        strlist.add("setTest3");
        System.out.println(sintersectAndStore("setTest",strlist,"destKey2"));
        System.out.println(members("destKey2"));
结果：setTest:[ddd, bbb, aaa, ccc]
setTest2:[ccc, aaa]
setTest3:[ccc, aaa]
2
[aaa, ccc]

union(String key, String otherKey)

key无序集合与otherKey无序集合的并集

使用：System.out.println("setTest:" + members("setTest"));
        System.out.println("setTest2:" + members("setTest2"));
        System.out.println(union("setTest","setTest2"));
结果：setTest:[ddd, bbb, aaa, ccc]
setTest2:[ccc, aaa]
[ccc, aaa, ddd, bbb]

union(String key, Collection< String> otherKeys)

key无序集合与多个otherKey无序集合的并集

使用：System.out.println("setTest:" + members("setTest"));
        System.out.println("setTest2:" + members("setTest2"));
        System.out.println("setTest3:" + members("setTest3"));
        List<String> strlist = new ArrayList<String>();
        strlist.add("setTest2");
        strlist.add("setTest3");
        System.out.println(union("setTest",strlist));
结果：setTest:[ddd, bbb, aaa, ccc]
setTest2:[ccc, aaa]
setTest3:[xxx, ccc, aaa]
[ddd, xxx, bbb, aaa, ccc]

sunionAndStore(String key, String otherKey, String destKey)

key无序集合与otherkey无序集合的并集存储到destKey无序集合中

使用：System.out.println("setTest:" + members("setTest"));
        System.out.println("setTest2:" + members("setTest2"));
        System.out.println(sunionAndStore("setTest","setTest2","unionAndStoreTest1"));
        System.out.println("unionAndStoreTest1:" + members("unionAndStoreTest1"));
结果：setTest:[ddd, bbb, aaa, ccc]
setTest2:[ccc, aaa]
4
unionAndStoreTest1:[ccc, aaa, ddd, bbb]

sunionAndStore(String key, Collection< String> otherKeys, String destKey)

key无序集合与多个otherkey无序集合的并集存储到destKey无序集合中

使用：System.out.println("setTest:" + members("setTest"));
        System.out.println("setTest2:" + members("setTest2"));
        System.out.println("setTest3:" + members("setTest3"));
        List<String> strlist = new ArrayList<String>();
        strlist.add("setTest2");
        strlist.add("setTest3");
        System.out.println(sunionAndStore("setTest",strlist,"unionAndStoreTest2"));
        System.out.println("unionAndStoreTest2:" + members("unionAndStoreTest2"));
结果：setTest:[ddd, bbb, aaa, ccc]
setTest2:[ccc, aaa]
setTest3:[xxx, ccc, aaa]
5
unionAndStoreTest2:[ddd, xxx, bbb, aaa, ccc]

difference(String key, String otherKey)

key无序集合与otherKey无序集合的差集

使用：System.out.println("setTest:" + members("setTest"));
        System.out.println("setTest2:" + members("setTest2"));
        System.out.println(difference("setTest","setTest2"));
结果：setTest:[ddd, bbb, aaa, ccc]
setTest2:[ccc, aaa]
[bbb, ddd]

difference(String key, Collection< String> otherKeys)

key无序集合与多个otherKey无序集合的差集

使用：System.out.println("setTest:" + members("setTest"));
        System.out.println("setTest2:" + members("setTest2"));
        System.out.println("setTest3:" + members("setTest3"));
        List<String> strlist = new ArrayList<String>();
        strlist.add("setTest2");
        strlist.add("setTest3");
        System.out.println(difference("setTest",strlist));
结果：setTest:[ddd, bbb, aaa, ccc]
setTest2:[ccc, aaa]
setTest3:[xxx, ccc, aaa]
[bbb, ddd]

differenceAndStore(String key, String otherKey, String destKey)

key无序集合与otherkey无序集合的差集存储到destKey无序集合中

使用：System.out.println("setTest:" + members("setTest"));
        System.out.println("setTest2:" + members("setTest2"));
        System.out.println(differenceAndStore("setTest","setTest2","differenceAndStore1"));
        System.out.println("differenceAndStore1:" + members("differenceAndStore1"));
结果：setTest:[ddd, bbb, aaa, ccc]
setTest2:[ccc, aaa]
2
differenceAndStore1:[bbb, ddd]

differenceAndStore(String key, Collection< String> otherKeys, String destKey)

key无序集合与多个otherkey无序集合的差集存储到destKey无序集合中

使用：System.out.println("setTest:" + members("setTest"));
        System.out.println("setTest2:" + members("setTest2"));
        System.out.println("setTest3:" + members("setTest3"));
        List<String> strlist = new ArrayList<String>();
        strlist.add("setTest2");
        strlist.add("setTest3");
        System.out.println(differenceAndStore("setTest",strlist,"differenceAndStore2"));
        System.out.println("differenceAndStore2:" + members("differenceAndStore2"));
结果：setTest:[ddd, bbb, aaa, ccc]
setTest2:[ccc, aaa]
setTest3:[xxx, ccc, aaa]
2
differenceAndStore2:[bbb, ddd]

members(String key)

返回集合中的所有成员

使用：System.out.println(members("setTest"));
结果：[ddd, bbb, aaa, ccc]

randomMember(String key)

随机获取key无序集合中的一个元素

使用：System.out.println("setTest:" + members("setTest"));
        System.out.println("setTestrandomMember:" + randomMember("setTest"));
        System.out.println("setTestrandomMember:" + randomMember("setTest"));
        System.out.println("setTestrandomMember:" + randomMember("setTest"));
        System.out.println("setTestrandomMember:" + randomMember("setTest"));
结果：setTest:[ddd, bbb, aaa, ccc]
setTestrandomMember:aaa
setTestrandomMember:bbb
setTestrandomMember:aaa
setTestrandomMember:ddd

distinctRandomMembers(String key, long count)

获取多个key无序集合中的元素（去重），count表示个数

使用：System.out.println("randomMembers:" + distinctRandomMembers("setTest",5));
结果：randomMembers:[aaa, bbb, ddd, ccc]

randomMembers(String key, long count)

获取多个key无序集合中的元素，count表示个数

使用：System.out.println("randomMembers:" + randomMembers("setTest",5));
结果：randomMembers:[ccc, ddd, ddd, ddd, aaa]

sscan(String key, ScanOptions options)

遍历set

使用： Cursor<Object> curosr = sscan("setTest", ScanOptions.NONE);
        while(curosr.hasNext()){
            System.out.println(curosr.next());
        }
结果：ddd
bbb
aaa
ccc

ZSet数据结构

add(String key, Object value, double score)

新增一个有序集合，存在的话为false，不存在的话为true

使用：System.out.println(add("zset1","zset-1",1.0));
结果：true

add(String key, Set<ZSetOperations.TypedTuple< Object>> tuples)

新增一个有序集合

使用：ZSetOperations.TypedTuple<Object> objectTypedTuple1 = new DefaultTypedTuple<Object>("zset-5",9.6);
        ZSetOperations.TypedTuple<Object> objectTypedTuple2 = new DefaultTypedTuple<Object>("zset-6",9.9);
        Set<ZSetOperations.TypedTuple<Object>> tuples = new HashSet<ZSetOperations.TypedTuple<Object>>();
        tuples.add(objectTypedTuple1);
        tuples.add(objectTypedTuple2);
        System.out.println(add("zset1",tuples));
        System.out.println(range("zset1",0,-1));
结果：[zset-1, zset-2, zset-3, zset-4, zset-5, zset-6]

remove(String key, Object... values)

从有序集合中移除一个或者多个元素

使用：System.out.println(range("zset1",0,-1));
        System.out.println(remove("zset1","zset-6"));
        System.out.println(range("zset1",0,-1));
结果：[zset-1, zset-2, zset-3, zset-4, zset-5, zset-6]
1
[zset-1, zset-2, zset-3, zset-4, zset-5]

incrementScore(String key, Object value, double score)

增加元素的score值，并返回增加后的值

使用：System.out.println(incrementScore("zset1","zset-1",1.1));  //原为1.1
结果：2.2

rank(String key, Object value)

返回有序集中指定成员的排名，其中有序集成员按分数值递增(从小到大)顺序排列

使用：System.out.println(range("zset1",0,-1));
        System.out.println(rank("zset1","zset-2"));
结果：[zset-2, zset-1, zset-3, zset-4, zset-5]
0   //表明排名第一

reverseRank(String key, Object value)

返回有序集中指定成员的排名，其中有序集成员按分数值递减(从大到小)顺序排列

使用：System.out.println(range("zset1",0,-1));
        System.out.println(reverseRank("zset1","zset-2"));
结果：[zset-2, zset-1, zset-3, zset-4, zset-5]
4 //递减之后排到第五位去了

range(String key, long start, long end)

通过索引区间返回有序集合成指定区间内的成员，其中有序集成员按分数值递增(从小到大)顺序排列

使用：System.out.println(range("zset1",0,-1));
结果：[zset-2, zset-1, zset-3, zset-4, zset-5]

rangeWithScores(String key, long start, long end)

通过索引区间返回有序集合成指定区间内的成员对象，其中有序集成员按分数值递增(从小到大)顺序排列

使用：Set<ZSetOperations.TypedTuple<Object>> tuples = rangeWithScores("zset1",0,-1);
        Iterator<ZSetOperations.TypedTuple<Object>> iterator = tuples.iterator();
        while (iterator.hasNext())
        {
            ZSetOperations.TypedTuple<Object> typedTuple = iterator.next();
            System.out.println("value:" + typedTuple.getValue() + "score:" + typedTuple.getScore());
        }
结果：value:zset-2score:1.2
value:zset-1score:2.2
value:zset-3score:2.3
value:zset-4score:6.6
value:zset-5score:9.6

rangeByScore(String key, double min, double max)

通过分数返回有序集合指定区间内的成员，其中有序集成员按分数值递增(从小到大)顺序排列

使用：System.out.println(rangeByScore("zset1",0,5));
结果：[zset-2, zset-1, zset-3]

rangeByScoreWithScores(String key, double min, double max)

使用：Set<ZSetOperations.TypedTuple<Object>> tuples = rangeByScoreWithScores("zset1",0,5);
        Iterator<ZSetOperations.TypedTuple<Object>> iterator = tuples.iterator();
        while (iterator.hasNext())
        {
            ZSetOperations.TypedTuple<Object> typedTuple = iterator.next();
            System.out.println("value:" + typedTuple.getValue() + "score:" + typedTuple.getScore());
        }
结果：value:zset-2score:1.2
value:zset-1score:2.2
value:zset-3score:2.3

通过分数返回有序集合指定区间内的成员对象，其中有序集成员按分数值递增(从小到大)顺序排列

rangeByScore(String key, double min, double max, long offset, long count)

通过分数返回有序集合指定区间内的成员，并在索引范围内，其中有序集成员按分数值递增(从小到大)顺序排列

使用： System.out.println(rangeByScore("zset1",0,5));
    System.out.println(rangeByScore("zset1",0,5,1,2));
结果：[zset-2, zset-1, zset-3]
[zset-1, zset-3]

rangeByScoreWithScores(String key, double min, double max, long offset, long count)

通过分数返回有序集合指定区间内的成员对象，并在索引范围内，其中有序集成员按分数值递增(从小到大)顺序排列

使用：Set<ZSetOperations.TypedTuple<Object>> tuples = rangeByScoreWithScores("zset1",0,5,1,2);
        Iterator<ZSetOperations.TypedTuple<Object>> iterator = tuples.iterator();
        while (iterator.hasNext())
        {
            ZSetOperations.TypedTuple<Object> typedTuple = iterator.next();
            System.out.println("value:" + typedTuple.getValue() + "score:" + typedTuple.getScore());
        }
结果：value:zset-1score:2.2
value:zset-3score:2.3

reverseRange(String key, long start, long end)

通过索引区间返回有序集合成指定区间内的成员，其中有序集成员按分数值递减(从大到小)顺序排列

使用：System.out.println(reverseRange("zset1",0,-1));
结果：[zset-5, zset-4, zset-3, zset-1, zset-2]

reverseRangeWithScores(String key, long start, long end)

通过索引区间返回有序集合成指定区间内的成员对象，其中有序集成员按分数值递减(从大到小)顺序排列

使用：Set<ZSetOperations.TypedTuple<Object>> tuples = reverseRangeWithScores("zset1",0,-1);
        Iterator<ZSetOperations.TypedTuple<Object>> iterator = tuples.iterator();
        while (iterator.hasNext())
        {
            ZSetOperations.TypedTuple<Object> typedTuple = iterator.next();
            System.out.println("value:" + typedTuple.getValue() + "score:" + typedTuple.getScore());
        }
结果：value:zset-5score:9.6
value:zset-4score:6.6
value:zset-3score:2.3
value:zset-1score:2.2
value:zset-2score:1.2

reverseRangeByScore(String key, double min, double max)

使用：与rangeByScore调用方法一样，其中有序集成员按分数值递减(从大到小)顺序排列

reverseRangeByScoreWithScores(String key, double min, double max)

使用：与rangeByScoreWithScores调用方法一样，其中有序集成员按分数值递减(从大到小)顺序排列

reverseRangeByScore(String key, double min, double max, long offset, long count)

使用：与rangeByScore调用方法一样，其中有序集成员按分数值递减(从大到小)顺序排列

reverseRangeByScoreWithScores(String key, double min, double max, long offset, long count)

使用：与rangeByScoreWithScores调用方法一样，其中有序集成员按分数值递减(从大到小)顺序排列

count(String key, double min, double max)

通过分数返回有序集合指定区间内的成员个数

使用：System.out.println(rangeByScore("zset1",0,5));
        System.out.println(count("zset1",0,5));
结果：[zset-2, zset-1, zset-3]
3

zsize(String key)

获取有序集合的成员数，内部调用的就是zCard方法

使用：System.out.println(zsize("zset1"));
结果：6

zCard(String key)

获取有序集合的成员数

使用：System.out.println(zCard("zset1"));
结果：6

score(String key, Object value)

获取指定成员的score值

使用：System.out.println(score("zset1","zset-1"));
结果：2.2

removeRange(String key, long start, long end)

移除指定索引位置的成员，其中有序集成员按分数值递增(从小到大)顺序排列

使用：System.out.println(range("zset2",0,-1));
        System.out.println(removeRange("zset2",1,2));
        System.out.println(range("zset2",0,-1));
结果：[zset-1, zset-2, zset-3, zset-4]
2
[zset-1, zset-4]

removeRangeByScore(String key, double min, double max)

根据指定的score值得范围来移除成员

使用：//System.out.println(add("zset2","zset-1",1.1));
        //System.out.println(add("zset2","zset-2",1.2));
        //System.out.println(add("zset2","zset-3",2.3));
        //System.out.println(add("zset2","zset-4",6.6));
System.out.println(range("zset2",0,-1));
System.out.println(removeRangeByScore("zset2",2,3));
    System.out.println(range("zset2",0,-1));
结果：[zset-1, zset-2, zset-3,zset-4]
1
[zset-1, zset-2, zset-4]

unionAndStore(String key, String otherKey, String destKey)

计算给定的一个有序集的并集，并存储在新的 destKey中，key相同的话会把score值相加

使用：System.out.println(add("zzset1","zset-1",1.0));
        System.out.println(add("zzset1","zset-2",2.0));
        System.out.println(add("zzset1","zset-3",3.0));
        System.out.println(add("zzset1","zset-4",6.0));

        System.out.println(add("zzset2","zset-1",1.0));
        System.out.println(add("zzset2","zset-2",2.0));
        System.out.println(add("zzset2","zset-3",3.0));
        System.out.println(add("zzset2","zset-4",6.0));
        System.out.println(add("zzset2","zset-5",7.0));
        System.out.println(unionAndStore("zzset1","zzset2","destZset11"));

        Set<ZSetOperations.TypedTuple<Object>> tuples = rangeWithScores("destZset11",0,-1);
        Iterator<ZSetOperations.TypedTuple<Object>> iterator = tuples.iterator();
        while (iterator.hasNext())
        {
            ZSetOperations.TypedTuple<Object> typedTuple = iterator.next();
            System.out.println("value:" + typedTuple.getValue() + "score:" + typedTuple.getScore());
        }
结果：value:zset-1score:2.0
value:zset-2score:4.0
value:zset-3score:6.0
value:zset-5score:7.0
value:zset-4score:12.0

unionAndStore(String key, Collection< String> otherKeys, String destKey)

计算给定的多个有序集的并集，并存储在新的 destKey中

使用：//System.out.println(add("zzset1","zset-1",1.0));
        //System.out.println(add("zzset1","zset-2",2.0));
        //System.out.println(add("zzset1","zset-3",3.0));
        //System.out.println(add("zzset1","zset-4",6.0));
        //
        //System.out.println(add("zzset2","zset-1",1.0));
        //System.out.println(add("zzset2","zset-2",2.0));
        //System.out.println(add("zzset2","zset-3",3.0));
        //System.out.println(add("zzset2","zset-4",6.0));
        //System.out.println(add("zzset2","zset-5",7.0));

        System.out.println(add("zzset3","zset-1",1.0));
        System.out.println(add("zzset3","zset-2",2.0));
        System.out.println(add("zzset3","zset-3",3.0));
        System.out.println(add("zzset3","zset-4",6.0));
        System.out.println(add("zzset3","zset-5",7.0));

        List<String> stringList = new ArrayList<String>();
        stringList.add("zzset2");
        stringList.add("zzset3");
        System.out.println(unionAndStore("zzset1",stringList,"destZset22"));

        Set<ZSetOperations.TypedTuple<Object>> tuples = rangeWithScores("destZset22",0,-1);
        Iterator<ZSetOperations.TypedTuple<Object>> iterator = tuples.iterator();
        while (iterator.hasNext())
        {
            ZSetOperations.TypedTuple<Object> typedTuple = iterator.next();
            System.out.println("value:" + typedTuple.getValue() + "score:" + typedTuple.getScore());
        }
结果：value:zset-1score:3.0
value:zset-2score:6.0
value:zset-3score:9.0
value:zset-5score:14.0
value:zset-4score:18.0

intersectAndStore(String key, String otherKey, String destKey)

计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中

使用：System.out.println(intersectAndStore("zzset1","zzset2","destZset33"));

        Set<ZSetOperations.TypedTuple<Object>> tuples = rangeWithScores("destZset33",0,-1);
        Iterator<ZSetOperations.TypedTuple<Object>> iterator = tuples.iterator();
        while (iterator.hasNext())
        {
            ZSetOperations.TypedTuple<Object> typedTuple = iterator.next();
            System.out.println("value:" + typedTuple.getValue() + "score:" + typedTuple.getScore());
        }
结果：value:zset-1score:2.0
value:zset-2score:4.0
value:zset-3score:6.0
value:zset-4score:12.0

intersectAndStore(String key, Collection< String> otherKeys, String destKey)

计算给定的一个或多个有序集的交集并将结果集存储在新的有序集合 key 中

使用：List<String> stringList = new ArrayList<String>();
        stringList.add("zzset2");
        stringList.add("zzset3");
        System.out.println(intersectAndStore("zzset1",stringList,"destZset44"));

        Set<ZSetOperations.TypedTuple<Object>> tuples = rangeWithScores("destZset44",0,-1);
        Iterator<ZSetOperations.TypedTuple<Object>> iterator = tuples.iterator();
        while (iterator.hasNext())
        {
            ZSetOperations.TypedTuple<Object> typedTuple = iterator.next();
            System.out.println("value:" + typedTuple.getValue() + "score:" + typedTuple.getScore());
        }
结果：value:zset-1score:3.0
value:zset-2score:6.0
value:zset-3score:9.0
value:zset-4score:18.0

zscan(String key, ScanOptions options)

遍历zset

使用： Cursor<ZSetOperations.TypedTuple<Object>> cursor = zscan("zzset1", ScanOptions.NONE);
        while (cursor.hasNext()){
            ZSetOperations.TypedTuple<Object> item = cursor.next();
            System.out.println(item.getValue() + ":" + item.getScore());
        }
结果：zset-1:1.0
zset-2:2.0
zset-3:3.0
zset-4:6.0

key操作

expire(String key, long timeout, TimeUnit unit)

设置key的失效时间，timeout是时间参数，timeunit是时间单位

expireAt(String key, Date date)

设置key在一个时间点失效

getExpire(String key)

获取key的存活时间

getExpire(String key, TimeUnit timeUnit)

获取key的存活时间，加上了时间单位

sort(SortQuery< String> query)

对列表、集合、有序集合的key进行排序，SortQuery是封装的对redis查询的类，返回值类型是List< Object>

SortQuery<String> query = SortQueryBuilder.sort("hanlist")// 排序的key
                                    //.by("pattern")       key的正则过滤
                                    .noSort()            //不使用正则过滤key
                                    .get("2")            //在value里过滤正则，可以连续写多个get
                                    .limit(0, 5)         //分页，和mysql一样
                                    .order(Order.DESC)   //正序or倒序
                                    .alphabetical(true)  //ALPHA修饰符用于对字符串进行排序，false的话只针对数字排序 
                                    .build();
redisTemplate.sort(query);

sort(SortQuery< String> query, BulkMapper<Object, Object> bulkMapper)

对列表、集合、有序集合的key进行排序，SortQuery是封装的对redis查询的类，BulkMapper可以把从redis里取出的元素转化成我们想要的对象，返回值类型是List< T>

BulkMapper<UserToken, Object> hm = new BulkMapper<UserToken, Object>() {
            @Override
            public UserToken mapBulk(List<Object> bulk) {// 实现BulkMapper接口的方法，来把获取到的排序的数据转换为我们需要的返回类型
                Iterator<Object> iterator = bulk.iterator();  
                UserToken userToken = new UserToken();
                userToken.setUserId((String)iterator.next());
                userToken.setLastTime((long)iterator.next());
                userToken.setElementids((LinkedList<String>)iterator.next());
                return userToken;
            }
        }; 
redisTemplate.sort(query, hm);

delete(String key)

删除指定key的缓存

delete(Collection< String> keys)

批量删除指定的key的缓存

hasKey(String key)

判断指定的key是否存在

rename(String oldKey, String newKey)

重新命名key

renameIfAbsent(String oldKey, String newKey)

重新命名key，如果key存在

keys(String pattern)

获取匹配正则的所有key

以上是关于redis接口手册的主要内容，如果未能解决你的问题，请参考以下文章

Redis实现分布式锁（设计模式应用实战）

Redis实现分布式锁（设计模式应用实战）

phpredis中文手册——《redis中文手册》 php版

sublime Text emmet插件使用手册

最全面的Redis命令行查阅手册（收藏查看）

转载：Emmet使用手册