Question

问题是用RX模拟双循环行为：

while True:
    try:
        token = get_token()
        while True:
            try:
                value = get_value_using_token(token)
                do_something(value)
            except:
                break
    except:
        break

如果将两个循环替换为两个可观察对象，一个充当外部观察者的观察者，那么它将是干净的，而do_something(value)可以由观察者自己替换。任何异常都可以很好地处理。外循环需要阻塞，但内循环可能不是，因为我试图使用外循环来处理异常，使用具有退避功能的重试功能。

到目前为止，我可以使用以下方法构建序列：

Observable.from_iterable(value for value in iter(get_token, None))
    .subscribe(do_something)

但是如何在外部阻塞模式下制作类似的结构呢？

Answer 1

您只需使用Repeat运算符即可创建循环。然后你需要Retry运算符继续失败。

像

这样的东西

Observable.return(get_token())
    .flatMap(token->Observable.return(get_value_using_token(token))
        .repeat())
    .retry()
.subscribe(do_something)

*我不懂python，所以我希望你能转换那个伪代码

Answer 2

我最终做的是使用repeat运算符创建无限的函数流，并在其调用中创建map。

def get_token():
    return some_value

def get_value_with_token(token):
    return some_value_using_token

Observable.repeat(get_token)\
    .map(lambda f: f())\
    .map(lambda n: O.repeat(lambda: get_value_with_token(n)))\
    .concat_all()\
    .map(lambda f: f())\
    .subscribe(logger.info)

其中get_token和get_value_with_token是函数。

通过对两者使用阻塞函数，我可以进行双循环，并将其他rx运算符（例如retry）应用于observable。

在RX中构建双无限轮询行为

2 个答案: