如何将LiveData转为Observable适配RxJava2？替代过时库的方法

Absolutely, that old RxJava<->ReactiveStreams library is long deprecated, and there are much cleaner, modern ways to convert LiveData to an Observable without relying on it. Here are two solid approaches you can use:

Jetpack Flow now plays nicely with LiveData, and the coroutines-rx2 bindings make switching to RxJava's Observable super straightforward. This is the go-to method since it leverages official libraries and minimizes manual code.

First, make sure you have these dependencies in your build.gradle (app module):

// Lifecycle KTX for LiveData → Flow conversion
implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.6.2"
// Coroutines Rx2 bindings for Flow → Observable conversion
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-rx2:1.7.3"

Then converting your LiveData to Observable is just two lines (or even one):

import androidx.lifecycle.asFlow
import kotlinx.coroutines.rx2.asObservable

// Your existing LiveData instance
val userLiveData: LiveData<User> = viewModel.userLiveData

// Convert to Observable
val userObservable: Observable<User> = userLiveData.asFlow().asObservable()

The asFlow() extension turns your LiveData into a lifecycle-aware Flow that only emits when there's an active subscriber, and asObservable() bridges that Flow directly to RxJava's Observable. No manual observer cleanup needed—everything is handled under the hood.

If you don't want to add Flow or coroutines to your project, you can build the conversion logic yourself. Just be careful to handle lifecycle properly to avoid memory leaks.

Kotlin Implementation #

import androidx.lifecycle.LifecycleOwner
import androidx.lifecycle.LiveData
import androidx.lifecycle.Observer
import io.reactivex.Observable

fun <T> LiveData<T>.toObservable(owner: LifecycleOwner): Observable<T> {
    return Observable.create { emitter ->
        val observer = Observer<T> { value ->
            if (!emitter.isDisposed) {
                emitter.onNext(value)
            }
        }
        // Attach the observer to the LiveData with your LifecycleOwner
        observe(owner, observer)
        
        // Clean up when the Observable is disposed
        emitter.setCancellable {
            removeObserver(observer)
        }
    }
}

Java Implementation #

import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.LiveData;
import androidx.lifecycle.Observer;
import io.reactivex.Observable;

public class LiveDataRxConverter {
    public static <T> Observable<T> convertToObservable(LiveData<T> liveData, LifecycleOwner owner) {
        return Observable.create(emitter -> {
            Observer<T> observer = emitter::onNext;
            liveData.observe(owner, observer);
            
            // Remove observer when the Observable is disposed
            emitter.setCancellable(() -> liveData.removeObserver(observer));
        });
    }
}

Key reminder: Always pass a valid LifecycleOwner (like your Activity or Fragment) so LiveData stops emitting when the component is destroyed. If you have to use observeForever (e.g., in a ViewModel without a direct lifecycle), make sure you explicitly remove the observer when the Observable is disposed—otherwise you'll end up with memory leaks.

内容的提问来源于stack exchange，提问作者dawzaw