Question

想象一下，您需要在其中一个片段中加载并保存一些数据。

我想使用RX Java。你如何处理一个片段上的多个订阅？ AndroidObservable.bindFragment完成了Job。但是当我需要更多订阅时如何使用它？

public class MyFragment extends SomeFragment implements Observer<List<Item>>
{

private Subscription mReadSubscription;

private Subscription mWriteSubscription;

private JSONLoader mLoader;

@Override
public void onCreate(final Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setHasOptionsMenu(true);
    final File theFile = new File(getActivity().getFilesDir(), FILE_NAME);
    mLoader = new JSONLoader(theFile);
    mReadSubscription = mLoader.getReadSubscription(this);
    mWriteSubscription = mLoader.createWriteSubscription(new WriteObserver(), Collections.EMPTY_LIST);

这背后的想法是使用loader.load（）loader.save（）来保存和加载项目，每个都会导致使用一个观察者（mReadSubscription，mWriteSubscription）。

WriteObserver只是一个简单的Bean再次实现Observer，但是有一部分我不明白：#bindFragment方法检查Fragment的实例。由于WriteObserver不是片段，因此导致异常。 但由于泛型，我无法注册第二个观察者。

我很确定我不太了解RX，任何人都可以指出我正确的方向来解决这个问题吗？

[更新1]

有我的WriteObserver：

private final class WriteObserver implements Observer<Void> {


    @Override
    public void onCompleted() {

        Toast.makeText(getActivity(), "Save Successful", Toast.LENGTH_SHORT).show();
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onNext(Void aVoid) {
    }
}

该设计不起作用，因为WriteObserver不是片段，在您执行时会导致异常：

java.lang.IllegalArgumentException: Target fragment is neither a native nor support library Fragment



AndroidObservable.bindFragment(observer, source)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(observer);

那么，我该如何解决这个限制呢？

Answer 1

根据我的理解，mLoader#getReadSubscription()和mLoader#createWriteSubscription()会创建流量并订阅它。

我不认为正确的方法，就像mLoader订阅流，它应该处理如何取消订阅它。

如果您想使用AndroidObservable.bindFragment，mLoader#getReadSubscription()和mLoader#createWriteSubscription()应该返回Observable而不是Subscription。

因此，在您的片段中，您将能够写下：

@Override
public void onCreate(final Bundle savedInstanceState) {
    // [...]
   Observable<?> readObs = mLoader.getReadSubscription();
   mReadSubscription = AndroidObservable.bindFragment(this, readObs).subscribe(this);

   Observable<?> writeObs =  mLoader.createWriteSubscription(Collections.emptyList());
   mWriteSubscription = AndroidObservable.bindFragment(this, writeObs).subscribe(new WriteObserver());
}

那么，我该如何解决这个限制？

这不是限制。

 public static <T> Observable<T> bindFragment(Object fragment, Observable<T> source) {
      // ...
 }

第一个参数应该是你的片段，而不是你的观察者。这就是为什么你应该把你的代码编写为：

yourSubscription = AndroidObservable.bindFragment(yourFraglebt, yourObservable).subscribe(yourObserver);

所以在你的情况下：

AndroidObservable.bindFragment(this, source) // as bindFragment observeOn mainThread, you can remove the observeOn method call
        .subscribeOn(Schedulers.io())
        .subscribe(observer);

而不是

AndroidObservable.bindFragment(observer, source)
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(observer);

RX Java多个订阅

1 个答案: