Question

一些上下文，我试图将一些干净的架构应用到我的一个项目中，并且我遇到了我的存储库的（Realm）磁盘实现问题。我有一个存储库，它根据某些条件（缓存）从不同的DataStore中提取一些数据。这就是理论，将所有这些与UseCases和RxJava2混合时会出现问题。

首先，我从Realm获取对象列表，然后手动创建它的Observable。 但subscribe（正如预期的那样）在不同的线程上执行，因此领域最终崩溃...... （第二段代码）

这是我用来创建Observables的代码（来自抽象类DiskStoreBase）：

Observable<List<T>> createListFrom(final List<T> list) {
    return Observable.create(new ObservableOnSubscribe<List<T>>() {
        @Override
        public void subscribe(ObservableEmitter<List<T>> emitter) throws Exception {
            if (list != null) {
                emitter.onNext(list);
                emitter.onComplete();
            } else {
                emitter.onError(new ExceptionCacheNotFound());
            }
        }
    });
}

我该如何处理这种情况？

DiskStoreForZone的更多代码：

@Override
public Observable<List<ResponseZone>> entityList() {
    Realm realm = Realm.getDefaultInstance();
    List<ResponseZone> result = realm.where(ResponseZone.class).findAll();
    return createListFrom(result);
}

确切的崩溃：

E/REALM_JNI: jni: ThrowingException 8, Realm accessed from incorrect thread.
E/REALM_JNI: Exception has been thrown: Realm accessed from incorrect thread.

Answer 1

它不起作用，因为尽管使用Rx，但您的数据层不是被动的。

Realm本质上是一个被动数据源，其管理对象本质上也是可变（由Realm更新），并且线程限制（只能在打开Realm的同一个线程上访问）。

要使代码生效，您需要从Realm中复制数据。

@Override
public Single<List<ResponseZone>> entityList() {
    return Single.fromCallable(() -> {
       try(Realm realm = Realm.getDefaultInstance()) {
           return realm.copyFromRealm(realm.where(ResponseZone.class).findAll());
       }
    });
}

我冒昧地代表您的Single作为Single，考虑到它不是Observable，它不会听取更改，只有 1 事件，并且列表本身。因此，通过ObservableEmitter发送它并不真正有意义，因为它不会发出事件。

因此，这就是为什么我说：你的数据层不是被动的。你不是在听取改变。您只是直接获取数据，并且您从未收到任何更改的通知;尽管使用Rx。

我画了一些油漆图片来说明我的观点。 （蓝色表示副作用）

在您的情况下，您调用一次性操作来从多个数据源（缓存，本地，远程）检索数据。一旦获得它，你就不会听取变化;从技术上讲，如果您在一个地方和另一个地方编辑数据，唯一的更新方法是“强制缓存手动检索新数据”;您必须知道您在其他地方修改了数据。您需要一种方法来直接调用回调，或发送消息/事件 - 更改通知。

因此，在某种程度上，您必须创建缓存失效通知事件。如果你听到这个，解决方案可能会再次被动。除非您手动执行此操作。

----------------------------------------------- -----------------------

考虑到Realm已经是一个被动数据源（类似于SQLite的SQLBrite），它能够提供更改通知，您可以通过它来“使缓存无效”。

事实上，如果您的本地数据源是唯一的数据源，并且来自网络的任何写入都是您收听的更改，则您的“缓存”可以写为replay(1).publish().refCount()（重播最新数据）对于新订阅者，如果评估新数据，则使用new替换数据）RxReplayingShare。

Using a Scheduler created from the looper of a handler thread，您可以在后台线程上侦听Realm中的更改，创建一个响应数据源，返回可以在线程之间传递的最新非托管副本（尽管直接映射到不可变域模型如果您选择此路线，则首选copyFromRealm() - 路线为清洁架构。

return io.reactivex.Observable.create(new ObservableOnSubscribe<List<ResponseZone>>() {
    @Override
    public void subscribe(ObservableEmitter<List<ResponseZone>> emitter)
            throws Exception {
        final Realm observableRealm = Realm.getDefaultInstance();
        final RealmResults<ResponseZone> results = observableRealm.where(ResponseZone.class).findAllAsync();
        final RealmChangeListener<RealmResults<ResponseZone>> listener = results -> {
            if(!emitter.isDisposed()) {
                if(results.isValid() && results.isLoaded()) {
                    emitter.onNext(observableRealm.copyFromRealm(results));
                }
            }
        };

        emitter.setDisposable(Disposables.fromRunnable(() -> {
            if(results.isValid()) {
                results.removeChangeListener(listener);
            }
            observableRealm.close();
        }));
        results.addChangeListener(listener);
        // initial value will be handled by async query
    }
}).subscribeOn(looperScheduler).unsubscribeOn(looperScheduler);

获取looper调度程序

    handlerThread = new HandlerThread("LOOPER_SCHEDULER");
    handlerThread.start();
    synchronized(handlerThread) {
        looperScheduler  = AndroidSchedulers.from(handlerThread.getLooper());
    }

这就是你使用Realm创建反应式清洁架构的方法。

增加：

只有在打算在Realm上实施Clean Architecture时才需要LooperScheduler。这是因为默认情况下，Realm会鼓励您将数据对象用作域模型，并且作为一个好处提供延迟加载的线程局部视图，这些视图在更新时会发生变异;但Clean Architecture表示您应该使用不可变域模型（独立于您的数据层）。因此，如果您想创建反应性干净的体系结构，您可以在Realm更改的任何时候在后台线程上从Realm进行复制，那么您将需要一个looper调度程序（或者在后台线程上观察，但是从{更新的Realm上进行复制} {1}}）。

使用Realm，通常您希望使用RealmObjects作为域模型，并依赖于延迟评估。在这种情况下，您不使用Schedulers.io()，也不会将RealmResults映射到其他内容;但您可以将其公开为copyFromRealm()或Flowable。

您可以阅读有关此here的相关内容。

领域：使用Clean-Architecture和RxJava2

1 个答案:

----------------------------------------------- -----------------------