RxJava2批处理项目

我有一个连续生成的日志流，即每当系统中有新日志可用时就会调用的方法。我不希望每次生成日志时都处理它（因为日志大约每毫秒生成一次）

我想收集在一段时间内（比如说5秒）发出的日志，然后批量处理它们

如何使用rxjava实现这一点

我试过类似的方法

private static void logResults(LogData logData) {
        Observable.create((ObservableOnSubscribe<LogData>) e -> {
            e.onNext(logData);
        }).buffer(5, TimeUnit.SECONDS).subscribeWith(new DisposableObserver<List<LogData>>() {
            @Override
            public void onNext(List<LogData> logData) {
               System.out.print(logData.toString()));
            }

            @Override
            public void onError(Throwable e) {
            }

            @Override
            public void onComplete() {
            }
        });
    }


 /**
    This method get called every time when new log is there
  */
  public static void logGenerated(LogData log) {
     logResults(log);
  }

私有静态无效日志结果（LogData LogData）{
可观察。创建（（可观察订阅）e->{
e、 onNext（日志数据）；
}).buffer（5，TimeUnit.SECONDS）.subscribeWidth（新的DisposableObserver（）{
@凌驾
public void onNext（列出日志数据）{
System.out.print（logData.toString（））；
}
@凌驾
公共无效申报人（可丢弃的e）{
}
@凌驾
未完成的公共空间（）{
}
});
}
/**
每次有新日志时都会调用此方法
*/
已生成公共静态无效日志（日志数据日志）{
日志结果（log）；
}

您需要创建一个流，该流在对

日志结果的多个调用中保持活动状态。最简单的方法是使用静态
PublishSubject
：

private static final Subject<LogData> subject =
    PublishSubject.<LogData>create(); // .toSerialized();

private static final Disposable logProcessing =
    subject.buffer(5, TimeUnit.SECONDS)
    .subscribeWith(new DisposableObserver<List<LogData>>() {
        @Override
        public void onNext(List<LogData> logData) {
           System.out.print(logData.toString()));
        }

        @Override
        public void onError(Throwable e) {
        }

        @Override
        public void onComplete() {
        }
    });

private static void logResults(LogData logData) {
    subject.onNext(logData);
}


/**
 * This method get called every time when new log is there
 */
public static void logGenerated(LogData log) {
    logResults(log);
}

私有静态最终主题=
PublishSubject.create（）；/。toSerialized（）；
私有静态最终处理=
主题。缓冲区（5，时间单位。秒）
.subscribowith（新可处置观察员）{
@凌驾
public void onNext（列出日志数据）{
System.out.print（logData.toString（））；
}
@凌驾
公共无效申报人（可丢弃的e）{
}
@凌驾
未完成的公共空间（）{
}
});
专用静态无效日志结果（LogData LogData）{
主题.onNext（日志数据）；
}
/**
*每次有新日志时都会调用此方法
*/
已生成公共静态无效日志（日志数据日志）{
日志结果（log）；
}
您需要创建一个流，该流在对
日志结果的多个调用中保持活动状态。最简单的方法是使用静态
PublishSubject
：

private static final Subject<LogData> subject =
    PublishSubject.<LogData>create(); // .toSerialized();

private static final Disposable logProcessing =
    subject.buffer(5, TimeUnit.SECONDS)
    .subscribeWith(new DisposableObserver<List<LogData>>() {
        @Override
        public void onNext(List<LogData> logData) {
           System.out.print(logData.toString()));
        }

        @Override
        public void onError(Throwable e) {
        }

        @Override
        public void onComplete() {
        }
    });

private static void logResults(LogData logData) {
    subject.onNext(logData);
}


/**
 * This method get called every time when new log is there
 */
public static void logGenerated(LogData log) {
    logResults(log);
}

私有静态最终主题=
PublishSubject.create（）；/。toSerialized（）；
私有静态最终处理=
主题。缓冲区（5，时间单位。秒）
.subscribowith（新可处置观察员）{
@凌驾
public void onNext（列出日志数据）{
System.out.print（logData.toString（））；
}
@凌驾
公共无效申报人（可丢弃的e）{
}
@凌驾
未完成的公共空间（）{
}
});
专用静态无效日志结果（LogData LogData）{
主题.onNext（日志数据）；
}
/**
*每次有新日志时都会调用此方法
*/
已生成公共静态无效日志（日志数据日志）{
日志结果（log）；
}
为什么要在每个
logResults
调用上重新创建整个流程？你看过
PublishSubject
了吗？为什么每次
logResults
调用都要重新创建整个流程？你看过《出版主题》了吗？+1谢谢你的帮助！我认为在
.buffer
之前应该是
subject.buffer
。如果我使用上面的方法，它会生成一些空块。也可以说我的日志流结束了，它不会发出最后一个在线程池中如何才能像
可观察的内部代码那样执行。如果我们使用
.subscribeOn（Schedulers.from（threadPoolExecutor））
很抱歉询问noob问题，您需要调用
subject.onComplete（）
来触发最后一个缓冲区。在
subject
和
buffer
之间添加
observeOn（）.map（）
，以便在缓冲发生之前进行一些处理。+1感谢您的帮助！我认为在
.buffer
之前应该是
subject.buffer
。如果我使用上面的方法，它会生成一些空块。也可以说我的日志流结束了，它不会发出最后一个在线程池中如何才能像
可观察的内部代码那样执行。如果我们使用
.subscribeOn（Schedulers.from（threadPoolExecutor））
很抱歉询问noob问题，您需要调用
subject.onComplete（）
来触发最后一个缓冲区。在
subject
和
buffer
之间添加
observeOn（）.map（）
，以便在缓冲发生之前进行一些处理。