使用Retrofit和RxJava的生命周期管理

On Android it is tricky for asynchronous actions to access framework objects in their callbacks. That’s because Android may decide to destroy an Activity, for instance, while a background thread is still running. The thread will attempt to access views on the now dead Activity, which results in a crash. (This will also create a memory leak, since your background thread holds on to the Activity even though it’s not visible anymore.)

This is still a concern when using RxJava on Android, but you can deal with the problem in a more elegant way by using Subscriptions and a number of Observable operators. In general, when you run an Observable inside an Activity that subscribes to the result (either directly or through an inner class), you must unsubscribe from the sequence in onDestroy, as shown in the following example:

// MyActivityprivate Subscription subscription;protected void onCreate(Bundle savedInstanceState) {    this.subscription = observable.subscribe(this);}...protected void onDestroy() {    this.subscription.unsubscribe();    super.onDestroy();}

This ensures that all references to the subscriber (the Activity) will be released as soon as possible, and no more notifications will arrive at the subscriber through onNext.

One problem with this is that if the Activity is destroyed because of a change in screen orientation, the Observable will fire again in onCreate. You can prevent this by using the cache or replay Observable operators, while making sure the Observable somehow survives theActivity life-cycle (for instance, by storing it in a global cache, in a Fragment, etc.) You can use either operator to ensure that when the subscriber subscribes to an Observable that’s already “running,” items emitted by the Observable during the span when it was detached from theActivity will be “played back,” and any in-flight notifications from the Observable will be delivered as usual.