Spring Data Redis 教程

ReactiveListOperations 操作接口

Spring Data Redis 中,list 类型的响应式接口为 ReactiveListOperations,该接口定义的方法和 ListOperations、BoundListOperations 接口定义的方法非常类似。

可以通过 ReactiveRedisTemplate 的 opsForList() 方法获取获取,代码如下:

ReactiveListOperations<String,String> ops = reactiveRedisTemplate.opsForList();

列表范围取值

  • reactor.core.publisher.Flux<V> range(K key, long start, long end) 从键的列表中获取 start 到 end 之间的元素

示例:

@Test
public void range() throws Exception {
    // 利用阻塞队列实现等待
    LinkedBlockingDeque<String> queue = new LinkedBlockingDeque<>();
    ReactiveListOperations<String,String> ops = reactiveRedisTemplate.opsForList();
    // 添加元素
    ops.leftPushAll("list-key", "value1", "value2", "value3", "value4")
            .subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long aLong) {
                    queue.add("leftPushAll 执行成功,添加 " + aLong + " 个元素");
                }
            });
    System.out.println(queue.take());

    // 使用 range 获取列表部分元素
    ops.range("list-key", 1, 2)
        .subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
}

运行示例,输出结果如下:

leftPushAll 执行成功,添加 4 个元素
value3
value2

注意,上面示例使用了 LinkedBlockingDeque 阻塞队列来实现两个或多个异步响应式操作的同步操作。

列表左边入栈

  • reactor.core.publisher.Mono<Long> leftPush(K key, V value) 将值添加到键存储列表的左边

  • reactor.core.publisher.Mono<Long> leftPush(K key, V pivot, V value) 将值添加到键存储列表中 prvot 值的前面,即值的左边

  • reactor.core.publisher.Mono<Long> leftPushAll(K key, Collection<V> values) 将多个值添加到键存储列表的左边

  • reactor.core.publisher.Mono<Long> leftPushAll(K key, V... values) 将多个值添加到键存储列表的左边

  • reactor.core.publisher.Mono<Long> leftPushIfPresent(K key, V value) 仅当列表存在时,才将值添加到键存储的列表

示例:

@Test
public void leftPush() throws Exception {
    // 利用阻塞队列实现等待
    LinkedBlockingDeque<String> queue = new LinkedBlockingDeque<>();
    ReactiveListOperations<String,String> ops = reactiveRedisTemplate.opsForList();
    // 添加一个元素
    ops.leftPush("list-key", "value1").subscribe(new Consumer<Long>() {
        @Override
        public void accept(Long aLong) {
            queue.add("leftPush 添加成功 aLong=" + aLong);
        }
    });
    System.out.println(queue.take());

    // 添加多个元素
    ops.leftPushAll("list-key", "value2", "value3", "value4")
            .subscribe(new Consumer<Long>() {
        @Override
        public void accept(Long aLong) {
            queue.add("leftPushAll 添加成功 aLong=" + aLong);
        }
    });
    System.out.println(queue.take());

    // 获取列表中的值
    ops.range("list-key", 0, -1).subscribe(new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    });
}

运行示例,输出结果如下:

leftPush 添加成功 aLong=1
leftPushAll 添加成功 aLong=4
value4
value3
value2
value1

列表左边出栈

  • reactor.core.publisher.Mono<V> leftPop(K key) 移除并返回存储在键的列表中的第一个元素

  • reactor.core.publisher.Mono<V> leftPop(K key, Duration timeout) 在指定的超时时间中移除并返回存储在键的列表中的第一个元素

示例:

@Test
public void leftPop() throws Exception {
    // 利用阻塞队列实现等待
    LinkedBlockingDeque<String> queue = new LinkedBlockingDeque<>();
    ReactiveListOperations<String,String> ops = reactiveRedisTemplate.opsForList();
    // 添加数据
    ops.leftPushAll("list-key", "value1", "value2", "value3", "value4", "value5")
            .subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long aLong) {
                    queue.add("成功添加了 " + aLong + " 元素");
                }
            });
    System.out.println(queue.take());

    // 异步获取数据
    ops.leftPop("list-key").subscribe(new Consumer<String>() {
        @Override
        public void accept(String s) {
            queue.add("leftPop 执行成功,值=" + s);
        }
    });
    System.out.println(queue.take());
}

运行示例,输出结果如下:

成功添加了 5 元素
leftPop 执行成功,值=value5

列表右边入栈

reactor.core.publisher.Mono<Long> rightPush(K key, V value) 将值添加到键存储的列表的右边

reactor.core.publisher.Mono<Long> rightPush(K key, V pivot, V value) 将值添加到键存储的列表中 pivot 值的前面,即右边

reactor.core.publisher.Mono<Long> rightPushAll(K key, Collection<V> values) 将多个值添加到键存储的列表的右边

reactor.core.publisher.Mono<Long> rightPushAll(K key, V... values) 将多个值添加到键存储的列表的右边

reactor.core.publisher.Mono<Long> rightPushIfPresent(K key, V value) 仅当列表存在时才将值追加到键存储的列表的右边

示例:

@Test
public void rightPush() throws Exception {
    // 利用阻塞队列实现等待
    LinkedBlockingDeque<String> queue = new LinkedBlockingDeque<>();
    ReactiveListOperations<String,String> ops = reactiveRedisTemplate.opsForList();
    ops.rightPush("list-key", "value1").subscribe(new Consumer<Long>() {
        @Override
        public void accept(Long aLong) {
            queue.add("rightPush 执行成功");
        }
    });
    System.out.println(queue.take());

    ops.rightPushAll("list-key", "value2", "value3", "value4", "value5")
        .subscribe(new Consumer<Long>() {
            @Override
            public void accept(Long aLong) {
                queue.add("rightPushAll 执行成功");
            }
        });
    System.out.println(queue.take());

    // 获取列表所有元素
    ops.range("list-key", 0, -1).subscribe(new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    });
}

运行示例,输出结果如下:

rightPush 执行成功
rightPushAll 执行成功
value1
value2
value3
value4
value5

列表右端出栈

  • reactor.core.publisher.Mono<V> rightPop(K key) 移除并返回键存储的列表中的最后一个元素

  • reactor.core.publisher.Mono<V> rightPop(K key, Duration timeout) 指定在超时时间内移除并返回键存储的列表中的最后一个元素

  • reactor.core.publisher.Mono<V> rightPopAndLeftPush(K sourceKey, K destinationKey) 从 sourceKey 的列表中删除最后一个元素,将其追加到 destinationKey 键存储的列表并返回其值

  • reactor.core.publisher.Mono<V> rightPopAndLeftPush(K sourceKey, K destinationKey, Duration timeout) 从列表中删除 srcKey 处的最后一个元素,将其附加到 dstKey 键存储的列表并返回其值

示例:

@Test
public void rightPop() throws Exception {
    // 利用阻塞队列实现等待
    LinkedBlockingDeque<String> queue = new LinkedBlockingDeque<>();
    ReactiveListOperations<String,String> ops = reactiveRedisTemplate.opsForList();
    // 初始化数据
    ops.rightPushAll("list-key", "value1", "value2", "value3", "value4", "value5")
        .subscribe(new Consumer<Long>() {
            @Override
            public void accept(Long aLong) {
                queue.add("rightPushAll 执行成功,添加了" + aLong + "个元素");
            }
        });
    System.out.println(queue.take());

    // 出栈数据
    ops.rightPop("list-key").subscribe(new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    });
}

运行示例,输出结果如下:

rightPushAll 执行成功,添加了5个元素
value5

设置/获取指定下标值

  • reactor.core.publisher.Mono<Boolean> set(K key, long index, V value) 将 value 设置给列表中 index 索引位置处

  • reactor.core.publisher.Mono<V> index(K key, long index) 获取列表中指定 index 索引的值

示例:

@Test
public void set() throws Exception {
    // 利用阻塞队列实现等待
    LinkedBlockingDeque<String> queue = new LinkedBlockingDeque<>();
    ReactiveListOperations<String,String> ops = reactiveRedisTemplate.opsForList();
    // 初始化数据
    ops.rightPushAll("list-key", "value1", "value2", "value3", "value4", "value5")
            .subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long aLong) {
                    queue.add("rightPushAll 执行成功,添加了" + aLong + "个元素");
                }
            });
    System.out.println(queue.take());

    // 设置元素
    ops.set("list-key", 1, "new value").subscribe(new Consumer<Boolean>() {
        @Override
        public void accept(Boolean aBoolean) {
            queue.add("set 执行" + (aBoolean ? "成功" : "失败"));
        }
    });
    System.out.println(queue.take());

    // 获取所有数据
    ops.range("list-key", 0, -1).subscribe(new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    });
}

运行示例,输出结果如下:

rightPushAll 执行成功,添加了5个元素
set 执行成功
value1
new value
value3
value4
value5

获取大小

  • reactor.core.publisher.Mono<Long> size(K key) 获取键存储的列表的大小

示例:

@Test
public void size() throws Exception {
    // 利用阻塞队列实现等待
    LinkedBlockingDeque<String> queue = new LinkedBlockingDeque<>();
    ReactiveListOperations<String,String> ops = reactiveRedisTemplate.opsForList();
    // 初始化数据
    ops.rightPushAll("list-key", "value1", "value2", "value3", "value4", "value5")
            .subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long aLong) {
                    queue.add("rightPushAll 执行成功,添加了" + aLong + "个元素");
                }
            });
    System.out.println(queue.take());

    // 获取列表大小
    ops.size("list-key").subscribe(new Consumer<Long>() {
        @Override
        public void accept(Long aLong) {
            System.out.println("size=" + aLong);
        }
    });
}

运行示例,输出结果如下:

rightPushAll 执行成功,添加了5个元素
size=5

移除元素

  • reactor.core.publisher.Mono<Long> remove(K key, long count, Object value) 从列表中移除首次出现的 count 个等于 value 的元素

示例:

@Test
public void remove() throws Exception {
    // 利用阻塞队列实现等待
    LinkedBlockingDeque<String> queue = new LinkedBlockingDeque<>();
    ReactiveListOperations<String,String> ops = reactiveRedisTemplate.opsForList();
    // 初始化数据
    ops.rightPushAll("list-key", "value1", "value2", "value2", "value2", "value5")
            .subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long aLong) {
                    queue.add("rightPushAll 执行成功,添加了" + aLong + "个元素");
                }
            });
    System.out.println(queue.take());

    // 删除数据
    ops.remove("list-key", 2, "value2").subscribe(new Consumer<Long>() {
        @Override
        public void accept(Long aLong) {
            queue.add("成功删除 " + aLong + " 个元素");
        }
    });
    System.out.println(queue.take());

    // 获取所有数据
    ops.range("list-key", 0, -1).subscribe(new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    });
}

运行示例,输出结果如下:

rightPushAll 执行成功,添加了5个元素
成功删除 2 个元素
value1
value2
value5

裁剪列表

  • reactor.core.publisher.Mono<Boolean> trim(K key, long start, long end) 将列表中 start 到 end 之间的元素保留,其他元素删除

示例:

@Test
public void trim() throws Exception {
    // 利用阻塞队列实现等待
    LinkedBlockingDeque<String> queue = new LinkedBlockingDeque<>();
    ReactiveListOperations<String,String> ops = reactiveRedisTemplate.opsForList();
    // 初始化数据
    ops.rightPushAll("list-key", "value1", "value2", "value3", "value4", "value5")
            .subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long aLong) {
                    queue.add("rightPushAll 执行成功,添加了" + aLong + "个元素");
                }
            });
    System.out.println(queue.take());

    // 裁剪列表
    ops.trim("list-key", 1, 3).subscribe(new Consumer<Boolean>() {
        @Override
        public void accept(Boolean aBoolean) {
            queue.add("trim 执行" + (aBoolean ? "成功" : "失败"));
        }
    });
    System.out.println(queue.take());

    // 获取所有数据
    ops.range("list-key", 0, -1).subscribe(new Consumer<String>() {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    });
}

运行示例,输出结果如下:

rightPushAll 执行成功,添加了5个元素
trim 执行成功
value2
value3
value4

删除键

  • reactor.core.publisher.Mono<Boolean> delete(K key) 删除指定的键

示例:

@Test
public void delete() throws Exception {
    // 利用阻塞队列实现等待
    LinkedBlockingDeque<String> queue = new LinkedBlockingDeque<>();
    ReactiveListOperations<String,String> ops = reactiveRedisTemplate.opsForList();
    // 初始化数据
    ops.rightPushAll("list-key", "value1", "value2", "value3", "value4", "value5")
            .subscribe(new Consumer<Long>() {
                @Override
                public void accept(Long aLong) {
                    queue.add("rightPushAll 执行成功,添加了" + aLong + "个元素");
                }
            });
    System.out.println(queue.take());

    // 删除列表
    ops.delete("list-key").subscribe(new Consumer<Boolean>() {
        @Override
        public void accept(Boolean aBoolean) {
            System.out.println(aBoolean ? "删除成功" : "删除失败");
        }
    });
}

运行示例,输出结果如下:

rightPushAll 执行成功,添加了5个元素
删除成功


说说我的看法
全部评论(
没有评论
关于
本网站属于个人的非赢利性网站,转载的文章遵循原作者的版权声明,如果原文没有版权声明,请来信告知:hxstrive@outlook.com
公众号