redis专项练习二redis常用命令以及java调用方式

目录

 

一、redis的数据类型

二、redis对key的相关操作

   1、redis客户端命令行

2、java代码调用

  三、Redis字符串类型的操作

      1、redis客户端命令行

      2、java代码调用

四、Redis列表list类型的操作

      1、redis客户端命令行

      2、java代码调用

五、Redis的Set类型操作

      1、redis客户端命令行

      2、java代码调用

六、Redis的SortSet类型操作

      1、redis客户端命令行

      2、java代码调用

七、Redis的hash类型操作

      1、redis客户端命令行

      2、java代码调用

---

一、redis的数据类型

     redis中有五种数据类型分别是String，list,sort.sort set,hash,下面分别对如下的redis的操作提供两种方式，一种是redis客户端操作，一种是使用java调用redis来进行操作。

二、redis对key的相关操作

   1、redis客户端命令行

• del key1 key2 ... Keyn

作用: 删除1个或多个键

返回值: 不存在的key忽略掉,返回真正删除的key的数量

• rename key newkey

作用: 给key赋一个新的key名

注:如果newkey已存在,则newkey的原值被覆盖

• renamenx key newkey  

作用: 把key改名为newkey

返回: 发生修改返回1,未发生修改返回0

注: nx--> not exists, 即, newkey不存在时,作改名动作

• move key db

将指定的key存放到指定的数据库索引中

(注意: 一个redis进程,打开了不止一个数据库, 默认打开16个数据库,从0到15编号,

如果想打开更多数据库,可以从配置文件修改)

redis 127.0.0.1:6379[1]> select 2

OK

redis 127.0.0.1:6379[2]> keys *

(empty list or set)

redis 127.0.0.1:6379[2]> select 0

OK

redis 127.0.0.1:6379> keys *

1) "name"

2) "cc"

3) "a"

4) "b"

redis 127.0.0.1:6379> move cc 2

(integer) 1

redis 127.0.0.1:6379> select 2

OK

redis 127.0.0.1:6379[2]> keys *

1) "cc"

redis 127.0.0.1:6379[2]> get cc

"3"

• keys pattern 查询相应的key

在redis里,允许模糊查询key

    有3个通配符 *, ? ,[]

    *: 通配任意多个字符

     ?: 通配单个字符

     []: 通配括号内的某1个字符randomkey 返回随机key

redis 127.0.0.1:6379> flushdb

OK

redis 127.0.0.1:6379> keys *

(empty list or set)

redis 127.0.0.1:6379> mset one 1 two 2 three 3 four 4

OK

redis 127.0.0.1:6379> keys o*

1) "one"

redis 127.0.0.1:6379> key *o

(error) ERR unknown command 'key'

redis 127.0.0.1:6379> keys *o

1) "two"

redis 127.0.0.1:6379> keys ???

1) "one"

2) "two"

redis 127.0.0.1:6379> keys on?

1) "one"

redis 127.0.0.1:6379> set ons yes

OK

redis 127.0.0.1:6379> keys on[eaw]

"one"

• exists key

判断key是否存在,返回1/0

• type key

返回key存储的值的类型

有string,link,set,order set, hash

        

2、java代码调用

/**
     * redis有关key的操作
     * RedisTemplate主要支持String，List,Hash,Set,ZSet这几种方式的参数，
     * 其对应的方法分别是opsForValue()、opsForList()、opsForHash()、opsForSet()、opsForZSet()。
     * 下面分别介绍这几个方法的使用。
     */
    @Test
    public void testRedisKey(){

      //获取操作字符串的操作对象
      ValueOperations stringOperations = redisTemplate.opsForValue();

        Map person = new HashMap<>(5);
        person.put("name","谢奇秀");
        person.put("age","23");
        person.put("birthday","1994-10-21");
        person.put("sex","男");
        stringOperations.multiSet(person);

      //keys  [pattern] 通过通配符获取到匹配的key * 匹配所有字符
        // ？匹配单个字符 [char/chaB/char] 匹配括号中的某个字符
       
      Set keys = redisTemplate.keys("*");
      log.info("redis中*匹配的所有keys;{}", JsonUtil.gsonString(keys));

      keys = redisTemplate.keys("??me");
      log.info("redis中的所有keys;{}", JsonUtil.gsonString(keys));


        keys = redisTemplate.keys("birthda[xy]");
        log.info("redis中的所有keys;{}", JsonUtil.gsonString(keys));

        //删除key del key1 [key2 ...]
        redisTemplate.delete("name");
        List delkeys = new ArrayList<>();
        delkeys.add("age");
        delkeys.add("sex");
        redisTemplate.delete(delkeys);

        keys = redisTemplate.keys("*");
        log.info("redis中*匹配的所有keys;{}", JsonUtil.gsonString(keys));
        

         //rename oldkey newkey 给key赋予一个新的name 如果新的key存在则原来的key值被覆盖
        redisTemplate.rename("name","alias");
        //作用: 把key改名为newkey
        //返回: 发生修改返回true(说明newkey不存在),不发生修改返回false(说明newkey已经存在)
        boolean falg = redisTemplate.renameIfAbsent("name","alias");
        if(falg){
            log.info("修改成功");
        }else{
            log.info("修改失败");
        }

        //move key db 将对应的key存放在 一台redis的服务中默认包含16个库 该行操作将key(默认在0)移动到库索引为2中
        //移动没有发生错误 为false  移动发生错误返回true
        falg = redisTemplate.move("alias",1);
        if(falg){
            log.info("没有移动");
        }else{
            log.info("已经移动");
        }
        Set keys = redisTemplate.keys("*");
        log.info("redis中*匹配的所有keys;{}", JsonUtil.gsonString(keys));


       // 获取一个随机的key
        String randomKey = (String)redisTemplate.randomKey();
        log.info("随机下获取的key:{}",randomKey);

        boolean has = redisTemplate.hasKey("name");
        if(has){
            log.info("存在");
        }else{
            log.info("不存在");
        }

        //获取redis中对应的key的类型
        DataType type = redisTemplate.type("name");
        log.info("redis中对应key的类型为：{}",type.name());

        //设置key的生命周期 
        redisTemplate.expire("age",1000, TimeUnit.MICROSECONDS);

        //查询key的生命周期
        Long expireTime = redisTemplate.getExpire("age");

        log.info("生命周期 -1 表示为持久化 -2表示key不存在 其他的正数为时间单位秒：{}",expireTime);

        //将对应的key持久化
        boolean isExpirst = redisTemplate.persist("age");

    }

  三、Redis字符串类型的操作

      1、redis客户端命令行

• set key value [ex 秒数] / [px 毫秒数]  [nx] /[xx]

如: set a 1 ex 10 , 10秒有效

Set a 1 px 9000  , 9秒有效

注: 如果ex,px同时写,以后面的有效期为准

如 set a 1 ex 100 px 9000, 实际有效期是9000毫秒

nx: 表示key不存在时,执行操作

xx: 表示key存在时,执行操作

• mset  multi set , 一次性设置多个键值

例: mset key1 v1 key2 v2 ....

get key

作用:获取key的值

mget key1 key2 ..keyn

作用:获取多个key的值

setrange key offset value

作用:把字符串的offset偏移字节,改成value

redis 127.0.0.1:6379> set greet hello

OK

redis 127.0.0.1:6379> setrange greet 2 x

(integer) 5

redis 127.0.0.1:6379> get greet

"hexlo"

注意: 如果偏移量>字符长度, 该字符自动补0x00

redis 127.0.0.1:6379> setrange greet 6 !

(integer) 7

redis 127.0.0.1:6379> get greet

"heyyo\x00!"

append key value

作用: 把value追加到key的原值上

getrange key start stop

作用: 是获取字符串中 [start, stop]范围的值

注意: 对于字符串的下标,左数从0开始,右数从-1开始

redis 127.0.0.1:6379> set title 'chinese'

OK

redis 127.0.0.1:6379> getrange title 0 3

"chin"

redis 127.0.0.1:6379> getrange title 1 -2

"hines"

注意:

1: start>=length, 则返回空字符串

2: stop>=length,则截取至字符结尾

3: 如果start 所处位置在stop右边, 返回空字符串

getset key newvalue

作用: 获取并返回旧值,设置新值

redis 127.0.0.1:6379> set cnt 0

OK

redis 127.0.0.1:6379> getset cnt 1

"0"

redis 127.0.0.1:6379> getset cnt 2

"1"

incr key

作用: 指定的key的值加1,并返回加1后的值

注意:

1:不存在的key当成0,再incr操作

2: 范围为64有符号

incrby key number

redis 127.0.0.1:6379> incrby age  90

(integer) 92

incrbyfloat key floatnumber 

自增根据浮点数

redis 127.0.0.1:6379> incrbyfloat age 3.5

"95.5"

decr key 自减

redis 127.0.0.1:6379> set age 20

OK

redis 127.0.0.1:6379> decr age

(integer) 19

decrby key number

redis 127.0.0.1:6379> decrby age 3

(integer) 16

getbit key offset

作用:获取值的二进制表示,对应位上的值(从左,从0编号)

redis 127.0.0.1:6379> set char A

OK

redis 127.0.0.1:6379> getbit char 1

(integer) 1

redis 127.0.0.1:6379> getbit char 2

(integer) 0

redis 127.0.0.1:6379> getbit char 7

(integer) 1

setbit  key offset value

设置offset对应二进制位上的值

返回: 该位上的旧值

注意:

1:如果offset过大,则会在中间填充0,

2: offset最大大到多少

3:offset最大2^32-1,可推出最大的的字符串为512M

bitop operation destkey key1 [key2 ...]

对key1,key2..keyN作operation,（位运算操作）并将结果保存到 destkey 上。

operation 可以是 AND（按位与） 、 OR（按位或） 、 NOT（非） 、 XOR（异或）

注意: 对于NOT操作, key不能多个

redis 127.0.0.1:6379> setbit lower 7 0

(integer) 0

redis 127.0.0.1:6379> setbit lower 2 1

(integer) 0

redis 127.0.0.1:6379> get lower

" "

redis 127.0.0.1:6379> set char Q

OK

redis 127.0.0.1:6379> get char

"Q"

redis 127.0.0.1:6379> bitop or char char lower

(integer) 1

redis 127.0.0.1:6379> get char

"q"

 

      2、java代码调用

    /**
     * redis相关的字符串类型的操作
     */
    @Test
    public void testRedisString(){
        //先获取可以操作redis字符串类型的操作对象
        ValueOperations stringOperations = redisTemplate.opsForValue();

        //设置单个字符串类型的key 默认持久化 且同名key覆盖
        stringOperations.set("title","redis字符串操作");
        //设置单个字符串类型的key 并设置过期时间 且同名key覆盖
        stringOperations.set("name","xieqx",10,TimeUnit.MINUTES);
        //设置单个字符串类型的key 持久化 不存在执行才操作，存在则不执行
        //第一次插入因为存在 所以返回true
        boolean success = stringOperations.setIfAbsent("age","24");
        log.info(success+"");
        //第二次因为已经存在了 所有返回false
        success = stringOperations.setIfAbsent("age","24");
        log.info(success+"");

        //一次性设置多个值 同名覆盖
        Map kvs = new HashMap<>();
        kvs.put("file","maven");
        kvs.put("length","234");
        kvs.put("size","1024");
        stringOperations.multiSet(kvs);

        //一次性设置多个值 存在则不进行设置
        boolean isSuccess = stringOperations.multiSetIfAbsent(kvs);
        log.info(""+ isSuccess);

        //获取其中单个key的值
        String value = (String)stringOperations.get("name");
        log.info("value: {}",value);

        //获取多个key的值
        List  keys = new ArrayList<>();
        keys.add("name");
        keys.add("size");
        keys.add("age");
        List values = stringOperations.multiGet(keys);
        log.info("values :{}",JsonUtil.gsonString(values));

        //设置对应key的字符串的偏移量改为value 如果偏移量>字符长度 该字符自动补全以0x00 没有实现
        // 获取对应的key中指定范围的值 没有实现
        stringOperations.append("name"," xiu");

        String name = (String)stringOperations.get("name");
        log.info("name: {}",value);

        //获取旧值设置新值
        String oldName = (String)stringOperations.getAndSet("name","shizb");

        log.info("oldName :{}"+oldName);

        stringOperations.set("age","24");
        //自增 整数类型   自减 数值为负数
        stringOperations.increment("age",-22);
        //Error in execution; nested exception is io.lettuce.core.RedisCommandExecutionException:
        // ERR value is not an integer or out of range
        //stringOperations.increment("name",2);
        //自增 浮点数类型(会有精度损失) 自减 数值为负浮点数
        stringOperations.increment("size",2.3);

   //操作值得二进制表示
        //示范例子 将A 转换为a  A 的ASCII 为65 a的ASCII 为97 两者相差 32 即为二进制上的第六位的值不同
        //A的第六位为0 a的第二位为1 在redis操作值的二进制位上
        stringOperations.set("charcter","A");
        stringOperations.setBit("charcter",2,true);

        String value = stringOperations.get("charcter");

        log.info("charcter :{}",value);

        //获取key的二进制值
        boolean bit =  stringOperations.getBit("charcter",3);
        if(bit){
            log.info("charcter 下的第二位的值：{}",1);
        }
       else{
            log.info("charcter 下的第二位的值：{}",0);
        }

    }

 

四、Redis列表list类型的操作

      1、redis客户端命令行

• lpush key value

作用: 把值插入到链接头部

• rpop key

作用: 返回并删除链表尾元素

rpush,lpop: 不解释

• lrange key start  stop

作用: 返回链表中[start ,stop]中的元素

规律: 左数从0开始,右数从-1开始

• lrem key count value

作用: 从key链表中删除 value值

注: 删除count的绝对值个value后结束

Count>0 从表头删除

Count<0 从表尾删除

• ltrim key start stop

作用: 剪切key对应的链接,切[start,stop]一段,并把该段重新赋给key

• lindex key index

作用: 返回index索引上的值,

如  lindex key 2

• llen key

作用:计算链接表的元素个数

redis 127.0.0.1:6379> llen task

(integer) 3

redis 127.0.0.1:6379> 

• linsert  key after|before search value

作用: 在key链表中寻找’search’,并在search值之前|之后,.插入value

注: 一旦找到一个search后,命令就结束了,因此不会插入多个value

rpoplpush source dest

作用: 把source的尾部拿出,放在dest的头部,

并返回 该单元值

场景: task + bak 双链表完成安全队列

Task列表                             bak列表

业务逻辑:

1:Rpoplpush task bak

2:接收返回值,并做业务处理

3:如果成功,rpop bak 清除任务. 如不成功,下次从bak表里取任务

brpop ,blpop  key timeout

作用:等待弹出key的尾/头元素,

Timeout为等待超时时间

如果timeout为0,则一直等待

场景: 长轮询Ajax,在线聊天时,能够用到

 

      2、java代码调用

/**
     * redis相关的list列表操作
     */
    @Test
    public void testRedisList() {
        //获取操作list的对象
        ListOperations listOperations = redisTemplate.opsForList();

        String key = "names";

        //从左边插入值到列表中（即插入到列表的头部）
        listOperations.leftPush(key,"zhangsan");

         //leftPush(key,privot,value)往names中插入key,插入的位置在privot的前面，如果privot不存在,则不会插入
        //在key链表中寻找’search’,并在search值之前(left)|之后(right),.插入value
        listOperations.leftPush(key,"zhangsan","wangwu");
        //一次性插入多个数据
        listOperations.leftPushAll(key,"xieqx","qixx","shzb","liangzj");
        //只有存在key对应的列表才能将这个value值插入到key所对应的列表中
        listOperations.rightPushIfPresent(key,"xieqx");

        //获取列表中的集合的大小
         Long  end = listOperations.size("names");
         //获取列表中指定范围中的数据 返回一个list集合
        List list = listOperations.range("names",0,end);

        log.info("names list:{}",JsonUtil.gsonString(list));

        //从头部获取并移除列表中的一个元素
       String first =  listOperations.leftPop(key);
        log.info("names list first:{}",first);
        //Blpop  从头部获取数据，没有则一直阻塞，直到超时（或者在超时之前获取到该值）
        first =  listOperations.leftPop(key,1,TimeUnit.MINUTES);
        log.info("names list first:{}",first);
        end = listOperations.size("names");
        list = listOperations.range("names",0,end);

        log.info("names list:{}",JsonUtil.gsonString(list));

        //listOperations.rightPush() rightPushALl rightPushIfPresent 与上边操作的相似，只是一个从左边（头部），一个是从右边（尾部）

        //从列表中删除count绝对值个value（count为负数则从尾部删除，count整数则从头部删除，返回真是删除的值的个数）
        long realRemLen = listOperations.remove(key,2,"szb");
        log.info("删除了 {}",realRemLen);

        // 剪切key对应的链接,切[start,stop]一段,并把该段重新赋给key
        listOperations.trim(key,0, 2);

        end = listOperations.size("names");
        list = listOperations.range("names",0,end);
        log.info("names list:{}",JsonUtil.gsonString(list));


        //lindex key index
        //作用: 返回index索引上的值,
        String value = listOperations.index(key,2);
        log.info("names list:index下的值{}",value);

    }

五、Redis的Set类型操作

      1、redis客户端命令行

           集合的性质: 唯一性,无序性,确定性

           注: 在string和link的命令中,可以通过range 来访问string中的某几个字符或某几个元素

           但,因为集合的无序性,无法通过下标或范围来访问部分元素.

           因此想看元素,要么随机先一个,要么全选

• sadd key  value1 value2

作用: 往集合key中增加元素

• srem value1 value2

作用: 删除集合中集为 value1 value2的元素

返回值: 忽略不存在的元素后,真正删除掉的元素的个数

• spop key

作用: 返回并删除集合中key中1个随机元素

随机--体现了无序性

• srandmember key

作用: 返回集合key中,随机的1个元素.

• sismember key  value

作用: 判断value是否在key集合中

是返回1,否返回0

• smembers key

作用: 返回集中中所有的元素

• scard key

作用: 返回集合中元素的个数

• smove source dest value

作用:把source中的value删除,并添加到dest集合中

• sinter  key1 key2 key3

作用: 求出key1 key2 key3 三个集合中的交集,并返回

redis 127.0.0.1:6379> sadd s1 0 2 4 6

(integer) 4

redis 127.0.0.1:6379> sadd s2 1 2 3 4

(integer) 4

redis 127.0.0.1:6379> sadd s3 4 8 9 12

(integer) 4

redis 127.0.0.1:6379> sinter s1 s2 s3

1) "4"

redis 127.0.0.1:6379> sinter s3 s1 s2

"4"

• sinterstore dest key1 key2 key3

作用: 求出key1 key2 key3 三个集合中的交集,并赋给dest

• suion key1 key2.. Keyn

作用: 求出key1 key2 keyn的并集,并返回

• sdiff key1 key2 key3

作用: 求出key1与key2 key3的差集

即key1-key2-key3

 

      2、java代码调用

  /**
     * redis相关的set操作
     */
    @Test
    public void testRedisSet() {
        //获取set相关的操作对象
        SetOperations setOperations = redisTemplate.opsForSet();

        String key = "sores";
        //添加元素
        setOperations.add(key,"12","15","9","13","13");

        //获取元素 ，要么获取所有，要么获取随机的一个，因为set无序
        //获取key下的所有
        Set sets = setOperations.members(key);
        log.info("set 列表：{}",JsonUtil.gsonString(sets));

       String randomValue = setOperations.randomMember(key);
       log.info("randomValue :{}",randomValue);


       List list = setOperations.randomMembers(key,2);
       log.info("随机获取指定个数的集合数据：{}",JsonUtil.gsonString(list));
        //获取多个key无序集合中的元素（去重），count表示个数
        sets =  setOperations.distinctRandomMembers(key,5);
        log.info("set 列表：{}",JsonUtil.gsonString(sets));

       //随机移除一个元素
        String aloenRem = setOperations.pop(key);
        log.info("移除一个元素：{}",aloenRem);
        //随机移除若干个元素
        List removes = setOperations.pop(key,2);
        log.info("移除若干个元素：{}",aloenRem);

        //根据值移除元素 ，值可以为一个或者多个 返回是指删除的元素个数
        long realRemve = setOperations.remove(key,"13","9");
        log.info("real remove element size is ：{}",aloenRem);

        //判断元素是否在集合中
        boolean falg = setOperations.isMember(key,"12");
        log.info("the value is exist ：{}",falg);

        //返回集合中元素的个数
        log.info("the set size is :{}",setOperations.size(key));

        //把source中的value删除,并添加到dest集合中
        boolean success =  setOperations.move(key,"9","outofDate");
        log.info("mcve is success :{}",success);
        sets = setOperations.members("outofDate");
        log.info("set 列表：{}",JsonUtil.gsonString(sets));

        //获取集合中并集，交集，差集
        setOperations.add("A","12","15","9","13","13");
        setOperations.add("B","1","15","4","13","6");

        //获取其中的交集并返回
        sets =  setOperations.intersect("A","B");
        log.info("集合之间的交集 列表：{}",JsonUtil.gsonString(sets));

        //获取其中的交集并存在另一个key中
        setOperations.intersectAndStore("A","B","C");
        sets = setOperations.members("C");
        log.info("集合之间的交集(存储) 列表：{}",JsonUtil.gsonString(sets));

        //获取集合中的交集
        setOperations.union("A","B");
        log.info("集合之间的并集 列表：{}",JsonUtil.gsonString(sets));

        setOperations.unionAndStore("A","B","C");
        sets = setOperations.members("C");
        log.info("集合之间的并集（存储） 列表：{}",JsonUtil.gsonString(sets));

        //获取集合中的差集
        setOperations.difference("A","B");
        log.info("集合之间的差集 列表：{}",JsonUtil.gsonString(sets));

        setOperations.differenceAndStore("A","B","C");
        sets = setOperations.members("C");
        log.info("集合之间的差集（存储） 列表：{}",JsonUtil.gsonString(sets));

    }

六、Redis的SortSet类型操作

      1、redis客户端命令行

• zadd key score1 value1 score2 value2 ..

添加元素

redis 127.0.0.1:6379> zadd stu 18 lily 19 hmm 20 lilei 21 lilei

(integer) 3

• zrem key value1 value2 ..

作用: 删除集合中的元素

• zremrangebyscore key min max

作用: 按照socre来删除元素,删除score在[min,max]之间的

redis 127.0.0.1:6379> zremrangebyscore stu 4 10

(integer) 2

redis 127.0.0.1:6379> zrange stu 0 -1

1) "f"

• zremrangebyrank key start end

作用: 按排名删除元素,删除名次在[start,end]之间的

redis 127.0.0.1:6379> zremrangebyrank stu 0 1

(integer) 2

redis 127.0.0.1:6379> zrange stu 0 -1

1) "c"

2) "e"

3) "f"

4) "g"

• zrank key member

查询member的排名(升续 0名开始)

• zrevrank key memeber

查询 member的排名(降续 0名开始)

• ZRANGE key start stop [WITHSCORES]

把集合排序后,返回名次[start,stop]的元素

默认是升续排列

Withscores 是把score也打印出来

• zrevrange key start stop

作用:把集合降序排列,取名字[start,stop]之间的元素

• zrangebyscore  key min max [withscores] limit offset N

作用: 集合(升续)排序后,取score在[min,max]内的元素,

并跳过 offset个, 取出N个

redis 127.0.0.1:6379> zadd stu 1 a 3 b 4 c 9 e 12 f 15 g

(integer) 6

redis 127.0.0.1:6379> zrangebyscore stu 3 12 limit 1 2 withscores

1) "c"

2) "4"

3) "e"

4) "9"

• zcard key

返回元素个数

zcount key min max

返回[min,max] 区间内元素的数量

• zinterstore destination numkeys key1 [key2 ...]

[WEIGHTS weight [weight ...]]

[AGGREGATE SUM|MIN|MAX]

求key1,key2的交集,key1,key2的权重分别是 weight1,weight2

聚合方法用: sum |min|max

聚合的结果,保存在dest集合内

注意: weights ,aggregate如何理解?

答: 如果有交集, 交集元素又有socre,score怎么处理?

 Aggregate sum->score相加   , min 求最小score, max 最大score

另: 可以通过weigth设置不同key的权重, 交集时,socre * weights

详见下例

redis 127.0.0.1:6379> zadd z1 2 a 3 b 4 c

(integer) 3

redis 127.0.0.1:6379> zadd z2 2.5 a 1 b 8 d

(integer) 3

redis 127.0.0.1:6379> zinterstore tmp 2 z1 z2

(integer) 2

redis 127.0.0.1:6379> zrange tmp 0 -1

1) "b"

2) "a"

redis 127.0.0.1:6379> zrange tmp 0 -1 withscores

1) "b"

2) "4"

3) "a"

4) "4.5"

redis 127.0.0.1:6379> zinterstore tmp 2 z1 z2 aggregate sum

(integer) 2

redis 127.0.0.1:6379> zrange tmp 0 -1 withscores

1) "b"

2) "4"

3) "a"

4) "4.5"

redis 127.0.0.1:6379> zinterstore tmp 2 z1 z2 aggregate min

(integer) 2

redis 127.0.0.1:6379> zrange tmp 0 -1 withscores

1) "b"

2) "1"

3) "a"

4) "2"

redis 127.0.0.1:6379> zinterstore tmp 2 z1 z2 weights 1 2

(integer) 2

redis 127.0.0.1:6379> zrange tmp 0 -1 withscores

1) "b"

2) "5"

3) "a"

4) "7"

      2、java代码调用

/**
     * redis相关的Sort set操作
     */
    @Test
    public void testRedisSortSet() {
        //获取操作SortSet 操作对象
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();

        String key = "names";
        //添加元素
        //单个元素添加
        zSetOperations.add(key,"xieqx",10);

        //添加多个
        Set> set = new HashSet<>();
        DefaultTypedTuple element = new DefaultTypedTuple("szb",9.3);
        DefaultTypedTuple elementA = new DefaultTypedTuple("lzj",9.0);
        DefaultTypedTuple elementB = new DefaultTypedTuple("qxx",8.9);

        set.add(element);
        set.add(elementA);
        set.add(elementB);
        zSetOperations.add(key,set);

        //获取单个值。获取所有值
        //获取 start 到end范围的数据
        Set sets = zSetOperations.range(key,0,2);

        log.info("根据范围获取的值：{}",JsonUtil.gsonString(sets));

        /*
        out(vo.rangeByLex("book", Range.range().lte("f").gte("b")));
        out(vo.rangeByLex("book", Range.range(), Limit.limit().count(2).offset(0)));
        out(vo.rangeByLex("book", Range.range(), Limit.limit().count(2).offset(2)));
         */

        //根据值去筛选数据
        //获取小于等于“value1”大于等于“value2”
        sets = zSetOperations.rangeByLex(key, RedisZSetCommands.Range.range().lte("xieqx").gte("lzj"));
        log.info("根据范围Rangge获取的值：{}",JsonUtil.gsonString(sets));

        //从key中获取从0（偏移量）数量为2的数据信息
        sets = zSetOperations.rangeByLex(key,  RedisZSetCommands.Range.range(), RedisZSetCommands.Limit.limit().count(2).offset(0));
        log.info("根据范围Rangge获取的值：{}",JsonUtil.gsonString(sets));

        //根据得分筛选数据
        sets = zSetOperations.rangeByScore(key,1,950);
        log.info("根据分数范围获取的值：{}",JsonUtil.gsonString(sets));

        sets = zSetOperations.rangeByScore(key,9.0,9.5,1,2);
        log.info("根据分数范围获取的值：{}",JsonUtil.gsonString(sets));

        //根据得分筛选数据 并将分数也会封装在TypedTuple
        Set> typeSet = zSetOperations.rangeByScoreWithScores(key,9.0,9.5,0,3);

         for(ZSetOperations.TypedTuple typedTuple:typeSet){
             log.info("获取的信息：score {}，value {}",typedTuple.getScore(),typedTuple.getValue());
         }

         //返回元素的个数
        long count = zSetOperations.count(key,0,10);
         log.info("所有元素的个数：{}",count);


        String key2 = "names2";
        //添加元素
        //单个元素添加
        zSetOperations.add(key2,"xieqx",4);

        //添加多个
        Set> set2 = new HashSet<>();
        DefaultTypedTuple element2 = new DefaultTypedTuple("szb",3D);
        DefaultTypedTuple element2A = new DefaultTypedTuple("lzj",1D);
        DefaultTypedTuple element2B = new DefaultTypedTuple("qxx",1D);

        set2.add(element);
        set2.add(elementA);
        set2.add(elementB);
        zSetOperations.add(key2,set2);

        zSetOperations.intersectAndStore(key,key,"desc");
        sets = zSetOperations.rangeByScore("desc",0,10);
        log.info("根据分数范围获取的值：{}",JsonUtil.gsonString(sets));

    }

七、Redis的hash类型操作

      1、redis客户端命令行

• hset key field value

作用: 把key中 filed域的值设为value

注:如果没有field域,直接添加,如果有,则覆盖原field域的值

• hmset key field1 value1 [field2 value2 field3 value3 ......fieldn valuen]

作用: 设置field1->N 个域, 对应的值是value1->N

• hget key field
• 作用: 返回key中field域的值
• hmget key field1 field2 fieldN

作用: 返回key中field1 field2 fieldN域的值

• hgetall key

作用:返回key中,所有域与其值

• hdel key field

作用: 删除key中 field域

• hlen key

作用: 返回key中元素的数量

• hexists key field

作用: 判断key中有没有field域

• hinrby key field value

作用: 是把key中的field域的值增长整型值value

• hinrby float  key field value

作用: 是把key中的field域的值增长浮点值value

• hkeys key

作用: 返回key中所有的field

• kvals key

作用: 返回key中所有的value

 

      2、java代码调用

    /**
     * redis相关的Hash操作
     */
    @Test
    public void testRedisHash() {
        //获取操作hash的对象
        HashOperations hashOperations = redisTemplate.opsForHash();
        String key = "hash";
        //存放单个hash 如果key不存在则存储，否则不存储
        hashOperations.putIfAbsent(key,"1","xieqx");
        hashOperations.putIfAbsent(key,"2","qixx");

        hashOperations.put(key,"3","szb");

        Map data = new HashMap<>();
        data.put("4","aaa");
        data.put("5","bbb");
        data.put("6","ccc");
        hashOperations.putAll(key,data);

        //获取单个数据
       String value = hashOperations.get(key,"1");
       log.info("value:{}",value);

       Map hashData = hashOperations.entries(key);
       log.info("hashData : {}",JsonUtil.gsonString(hashData));

       //删除 真实删除的数据
        long deleNum = hashOperations.delete(key,"1","2","3");

        //获取hash数据的长度
        long len = hashOperations.size(key);
        log.info("hash 数据长度:{}",len);

        //判断hashKey是否存在
        boolean hasKey = hashOperations.hasKey(key,"123");
        log.info("查看hashkey是否存在：{}",hasKey);

        hashOperations.put(key,"num","123");

        hashOperations.increment(key,"num",5);

        String num = hashOperations.get(key,"num");
        log.info("num:{}",num);

        //获取所有的keys
        Set sets = hashOperations.keys(key);
        log.info("获取hash中所有的key:{}",JsonUtil.gsonString(key));

        //获取所有的values
        List values = hashOperations.values(key);
        log.info("获取hash中所有的key:{}",JsonUtil.gsonString(values));
    }