如何在 RxJava 2 和 Kotlin 中将 null 传递给具有可空类型的 Observable

Question

我这样初始化我的变量：-

 val user: BehaviorSubject<User?> user = BehaviorSubject.create()

但是我做不到。 IDE 抛出错误：-

user.onNext(null)

这样做，IDE 说你永远不会为 null:-

user.filter( u -> u!=null)

Answer 1

如果您使用 rxkotlin/rxjava 2.0（我假设如此），那么答案是：您不能。原因在这里解释。

这是界面中断。查看 Observable 界面

public interface Observer<T> {

    /** ... */
    void onSubscribe(@NonNull Disposable d);

    /** ... */
    void onNext(@NonNull T t);

    /** ... */
    void onError(@NonNull Throwable e);

    /** ... */
    void onSubscribe(@NonNull Disposable d);

    /** ... */
    void onNext(@NonNull T t);

    /** ... */
    void onError(@NonNull Throwable e);
...

Kotlin 编译器会考虑 @NonNull，因此您不能传递 null。

即使可以，onNext 也会立即抛出错误：

@Override
public void onNext(T t) {
    if (t == null) {
        onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
        return;
    }
    ...
}

如果你真的需要 null 这样的东西，你必须伪造它。例如通过创建代表您的 null 元素的 User 静态对象。

例如

data class User(val username, val password) {

    companion object {
        val NULL_USER = User("", "")
    }
}
...
val user = BehaviorSubject.create<User>()
...
user.onNext(User.NULL_USER)
...
user.filter { it !== User.NULL_USER }

但是，如果可能的话，请尽量避免 null 概念，并可能考虑另一种不需要的解决方案。

Answer 2

正如所解释的，这是不可能的。但是，我不建议空对象模式，而是推荐 Optional 类型的实现：

data class Optional<T>(val value: T?)
fun <T> T?.asOptional() = Optional(this)

这使您的意图更加清晰，并且您可以在函数中使用解构声明：

Observable.just(Optional("Test"))
  .map { (text: String?) -> text?.substring(1)?.asOptional() }
  .subscribe()

在这里使用空对象模式会导致比它解决的更多的错误。

Answer 3

非常感谢您的所有回答，但我最终采用了这个解决方案：-

class UserEnvelope(val user:User?) {}

并在 observables 中使用它。

这最符合我的要求。

我是 Kotlin 的新手，所以我不知道如何使用 Optionals。但据我了解，每次我需要观察值时，我都必须将其类型转换为用户类型，对吗？

Answer 4

由于 RxJava 2 不支持 null 值，您可以使用其他一些可接受的解决方案：

像一些已发布的答案所建议的那样，使用可选的自定义或第三方包装器库。当我摆脱 Java 以支持 Kotlin 时，Optionals 在同一个包中消失了，因为 Kotlin 本身支持可空性作为其类型 System 的一部分。仅仅通过这个更改，代码就更加清晰了，我个人不想在我的代码中重新使用 Optionals，只要我能避免它们。
使用您的主题类型发出 Any class 个实例。例如，您可以创建一个 Empty.INSTANCE 枚举 class 来模拟 null 值，然后按枚举 class.

最后一个是我使用的并且更喜欢作为先前解决方案的变体并且基于专业化。我们的 JetBrains 朋友总是强调 class es 在 Kotlin 中非常便宜，所以这将是一个区分登录用户和未登录用户的快速示例：

abstract class SessionUser
sealed class LoggedUser(val username: String, val password: String) : SessionUser()
sealed class LogoutUser : SessionUser()

private val user = BehaviorSubject.create<SessionUser>()
private val loggedUser = 
   user.filter { it is LoggedUser }.cast(LoggedUser::class.java)

fun login(username: String, password: String) {
   user.onNext(LoggedUser(username, password))
}

fun logout() {
   user.onNext(LogoutUser())
}

Answer 5

从 Android SDK 实施 nhaarman's answer, you can use the util class Optional (doc) 中提到的解决方案，该 SDK 在 API 级别 24.

如果你的应用minSdkVersion小于24那么你还是需要自己实现。

Answer 6

我采用了类似于 Optional<User> 和 UserEnvelope 的方法。我做了一个简单的 User class 和一个从它继承的 ReifiedUser class 。 User class 有一个 companion object 有一个 NONE 实例。 BehaviorSubject 用 User.NONE 实例实例化。它看起来像这样：

open class User {
    companion object {
        val NONE = User()
    }
}

class ReifiedUser(
        @field:JsonProperty(J.FirstName) val firstName: String,
        @field:JsonProperty(J.LastName) val lastName: String
) : User()

我的BehaviorSubject是这样实例化的：

val activeUser: BehaviorSubject<User> = BehaviorSubject.createDefault(User.NONE)

无论我需要使用 activeUser 还是 flatMap 到 Observable.empty() 如果它是 NONE 或者只是弄清楚它是什么以及在订户。

我不喜欢将 java Optional 与 kotlin nullable 混合使用，因为混合使用 map 和 let 会变得非常混乱和丑陋。这样一目了然。

Answer 7

我觉得写一个容器class更有意义，比如Result。一个例子是

data class Result<T>(value: T?, error: Throwable?)

用法

Observable.create { observer ->
   upstreamService.listen(object: UpstreamListener {
     onSuccess(data: User) {
       observer.onSuccess(Result(data))
     }
     onError(exception: Throwable) {
       observer.onSuccess(Result(null, exception))
     }
   }
}

如何在 RxJava 2 和 Kotlin 中将 null 传递给具有可空类型的 Observable

How to pass null to an Observable with nullable type in RxJava 2 and Kotlin

android

kotlin

rx-java

rx-kotlin

rx-java2