0

我正在尝试使用 Redis 的扫描功能，该功能需要调用，直到返回的光标为“0”。

这种方法有效，但感觉过于复杂 - 有没有一种方法可以在没有递归的情况下做到这一点？

Uni<Object> callScanRecursively(String cursorNum, List<String> results) {
  List<String> args = new ArrayList<>(List.of(cursorNum, "MATCH", "*"));
  return reactiveRedisClient.scan(args)
      .onItem()
      .transformToUni(item -> {
            List<String> keysList = new ArrayList<>();
            item.get(1).forEach(k -> {
              keysList.add(k.toString());
            });
            results.addAll(keysList);

            if (item.get(0).toString().equals("0")) {
              return Uni.createFrom().item(results);
            } else {
              String nextCursorNum = item.get(0).toString();
              return callScanRecursively(nextCursorNum, results);
            }
          }
      );
}

List<String> results = new ArrayList<>();
String startingCursorRedis = "0";
callScanRecursively(startingCursorRedis, results)
    .subscribe()
    .with(item ->
        LOGGER.info(item)
    );
4

1 回答 1

1

当给定条件仍未满足时，您可以使用通过发射器MultiRepeat收集结果：ReactiveRedisClient#scanUniresponse.get(0).toString().equals("0")

单向发射器

Multi<String> callScan(String initialCursor) {
    final AtomicReference<String> cursorReference = new AtomicReference<>(initialCursor);
    return Multi.createBy()
            .repeating()
            .<AtomicReference<String>, List<String>>uni(
                    () -> cursorReference,
                    (state, emitter) -> reactiveRedisClient.scan(List.of(state.get(), "MATCH", "*"))
                            .subscribe()
                            .with(response -> {
                                if (response.get(0).toString().equals("0")) {
                                    cursorReference.set(null);
                                } else {
                                    state.set(response.get(0).toString());
                                }
                                java.util.List<String> keysList = new ArrayList<>();
                                response.get(1).forEach(k -> keysList.add(k.toString()));
                                emitter.complete(keysList);
                            })
            )
            .whilst(o -> cursorReference.get() != null)
            .flatMap(l -> Multi.createFrom().iterable(l));
}

单

如果您不需要对发出的项目进行更多控制，甚至更简单：

Multi<String> callScan(String initialCursor) {
    ReactiveRedisClientImpl reactiveRedisClient = new ReactiveRedisClientImpl();
    final AtomicReference<String> cursorReference = new AtomicReference<>(initialCursor);
    return Multi.createBy()
            .repeating()
            .uni(
                    () -> cursorReference,
                    (state) -> reactiveRedisClient.scan(List.of(state.get(), "MATCH", "*"))
                            .invoke(response -> {
                                if (response.get(0).toString().equals("0")) {
                                    cursorReference.set(null);
                                } else {
                                    state.set(response.get(0).toString());
                                }
                            })
                            .map(response -> {
                                List<String> keysList = new ArrayList<>();
                                response.get(1).forEach(k -> keysList.add(k.toString()));
                                return keysList;
                            })
            )
            .whilst(o -> cursorReference.get() != null)
            .flatMap(l -> Multi.createFrom().iterable(l));
}
于 2021-11-10T16:00:00.263 回答