android - 关于带有RxAndroid，Dagger 2和Realm的Android的问题

我目前正在开发一个应用程序，并希望使用Android的最新版本：Rxandroid、Dagger2和Realm。我在网上找不到好的例子，所以我不得不在这里问。
一。为什么要使用observate作为领域查询的返回类型？

public Observable<Bla> getBla() {
    Bla b = realm.where(Bla.class).findFirst();
    return Observable.just(b);
}

在大多数情况下，领域查询是在uithread上运行的，所以我为什么不直接返回结果作为list而不是

Observable<List<Bla>>

也许有人知道一个很好的例子与领域在这个自由组合？
2.为什么我可以注入一个服务而不必在模块中提到提供者。我的结构有问题吗？

@Inject
TableService mTableService;

（以下代码）
三。servicecomponent需要appcomponent中的应用程序，如何正确配置@component？

@Singleton
@Component(modules = {AppModule.class, ServiceModule.class})
public interface AppComponent {

    void inject(MainActivity activity);
}

@Singleton
@Component(modules = {AppModule.class, ServiceModule.class})
public interface ServiceComponent {

    void inject(MainActivity activity);
}

public class AppModule {

    Application mApplication;

    public AppModule(Application application) {
        mApplication = application;
    }

    @Provides
    @Singleton
    Application providesApplication() {
        return mApplication;
    }

    @Provides
    @Singleton
    RealmConfiguration provideRealmConfiguration(Application application) {
        return new RealmConfiguration.Builder(application)
               .schemaVersion(1)
               .deleteRealmIfMigrationNeeded()
               .build();
    }

    @Provides
    Realm provideRealm(RealmConfiguration realmConfiguration) {
        try {
            return Realm.getInstance(realmConfiguration);
        } catch (Exception cause) {
            Realm.deleteRealm(realmConfiguration);
            return Realm.getInstance(realmConfiguration);
        }
    }
}

@Module
public class ServiceModule {

    public ServiceModule() {
    }

    @Provides
    @Singleton
    GuestService provideGuestService(Realm realm) {
        return new GuestService(realm);
    }
}

public class Application extends android.app.Application {

    private AppComponent mAppComponent;

    @Override
    public void onCreate() {
        super.onCreate();

        mAppComponent = DaggerAppComponent.builder()
                .appModule(new AppModule(this))
                .build();

    }

    public AppComponent getAppComponent() {
        return mAppComponent;
    }
}

谢谢您！

最佳答案

1.）RealmResults<T>是自动更新的，如果在RealmChangeListener中添加一个RealmResults，则在基础数据发生更改时将调用它。

private final RealmChangeListener listener = new RealmChangeListener() {
    @Override
    public void onChange(Object results) {
        notifyDataSetChanged();
    }
};

但是，当您在asObservable()上调用RealmResults时，会创建一个Observable<RealmResults<T>>自动附加一个RealmChangeListener通知您更改，并在您取消订阅时将其删除。如果检查默认RealmObservableFactory实现，则可以查看确切的行为。
因此，它实际上是一个在结果中添加RealmChangeListener的简写，以便您可以随时更新视图。

Subscription subscription = RxTextView.textChanges(editText).switchMap(charSequence ->
    realm.where(SomeObject.class)
         .contains("searchField", charSequence.toString(), Case.INSENSITIVE)
         .findAllAsync()
         .asObservable())
.filter(RealmResults::isLoaded) //
.subscribe(objects -> adapter.updateData(objects));

2.）您可能指定了带注释的构造函数。

public class TableService {
    @Inject
    Application application;

    @Inject
    public TableService() {
    }
}

3.）Typically you should have 1 component / scope.
编辑：
为什么要使用observate作为领域查询的返回类型？

public Observable<Bla> getBla() {
    Bla b = realm.where(Bla.class).findFirst();
    return Observable.just(b);
}

这对realm来说没有意义，因为它不听变化。
用起来比较合理

public Observable<Blah> getBla() {
    Blah blah = realm.where(Blah.class).findFirst();
    if(blah == null) {
        return Observable.empty();
    } else {
        return blah.asObservable();
    }
}

尽管personally I advise to use @Inject because it is more reliable.
3）不知道你的意思。没有@component appmodule.class，服务组件无法工作，但我应该理解它。
甚至不应该有一个Observable<RealmResults<T>>。只是ServiceComponent。