Question

我对RxJava和反应式编程完全陌生。我有一个作业，我必须读取文件并将其存储到Observable。我试图在内部使用BufferedReader创建一个Callable，并使用Observable.fromCallable（），但它没有多大用处。

你能告诉我我该怎么办？

我正在使用RxJava 2.0。

Answer 1

一个基本的解决方案，我使用嵌套类FileObservableSource来生成数据，然后推迟创建Observable直到Observer订阅：

import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class StackOverflow {

    public static void main(String[] args) {
        final Observable<String> observable = Observable.defer(() -> new FileObservableSource("pom.xml"));
        observable.subscribe(
                line -> System.out.println("next line: " + line),
                        Throwable::printStackTrace,
                        () -> System.out.println("finished")
                );
    }

    static class FileObservableSource implements ObservableSource<String> {

        private final String filename;

        FileObservableSource(String filename) {
            this.filename = filename;
        }

        @Override
        public void subscribe(Observer<? super String> observer) {
            try {
                Files.lines(Paths.get(filename)).forEach(observer::onNext);
                observer.onComplete();
            } catch (IOException e) {
                observer.onError(e);
            }
        }
    }
}

Answer 2

对于Java 8，BufferedReader具有文件流和迭代器，可与RxJava一起使用。 https://dzone.com/articles/java-8-stream-rx-java

您可以使用以下代码获得Flowable

 Flowable.fromIterable(bufferedReader.lines()::iterator)

我使用Flowable和Single更加简洁，它仍然可以与Observable一起使用。该代码段是如何从缓冲读取器读取每一行的一个示例。

try (
       FileReader fr = new FileReader("./folder1/source.txt");
       BufferedReader br = new BufferedReader(fr); 

       //e.g. i write the output into this file
       FileWriter fw = new FileWriter("./folder1/destination.txt");
       BufferedWriter bw = new BufferedWriter(fw)
        ) { 

      //=========================================
      //calling br.lines() gives you the stream. 
      //br.lines()::iterator returns you the iterable
      //=========================================
      Flowable.fromIterable(br.lines()::iterator)

         //at this point you can do what you want for each line
                 //e.g. I split long strings into smaller Flowable<String> chunks.
                .flatMap(i -> splitLine(i))
                 //e.g. I then use the output to query an external server with retrofit.
                 //     which returns me a Single<String> result
                .flatMapSingle(i -> handlePinyin(pr, i))  

                .subscribe(
                        //I save the results from server to destination.txt
                        py -> appendToFile(bw, py),
                        //print and quit if error
                        err -> print("ERROR " + err), 
                        () -> print("Completed!"));


}catch (IOException e) {
        print("Error " + e);
}

Answer 3

您可以执行与this implementation类似的操作。

然后以这种方式使用here该类：

public static Observable<byte[]> from(InputStream is, int size) {
     return Observable.create(new OnSubscribeInputStream(is, size));
}

最终你可以使用它：

Observable<byte[]> chunks = Bytes.from(file, chunkSize);

更多详情here。

RxJava。将文件读取为可观察的

3 个答案: