jedis操作redis

http://www.cnblogs.com/liuling/p/2014-4-19-04.html


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


1、判断该键是否存在
public void existsKey(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Boolean result = jedis.exists("key");
        System.out.println(result);
        jedis.close();
    }


2、在设定的key 后面追加value，并返回添加后value的总长度
public void appendValue(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long result = jedis.append("key", "value");
        System.out.println(result);
        jedis.close();
    }


3、通过get命令获取key对应的value
public void getValue(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        String result = jedis.get("key");
        System.out.println(result);
        jedis.close();


    }

4、通过set命令为key设置新值，并覆盖原有的值,插入成功返回OK
public void setValue(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        String result = jedis.set("key", "value");
        System.out.println(result);
        jedis.close();
    }

5、获取制定的key的字符长度
public void getLen(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long result = jedis.strlen("key");
        System.out.println(result);
        jedis.close();
    }

6、设置key对应value(数字类型)每次incr调用递增1 -- 可以为负数
public void setValueIncr(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        jedis.set("key","20");
        Long result = jedis.incr("key"); -- 可以指定递增数值，例如递增5，5
        System.out.println(result);
    }


7、设置key对应value(数字类型)每次decr调用递减1 -- 可以为负数
public void setValueDecr(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        //jedis.set("key","20");
        Long result = jedis.decr("key"); -- 可以指定递减数值，例如递减10，10
        System.out.println(result);
    }


8、删除key所对应的value
public void delValue(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        //jedis.set("key","20");
        Long result = jedis.del("key");
        System.out.println(result);
    }


9、返回上步执行的结果，并重新设置这个key的value为0
public void myCounter(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        jedis.incr("key");
        String newResult = jedis.getSet("key", "0");
        String oldResult = jedis.get("key");
        System.out.println(newResult);
        System.out.println(oldResult);
    }

10、设置当前key的存活时间,设置成功返回结果OK
public void setexTime(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        String result = jedis.setex("key", second, " value");
        System.out.println(result);
    }


11、设置时间后通过ttl获取剩余时间数，时间结束返回-2，没有设置时间返回-1
public void setexTime(){
Jedis jedis = new Jedis("127.0.0.1",6379);
Long time = jedis.ttl("key");
System.out.println(time);
    }

12、设置值成功返回1，第二次设置相同key返回0，默认不能被覆盖
public void setnxValue(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long result = jedis.setnx("key", "value");
        System.out.println(result);
    }

13、从第X个字节开始替换Value，如果定义的长度超过本身value的长度则会自动追加在value后面
public void setrangeValue(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long result = jedis.setrange("key", 3, "value");
        System.out.println(result);
    }


14、截取第x+1字节后面的y+1字符
public void getrangeValue(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        jedis.set("key","hello world");
        String result = jedis.getrange("key", x, y);
        System.out.println(result);
    }

15、批量设置key1和key2。。。默认是一个key对应一个value
public void msetKeyAndValues(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        String mset = jedis.mset("key1", "value1", "key2", "key3");
        System.out.println(mset);                                       //OK
        List<String> result = jedis.mget("key1", "key2");               
        for (String value :result) {
            System.out.println(value);
        }
    }

16、msetnx批量设值key。。。value，如果存在相同key则直接停止该批量操作后面的操作
public void msetnx(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long result = jedis.msetnx("key2", "value2","key5", "value5");
        System.out.println(result);
    }
public void mgetnx(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        List<String> mget = jedis.mget("key2", "key5");
        for (String value:mget) {
            System.out.println(value);
        }
    }

Redis--List数据类型
概述：
在Redis中，List类型是按照插入顺序排序的字符串链表，和数据结构中的普通链表一样，我们可以在其头部(left)
和尾部(right)添加新的元素，在插入时，如果该键并不存在，Redis将为该键创建一个新的链表，与此相反，如果链表
中所有元素均被移除，那么该键将会被从数据库中删除，List中可以包含最大元素数量4294967295。
从元素插入和删除的效率角度来看，如果我们在链表的两头插入和删除元素，这将会是非常搞笑的操作，即使链表中
已经存在上百万条记录，该操作也可以在常量时间内完成，然后需要说明的是如果元素插入或删除操作是作用于链表中间
那将会是非常低效的。
Redis链表经常会被用于消息队列的服务，已完成更多程序之间的消息交换，假设一个应用程序正在执行LPUSH操作向
链表中添加新的元素，我们通常将这个程序称为"生产者(Producer)",而另外一个应用程序正在执行RPOP操作从链表中取出元素
我们成这样的程序为"消费者(Consumer)",如果此时消费者程序在取出消息元素后立刻崩溃，由于该消息已经被全部取出且没有
正常处理，那么我们就可以认为该消息已经丢失，由此可能会导致业务数据丢失，或业务状态不一致等现象发生，然而通过使用
RPOPLPUSH命令，消费者程序在从主消息队列中取出消息后再将其插入到备份消息队列中，直接消费者程序完成正常的处理逻辑后
将消息从备份队列中删除，同时我们还可以提供一个守护进程，当发现备份队列中的消息过期，可以重新将其放回到主消息队列中
以变其他消费者继续处理


1、lpush返回插入后的长度，lrange获得制定key，从x长度到y长度，-1表示返回所有长度
public void lpush(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long result1 = jedis.lpush("key","a");
        List<String> result = jedis.lrange("key", 0, -1);
        for (String value: result) {
            System.out.println(value);
        }
        System.out.println(result1);
    }

2、lpushx 无法对不存在的key进行操作并返回0，成功添加一个对象返回1
public void lpushx(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long result1 = jedis.lpushx("keys","a");
        List<String> result = jedis.lrange("keys", 0, -1);
        for (String value: result) {
            System.out.println(value);
        }
        System.out.println(result1);
    }

3、lpop 在list集合中从后往前取数据， 取完后该数据就不存在了
public void lpop(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        String result = jedis.lpop("key");
        System.out.println(result);
    }

4、获得指定list集合的长度
public void llen(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long result = jedis.llen("key");
        System.out.println(result);
    }

5、lrem删除指定的字符串，并设定删除个数，返回结果为删除的实际个数,从前往后删除，类似堆结构
public void lrem(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long result = jedis.lrem("key", 3, "b");
        System.out.println(result);
    }

6、获得指定索引的值
public void lindex(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        String result = jedis.lindex("key", 0);
        System.out.println(result);
    }


7、通过lset指定索引直接把该值替换掉
public void lset(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        //List<String> key = jedis.lrange("key", 0, -1);
        //for (String value:key ) {
            //System.out.println(value);
        //}
        String result = jedis.lset("key", 2, "kai");
    }

8、保留索引x到索引y的元素，保存成功返回OK
public void ltrim(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        String reuslt = jedis.ltrim("key", x, y);
        System.out.println(reuslt);
    }

9、 在指定value之前插入新元素new value
public void linsert(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        jedis.del("key");
        jedis.lpush("key","a","b");
        Long result = jedis.linsert("key", BinaryClient.LIST_POSITION.BEFORE, "a", "miss");
        //System.out.println(result);
        List<String> results = jedis.lrange("key", 0, -1);
        for (String value:results) {
            System.out.println(value);
        }
    }

10、在指定value之后插入新元素new value
public void linsertAfter(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        jedis.del("key");
        jedis.lpush("key","a","b");
        Long result = jedis.linsert("key", BinaryClient.LIST_POSITION.AFTER, "a", "miss");
        //System.out.println(result);
        List<String> results = jedis.lrange("key", 0, -1);
        for (String value:results) {
            System.out.println(value);
        }
    }

11、从链表的尾部插入value
public void rpush(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long result = jedis.rpush("key", "a", "b", "c");
        List<String> key = jedis.lrange("key", 0, -1);
        System.out.println(key.toString());
    }


12、从链表的尾部插入value,只能追加一个
public void rpushx(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long result = jedis.rpushx("key","a");
        List<String> key = jedis.lrange("key", 0, -1);
        System.out.println(key.toString());
    }

13、将key尾部的袁术弹出，同时插入到key2的头部(原子性的完成这两步)
public void rpoplpush(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        String resout = jedis.rpoplpush("key1", "key2");
        System.out.println(resout);
    }



Redis--Set数据类型
概述：
在Redis中，我们可以将Set类型看作为没有排序的字符集合，和List类型一样，我们也可以在该类型的数值上执行添加，
删除或判断某一元素是否存在等操作，需要说明是，这些操作的时间复杂为0(1),即常量时间内完成本次操作，Set包含的最大
元素数量是4294967295。
Set和List类型不同的是，Set集合不准许出现重复元素，这一点优点跟C++标准库中的set容器是完全相同的，多次添加相同元素，
Set中将仅保留该元素的一份拷贝，和List类型相比，Set类型在功能上还存在着一个非常重要的特性，即在服务器端完成多个Sets
之间的聚合计算操作，由于这些操作均在服务器端完成，应为效率极高，而且也节约了大量的网络IO开销。


应用范围:
1)可以使用Redis的Set数据类型跟踪一些唯一性数据，比如访问某一个博客的唯一IP地址信息，对于此类场景，我们仅需在每次访问
博客时将访问者的IP存入Redis中，Set数据类型会自动保证IP地址的唯一性。
2)充分利用Set类型的服务端聚合操作方便、高效的特性，可以用于维护数据对象之间的关联关系。比如购买某家电子设备的客户ID被
存储在一个指定的Set中，而购买另外一种电子产品的客户ID被存储在另外一个Set中，如果此时我们想获得哪个客户同时购买了这两种商品
时，Set的intersections命令就是充分发挥它的方便和效率的优势。

1、添加set集合，不能重复添加
public void sadd(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long result = jedis.sadd("key", "a", "b", "c");
        System.out.println(result);
    }


2、判断value是否存在，1表示存在，0表示不存在
public void sismember(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Boolean result = jedis.sismember("key", "a");
        System.out.println(result);
    }


3、获得set集合，和set里面的所有值
public void smembers(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Set<String> key = jedis.smembers("key");
        System.out.println(key.toString());
    }


4、随机的返回某一成员
public void srandmember(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        String key = jedis.srandmember("key");
        System.out.println(key);
    }


5、通过spop随机取出里面的内容
public void spop(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        String key = jedis.spop("key");
        System.out.println(key);
    }


6、从Set中移除a、b和f三个成员，其中f并不存在，因此只有a和b两个成员被移除，返回为2
public void srem(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long result = jedis.srem("key", "a", "b", "f");
        System.out.println(result);
    }


7、将a从key移到key2，从结果可以看出移动成功
public void smove(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long result = jedis.smove("key", "keys", "a");
        System.out.println(result);
    }

8、 sdiff得到多个对象的value的区别是什么
public void sdiff(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Set<String> sdiff = jedis.sdiff("key", "key1");
        System.out.println(sdiff.toString());
    }

9、 sinter多个set对象value的交集
public void sinter(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Set<String> sinter = jedis.sinter("key", "key1");
        System.out.println(sinter.toString());
    }

10、sunion多个set对象value的并集
public void sunion(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Set<String> sunion = jedis.sunion("key", "key1");
        System.out.println(sunion.toString());
    }

Redis--Hash数据类型
概述：
我们可以将Redis中的Hash类型看成具有String Key和String Value的map容器。所以该类型非常适合用于存储对象的信息，如果Hash
中包含很少的字段，那么该类型的数据也将仅占很少的磁盘空间，每一个Hahs可以存储44294967295个键值对




1、hset方法存入值:key、field、value
public void hsetValue(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long hset = jedis.hset("key", "field", "value");
        System.out.println(hset);
    }

2、hget方法获取key、field的value
public void hgetValue(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        String hget = jedis.hget("key", "field");
        System.out.println(hget);
    }


3、hlen方法获取key 内的个数
public void hlen(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long hlen = jedis.hlen("myhash");
        System.out.println(hlen);
    }

4、hexists判断key中是否存在field ，1(true)表示存在，0(false)表示不存在
public void hexists(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Boolean hexists = jedis.hexists("myhash", "field");
        System.out.println(hexists);
    }


5、hdel删除key field 对应的所有value,删除成功结果1(true)表示存在，0(false)表示不存在
public void hdel(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long hdel = jedis.hdel("myhash", "field");
        System.out.println(hdel);
    }

6、 hsetnx设置不存在的值，返回结果1(true)表示插入成功，0(false)表示插入失败
public void hsetnx(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long hsetnx = jedis.hsetnx("myhash", "field","hello");
        System.out.println(hsetnx);
    }

7、 给指定key field 字段上的值加1，-数就是减
public void hincrby(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long aLong = jedis.hincrBy("myhash", "field123", 222);
        System.out.println(aLong);
    }

8、hmset 为key一次性设置多个field和对应的value,插入成功返回OK
public void hmset(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Map map = new HashMap();
        map.put("field1","a");
        map.put("field2","b");
        String result = jedis.hmset("keys",map);
        System.out.println(result);
    }


9、hmget 为key获得多个field上面的value，返回一个list集合
public void hmget(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        List<String> result = jedis.hmget("keys","field1","field2");
        System.out.println(result.toString());
    }


10、hgetall 获得key-value的键值对
public void hgetall(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Map<String, String> result = jedis.hgetAll("keys");
        System.out.println(result.toString());
    }


11、hkeys 获得所有field，
public void hkeys(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Set<String> result = jedis.hkeys("keys");
        System.out.println(result.toString());
    }


12、hvals 获得所有value
public void hvals(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        List<String> result = jedis.hvals("keys");
        System.out.println(result.toString());
    }


Redis--Sorted-Sets数据类型
概述：
Sorted-Sets和Sets类型极为相似，他们都是字符串的集合，都不准许重复的成员出现在一个Set中，他们之间的主要差别是
Sorted-Sets中的每一个成员都会有一个分数(score)与之关联，Redis正是通过分数来为集合中的成员进行小到大的排序。然而
需要额外指出的是，尽管Sorted-Sets中的成员必须是唯一的，但是分数(score)却是可以重复的。
在Sorted-Sets中的成员在集合中的位置是有序的，因此，即便是访问位于集合中部的成员也任然是非常高效的，事实上，
Redis所具有的这一特征在很多其他类似的数据库中很难实现，在该店上想要达到Redis同样的高效，在其它数据库中进行建模
非常困难。
应用范围：
1、可以用于一个大型的在线游戏的积分排行榜，每当玩家的分数发生变化时，可以执行ZADD命令更新玩家的分数，此后在通过
ZRANGE命令获取积分TOP TEN的用户信息，当然我们也可以利用ZRANK命令通过username来获得玩家游戏排行信息，最后我们将组合
使用ZRANGE和ZRANK命令快速的获取和某个玩家积分相近的用户信息
2、Sorted-Sets 类型还可以用于构建索引数据


1、zadd 添加Sorted-Sets数据
public void zadd(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long result = jedis.zadd("myzset", 1, "one");
        System.out.println(result);
    }




2、zrange 获取添加Sorted-Sets的成员
public void zrange(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Set<String> result = jedis.zrange("myzset", 0, -1);
        System.out.println(result.toString());
    }


3、zrange 获取添加Sorted-Sets的成员
public void zrangeWithScores(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Set<Tuple> result = jedis.zrangeWithScores("myzset", 0, -1);
        System.out.println(result.toString());
    }


4、zrank 获得成员所在的索引位置
public void zrank(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long result = jedis.zrank("myzset", "two");
        System.out.println(result);
    }


5、zcard 获得成员的数量
public void zcard(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long result = jedis.zcard("myzset");
        System.out.println(result);
    }

6、zrem 删除成员，并返回删除成员的数量
public void zrem(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long result = jedis.zrem("myzset", "one");
        System.out.println(result);
    }


7、zscore 获得two成员的分数，并返回时字符串形式
public void zscore(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Double result = jedis.zscore("myzset", "two");
        System.out.println(result);
    }

8、zincrby 将指定two成员的分数值增加-3，并返回增加后的成员结果
public void zincrby(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Double result = jedis.zincrby("myzset", -3, "two");
        System.out.println(result);
    }

9、-inf表示第一个成员，+inf表示最后一个成员，limit后面的参数用于限制自己的索引位置
public void zrangebyscore(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Set<String> myzset = jedis.zrangeByScore("myzset", "-inf", "+inf",0,1);
        System.out.println(myzset.toString());
    }


10、返回成员存在的个数
public void zremrangebyscore1(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long result = jedis.zremrangeByScore("myzset", "-inf", "+inf");
        System.out.println(result);
    }

public void zremrangebyscore2(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long result = jedis.zremrangeByScore("myzset", 0, 1);
        System.out.println(result);
    }

11、按照位置索引送高到低的方式获取并返回此区间内的成员结果
public void zrevrange(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        //Map<String, Double> map = new LinkedHashMap<>();
        //map.put("one",1.0);
        //map.put("two",2.0);
        //map.put("three",3.0);
        //map.put("four",4.0);
        //Long result = jedis.zadd("myzset", map);
        Set<String> result = jedis.zrevrange("myzset", 0, -1);
        System.out.println(result.toString());
    }


12、返回成员所在的索引位置
public void zrevrank(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long result = jedis.zrevrank("myzset", "two");
        System.out.println(result);


    }


Redis--Key操作
Redis数据类型相关命令，如String、List、Set、Hashes和Sorted-Set,命令都具有一个共同点，即使所有的操作都针对与
Key关联的Value的，此处主要讲述与Key相关的Redis命令，学习这些命令对于学习Redis非常重要的基础，也是能够充分挖掘
Reids潜力的利器

1、清理当前数据库,成功返回OK
public void flushdb(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        String result = jedis.flushDB();
        System.out.println(result);
    }

2、获取所有类型的key,*表示全匹配
public void keys(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Set<String> result = jedis.keys("*");
        System.out.println(result.toString());
    }


3、expire 设置制定key的过期时间
public void expirt(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        //String mykeys = jedis.set("mykeys", "123");
        Long result = jedis.expire("mykeys", 100);
        System.out.println(result);
    }

4、 ttl 得到该key的过期时间
public void ttl(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long result = jedis.ttl("mykeys");
        System.out.println(result);
    }

5、persist 该存在超市的键变成持久化键，即将该key的过期时间去掉，一定要在未过期之前执行该命令
public void persist(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        Long result = jedis.persist("mykeys");
        System.out.println(result);
    }

6、type 通过key获得value的类型
public void type(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        String result = jedis.type("mykeys");
        System.out.println(result);
    }

7、randomkey 随机返回key
public void randomkey(){
        Jedis jedis = new Jedis("127.0.0.1",6379);
        String reuslt = jedis.randomKey();
        System.out.println(reuslt);
    }