Redis实战-Redis命令

1 字符串

由字节组成的序列，可以存储字符串、整数和浮点数。

表 1 redis字符串的自增和自减命令

命令	用例和描述
INCR	INCR key-name，将键的存储值加1
DECR	DECR key-name，将键的存储值减一
DECRBY	DECRBY key-name amount，将键存储值减少amount
INCRBY	INCRBY key-name amount，将键存储值增加amount

Java示例demo-1：

/**
     * 字符串基本命令操作
     */
    @Test
    void strCommandTest() {
        //自增自减命令
        redisTemplate.opsForValue().set("age", 10);
        Assertions.assertEquals(redisTemplate.opsForValue().get("age"), 10);
        redisTemplate.opsForValue().increment("age");
        redisTemplate.opsForValue().increment("age", 20);
        Assertions.assertEquals(redisTemplate.opsForValue().get("age"), 31);
        redisTemplate.opsForValue().decrement("age");
        redisTemplate.opsForValue().decrement("age", 20);
        Assertions.assertEquals(redisTemplate.opsForValue().get("age"), 10);
    }

表 2 redis字符串高级命令

命令	用例和描述
APPEND	APPEND key-name value，将给定value追加到给定键存储值末尾
GETRANGE	GETRANGE key-name start end，获取偏移量start-end的子串
SETRANGE	SETRANGE key-name offset value，从offset开始设置value覆盖后续字符串内容

Java示例demo-2：

/**
     * 字符串高级命令操作
     */
    @Test
    void strAdvancedCommandTest() {
        //不适用默认的配置序列化解析器
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        redisTemplate.opsForValue().set("hello", "world");
        redisTemplate.opsForValue().append("hello", "nihao");
        Assertions.assertEquals("worldnihao", redisTemplate.opsForValue().get("hello"));
        Assertions.assertEquals("world", redisTemplate.opsForValue().get("hello", 0, 4));
        //会覆盖之后的字符
        redisTemplate.opsForValue().set("hello", "aaa", 0);
        Assertions.assertEquals("aaaldnihao", redisTemplate.opsForValue().get("hello"));
    }

注意：这里将Value序列化设置为字符串，不使用我们之前配置的序列化器，因为append默认是使用字符串序列化器进行序列化添加内容，如果不设置可能导致无法解析出正确结果。

2 列表

列表允许从两端推入或者弹出元素。

表 3 redis列表的常用命令

命令	用例和描述
RPUSH	RPUSH key-name value……，将一个多个value从列表右侧推入
LPUSH	LPUSH key-name value……，将一个多个value从列表左侧推入
RPOP	RPOP key-name ，移除并返回最右侧元素
LPOP	LPOP key-name ，移除并返回最左侧元素
LINDEX	LINDEX key-name offset，返回列表中偏移量为offset的元素
LRANGE	LRANGE key-name start end，返回start-end范围的所以元素
LTRIM	LTRIM key-name start end，修建列表为start-end范围内元素

Java代码示例demo-3：

@Test
    void listCommandTest() {
        redisTemplate.opsForList().rightPushAll("list1", "aa", "bb", "cc", "dd");
        System.out.println(redisTemplate.opsForList().range("list1", 0, -1));
        Assertions.assertEquals(redisTemplate.opsForList().index("list1", 1), "bb");
        redisTemplate.opsForList().trim("list1", 0, 2);
        System.out.println(redisTemplate.opsForList().range("list1", 0, -1));
    }

列表还有一些阻塞命令，通过阻塞直到存在元素。

表 4 redis列表的高级命令

命令	用例和描述
BLPOP	BLPOP key-name …… timeout，从第一个非空列表弹出最左端元素，等待时间timeout
BRPOP	BRPOP key-name…… timeout，从第一个非空列表弹出最右端元素，等待时间timeout
RPOPLPUSH	RPOPLPUSH source-key dest-key，从source-key弹出右侧元素，推入dest-key左侧
BRPOPLPUSH	BRPOPLPUSH source-key dest-key timeout，从source-key弹出右侧元素，推入dest-key左侧，等待阻塞时间timeout

Java示例demo-4：

/**
     * 列表阻塞命令操作
     */
    @Test
    void listBlockCommandTest() {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        redisTemplate.delete(Arrays.asList("listTwo", "listDestinagtion"));
        redisTemplate.opsForList().leftPushAll("listTwo", "aa");
        redisTemplate.opsForList().rightPopAndLeftPush("listTwo", "listDestination");
        //测试阻塞弹出-类似生产者-消费者
        try {
            executorService.execute(() -> {
                //生产者
                redisTemplate.opsForList().leftPushAll("listTwo", "dd", "ee");
            });
        } finally {
            executorService.shutdown();
        }
        //消费者
        Object leftPop = redisTemplate.opsForList().leftPop("listTwo", 2, TimeUnit.SECONDS);
        Assertions.assertEquals(leftPop, "ee");
        Assertions.assertEquals(redisTemplate.opsForList().rightPop("listTwo", 2, TimeUnit.SECONDS), "dd");
    }

这里需要通过多线程进行演示阻塞情况。
阻塞命令常用于消息传递和任务队列。

3 集合

以无序方式存储多个各不相同的元素。

表 5 redis集合的基本命令

命令	用例和描述
SADD	SADD key-name item……，将一个或多个item添加到集合
SREM	SREM key-name item……，将一个或多个元素从集合移除
SISMEMBER	SISMEMBER key-name item，检查item是否存在于集合中
SCARD	SCARD key-name，返回集合包含元素个数
SMEMBERS	SMEMBERS key-name，返回集合包含的所以元素
SRANDMEMBER	SRANDMEMBER key-name count，从集合随机返回count个元素
SPOP	SPOP key-name，随机移除集合中一个元素，并返回
SMOVE	SMOVE source-key dest-key item，如果元素存在于源key，则移动到目的key

Java示例demo-5：

/**
     * 集合基本命令
     */
    @Test
    void collectionCommandTest() {
        redisTemplate.opsForSet().add("collOne", "v1", "v2", "v3");
        Assertions.assertTrue(redisTemplate.opsForSet().isMember("collOne", "v1"));
        redisTemplate.opsForSet().remove("collOne", "v1");
        //随机返回一个
        System.out.println(redisTemplate.opsForSet().randomMember("collOne"));
        Assertions.assertEquals(redisTemplate.opsForSet().size("collOne"), 2);
        redisTemplate.delete("collOne");
    }

集合还有一些高级命令可以操作多个集合。

以无序方式存储多个各不相同的元素。

表 6 redis集合的高级命令

命令	用例和描述
SDIFF	SDIFF key-name [key-name……]，返回存在于第一个集合，不存在其它集合的元素，差集
SDIFFSTORE	SDIFFSTORE dest-key key-name [key-name……]，将差集内容存储到集合dest-key
SINTER	SINTER key-name [key-name……]，返回同时存在于集合中的元素，交集
SINTERSTORE	SINTERSTORE dest-key key-name [key-name……]，将交集存储到dest-key
SUNION	SUNION key-name [key-name……]，返回至少存在于一个集合中的元素，并集
SUNIONSTORE	SUNIONSTORE dest-key key-name [key-name……]，将并集存储到dest-key

Java示例demo-6：

/**
     * 集合并集、交集和差集操作。
     */
    @Test
    void collectionAdvancedCommandTest() {
        redisTemplate.opsForSet().add("skey1", "a", "b", "c", "d");
        redisTemplate.opsForSet().add("skey2", "c", "d", "e", "f");
        redisTemplate.opsForSet().difference("skey1", "skey2").stream().forEach(System.out::print);
        redisTemplate.opsForSet().differenceAndStore("skey1", "skey2", "diffColl");
        Assertions.assertEquals(2, redisTemplate.opsForSet().size("diffColl"));
        System.out.println();
        redisTemplate.opsForSet().intersect("skey1", "skey2").stream().forEach(System.out::print);
        redisTemplate.opsForSet().intersectAndStore("skey1", "skey2", "intersectColl");
        Assertions.assertEquals(2, redisTemplate.opsForSet().size("intersectColl"));
        System.out.println();
        redisTemplate.opsForSet().union("skey1", "skey2").stream().forEach(System.out::print);
        redisTemplate.opsForSet().unionAndStore("skey1", "skey2", "unionColl");
        Assertions.assertEquals(6, redisTemplate.opsForSet().size("unionColl"));
        redisTemplate.delete(Arrays.asList("skey1", "skey2", "diffColl", "intersectColl", "unionColl"));
    }

4 散列

散列类似数据库的行，每个散列可以存储对应的各种属性项。

常见的散列操作：

表 7 redis散列的基本命令

命令	用例和描述
HMGET	HMGET key-name key [key……]，从散列中取出一个或n个键值对
HMSET	HMSET key-name key value [key value……]，设置散列的一个或多个键值对
HDEL	HDEL key-name key [key……]，从散列删除一个多个键值对
HLEN	HLEN key-name，返回散列的键值对数量

Java示例demo-7：

/**
     * hash基本操作
     */
    @Test
    void hashCommandTest() {
        Map<String, String> map = new HashMap<>();
        map.put("k1", "v1");
        map.put("k2", "v2");
        map.put("k3", "v3");
        redisTemplate.opsForHash().putAll("hashOne", map);
        redisTemplate.opsForHash().multiGet("hashOne", Arrays.asList("k1", "k2", "k3")).stream().forEach(System.out::print);
        redisTemplate.opsForHash().delete("hashOne", "k1");
        Assertions.assertEquals(2, redisTemplate.opsForHash().size("hashOne"));
        redisTemplate.delete("hashOne");
    }

散列还存在一些高级命令：

表 8 redis散列的高级命令

命令	用例和描述
HEXISTS	HEXISTS key-name key，检查key是否存在于散列中
HKEYS	HKEYS key-name，返回散列所有键
HVALS	HVALS key-name，返回散列所有值
HGETALL	HGETALL key-name 返回散列所有键值对
HINCRBY	HINCRBY key-name key increment，将key的值增加increment

Java示例demo-8：

/**
     * hash高级操作
     */
    @Test
    void hashAdvancedCommandTest() {
        Map<String, String> map = new HashMap<>();
        map.put("k1", "v1");
        map.put("k2", "v2");
        map.put("k3", "v3");
        redisTemplate.opsForHash().putAll("hashOne", map);
        Assertions.assertTrue(redisTemplate.opsForHash().hasKey("hashOne", "k1"));
        redisTemplate.opsForHash().keys("hashOne").stream().forEach(System.out::print);
        System.out.println();
        redisTemplate.opsForHash().values("hashOne").stream().forEach(System.out::print);
        System.out.println();
        redisTemplate.opsForHash().entries("hashOne").forEach((k, v) -> {
            System.out.printf("key-val: %s-%s; ", k, v);

        });
        redisTemplate.opsForHash().increment("hashOne", "k4", 10);
        Assertions.assertEquals(10, redisTemplate.opsForHash().get("hashOne", "k4"));
        redisTemplate.delete("hashOne");
    }

5 有序集合

存储键和值之间的映射。

常见的有序集合命令：

表 9 redis有序集合的基本命令

命令	用例和描述
ZADD	ZADD key-name score member [score member……]，添加一个多个成员
ZREM	ZREM key-name member [member……]，移除一个或多个成员
ZCARD	ZCARD key-name，返回成员个数
ZINCRBY	ZINCRBY key-name increment member，增加成员对应分数
ZCOUNT	ZCOUNT key-name min max，返回分值介于min，max直接成员个数
ZRANK	ZRANK key-name member，返回成员的排名
ZSCORE	ZSCORE key-name member，返回成员分数
ZRANGE	ZRANGE key-name start end [withscores]，返回介于指定范围的成员，可选项带分数返回

Java示例demo-9：

/**
     * 有序集合基本命令
     */
    @Test
    void orderedSetCommandTest() {
        @Data
        class Tuple implements ZSetOperations.TypedTuple<Object> {
            private String value;
            private double score;

            @Override
            public Object getValue() {
                return value;
            }

            @Override
            public Double getScore() {
                return score;
            }

            @Override
            public int compareTo(ZSetOperations.TypedTuple<Object> o) {
                return Double.compare(this.score, o.getScore());
            }
        }
        Tuple tupleOne = new Tuple();
        tupleOne.setScore(30);
        tupleOne.setValue("k1");
        Tuple tupleTwo = new Tuple();
        tupleTwo.setScore(40);
        tupleTwo.setValue("k2");
        Set<ZSetOperations.TypedTuple<Object>> set = new HashSet<>();
        set.add(tupleOne);
        set.add(tupleTwo);
        redisTemplate.opsForZSet().add("orderedsetOne", set);
        redisTemplate.opsForZSet().remove("orderedsetOne", "k1");
        Assertions.assertEquals(1, redisTemplate.opsForZSet().size("orderedsetOne"));
        redisTemplate.opsForZSet().incrementScore("orderedsetOne", "k2", 21);
        Assertions.assertEquals(61, redisTemplate.opsForZSet().score("orderedsetOne", "k2"));
        Assertions.assertEquals(1, redisTemplate.opsForZSet().count("orderedsetOne", 60, 62));
        Assertions.assertEquals(0, redisTemplate.opsForZSet().rank("orderedsetOne", "k2"));
        redisTemplate.opsForZSet().range("orderedsetOne", 0, -1).stream().forEach(System.out::print);
        redisTemplate.delete("orderedsetOne");
    }

高级的有序集合命令：

表 10 redis有序集合的高级命令

命令	用例和描述
ZINTERSTORE	ZINTERSTORE dest-key key-count key [key……] [weight] [aggregate sum
ZUNIONSTORE	ZUNIONSTORE dest-key key-count key [key……] [weight] [aggregate sum

还包括各种rev命令同上述基本命令相反的从大到小的排列顺序。

Java示例demo-10：

@Test
    void orderedsetAdvancedCommandTest() {
        redisTemplate.opsForZSet().add("setOne", "k1", 10);
        redisTemplate.opsForZSet().add("setOne", "k2", 20);
        redisTemplate.opsForZSet().add("setOne", "k3", 30);
        redisTemplate.opsForZSet().add("setTwo", "k2", 20);
        redisTemplate.opsForZSet().add("setTwo", "k3", 30);
        redisTemplate.opsForZSet().add("setTwo", "k4", 40);
        //操作类似集合操作
        System.out.println();
        redisTemplate.opsForZSet().intersectAndStore("setOne", "setTwo", "intersect");
        Assertions.assertEquals(2, redisTemplate.opsForZSet().zCard("intersect"));
        System.out.println();
        redisTemplate.opsForZSet().unionAndStore("setOne", "setTwo", "union");
        Assertions.assertEquals(4, redisTemplate.opsForZSet().zCard("union"));
        redisTemplate.delete(Arrays.asList("setOne", "setTwo", "intersect", "union"));
    }