redis使用实例

转：http://javacrazyer.iteye.com/blog/1840161

http://alanland.iteye.com/blog/1600685
三、redis常用命令
https://redis.readthedocs.org/en/latest/
1）连接操作命令

quit：关闭连接（connection）

auth：简单密码认证

help cmd： 查看cmd帮助，例如：help quit



2）持久化

save：将数据同步保存到磁盘

bgsave：将数据异步保存到磁盘

lastsave：返回上次成功将数据保存到磁盘的Unix时戳

shundown：将数据同步保存到磁盘，然后关闭服务



3）远程服务控制

info：提供服务器的信息和统计

monitor：实时转储收到的请求

slaveof：改变复制策略设置

config：在运行时配置Redis服务器



4）对value操作的命令

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）：获得一个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

Jedis 是 Redis 官方首选的 Java 客户端开发包。

工作过程总结的一个示例，贴出来，如下：

package com.wujintao.redis;  
  
import java.util.Date;  
import java.util.HashMap;  
import java.util.Iterator;  
import java.util.List;  
import java.util.Map;  
import java.util.Set;  
  
import org.junit.Test;  
  
import redis.clients.jedis.Jedis;  
import redis.clients.jedis.Pipeline;  
import redis.clients.jedis.SortingParams;  
  
import com.wujintao.redis.util.RedisUtil;  
  
  
public class TestCase {  
  
    /** 
     * 在不同的线程中使用相同的Jedis实例会发生奇怪的错误。但是创建太多的实现也不好因为这意味着会建立很多sokcet连接， 
     * 也会导致奇怪的错误发生。单一Jedis实例不是线程安全的。为了避免这些问题，可以使用JedisPool, 
     * JedisPool是一个线程安全的网络连接池。可以用JedisPool创建一些可靠Jedis实例，可以从池中拿到Jedis的实例。 
     * 这种方式可以解决那些问题并且会实现高效的性能 
     */  
  
    public static void main(String[] args) {  
  
        // ...when closing your application:  
        RedisUtil.getPool().destroy();  
  
    }  
  
    public static void Hello() {  
        Jedis jedis = RedisUtil.getJedis();  
        try {  
            // 向key-->name中放入了value-->minxr  
            jedis.set("name", "minxr");  
            String ss = jedis.get("name");  
            System.out.println(ss);  
  
            // 很直观，类似map 将jintao append到已经有的value之后  
            jedis.append("name", "jintao");  
            ss = jedis.get("name");  
            System.out.println(ss);  
  
            // 2、直接覆盖原来的数据  
            jedis.set("name", "jintao");  
            System.out.println(jedis.get("jintao"));  
  
            // 删除key对应的记录  
            jedis.del("name");  
            System.out.println(jedis.get("name"));// 执行结果：null  
  
            /** 
             * mset相当于 jedis.set("name","minxr"); jedis.set("jarorwar","aaa"); 
             */  
            jedis.mset("name", "minxr", "jarorwar", "aaa");  
            System.out.println(jedis.mget("name", "jarorwar"));  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            RedisUtil.getPool().returnResource(jedis);  
        }  
  
    }  
  
    private void testKey() {  
        Jedis jedis = RedisUtil.getJedis();  
        System.out.println("=============key==========================");  
        // 清空数据  
        System.out.println(jedis.flushDB());  
        System.out.println(jedis.echo("foo"));  
        // 判断key否存在  
        System.out.println(jedis.exists("foo"));  
        jedis.set("key", "values");  
        System.out.println(jedis.exists("key"));  
    }  
  
    public static void testString() {  
        System.out.println("==String==");  
        Jedis jedis = RedisUtil.getJedis();  
        try {  
            // String  
            jedis.set("key", "Hello World!");  
            String value = jedis.get("key");  
            System.out.println(value);  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            RedisUtil.getPool().returnResource(jedis);  
        }  
  
        System.out.println("=============String==========================");  
        // 清空数据  
        System.out.println(jedis.flushDB());  
        // 存储数据  
        jedis.set("foo", "bar");  
        System.out.println(jedis.get("foo"));  
        // 若key不存在，则存储  
        jedis.setnx("foo", "foo not exits");  
        System.out.println(jedis.get("foo"));  
        // 覆盖数据  
        jedis.set("foo", "foo update");  
        System.out.println(jedis.get("foo"));  
        // 追加数据  
        jedis.append("foo", " hello, world");  
        System.out.println(jedis.get("foo"));  
        // 设置key的有效期，并存储数据  
        jedis.setex("foo", 2, "foo not exits");  
        System.out.println(jedis.get("foo"));  
        try {  
            Thread.sleep(3000);  
        } catch (InterruptedException e) {  
        }  
        System.out.println(jedis.get("foo"));  
        // 获取并更改数据  
        jedis.set("foo", "foo update");  
        System.out.println(jedis.getSet("foo", "foo modify"));  
        // 截取value的值  
        System.out.println(jedis.getrange("foo", 1, 3));  
        System.out.println(jedis.mset("mset1", "mvalue1", "mset2", "mvalue2",  
                "mset3", "mvalue3", "mset4", "mvalue4"));  
        System.out.println(jedis.mget("mset1", "mset2", "mset3", "mset4"));  
        System.out.println(jedis.del(new String[] { "foo", "foo1", "foo3" }));  
    }  
  
    public static void testList() {  
        System.out.println("==List==");  
        Jedis jedis = RedisUtil.getJedis();  
        try {  
            // 开始前，先移除所有的内容  
            jedis.del("messages");  
            jedis.rpush("messages", "Hello how are you?");  
            jedis.rpush("messages", "Fine thanks. I'm having fun with redis.");  
            jedis.rpush("messages", "I should look into this NOSQL thing ASAP");  
  
            // 再取出所有数据jedis.lrange是按范围取出，  
            // 第一个是key，第二个是起始位置，第三个是结束位置，jedis.llen获取长度 -1表示取得所有  
            List<String> values = jedis.lrange("messages", 0, -1);  
            System.out.println(values);  
  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            RedisUtil.getPool().returnResource(jedis);  
        }  
  
        // 清空数据  
        System.out.println(jedis.flushDB());  
        // 添加数据  
        jedis.lpush("lists", "vector");  
        jedis.lpush("lists", "ArrayList");  
        jedis.lpush("lists", "LinkedList");  
        // 数组长度  
        System.out.println(jedis.llen("lists"));  
        // 排序  
        System.out.println(jedis.sort("lists"));  
        // 字串  
        System.out.println(jedis.lrange("lists", 0, 3));  
        // 修改列表中单个值  
        jedis.lset("lists", 0, "hello list!");  
        // 获取列表指定下标的值  
        System.out.println(jedis.lindex("lists", 1));  
        // 删除列表指定下标的值  
        System.out.println(jedis.lrem("lists", 1, "vector"));  
        // 删除区间以外的数据  
        System.out.println(jedis.ltrim("lists", 0, 1));  
        // 列表出栈  
        System.out.println(jedis.lpop("lists"));  
        // 整个列表值  
        System.out.println(jedis.lrange("lists", 0, -1));  
    }  
  
    public static void testSet() {  
        System.out.println("==Set==");  
        Jedis jedis = RedisUtil.getJedis();  
        try {  
            jedis.sadd("myset", "1");  
            jedis.sadd("myset", "2");  
            jedis.sadd("myset", "3");  
            jedis.sadd("myset", "4");  
            Set<String> setValues = jedis.smembers("myset");  
            System.out.println(setValues);  
  
            // 移除noname  
            jedis.srem("myset", "4");  
            System.out.println(jedis.smembers("myset"));// 获取所有加入的value  
            System.out.println(jedis.sismember("myset", "4"));// 判断 minxr  
                                                                // 是否是sname集合的元素  
            System.out.println(jedis.scard("sname"));// 返回集合的元素个数  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            RedisUtil.getPool().returnResource(jedis);  
        }  
  
        // 清空数据  
        System.out.println(jedis.flushDB());  
        // 添加数据  
        jedis.sadd("sets", "HashSet");  
        jedis.sadd("sets", "SortedSet");  
        jedis.sadd("sets", "TreeSet");  
        // 判断value是否在列表中  
        System.out.println(jedis.sismember("sets", "TreeSet"));  
        ;  
        // 整个列表值  
        System.out.println(jedis.smembers("sets"));  
        // 删除指定元素  
        System.out.println(jedis.srem("sets", "SortedSet"));  
        // 出栈  
        System.out.println(jedis.spop("sets"));  
        System.out.println(jedis.smembers("sets"));  
        //  
        jedis.sadd("sets1", "HashSet1");  
        jedis.sadd("sets1", "SortedSet1");  
        jedis.sadd("sets1", "TreeSet");  
        jedis.sadd("sets2", "HashSet2");  
        jedis.sadd("sets2", "SortedSet1");  
        jedis.sadd("sets2", "TreeSet1");  
        // 交集  
        System.out.println(jedis.sinter("sets1", "sets2"));  
        // 并集  
        System.out.println(jedis.sunion("sets1", "sets2"));  
        // 差集  
        System.out.println(jedis.sdiff("sets1", "sets2"));  
    }  
  
    public static void sortedSet() {  
        System.out.println("==SoretedSet==");  
        Jedis jedis = RedisUtil.getJedis();  
        try {  
            jedis.zadd("hackers", 1940, "Alan Kay");  
            jedis.zadd("hackers", 1953, "Richard Stallman");  
            jedis.zadd("hackers", 1965, "Yukihiro Matsumoto");  
            jedis.zadd("hackers", 1916, "Claude Shannon");  
            jedis.zadd("hackers", 1969, "Linus Torvalds");  
            jedis.zadd("hackers", 1912, "Alan Turing");  
            Set<String> setValues = jedis.zrange("hackers", 0, -1);  
            System.out.println(setValues);  
            Set<String> setValues2 = jedis.zrevrange("hackers", 0, -1);  
            System.out.println(setValues2);  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            RedisUtil.getPool().returnResource(jedis);  
        }  
  
        // 清空数据  
        System.out.println(jedis.flushDB());  
        // 添加数据  
        jedis.zadd("zset", 10.1, "hello");  
        jedis.zadd("zset", 10.0, ":");  
        jedis.zadd("zset", 9.0, "zset");  
        jedis.zadd("zset", 11.0, "zset!");  
        // 元素个数  
        System.out.println(jedis.zcard("zset"));  
        // 元素下标  
        System.out.println(jedis.zscore("zset", "zset"));  
        // 集合子集  
        System.out.println(jedis.zrange("zset", 0, -1));  
        // 删除元素  
        System.out.println(jedis.zrem("zset", "zset!"));  
        System.out.println(jedis.zcount("zset", 9.5, 10.5));  
        // 整个集合值  
        System.out.println(jedis.zrange("zset", 0, -1));  
    }  
  
    public static void testHsh() {  
        System.out.println("==Hash==");  
        Jedis jedis = RedisUtil.getJedis();  
        try {  
            Map<String, String> pairs = new HashMap<String, String>();  
            pairs.put("name", "Akshi");  
            pairs.put("age", "2");  
            pairs.put("sex", "Female");  
            jedis.hmset("kid", pairs);  
            List<String> name = jedis.hmget("kid", "name");// 结果是个泛型的LIST  
            // jedis.hdel("kid","age"); //删除map中的某个键值  
            System.out.println(jedis.hmget("kid", "pwd")); // 因为删除了，所以返回的是null  
            System.out.println(jedis.hlen("kid")); // 返回key为user的键中存放的值的个数  
            System.out.println(jedis.exists("kid"));// 是否存在key为user的记录  
            System.out.println(jedis.hkeys("kid"));// 返回map对象中的所有key  
            System.out.println(jedis.hvals("kid"));// 返回map对象中的所有value  
  
            Iterator<String> iter = jedis.hkeys("kid").iterator();  
            while (iter.hasNext()) {  
                String key = iter.next();  
                System.out.println(key + ":" + jedis.hmget("kid", key));  
            }  
  
            List<String> values = jedis.lrange("messages", 0, -1);  
            values = jedis.hmget("kid", new String[] { "name", "age", "sex" });  
            System.out.println(values);  
            Set<String> setValues = jedis.zrange("hackers", 0, -1);  
            setValues = jedis.hkeys("kid");  
            System.out.println(setValues);  
            values = jedis.hvals("kid");  
            System.out.println(values);  
            pairs = jedis.hgetAll("kid");  
            System.out.println(pairs);  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            RedisUtil.getPool().returnResource(jedis);  
        }  
  
        // 清空数据  
        System.out.println(jedis.flushDB());  
        // 添加数据  
        jedis.hset("hashs", "entryKey", "entryValue");  
        jedis.hset("hashs", "entryKey1", "entryValue1");  
        jedis.hset("hashs", "entryKey2", "entryValue2");  
        // 判断某个值是否存在  
        System.out.println(jedis.hexists("hashs", "entryKey"));  
        // 获取指定的值  
        System.out.println(jedis.hget("hashs", "entryKey")); // 批量获取指定的值  
        System.out.println(jedis.hmget("hashs", "entryKey", "entryKey1"));  
        // 删除指定的值  
        System.out.println(jedis.hdel("hashs", "entryKey"));  
        // 为key中的域 field 的值加上增量 increment  
        System.out.println(jedis.hincrBy("hashs", "entryKey", 123l));  
        // 获取所有的keys  
        System.out.println(jedis.hkeys("hashs"));  
        // 获取所有的values  
        System.out.println(jedis.hvals("hashs"));  
    }  
  
    public static void testOther() throws InterruptedException {  
        Jedis jedis = RedisUtil.getJedis();  
  
        try {  
            // keys中传入的可以用通配符  
            System.out.println(jedis.keys("*")); // 返回当前库中所有的key [sose, sanme,  
                                                    // name, jarorwar, foo,  
                                                    // sname, java framework,  
                                                    // user, braand]  
            System.out.println(jedis.keys("*name"));// 返回的sname [sname, name]  
            System.out.println(jedis.del("sanmdde"));// 删除key为sanmdde的对象 删除成功返回1  
                                                        // 删除失败（或者不存在）返回 0  
            System.out.println(jedis.ttl("sname"));// 返回给定key的有效时间，如果是-1则表示永远有效  
            jedis.setex("timekey", 10, "min");// 通过此方法，可以指定key的存活（有效时间） 时间为秒  
            Thread.sleep(5000);// 睡眠5秒后，剩余时间将为<=5  
            System.out.println(jedis.ttl("timekey")); // 输出结果为5  
            jedis.setex("timekey", 1, "min"); // 设为1后，下面再看剩余时间就是1了  
            System.out.println(jedis.ttl("timekey")); // 输出结果为1  
            System.out.println(jedis.exists("key"));// 检查key是否存在  
            System.out.println(jedis.rename("timekey", "time"));  
            System.out.println(jedis.get("timekey"));// 因为移除，返回为null  
            System.out.println(jedis.get("time")); // 因为将timekey 重命名为time  
                                                    // 所以可以取得值 min  
            // jedis 排序  
            // 注意，此处的rpush和lpush是List的操作。是一个双向链表（但从表现来看的）  
            jedis.del("a");// 先清除数据，再加入数据进行测试  
            jedis.rpush("a", "1");  
            jedis.lpush("a", "6");  
            jedis.lpush("a", "3");  
            jedis.lpush("a", "9");  
            System.out.println(jedis.lrange("a", 0, -1));// [9, 3, 6, 1]  
            System.out.println(jedis.sort("a")); // [1, 3, 6, 9] //输入排序后结果  
            System.out.println(jedis.lrange("a", 0, -1));  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            RedisUtil.getPool().returnResource(jedis);  
        }  
  
    }  
  
    @org.junit.Test  
    public void testUnUsePipeline() {  
        long start = new Date().getTime();  
  
        Jedis jedis = RedisUtil.getJedis();  
        for (int i = 0; i < 10000; i++) {  
            jedis.set("age1" + i, i + "");  
            jedis.get("age1" + i);// 每个操作都发送请求给redis-server  
        }  
        long end = new Date().getTime();  
  
        System.out.println("unuse pipeline cost:" + (end - start) + "ms");  
  
        RedisUtil.getPool().returnResource(jedis);  
    }  
  
    @org.junit.Test  
    /** 
     * 参考:http://blog.csdn.net/freebird_lb/article/details/7778919 
     */  
    public void testUsePipeline() {  
        long start = new Date().getTime();  
  
        Jedis jedis = RedisUtil.getJedis();  
        jedis.flushDB();  
        Pipeline p = jedis.pipelined();  
        for (int i = 0; i < 10000; i++) {  
            p.set("age2" + i, i + "");  
            System.out.println(p.get("age2" + i));  
        }  
        p.sync();// 这段代码获取所有的response  
  
        long end = new Date().getTime();  
  
        System.out.println("use pipeline cost:" + (end - start) + "ms");  
  
        RedisUtil.getPool().returnResource(jedis);  
    }  
  
  
    @org.junit.Test  
    /** 
     * 时间复杂度： 
          O(N+M*log(M))， N 为要排序的列表或集合内的元素数量， M 为要返回的元素数量。 
            如果只是使用 SORT 命令的 GET 选项获取数据而没有进行排序，时间复杂度 O(N)。 
     */  
    public void testSort1() {  
        // 排序默认以数字作为对象，值被解释为双精度浮点数，然后进行比较  
        Jedis redis = RedisUtil.getJedis();  
        // 一般SORT用法 最简单的SORT使用方法是SORT key。  
        redis.lpush("mylist", "1");  
        redis.lpush("mylist", "4");  
        redis.lpush("mylist", "6");  
        redis.lpush("mylist", "3");  
        redis.lpush("mylist", "0");  
        // List<String> list = redis.sort("sort");// 默认是升序  
        SortingParams sortingParameters = new SortingParams();  
        sortingParameters.desc();  
        // sortingParameters.alpha();//当数据集中保存的是字符串值时，你可以用 ALPHA  
        // 修饰符(modifier)进行排序。  
        sortingParameters.limit(0, 2);// 可用于分页查询  
        List<String> list = redis.sort("mylist", sortingParameters);// 默认是升序  
        for (int i = 0; i < list.size(); i++) {  
            System.out.println(list.get(i));  
        }  
        redis.flushDB();  
        RedisUtil.closeJedis(redis);  
    }  
  
    @org.junit.Test  
    /** 
     * sort list 
     * LIST结合hash的排序 
     */  
    public void testSort2() {  
        Jedis jedis = RedisUtil.getJedis();  
        jedis.del("user:66", "user:55", "user:33", "user:22", "user:11",  
                "userlist");  
        jedis.lpush("userlist", "33");  
        jedis.lpush("userlist", "22");  
        jedis.lpush("userlist", "55");  
        jedis.lpush("userlist", "11");  
  
        jedis.hset("user:66", "name", "66");  
        jedis.hset("user:55", "name", "55");  
        jedis.hset("user:33", "name", "33");  
        jedis.hset("user:22", "name", "79");  
        jedis.hset("user:11", "name", "24");  
        jedis.hset("user:11", "add", "beijing");  
        jedis.hset("user:22", "add", "shanghai");  
        jedis.hset("user:33", "add", "guangzhou");  
        jedis.hset("user:55", "add", "chongqing");  
        jedis.hset("user:66", "add", "xi'an");  
  
        SortingParams sortingParameters = new SortingParams();  
        // 符号 "->" 用于分割哈希表的键名(key name)和索引域(hash field)，格式为 "key->field" 。  
        sortingParameters.get("user:*->name");  
        sortingParameters.get("user:*->add");  
//      sortingParameters.by("user:*->name");  
//      sortingParameters.get("#");  
        List<String> result = jedis.sort("userlist", sortingParameters);  
        for (String item : result) {  
            System.out.println("item...." + item);  
        }  
        /** 
         * 对应的redis客户端命令是：sort ml get user*->name sort ml get user:*->name get 
         * user:*->add 
         */  
    }  
  
    @org.junit.Test  
    /** 
     * sort set 
     * SET结合String的排序 
     */  
    public void testSort3() {  
        Jedis jedis = RedisUtil.getJedis();  
        jedis.del("tom:friend:list", "score:uid:123", "score:uid:456",  
                "score:uid:789", "score:uid:101", "uid:123", "uid:456",  
                "uid:789", "uid:101");  
  
        jedis.sadd("tom:friend:list", "123"); // tom的好友列表  
        jedis.sadd("tom:friend:list", "456");  
        jedis.sadd("tom:friend:list", "789");  
        jedis.sadd("tom:friend:list", "101");  
  
        jedis.set("score:uid:123", "1000"); // 好友对应的成绩  
        jedis.set("score:uid:456", "6000");  
        jedis.set("score:uid:789", "100");  
        jedis.set("score:uid:101", "5999");  
  
        jedis.set("uid:123", "{'uid':123,'name':'lucy'}"); // 好友的详细信息  
        jedis.set("uid:456", "{'uid':456,'name':'jack'}");  
        jedis.set("uid:789", "{'uid':789,'name':'jay'}");  
        jedis.set("uid:101", "{'uid':101,'name':'jolin'}");  
  
        SortingParams sortingParameters = new SortingParams();  
  
        sortingParameters.desc();  
        // sortingParameters.limit(0, 2);  
        // 注意GET操作是有序的，GET user_name_* GET user_password_*  
        // 和 GET user_password_* GET user_name_*返回的结果位置不同  
        sortingParameters.get("#");// GET 还有一个特殊的规则—— "GET #"  
                                    // ，用于获取被排序对象(我们这里的例子是 user_id )的当前元素。  
        sortingParameters.get("uid:*");  
        sortingParameters.get("score:uid:*");  
        sortingParameters.by("score:uid:*");  
        // 对应的redis 命令是./redis-cli sort tom:friend:list by score:uid:* get # get  
        // uid:* get score:uid:*  
        List<String> result = jedis.sort("tom:friend:list", sortingParameters);  
        for (String item : result) {  
            System.out.println("item..." + item);  
        }  
  
    }  
  
    /** 
     *  
     * 只获取对象而不排序 BY 修饰符可以将一个不存在的 key 当作权重，让 SORT 跳过排序操作。 
     * 该方法用于你希望获取外部对象而又不希望引起排序开销时使用。 # 确保fake_key不存在 redis> EXISTS fake_key 
     * (integer) 0 # 以fake_key作BY参数，不排序，只GET name 和 GET password redis> SORT 
     * user_id BY fake_key GET # GET user_name_* GET user_password_* 1) "222" # 
     * id 2) "hacker" # user_name 3) "hey,im in" # password 4) "59230" 5) "jack" 
     * 6) "jack201022" 7) "2" 8) "huangz" 9) "nobodyknows" 10) "1" 11) "admin" 
     * 12) "a_long_long_password" 
     */  
    public void testSort4() {  
  
    }  
  
    /** 
     *  
     保存排序结果 默认情况下， SORT 操作只是简单地返回排序结果，如果你希望保存排序结果，可以给 STORE 选项指定一个 key 
     * 作为参数，排序结果将以列表的形式被保存到这个 key 上。(若指定 key 已存在，则覆盖。) redis> EXISTS 
     * user_info_sorted_by_level # 确保指定key不存在 (integer) 0 redis> SORT user_id BY 
     * user_level_* GET # GET user_name_* GET user_password_* STORE 
     * user_info_sorted_by_level # 排序 (integer) 12 # 显示有12条结果被保存了 redis> LRANGE 
     * user_info_sorted_by_level 0 11 # 查看排序结果 1) "59230" 2) "jack" 3) 
     * "jack201022" 4) "2" 5) "huangz" 6) "nobodyknows" 7) "222" 8) "hacker" 9) 
     * "hey,im in" 10) "1" 11) "admin" 12) "a_long_long_password" 一个有趣的用法是将 SORT 
     * 结果保存，用 EXPIRE 为结果集设置生存时间，这样结果集就成了 SORT 操作的一个缓存。 这样就不必频繁地调用 SORT 
     * 操作了，只有当结果集过期时，才需要再调用一次 SORT 操作。 
     * 有时候为了正确实现这一用法，你可能需要加锁以避免多个客户端同时进行缓存重建(也就是多个客户端，同一时间进行 SORT 
     * 操作，并保存为结果集)，具体参见 SETNX 命令。 
     */  
    @Test  
    public void testSort5() {  
        // 排序默认以数字作为对象，值被解释为双精度浮点数，然后进行比较  
        Jedis jedis = RedisUtil.getJedis();  
        // 一般SORT用法 最简单的SORT使用方法是SORT key。  
        jedis.lpush("mylist", "1");  
        jedis.lpush("mylist", "4");  
        jedis.lpush("mylist", "6");  
        jedis.lpush("mylist", "3");  
        jedis.lpush("mylist", "0");  
        // List<String> list = redis.sort("sort");// 默认是升序  
        SortingParams sortingParameters = new SortingParams();  
        sortingParameters.desc();  
        // sortingParameters.alpha();//当数据集中保存的是字符串值时，你可以用 ALPHA  
        // 修饰符(modifier)进行排序。  
        // sortingParameters.limit(0, 2);//可用于分页查询  
  
        // 没有使用 STORE 参数，返回列表形式的排序结果. 使用 STORE 参数，返回排序结果的元素数量。  
  
        jedis.sort("mylist", sortingParameters, "mylist");// 排序后指定排序结果到一个KEY中，这里讲结果覆盖原来的KEY  
  
        List<String> list = jedis.lrange("mylist", 0, -1);  
        for (int i = 0; i < list.size(); i++) {  
            System.out.println(list.get(i));  
        }  
  
        jedis.sadd("tom:friend:list", "123"); // tom的好友列表  
        jedis.sadd("tom:friend:list", "456");  
        jedis.sadd("tom:friend:list", "789");  
        jedis.sadd("tom:friend:list", "101");  
  
        jedis.set("score:uid:123", "1000"); // 好友对应的成绩  
        jedis.set("score:uid:456", "6000");  
        jedis.set("score:uid:789", "100");  
        jedis.set("score:uid:101", "5999");  
  
        jedis.set("uid:123", "{'uid':123,'name':'lucy'}"); // 好友的详细信息  
        jedis.set("uid:456", "{'uid':456,'name':'jack'}");  
        jedis.set("uid:789", "{'uid':789,'name':'jay'}");  
        jedis.set("uid:101", "{'uid':101,'name':'jolin'}");  
  
        sortingParameters = new SortingParams();  
        // sortingParameters.desc();  
        sortingParameters.get("#");// GET 还有一个特殊的规则—— "GET #"  
                                    // ，用于获取被排序对象(我们这里的例子是 user_id )的当前元素。  
        sortingParameters.by("score:uid:*");  
        jedis.sort("tom:friend:list", sortingParameters, "tom:friend:list");  
        List<String> result = jedis.lrange("tom:friend:list", 0, -1);  
        for (String item : result) {  
            System.out.println("item..." + item);  
        }  
  
        jedis.flushDB();  
        RedisUtil.closeJedis(jedis);  
    }  
      
      
    public void testMore(){  
        //ZRANGE取出最新的10个项目。  
        //使用LPUSH + LTRIM，确保只取出最新的1000条项目。  
        //HINCRBY key field increment,为哈希表 key 中的域 field 的值加上增量 increment  
        //INCRBY,HINCRBY等等，redis有了原子递增（atomic increment），你可以放心的加上各种计数，用GETSET重置，或者是让它们过期。  
        // LREM greet 2 morning     # 移除从表头到表尾，最先发现的两个 morning,这个可以用来删除特定评论  
        // zrevrank test a 查看a在sorted set中倒排序时排在第几名，查询结果按照INDEX，所以INDEX是3表示排在第四名  
        // zrank test a 相反，表示正排序时候的名次  
        // zscore test one表示one这个元素在sorted set中的score为多少  
        // zrevrange test 0 -1 表示sorted set倒排序,zrange test 0 -1表示正排序  
        //将一个或多个 member 元素及其 score 值加入到有序集 key 当中。如果某个 member 已经是有序集的成员，那么更新这个 member 的 score 值，并通过重新插入这个 member 元素，来保证该 member 在正确的位置上。  
        //zrem test one删除sorted set中某个元素  
    }  
      
    public List<String> get_latest_comments(int start, int num_items){  
        //获取最新评论  
        //LPUSH latest.comments <ID>   
        //-我们将列表裁剪为指定长度，因此Redis只需要保存最新的5000条评论：  
        //LTRIM latest.comments 0 5000   
        //们做了限制不能超过5000个ID，因此我们的获取ID函数会一直询问Redis。只有在start/count参数超出了这个范围的时候，才需要去访问数据库。  
        Jedis jedis = RedisUtil.getJedis();  
        List<String> id_list = jedis.lrange("latest.comments",start,start+num_items-1) ;  
          
        if(id_list.size()<num_items){  
            //id_list = SQL.EXECUTE("SELECT ... ORDER BY time LIMIT ...");  
        }  
        return id_list;  
    }  
             
      
  
    @Test  
    public void testDB() {  
        Jedis jedis = RedisUtil.getJedis();  
        System.out.println(jedis.select(0));// select db-index  
                                            // 通过索引选择数据库，默认连接的数据库所有是0,默认数据库数是16个。返回1表示成功，0失败  
        System.out.println(jedis.dbSize());// dbsize 返回当前数据库的key数量  
        System.out.println(jedis.keys("*")); // 返回匹配指定模式的所有key  
        System.out.println(jedis.randomKey());  
        jedis.flushDB();// 删除当前数据库中所有key,此方法不会失败。慎用  
        jedis.flushAll();// 删除所有数据库中的所有key，此方法不会失败。更加慎用  
  
    }  
  
    @Test  
    public void testMget() {  
  
        Jedis jedis = RedisUtil.getJedis();  
        jedis.flushDB();// 删除当前数据库中所有key,此方法不会失败。慎用  
  
        jedis.rpush("ids", "aa");  
        jedis.rpush("ids", "bb");  
        jedis.rpush("ids", "cc");  
  
        List<String> ids = jedis.lrange("ids", 0, -1);  
  
        jedis.set("aa", "{'name':'zhoujie','age':20}");  
        jedis.set("bb", "{'name':'yilin','age':28}");  
        jedis.set("cc", "{'name':'lucy','age':21}");  
        List<String> list = jedis.mget(ids.toArray(new String[ids.size()]));  
        System.out.println(list);  
    }  
  
    /** 
     * 可以利用lrange对list进行分页操作 
     */  
    @Test  
    public void queryPageBy() {  
        int pageNo = 6;  
        int pageSize = 6;  
        Jedis jedis = RedisUtil.getJedis();  
        jedis.del("a");  
        for (int i = 1; i <= 30; i++) {  
            jedis.rpush("a", i + "");  
        }  
  
        int start = pageSize * (pageNo - 1);// 因为redis中list元素位置基数是0  
        int end = start + pageSize - 1;  
  
        List<String> results = jedis.lrange("a", start, end);// 从start算起，start算一个元素，到结束那个元素  
        for (String str : results) {  
            System.out.println(str);  
        }  
  
    }  
  
    @Test  
    /** 
     * [向Redis list压入ID而不是实际的数据] 
        在上面的例子里 ，我们将“对象”（此例中是简单消息）直接压入Redis list，但通常不应这么做， 
        由于对象可能被多次引用：例如在一个list中维护其时间顺序，在一个集合中保存它的类别，只要有必要，它还会出现在其他list中，等等。 
        让我们回到reddit.com的例子，将用户提交的链接（新闻）添加到list中，有更可靠的方法如下所示： 
        $ redis-cli incr next.news.id 
        (integer) 1 
        $ redis-cli set news:1:title "Redis is simple" 
        OK 
        $ redis-cli set news:1:url "http://code.google.com/p/redis" 
        OK 
        $ redis-cli lpush submitted.news 1 
        OK 
        我们自增一个key，很容易得到一个独一无二的自增ID，然后通过此ID创建对象–为对象的每个字段设置一个key。最后将新对象的ID压入submitted.news list。 
        这只是牛刀小试。在命令参考文档中可以读到所有和list有关的命令。你可以删除元素，旋转list，根据索引获取和设置元素，当然也可以用LLEN得到list的长度。 
     */  
    public void testListStrUsage() {  
        String title = "太阳能是绿色能源4";  
        String url = "http://javacreazyer.iteye.com";  
        Jedis jedis = RedisUtil.getJedis();  
  
        long adInfoId = jedis.incr("ad:adinfo:next.id");  
        jedis.set("ad:adinfo:" + adInfoId + ":title", title);  
        jedis.set("ad:adinfo:" + adInfoId + ":url", url);  
        jedis.lpush("ad:adinfo", String.valueOf(adInfoId));  
  
        String resultTitle = jedis.get("ad:adinfo:" + adInfoId + ":title");  
        String resultUrl = jedis.get("ad:adinfo:" + adInfoId + ":url");  
        List<String> ids = jedis.lrange("ad:adinfo", 0, -1);  
        System.out.println(resultTitle);  
        System.out.println(resultUrl);  
        System.out.println(ids);  
  
        /** 
         * dbsize返回的是所有key的数目，包括已经过期的， 而redis-cli keys "*"查询得到的是有效的key数目 
         */  
        System.out.println(jedis.dbSize());  
  
        jedis.flushAll();  
    }  
  
    /** 
     * 下面是一个简单的方案：对每个想加标签的对象，用一个标签ID集合与之关联，并且对每个已有的标签，一组对象ID与之关联。 例如假设我们的新闻ID 
     * 1000被加了三个标签tag 1,2,5和77，就可以设置下面两个集合： $ redis-cli sadd news:1000:tags 1 
     * (integer) 1 $ redis-cli sadd news:1000:tags 2 (integer) 1 $ redis-cli 
     * sadd news:1000:tags 5 (integer) 1 $ redis-cli sadd news:1000:tags 77 
     * (integer) 1 $ redis-cli sadd tag:1:objects 1000 (integer) 1 $ redis-cli 
     * sadd tag:2:objects 1000 (integer) 1 $ redis-cli sadd tag:5:objects 1000 
     * (integer) 1 $ redis-cli sadd tag:77:objects 1000 (integer) 1 
     * 要获取一个对象的所有标签，如此简单： $ redis-cli smembers news:1000:tags 1. 5 2. 1 3. 77 4. 
     * 2 而有些看上去并不简单的操作仍然能使用相应的Redis命令轻松实现。例如我们也许想获得一份同时拥有标签1, 2, 
     * 10和27的对象列表。这可以用SINTER命令来做，他可以在不同集合之间取出交集。因此为达目的我们只需： $ redis-cli sinter 
     * tag:1:objects tag:2:objects tag:10:objects tag:27:objects ... no result 
     * in our dataset composed of just one object ... 
     * 在命令参考文档中可以找到和集合相关的其他命令，令人感兴趣的一抓一大把。一定要留意SORT命令，Redis集合和list都是可排序的。 
     */  
    @Test  
    public void testSetUsage() {  
        Jedis jedis = RedisUtil.getJedis();  
        jedis.sadd("zhongsou:news:1000:tags", "1");  
        jedis.sadd("zhongsou:news:1000:tags", "2");  
        jedis.sadd("zhongsou:news:1000:tags", "5");  
        jedis.sadd("zhongsou:news:1000:tags", "77");  
        jedis.sadd("zhongsou:news:2000:tags", "1");  
        jedis.sadd("zhongsou:news:2000:tags", "2");  
        jedis.sadd("zhongsou:news:2000:tags", "5");  
        jedis.sadd("zhongsou:news:2000:tags", "77");  
        jedis.sadd("zhongsou:news:3000:tags", "2");  
        jedis.sadd("zhongsou:news:4000:tags", "77");  
        jedis.sadd("zhongsou:news:5000:tags", "1");  
        jedis.sadd("zhongsou:news:6000:tags", "5");  
  
        jedis.sadd("zhongsou:tag:1:objects", 1000 + "");  
        jedis.sadd("zhongsou:tag:2:objects", 1000 + "");  
        jedis.sadd("zhongsou:tag:5:objects", 1000 + "");  
        jedis.sadd("zhongsou:tag:77:objects", 1000 + "");  
  
        jedis.sadd("zhongsou:tag:1:objects", 2000 + "");  
        jedis.sadd("zhongsou:tag:2:objects", 2000 + "");  
        jedis.sadd("zhongsou:tag:5:objects", 2000 + "");  
        jedis.sadd("zhongsou:tag:77:objects", 2000 + "");  
  
        Set<String> sets = jedis.sinter("zhongsou:tag:1:objects",  
                "zhongsou:tag:2:objects", "zhongsou:tag:5:objects",  
                "zhongsou:tag:77:objects");  
        System.out.println(sets);  
        jedis.flushAll();  
    }  
  
    @Test  
    public void testSortedSetUsage() {  
        Jedis jedis = RedisUtil.getJedis();  
        jedis.zadd("zhongsou:hackers", 1940, "Alan Kay");  
        jedis.zadd("zhongsou:hackers", 1953, "Richard Stallman");  
        jedis.zadd("zhongsou:hackers", 1943, "Jay");  
        jedis.zadd("zhongsou:hackers", 1920, "Jellon");  
        jedis.zadd("zhongsou:hackers", 1965, "Yukihiro Matsumoto");  
        jedis.zadd("zhongsou:hackers", 1916, "Claude Shannon");  
        jedis.zadd("zhongsou:hackers", 1969, "Linus Torvalds");  
        jedis.zadd("zhongsou:hackers", 1912, "Alan Turing");  
  
        Set<String> hackers = jedis.zrange("zhongsou:hackers", 0, -1);  
        System.out.println(hackers);  
  
        Set<String> hackers2 = jedis.zrevrange("zhongsou:hackers", 0, -1);  
        System.out.println(hackers2);  
  
        // 区间操作,我们请求Redis返回score介于负无穷到1920年之间的元素（两个极值也包含了）。  
        Set<String> hackers3 = jedis.zrangeByScore("zhongsou:hackers", "-inf",  
                "1920");  
        System.out.println(hackers3);  
  
        // ZREMRANGEBYSCORE 这个名字虽然不算好，但他却非常有用，还会返回已删除的元素数量。  
        long num = jedis.zremrangeByScore("zhongsou:hackers", "-inf", "1920");  
        System.out.println(num);  
  
        jedis.flushAll();  
    }  
  
}

package org.senssic.redis;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public final class JedisUtil {
    
    //Redis服务器IP
    private static String ADDR = "192.168.0.100";
    
    //Redis的端口号
    private static int PORT = 6379;
    
    //访问密码
    private static String AUTH = "admin";
    
    //可用连接实例的最大数目，默认值为8；
    //如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
    private static int MAX_ACTIVE = 1024;
    
    //控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
    private static int MAX_IDLE = 200;
    
    //等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
    private static int MAX_WAIT = 10000;
    
    private static int TIMEOUT = 10000;
    
    //在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
    private static boolean TEST_ON_BORROW = true;
    
    private static JedisPool jedisPool = null;
    
    /**
     * 初始化Redis连接池
     */
    static {
        try {
            JedisPoolConfig config = new JedisPoolConfig();
            config.setMaxActive(MAX_ACTIVE);
            config.setMaxIdle(MAX_IDLE);
            config.setMaxWait(MAX_WAIT);
            config.setTestOnBorrow(TEST_ON_BORROW);
            jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT, AUTH);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public synchronized static JedisPool getPool(){
    <span style="white-space:pre">	</span>return jedisPool;
    }
    /**
     * 获取Jedis实例
     * @return
     */
    public synchronized static Jedis getJedis() {
        try {
            if (jedisPool != null) {
                Jedis resource = jedisPool.getResource();
                return resource;
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    
    /**
     * 释放jedis资源
     * @param jedis
     */
    public static void closeJedis(final Jedis jedis) {
        if (jedis != null) {
            jedisPool.returnResource(jedis);
        }
    }
}

附加一个工作中常用到的Jedis工具类，如下：

package com.zhongsou.vertportal.util;  
  
import java.util.HashMap;  
import java.util.Map;  
  
import org.slf4j.Logger;  
import org.slf4j.LoggerFactory;  
  
import redis.clients.jedis.Jedis;  
import redis.clients.jedis.JedisPool;  
import redis.clients.jedis.JedisPoolConfig;  
  
import com.zhongsou.vertportal.conf.BaseConfig;  
import com.zhongsou.vertportal.conf.RedisConfig;  
  
/** 
 * Redis工具类,用于获取RedisPool. 
 * 参考官网说明如下： 
 * You shouldn't use the same instance from different threads because you'll have strange errors. 
 * And sometimes creating lots of Jedis instances is not good enough because it means lots of sockets and connections, 
 * which leads to strange errors as well. A single Jedis instance is not threadsafe! 
 * To avoid these problems, you should use JedisPool, which is a threadsafe pool of network connections. 
 * This way you can overcome those strange errors and achieve great performance. 
 * To use it, init a pool: 
 *  JedisPool pool = new JedisPool(new JedisPoolConfig(), "localhost"); 
 *  You can store the pool somewhere statically, it is thread-safe. 
 *  JedisPoolConfig includes a number of helpful Redis-specific connection pooling defaults. 
 *  For example, Jedis with JedisPoolConfig will close a connection after 300 seconds if it has not been returned. 
 * @author wujintao 
 */  
public class JedisUtil  {  
    protected Logger log = LoggerFactory.getLogger(getClass());  
      
    /** 
     * 私有构造器. 
     */  
    private JedisUtil() {  
          
    }  
    private static Map<String,JedisPool> maps  = new HashMap<String,JedisPool>();  
      
      
    /** 
     * 获取连接池. 
     * @return 连接池实例 
     */  
    private static JedisPool getPool(String ip,int port) {  
        String key = ip+":" +port;  
        JedisPool pool = null;  
        if(!maps.containsKey(key)) {  
            JedisPoolConfig config = new JedisPoolConfig();  
            config.setMaxActive(RedisConfig.getMaxactive());  
            config.setMaxIdle(RedisConfig.getMaxidle());  
            config.setMaxWait(RedisConfig.getMaxwait());  
            config.setTestOnBorrow(true);  
            config.setTestOnReturn(true);  
            try{    
                /** 
                 *如果你遇到 java.net.SocketTimeoutException: Read timed out exception的异常信息 
                 *请尝试在构造JedisPool的时候设置自己的超时值. JedisPool默认的超时时间是2秒(单位毫秒) 
                 */  
                pool = new JedisPool(config, ip, port,RedisConfig.getTimeout());  
                maps.put(key, pool);  
            } catch(Exception e) {  
                e.printStackTrace();  
            }  
        }else{  
            pool = maps.get(key);  
        }  
        return pool;  
    }  
  
    /** 
     *类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例 
     *没有绑定关系，而且只有被调用到时才会装载，从而实现了延迟加载。 
     */  
    private static class RedisUtilHolder{  
        /** 
         * 静态初始化器，由JVM来保证线程安全 
         */  
        private static JedisUtil instance = new JedisUtil();  
    }  
  
    /** 
     *当getInstance方法第一次被调用的时候，它第一次读取 
     *RedisUtilHolder.instance，导致RedisUtilHolder类得到初始化；而这个类在装载并被初始化的时候，会初始化它的静 
     *态域，从而创建RedisUtil的实例，由于是静态的域，因此只会在虚拟机装载类的时候初始化一次，并由虚拟机来保证它的线程安全性。 
     *这个模式的优势在于，getInstance方法并没有被同步，并且只是执行一个域的访问，因此延迟初始化并没有增加任何访问成本。 
     */  
    public static JedisUtil getInstance() {  
        return RedisUtilHolder.instance;  
    }  
      
    /** 
     * 获取Redis实例. 
     * @return Redis工具类实例 
     */  
    public Jedis getJedis(String ip,int port) {  
        Jedis jedis  = null;  
        int count =0;  
        do{  
            try{   
                jedis = getPool(ip,port).getResource();  
                //log.info("get redis master1!");  
            } catch (Exception e) {  
                log.error("get redis master1 failed!", e);  
                 // 销毁对象    
                getPool(ip,port).returnBrokenResource(jedis);    
            }  
            count++;  
        }while(jedis==null&&count<BaseConfig.getRetryNum());  
        return jedis;  
    }  
  
    /** 
     * 释放redis实例到连接池. 
     * @param jedis redis实例 
     */  
    public void closeJedis(Jedis jedis,String ip,int port) {  
        if(jedis != null) {  
            getPool(ip,port).returnResource(jedis);  
        }  
    }  
}

Jedis接口分类说明

1. 字符串数据类型（String）接口说明

字符串类型是Redis中最为基础的数据存储类型，它在Redis中是二进制安全的，这便意味着该类型可以接受任何格式的数据，如JPEG图像数据或Json对象描述信息等。在Redis中字符串类型的Value最多可以容纳的数据长度是512M。

#设定该Key持有指定的字符串Value，如果该Key已经存在，则覆盖其原有值。

void set(final String key, final String value)

#获取指定Key的Value，如果该Key不存在，返回null。

byte[] get(final String key)

#判断该键是否存在，存在返回1，否则返回0

boolean exists(final String key)

//删除指定的Key

long delete(final String... keys)

//重命名指定的Key, 如果参数中的两个Keys的命令相同，或者是源Key不存在，该命令都会返回相关的错误信息。如果newKey已经存在，则直接覆盖。

void rename(final String oldkey, final String newkey)

//如果新值不存在，则将参数中的原值修改为新值。其它条件和RENAME一致。

boolean renamenx(final String oldkey, final String newkey)

//设置某个key的过期时间（单位：秒）, 在超过该时间后，Key被自动的删除。如果该Key在超时之前被修改，与该键关联的超时将被移除。

boolean expire(final String key, final int seconds)

# EXPIREAT 的作用和 EXPIRE 类似，都用于为 key 设置生存时间。不同在于 EXPIREAT 命令接受的时间参数是 UNIX 时间戳(unix timestamp)。

boolean expireAt(final String key, final long unixTime)

#通过ttl命令查看一下指定Key的剩余存活时间(秒数)，0表示已经过期，-1表示永不过期。long ttl(final String key)

#将当前数据库中的mysetkey键移入到ID为dbIndex的数据库中

boolean move(final String key, final int dbIndex)

#原子性的设置该Key为指定的Value，返回该Key的原有值，如果该Key之前并不存在，则返回null。

byte[] getSet(final String key, final String value)

#返回一组指定Keys的Values的列表。

List<byte[]> mget(final String... keys)

#如果指定的Key不存在，则设定该Key持有指定字符串Value，此时其效果等价于SET命令。相反，如果该Key已经存在，该命令将不做任何操作并返回。

boolean setnx(final String key, final String value)

boolean setex(final String key, final int seconds, final String value)

#该命令原子性的完成参数中所有key/value的设置操作，如果在这一批Keys中有任意一个Key已经存在了，那么该操作将全部回滚，即所有的修改都不会生效。

boolean msetnx(final String... keysvalues)

#将指定Key的Value原子性的递增1。如果该Key不存在，其初始值为0，在incr之后其值为1,返回递增后的值。

void incrBy(final String key, final long integer) {

void incr(final String key)

#将指定Key的Value原子性的递减1。如果该Key不存在，其初始值为-1，在incr之后其值为1,返回递减后的值。

long decrBy(final String key, final long integer)

long decr(final String key)

#如果该Key已经存在，APPEND命令将参数Value的数据追加到已存在Value的末尾。如果该Key不存在，APPEND命令将会创建一个新的Key/Value。返回追加后的Value的长度。

long append(final String key, final String value)

2. 字符链表（List）数据类型接口说明

在Redis中，List类型是按照插入顺序排序的字符串链表。和数据结构中的普通链表一样，我们可以在其头部(left)和尾部(right)添加新的元素。在插入时，如果该键并不存在，Redis将为该键创建一个新的链表。与此相反，如果链表中所有的元素均被移除，那么该键也将会被从数据库中删除。List中可以包含的最大元素数量是4,294,967,295(42亿左右)。

#在指定Key所关联的List Value的尾部插入参数中给出的所有Values。如果该Key不存在，该命令将在插入之前创建一个与该Key关联的空链表，之后再将数据从链表的尾部插入。如果该键的Value不是链表类型，该命令将返回相关的错误信息。

void rpush(final String key, final String... string)

#在指定Key所关联的List Value的头部插入参数中给出的所有Values。如果该Key不存在，该命令将在插入之前创建一个与该Key关联的空链表，之后再将数据从链表的头部插入。如果该键的Value不是链表类型，该命令将返回相关的错误信息。

void lpush(final String key, final String... string)

#返回指定Key关联的链表中元素的数量，如果该Key不存在，则返回0。如果与该Key关联的Value的类型不是链表，则返回相关的错误信息。

long llen(final String key)

#返回指定范围内元素的列表。该命令的参数start和end都是0-based。即0表示链表头部(leftmost)的第一个元素。其中start的值也可以为负值，-1将表示链表中的最后一个元素，即尾部元素，-2表示倒数第二个并以此类推。该命令在获取元素时，start和end位置上的元素也会被取出。如果start的值大于链表中元素的数量，空链表将会被返回。如果end的值大于元素的数量，该命令则获取从start(包括start)开始，链表中剩余的所有元素。

List<byte[]> lrange(final String key, final long start, final long end)

#该命令将仅保留指定范围内的元素，从而保证链接中的元素数量相对恒定。start和stop参数都是0-based，0表示头部元素。和其他命令一样，start和stop也可以为负值，-1表示尾部元素。如果start大于链表的尾部，或start大于stop，该命令不错报错，而是返回一个空的链表，与此同时该Key也将被删除。如果stop大于元素的数量，则保留从start开始剩余的所有元素。

void ltrim(final String key, final long start, final long end)

#该命令将返回链表中指定位置(index)的元素，index是0-based，表示头部元素，如果index为-1，表示尾部元素。如果与该Key关联的不是链表，该命令将返回相关的错误信息。

byte[] lindex(final String key, final long index)

#设定链表中指定位置的值为新值，其中0表示第一个元素，即头部元素，-1表示尾部元素。如果索引值Index超出了链表中元素的数量范围，该命令将返回相关的错误信息。

void lset(final String key, final long index, final String value)

#在指定Key关联的链表中，删除前count个值等于value的元素。如果count大于0，从头向尾遍历并删除，如果count小于0，则从尾向头遍历并删除。如果count等于0，则删除链表中所有等于value的元素。如果指定的Key不存在，则直接返回0,返回被删除的元素数量。

long lrem(final String key, long count, final String value)

#返回并弹出指定Key关联的链表中的第一个元素，即头部元素。如果该Key不存，返回null。

byte[] lpop(final String key)

#返回并弹出指定Key关联的链表中的最后一个元素，即尾部元素。如果该Key不存，返回nil。

byte[] rpop(final String key)

#原子性的从与srckey键关联的链表尾部弹出一个元素，同时再将弹出的元素插入到与dstkey键关联的链表的头部。如果srckey键不存在，该命令将返回null，同时不再做任何其它的操作了。如果srckey和dstkey是同一个键，则相当于原子性的将其关联链表中的尾部元素移到该链表的头部。

byte[] rpoplpush(final String srckey, final String dstkey)

3. Hashes数据类型接口说明

我们可以将Redis中的Hashes类型看成具有String Key和String Value的map容器。所以该类型非常适合于存储值对象的信息。如Username、Password和Age等。如果Hash中包含很少的字段，那么该类型的数据也将仅占用很少的磁盘空间。每一个Hash可以存储4,294,967,295个键值对。

#为指定的Key设定Field/Value对，如果Key不存在，该命令将创建新Key以参数中的Field/Value对，如果参数中的Field在该Key中已经存在，则用新值覆盖其原有值。

boolean hset(final String key, final String field, final String value)

#返回参数中Field的关联值，如果参数中的Key或Field不存，返回null。

void hget(final String key, final String field)

#只有当参数中的Key或Field不存在的情况下，为指定的Key设定Field/Value对，否则该命令不会进行任何操作。

void hsetnx(final String key, final String field, final String value)

#逐对依次设置参数中给出的Field/Value对。如果其中某个Field已经存在，则用新值覆盖原有值。如果Key不存在，则创建新Key，同时设定参数中的Field/Value。

void hmset(final String key, final Map<String, String> hash)

#获取和参数中指定Fields关联的一组Values。如果请求的Field不存在，其值返回null。如果Key不存在，该命令将其视为空Hash，因此返回一组null。

byte[] hmget(final String key, final String... fields)

#增加指定Key中指定Field关联的Value的值。如果Key或Field不存在，该命令将会创建一个新Key或新Field，并将其关联的Value初始化为0，之后再指定数字增加的操作。返回运算后的值

long hincrBy(final String key, final String field, final long value)

#判断指定Key中的指定Field是否存在。

void hexists(final String key, final String field)

#从指定Key的Hashes Value中删除参数中指定的多个字段，如果不存在的字段将被忽略。如果Key不存在，则将其视为空Hashes，并返回0.返回实际删除的Field数量。

void hdel(final String key, final String... fields)

#获取该Key所包含的Field的数量。

void hlen(final String key)

#返回指定Key的所有Fields名。

List<byte[]> hkeys(final String key)

#返回指定Key的所有Values名。

List<byte[]> hvals(final String key)

#获取该键包含的所有Field/Value。其返回格式为一个Field、一个Value，并以此类推。

Map<byte[], byte[]> hgetAll(final String key)

4. 字符集合（Set）数据类型接口说明

在Redis中，我们可以将Set类型看作为没有排序的字符集合，和List类型一样，我们也可以在该类型的数据值上执行添加、删除或判断某一元素是否存在等操作。需要说明的是，这些操作的时间复杂度为O(1)，即常量时间内完成次操作。Set可包含的最大元素数量是4,294,967,295。

和List类型不同的是，Set集合中不允许出现重复的元素，这一点和C++标准库中的set容器是完全相同的。换句话说，如果多次添加相同元素，Set中将仅保留该元素的一份拷贝。和List类型相比，Set类型在功能上还存在着一个非常重要的特性，即在服务器端完成多个Sets之间的聚合计算操作，如unions、intersections和differences。由于这些操作均在服务端完成，因此效率极高，而且也节省了大量的网络IO开销。

#如果在插入的过程用，参数中有的成员在Set中已经存在，该成员将被忽略，而其它成员仍将会被正常插入。如果执行该命令之前，该Key并不存在，该命令将会创建一个新的Set，此后再将参数中的成员陆续插入。如果该Key的Value不是Set类型，该命令将返回相关的错误信息。

boolean sadd(final String key, final String... members)

#获取与该Key关联的Set中所有的成员。

List<byte[]> smembers(final String key)

#从与Key关联的Set中删除参数中指定的成员，不存在的参数成员将被忽略，如果该Key并不存在，将视为空Set处理。

void srem(final String key, final String... members)

#随机的移除并返回Set中的某一成员。由于Set中元素的布局不受外部控制，因此无法像List那样确定哪个元素位于Set的头部或者尾部。

byte[] spop(final String key)

#原子性的将参数中的成员从srckey 键移入到dstkey键所关联的Set中。因此在某一时刻，该成员或者出现在source中，或者出现在dstkey中。如果该成员在srckey中并不存在，该命令将不会再执行任何操作并返回0，否则，该成员将从srckey移入到dstkey。如果此时该成员已经在dstkey中存在，那么该命令仅是将该成员从srckey中移出。如果和Key关联的Value不是Set，将返回相关的错误信息。

boolean smove(final String srckey, final String dstkey,final String member)

#获取Set中成员的数量。

long scard(final String key)

#判断参数中指定成员是否已经存在于与Key相关联的Set集合中。

boolean sismember(final String key, final String member)

#该命令将返回参数中所有Keys关联的Sets中成员的交集。因此如果参数中任何一个Key关联的Set为空，或某一Key不存在，那么该命令的结果将为空集。

List<byte[]> sinter(final String... keys)

#该命令和sinter 命令在功能上完全相同，两者之间唯一的差别是sinter返回交集的结果成员，而该命令将交集成员存储在dstkey关联的Set中。如果dstkey键已经存在，该操作将覆盖它的成员。

void sinterstore(final String dstkey, final String... keys)

#该命令将返回参数中所有Keys关联的Sets中成员的并集。

List<byte[]> sunion(final String... keys)

#该命令和sunion命令在功能上完全相同，两者之间唯一的差别是sunion返回并集的结果成员，而该命令将并集成员存储在dstkey关联的Set中。如果dstkey键已经存在，该操作将覆盖它的成员。

void sunionstore(final String dstkey, final String... keys)

#返回参数中第一个Key所关联的Set和其后所有Keys所关联的Sets中成员的差异。如果Key不存在，则视为空Set。

List<byte[]> sdiff(final String... keys)

#该命令和SDIFF命令在功能上完全相同，两者之间唯一的差别是SDIFF返回差异的结果成员，而该命令将差异成员存储在dstkey关联的Set中。如果dstkey键已经存在，该操作将覆盖它的成员。

void sdiffstore(final String dstkey, final String... keys)

#和SPOP一样，随机的返回Set中的一个成员，不同的是该命令并不会删除返回的成员。

void srandmember(final String key)

5. 有序集合（Sorted-Sets）数据类型接口说明

Sorted-Sets和Sets类型极为相似，它们都是字符串的集合，都不允许重复的成员出现在一个Set中。它们之间的主要差别是Sorted-Sets中的每一个成员都会有一个分数(score)与之关联，Redis正是通过分数来为集合中的成员进行从小到大的排序。然而需要额外指出的是，尽管Sorted-Sets中的成员必须是唯一的，但是分数(score)却是可以重复的。

在Sorted-Set中添加、删除或更新一个成员都是非常快速的操作，其时间复杂度为集合中成员数量的对数。由于Sorted-Sets中的成员在集合中的位置是有序的，因此，即便是访问位于集合中部的成员也仍然是非常高效的。事实上，Redis所具有的这一特征在很多其它类型的数据库中是很难实现的，换句话说，在该点上要想达到和Redis同样的高效，在其它数据库中进行建模是非常困难的。

#在该命令中我们可以指定多组score/member作为参数。如果在添加时参数中的某一成员已经存在，该命令将更新此成员的分数为新值，同时再将该成员基于新值重新排序。如果键不存在，该命令将为该键创建一个新的Sorted-Sets Value，并将score/member对插入其中。如果该键已经存在，但是与其关联的Value不是Sorted-Sets类型，相关的错误信息将被返回。

boolean zadd(final String key, final double score, final String member)

#该命令按顺序返回在参数start和stop指定范围内的成员，这里start和stop参数都是0-based，即0表示第一个成员，-1表示最后一个成员。如果start大于该Sorted-Set中的最大索引值，或start > stop，此时一个空集合将被返回。如果stop大于最大索引值，该命令将返回从start到集合的最后一个成员。如果命令中带有可选参数WITHSCORES选项，该命令在返回的结果中将包含每个成员的分数值，如value1,score1,value2,score2...。　

List<byte[]> zrange(final String key, final long start, final long end)

#该命令将移除参数中指定的成员，其中不存在的成员将被忽略。如果与该Key关联的Value不是Sorted-Set，相应的错误信息将被返回。

boolean zrem(final String key, final String... members)

#该命令将为指定Key中的指定成员增加指定的分数。如果成员不存在，该命令将添加该成员并假设其初始分数为0，此后再将其分数加上increment。如果Key不存，该命令将创建该Key及其关联的Sorted-Sets，并包含参数指定的成员，其分数为increment参数。如果与该Key关联的不是Sorted-Sets类型，相关的错误信息将被返回。

Double zincrby(final String key, final double score,final String member)

# Sorted-Set中的成员都是按照分数从低到高的顺序存储，该命令将返回参数中指定成员的位置值，其中0表示第一个成员，它是Sorted-Set中分数最低的成员。

long zrank(final String key, final String member)

#该命令的功能和ZRANK基本相同，唯一的差别在于该命令获取的索引是从高到低排序后的位置，同样0表示第一个元素，即分数最高的成员。

long zrevrank(final String key, final String member)

#该命令的功能和ZRANGE基本相同，唯一的差别在于该命令是通过反向排序获取指定位置的成员，即从高到低的顺序。如果成员具有相同的分数，则按降序字典顺序排序。

List<byte[]> zrevrange(final String key, final long start, final long end)

#该命令将返回分数在min和max之间的所有成员，即满足表达式min <= score <= max的成员，其中返回的成员是按照其分数从低到高的顺序返回，如果成员具有相同的分数，则按成员的字典顺序返回。

List<byte[]> zrangeWithScores(final String key, final long start,final long end)

#该命令除了排序方式是基于从高到低的分数排序之外，其它功能和参数含义均与ZRANGEBYSCORE相同。

List<byte[]> zrevrangeWithScores(final String key, final long start,final long end)

#获取与该Key相关联的Sorted-Sets中包含的成员数量。

long zcard(final String key)

#获取指定Key的指定成员的分数。

Double zscore(final String key, final String member)

##获取指定Key的指定成员的分数。

void watch(final String... keys)

#给指定的Key的成员排序

Sort sort(final String key)

Sort sort(final String key, final SortingParams sortingParameters,

final String dstkey)

Sort sort(final String key, final String dstkey)

#

void blpop(final String[] args)

void brpop(final String[] args)

#该命令用于获取分数(score)在min和max之间的成员数量。

long zcount(final String key, final double min, final double max)

long zcount(final String key, final String min, final String max)

#该命令将返回分数在min和max之间的所有成员，即满足表达式min <= score <= max的成员，其中返回的成员是按照其分数从低到高的顺序返回，如果成员具有相同的分数，则按成员的字典顺序返回。

List<byte[]> zrangeByScore(final String key, final double min,final double max)

List<byte[]> zrangeByScore(final String key, final String min,final String max)

List<byte[]> zrangeByScore(final String key, final double min,final double max, final int offset, int count)

List<byte[]> zrangeByScoreWithScores(final String key, final double min,final double max)

List<byte[]> zrangeByScoreWithScores(final String key, final double min,

final double max, final int offset, final int count)

#

void zremrangeByRank(final String key, final long start,final long end)

void zremrangeByScore(final String key, final double start,final double end)

void zremrangeByScore(final String key, final String start,final String end)

void zunionstore(final String dstkey, final String... sets)

void zunionstore(final String dstkey, final ZParams params,final String... sets)

void zinterstore(final String dstkey, final String... sets)

void zinterstore(final String dstkey, final ZParams params,final String... sets)



开发参考资料：

redis官方文档：http://redis.io/documentation

redis命令参考中文版：http://redis.readthedocs.org/en/2.4/index.html