标签: reactive-programming

如何从队列中创建 IObservable,以便在队列为空时序列不会结束?

我正在研究使用 Reactive Extensions for .NET (Rx) 的东西,我想要一个从队列(或类似的)中获取输入的序列。

我试过这样做:

    static readonly Queue<DeviceTransaction> TransactionQueue = new Queue<DeviceTransaction>();
    //...
    var observableTransactionSource = TransactionQueue.ToObservable();
    //...
    observableTransactionSource.Subscribe(transactionObserver);
Run Code Online (Sandbox Code Playgroud)

它在一定程度上起作用,但是当队列为空时序列完成。我不想要一个空队列来结束序列。空并不意味着结束,它只是意味着“此刻不再”。

有没有办法在队列为空时停止序列完成,或者我应该以不同的方式思考整个问题?

c# reactive-programming system.reactive

4
推荐指数
1
解决办法
1360
查看次数

将 RxSwift 计时器和间隔可观察量组合成一个可完成的可观察量

我想创建一个行为类似于这样的 observable。

var count = 0

func setupCountdownTimer() {
  let rx_countdownTimer = CountdownTimer.observable(5)

  rx_countdownTimer >- subscribeNext {
    secondsRemaining in
    println(secondsRemaining) // prints 5, then 4, 3, 2, 1, then finally 0
    count = secondsRemaining
  }

  rx_countdownTimer >- subscribeCompleted {
    println(count) // prints 5, assuming countdownTimer stopped 'naturally'
  }
}

@IBAction func stop(sender: UIButton) {
  rx_countdownTimer.sendCompleted() // Causes 2nd println above to output, say, 3, if that's how many seconds had elapsed thus far.
}
Run Code Online (Sandbox Code Playgroud)

似乎我应该能够以某种方式将计时器 observable和interval observable …

timer reactive-programming countdown swift rx-swift

4
推荐指数
1
解决办法
4153
查看次数

无需递归即可对 Observable 结果进行分页 - RxJava

我有一个非常标准的 API 分页问题,​​您可以通过一些简单的递归来处理。这是一个虚构的例子:

public Observable<List<Result>> scan() {
    return scanPage(Optional.empty(), ImmutableList.of());
}

private Observable<?> scanPage(Optional<KEY> startKey, List<Result> results) {
    return this.scanner.scan(startKey, LIMIT)
            .flatMap(page -> {
                if (!page.getLastKey().isPresent()) {
                    return Observable.just(results);
                }
                return scanPage(page.getLastKey(), ImmutableList.<Result>builder()
                        .addAll(results)
                        .addAll(page.getResults())
                        .build()
                );
            });
}
Run Code Online (Sandbox Code Playgroud)

但这显然会创建一个庞大的调用堆栈。如何强制执行此操作但维护 Observable 流?

这是一个命令式阻塞示例:

public List<Result> scan() {
    Optional<String> startKey = Optional.empty();
    final ImmutableList.Builder<Result> results = ImmutableList.builder();

    do {
        final Page page = this.scanner.scan(startKey);
        startKey = page.getLastKey();
        results.addAll(page.getResults());
    } while (startKey.isPresent());

    return results.build();
}
Run Code Online (Sandbox Code Playgroud)

java pagination reactive-programming observable rx-java

4
推荐指数
2
解决办法
3346
查看次数

Rxjava 为什么Schedulers.trampoline() 命名为'trampoline'?

在 rxjava 中有一些调度程序,就像 io(),newThread()...,有一个名为 'trampoline' 的调度程序,这个调度程序用于:创建并返回一个调度程序,该调度程序将当前线程上的工作排队等待执行当前工作完成。

我不明白为什么这个调度程序命名为“trampoline”而不是“queue”(或其他名称,如“queue”)。

你有相同的拼图吗?

java android reactive-programming

4
推荐指数
1
解决办法
1076
查看次数

不同类型的 Concat Observables

我有一个网络调用来验证和接收一个令牌,另一个使用这个令牌请求数据。

我想将它们组合成一个Single<Data>. 为此,我正在查看concat,但这似乎仅适用于Observable相同类型。使用zipI 可以只返回第二个的响应Observable,但据我所知,它可以并行工作,而我需要等待第一个Observable并在我开始第二个之前处理它的响应。

在这种情况下,我应该使用什么运算符?

java reactive-programming rx-java reactivex

4
推荐指数
1
解决办法
2517
查看次数

端到端响应式流 RESTful 服务

我已经阅读了这篇文章,我不知道这是否是一个愚蠢的问题。我是反应式编程的新手。

问题很简单:假设我有一个完全反应式的后端,我怎样才能流式传输到浏览器(例如一个大文本),并在每个块来自服务器时立即将它们打印给用户?

可能我遗漏了一些重要的概念点,但我需要知道的是:我可以通过一个 HTTP GET(?或不)请求发送一小部分数据(从服务器到浏览器)吗?关键是:我可以写那些小部分,直到全部数据发送出去吗?

谢谢你的帮助。我之前确实尝试过 google,但我总是得到有关其他概念(如 websockets、长轮询、react.js)的信息,我认为情况并非如此。

编辑:我不是要求特定的 API ou 库。我只是想理解这个概念,例如:“你不能用 HTTP 协议做到这一点,句号!” 或“这与响应式编程无关,您对流的真正含义感到困惑。请参阅'something_else.js'”。

EDIT2:我使用 spring-mvc (spring-boot) 和这个方法做了一个小的休息控制器:

@RequestMapping(value = "/flush", method = RequestMethod.GET)
public void flushTest(HttpServletResponse response) {

    response.setContentType("text/html");
    response.setStatus(SC_OK);

    try (ServletOutputStream outputStream = response.getOutputStream()) {
        for (int i = 0; i < 3; i++) {
            String chunk = "chunk_" + i;
            outputStream.print(chunk);
            outputStream.flush();
            response.flushBuffer();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

}
Run Code Online (Sandbox Code Playgroud)

在浏览器中,即使使用了flushBuffer,也只有整个响应到达。经过一番研究,这可能是一个 TOMCAT 问题,我改变了我的 pom.xml,包括 undertow:

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-undertow</artifactId>
</dependency>
Run Code Online (Sandbox Code Playgroud)

使用默认配置:

server.undertow.accesslog.enabled=true
server.undertow.accesslog.dir=target/logs …
Run Code Online (Sandbox Code Playgroud)

java reactive-programming rxjs

4
推荐指数
1
解决办法
2838
查看次数

使用 RxSwift 限制对服务类的并发访问

给定一个这样的服务类:

class Service {
    let networkService = NetworkService()

    func handleJobA(input: String) -> Observable<ResultA> {
        return networkService
            .computeA(input)
            .map { $0.a }
    }
}
Run Code Online (Sandbox Code Playgroud)

当我像这样从调用方使用它时:

let service = Service()

Observable
    .from(["Hello", "World"])
    .flatMap {
        service.handleJobA($0)
    }
    .subscribe()
Run Code Online (Sandbox Code Playgroud)

然后这将同时发送多个请求service。我希望流等待每个请求完成。使用merge操作符可以实现这一点。

Observable
    .from(["Hello", "World"])
    .flatMap {
        Observable.just(
            service.handleJobA($0)
        )
    }
    .merge(maxConcurrent: 1)
    .subscribe()
Run Code Online (Sandbox Code Playgroud)

到目前为止,一切都很好 - 该服务不会同时执行多项handleJobA任务。

然而,并发是一个服务细节,调用者不应该关心它。事实上,服务在稍后阶段可能会决定允许不同的并发值。

其次,当我添加一个新方法时handleJobB,它不能与作业 A 同时处于活动状态,反之亦然。

所以我的问题是:

  1. 如何将 maxConcurrency 限制为 handleJobA observable 作为实现细节?
  2. 哪种 RxSwift 模式允许对任何服务方法进行限制?

reactive-programming swift rx-swift

4
推荐指数
1
解决办法
1443
查看次数

如何从 xhr 返回 Observable

我有这样的功能,它只是上传带有 xhr 请求的图像:

public uploadAvatar(avatarFile, callback) {
    return new Promise((resolve, reject) => {
      let formData: any = new FormData();
      let url = 'avatar';
      let imgArr = "avatar";
      let xhr = new XMLHttpRequest();

      formData.append(imgArr, avatarFile, avatarFile.name);
      xhr.onreadystatechange = function () {
        if (xhr.readyState == 4) {
          if (xhr.status == 200) {
            resolve(JSON.parse(xhr.response));
            callback('success');
          } else {
            reject(xhr.response);
            callback('error');
          }
        }
      };

      xhr.open("POST", environment.baseUrl + url, true);
      xhr.setRequestHeader('Auth', this._auth.getToken());
      xhr.send(formData);
    });
  }
Run Code Online (Sandbox Code Playgroud)

我怎样才能返回 Observable insted Promise?

reactive-programming observable rxjs angular

4
推荐指数
1
解决办法
3195
查看次数

RxJS:特别对待第一种情况,但继续流式传输其余部分

假设我想单独处理 Observable 发出的第一个事件,然后继续我的订阅。

例如,如果我有以下链:

observable.throttleTime(2000)
      .takeFirst(() => console.log('potato'))
      .switchMap((event:MouseEvent) => {
        const element:Element = event.target as Element;
        return this.innerObservable(('tomato'));
      })
      .subscribe(({result}) => console.log(result))
Run Code Online (Sandbox Code Playgroud)

那失败了,但是我将如何使这种行为起作用?

javascript observers reactive-programming rxjs

4
推荐指数
2
解决办法
1178
查看次数

使用rxjs时,为什么switchMap不会触发完成事件?

最近,在我的Angular应用程序中,我开始在几种不同的情况下使用rxjs switchMap运算符。我很快意识到,当使用switchMap时,当您订阅此流时,完成块不会触发(我也不认为错误块也会触发)。我在网上看到的所有示例似乎也都无法处理补全问题,我对此感到困惑,原因是什么?

我显然缺少关于switchMap或如何使用它的东西,但是我不知道是什么。

理想情况下,我希望使用触发Http请求的函数来调用函数,然后在错误块中处理错误,然后在完成块中处理请求后的内容。

这是我正在做的事的例子:

export class ResultsComponent {

  ngAfterViewInit() {

    Observable.combineLatest(...filters)
        .debounceTime(500)
        .distinctUntilChanged()
        .switchMap((activeFilters: Array<ActiveFilter>) => {
            const filters = this.mapFilters(activeFilters);
            return this.doSearch(this.term$.getValue(), filters);
        })
        .subscribe((res) => {
           this.onSearchSuccess(res);
        },
        (err) => {
            // THIS NEVER FIRES
            console.error(err);
            this.loading$.next(false);
        ,() => {
            // THIS NEVER FIRES
            this.loading$.next(false);
        });
  }

  private doSearch(input: string, filters: object): Observable<object> {
    return this.searchService.search(input, filters);
  }
}
Run Code Online (Sandbox Code Playgroud)

服务

export class SearchService {

  private baseUrl: string = 'http://mydomainhere.com/api';

  constructor(private http: Http) {}

  public search(input: string, filters: …
Run Code Online (Sandbox Code Playgroud)

javascript reactive-programming rxjs angular

4
推荐指数
2
解决办法
2193
查看次数