可以观察到onComplete重新提交自身的RxJava 2

我是RxJava新手。我试图创建一个可观察的对象，当它完成时，它将重新开始，直到调用dispose，但过了一段时间后，我面临一个OutofMemory错误，下面是一个简单的示例

  public void start() throws RuntimeException {
        log.info("\t * Starting {} Managed Service...", getClass().getSimpleName());

        try {

            executeObserve();

            log.info("\t * Starting {} Managed Service...OK!", getClass().getSimpleName());
        } catch (Exception e) {
            log.info("Managed Service {} FAILED! Reason is {} ", getClass().getSimpleName(), e.getMessage(), e);
        }
    }

start在初始化阶段调用一次，executeObserve如下所示（简化形式..）。请注意，在onComplete上，我“重新提交”executeObserve

public void executeObserve() throws RuntimeException {

        Observable<Book> booksObserve
                = manager.getAsObservable();

        booksObserve
                 .map(Book::getAllOrders)
                 .flatMap(Observable::fromIterable)
                 .toList()
                 .subscribeOn(Schedulers.io())
                 .subscribe(collectedISBN ->  
                      Observable.fromIterable(collectedISBN)
                       .buffer(10)
                       // ...some more steps here...
                       .toList()
                       .toObservable()
                       // resubmit
                      .doOnComplete(this::executeObserve)
                      .subscribe(validISBN -> {
                             // do something with the valid ones
                      })
             )
        );
    }

public void executeObserve（）引发RuntimeException{
可观察的书
=manager.getAsObservable（）；
书本观察
.map（Book:：getAllOrders）
.flatMap（可观察：：fromIterable）
托利斯先生（）
.subscribeOn（Schedulers.io（））
.订阅（collectedISBN->
可观察的。从可观察的（收集的）
.缓冲器（10）
//…这里还有一些步骤。。。
托利斯先生（）
.TooObservable（）文件
//重新提交
.doOnComplete（此：：executeObserve）
.订阅（N->{
//用有效的做点什么
})
)
);
}

我的猜测是，如果我想重新提交我的任务，但找不到任何文档，那么这不是一种方法

该方法的实现如下所示

public Observable<Book> getAsObservable() {
    return Observable.create(e -> {
        try (CloseableResultSet<Book> rs = (CloseableResultSet<Book>) datasource.retrieveAll())) {
            for (Book r : rs) {
                e.onNext(r);
            }
            e.onComplete();
        } catch (Exception ex) {
            e.onError(ex);
        }
    });
}

public Observable getAsObservable（）{
返回可观察。创建（e->{
try（CloseableResultSet rs=（CloseableResultSet）datasource.retrieveAll（））{
（r:rs册）{
e、 onNext（r）；
}
e、 onComplete（）；
}捕获（例外情况除外）{
e、 onError（ex）；
}
});
}

---

在调用dispose或等效程序之前，不断重新提交操作的正确方法是什么？我使用的是RxJava 2

如果您创建了一个无休止的递归，那么循环将创建越来越多的资源，有时它会爆发OutOfMemory/堆栈溢出异常

为了重复

Observable

工作，您应该使用

repeat（）

操作符，当它接收到

onComplete（）

时，它将重新订阅

Observable

除此之外，对代码的一些一般性评论：

• 为什么要将第二个

  可见的
  嵌套在订阅服务器中？您正在断开链，您可以继续链，而不是在订阅服务器上创建新的
  Observable
  
  此外，似乎（假设O
  observable.fromIterable（collectedBets）
  使用
  collectedISBN
  这是通过
  onNext（）
  O.w.从哪里来的？）将所有项目收集到一个列表中，然后再次使用fromIterable将其展平，因此，似乎您可以继续使用流，诸如此类：
  
  booksObserve
     .map(Book::getAllOrders)
     .flatMap(Observable::fromIterable)
     .buffer(10)
     // ...some more steps here...
     .toList()
     .toObservable()
     // resubmit
     .doOnComplete(this::executeObserve)
     .subscribeOn(Schedulers.io())
     .subscribe(validISBN -> {
           // do something with the valid ones
      });       
  
  
  无论如何，对于嵌套的
  Observable
  ，
  repeat（）
  操作符只会重复嵌套的流，而不会重复整个流（这是您想要的），因为它没有连接到它
  
  

您已经创建了一个无休止的递归，循环将创建越来越多的资源，有时它会以OutOfMemory/堆栈溢出异常而崩溃

为了重复

Observable

工作，您应该使用

repeat（）

操作符，当它接收到

onComplete（）

时，它将重新订阅

Observable

除此之外，对代码的一些一般性评论：

• 为什么要将第二个

  可见的
  嵌套在订阅服务器中？您正在断开链，您可以继续链，而不是在订阅服务器上创建新的
  Observable
  
  此外，似乎（假设O
  observable.fromIterable（collectedBets）
  使用
  collectedISBN
  这是通过
  onNext（）
  O.w.从哪里来的？）将所有项目收集到一个列表中，然后再次使用fromIterable将其展平，因此，似乎您可以继续使用流，诸如此类：
  
  booksObserve
     .map(Book::getAllOrders)
     .flatMap(Observable::fromIterable)
     .buffer(10)
     // ...some more steps here...
     .toList()
     .toObservable()
     // resubmit
     .doOnComplete(this::executeObserve)
     .subscribeOn(Schedulers.io())
     .subscribe(validISBN -> {
           // do something with the valid ones
      });       
  
  
  无论如何，对于嵌套的
  Observable
  ，
  repeat（）
  操作符只会重复嵌套的流，而不会重复整个流（这是您想要的），因为它没有连接到它
  
  

在继续我的问题时，@yosriz建议的

重复是正确的方法，下面的简单片段演示了每次重复时都会调用可观察的源

Observable<Integer> recursiveObservable = Observable.create(emitter -> {
            System.out.println("Calling to emit data");
            Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8, 9, 0).forEach(emitter::onNext);
            emitter.onComplete();
        });
        recursiveObservable
                .buffer(2)
                .repeat()
                .subscribe(integers -> {
                    System.out.println(integers);
                    TimeUnit.SECONDS.sleep(1);
                });

Observable recursiveObservable=Observable.create（发射器->{
System.out.println（“调用以发出数据”）；
newArrayList（1,2,3,4,5,6,7,8,9,0）.forEach（发射器：：onNext）；
emitter.onComplete（）；
});
递归可观测
.缓冲区（2）
.重复
.订阅（整数->{
System.out.println（整数）；
时间单位。秒。睡眠（1）；
});
在继续我的问题时，@yosriz建议的
重复
是正确的方法，下面的简单片段演示了每次重复都会调用可观察的源

Observable<Integer> recursiveObservable = Observable.create(emitter -> {
            System.out.println("Calling to emit data");
            Lists.newArrayList(1, 2, 3, 4, 5, 6, 7, 8, 9, 0).forEach(emitter::onNext);
            emitter.onComplete();
        });
        recursiveObservable
                .buffer(2)
                .repeat()
                .subscribe(integers -> {
                    System.out.println(integers);
                    TimeUnit.SECONDS.sleep(1);
                });

Observable recursiveObservable=Observable.create（发射器->{
System.out.println（“调用以发出数据”）；
newArrayList（1,2,3,4,5,6,7,8,9,0）.forEach（发射器：：onNext）；
emitter.onComplete（）；
});
递归可观测
.缓冲区（2）
.重复
.订阅（整数->{
System.out.println（整数）；
时间单位。秒。睡眠（1）；
});
您好，非常感谢您的回答，+1感谢您的重复。我有一个问题要问你