Jetpack架构组件库-LiveData实战与应用-总有适合你的方案

好文推荐:
作者：heiyulong

前言

先前针对LiveData 组件从使用到原理都做了充分的解析，可以参考链接：

可以发现在使用 LiveData 分发数据的时候，是不会耦合任何 Context 对象的，并且是生命周期感知的，所以：

这个机制就从框架层避免了 NPE(空指针异常),OOM(内存泄露) 等问题。

但于此同时我们也发现了一些问题，比如 LiveData 无法取消黏性事件。

如果之前发送的事件，而后注册的观察者也能接收到这条消息。

1、LiveData和ViewModel实现跨页面通信

官方建议LiveData和ViewModel一起使用，因为 ViewModel 支持共享作用域，并且官方文档都推荐了通过共享 ViewModel 来实现跨页面通信的需求：

如下两个 Fragment 可以使用其 Activity 范围共享 ViewModel 来处理此类通信

public class SharedViewModel extends ViewModel {
        private final MutableLiveData<Item> selected = new MutableLiveData<Item>();

        public void select(Item item) {
            selected.setValue(item);
        }

        public LiveData<Item> getSelected() {
            return selected;
        }
    }

    //获取 ViewModelProvider 时,会收到相同的 SharedViewModel 实例（其范围限定为该 Activity）
    public class MasterFragment extends Fragment {
        private SharedViewModel model;

        public void onViewCreated(@NonNull View view, Bundle savedInstanceState) {
            super.onViewCreated(view, savedInstanceState);
            //通过requireActivity() Fragment 会检索包含它们的 Activity
            model = new ViewModelProvider(requireActivity()).get(SharedViewModel.class);
            itemSelector.setOnClickListener(item -> {
                model.select(item);
            });
        }
    }

    //获取 ViewModelProvider 时,会收到相同的 SharedViewModel 实例（其范围限定为该 Activity）
    public class DetailFragment extends Fragment {

        public void onViewCreated(@NonNull View view, Bundle savedInstanceState) {
            super.onViewCreated(view, savedInstanceState);
            //通过requireActivity() Fragment 会检索包含它们的 Activity
            SharedViewModel model = new ViewModelProvider(requireActivity()).get(SharedViewModel.class);
            model.getSelected().observe(getViewLifecycleOwner(), { item ->
               // Update the UI.
            });
        }
    }

该方法的优势：

Activity 不需要执行任何操作，也不需要对此通信有任何了解。
除了 SharedViewModel 约定之外，Fragment 不需要相互了解。如果其中一个 Fragment 消失，另一个 Fragment 将继续照常工作。
每个 Fragment 都有自己的生命周期，而不受另一个 Fragment 的生命周期的影响。如果一个 Fragment 替换另一个 Fragment，界面将继续工作而没有任何问题。

2、SingleLiveEvent官方解决单次监听的方案

视图层（Activity 或者 Fragment）与 ViewModel 层进行通讯的一种便捷的方式就是使用 LiveData 来进行观察。这个视图层订阅 Livedata 的数据变化并对其变化做出反应。这适用于连续不断显示在屏幕的数据，比如上面LiveData和ViewModel实现跨页面通信的列子。

但是，有一些数据只会消费一次，就像是 Snackbar 消息，导航事件或者一个触发 Dialog 展示/消失的数据。

如下场景，主页面监听是否跳转到详情页面，来执行跳转逻辑的情况：

主页的 MainActivityViewModel 代码如下：

public class MainActivityViewModel extends ViewModel {

    private MutableLiveEvent<Boolean> _navigateToDetails = new MutableLiveEvent<>();

    public LiveData<Boolean> navigateToDetails(){

        return _navigateToDetails;
    }

    public void userClicksOnButton() {
        _navigateToDetails.setValue(true);
    }

}

主页面onResume中监听，保证每次到主页面就监听：

@Override
    public void onResume() {
        super.onResume();
        mViewModel.navigateToDetails().observe(this, new Observer<Boolean>() {
            @Override
            public void onChanged(Boolean aBoolean) {
                if (mViewModel.navigateToDetails().getValue()){
                    NavigatorUser.starDetailActivity();
                }
            }
        });
    }

这种使用方式的问题是：_navigateToDetails 中的值会永远为 true，从而导致无法回到首页。复现步骤是：

用户点击按钮，启动详情页 DetailsActivity
用户点击返回键，返回到主界面 MainActivity
这时 MainActivity 由非活动状态恢复到活动状态
但 myViewModel 观察到 _navigateToDetails 仍旧为 true，就又跳转到详情页 DetailsActivity

一种看起来没问题的解决方案是：页面跳转后立马把标志位设为 false，如 MainActivityViewModel 所示：

public void userClicksOnButton() {
        _navigateToDetails.setValue(true);
        _navigateToDetails.setValue(false);
    }

然而，需要注意的是：

LiveData 不能保证发射它接收到的每个数据值。

例如我们在没有活动的观察者时设置了一个新值，这个新值不会被发送，

此外，在多个子线程中操作 LiveData 可能发生竞争状况，从而导致观察者只会收到一次回调。

但这个方案的主要问题是：别人很难看懂这个代码，并且这种代码也很丑陋。那么，我们应该怎么确保在导航事件发生后恢复初值呢？

另一种稍微好点，但仍有问题的方案是：View 告诉 ViewModel，导航事件已经完成，LiveData 应该恢复默认值了。

@Override
public void onResume() {
    super.onResume();
    mViewModel.navigateToDetails().observe(this, new Observer<Boolean>() {
        @Override
        public void onChanged(Boolean aBoolean) {
            if (mViewModel.navigateToDetails().getValue()){
                myViewModel.navigateToDetailsHandled()
                NavigatorUser.starDetailActivity();
            }
        }
    });
}

然后在 MainActivityViewModel 中添加一个 navigateToDetailsHandled() 方法：

public class MainActivityViewModel extends ViewModel {
    //对外提供请求接口对象
    public final CommonRequest commonRequest = new CommonRequest();

    private SingleLiveEvent<Boolean> _navigateToDetails = new SingleLiveEvent<>();

    public LiveData<Boolean> navigateToDetails(){

        return _navigateToDetails;
    }

    public void userClicksOnButton() {
        _navigateToDetails.setValue(true);
    }

    //新增方法
    public void navigateToDetailsHandled() {
        _navigateToDetails.setValue(true);
    }

}

这种方法的问题是：存在很多样板代码，

ViewModel 中每添加一个事件都要添加一个对应的方法，并且很容易出错。

此外，观察者（View）很容易忘记调用 ViewModel 的这个方法。

一种还可以接受的解决方案是：SingleLiveEvent。

这个类是 Google 官方 Demo 中的适用于这种特殊场景的解决方案，它是一个仅发送一次更新的 LiveData。

SingleLiveEvent代码如下：

/**
 * A lifecycle-aware observable that sends only new updates after subscription, used for events like
 * navigation and Snackbar messages.
 * <p>
 * This avoids a common problem with events: on configuration change (like rotation) an update
 * can be emitted if the observer is active. This LiveData only calls the observable if there's an
 * explicit call to setValue() or call().
 * <p>
 * Note that only one observer is going to be notified of changes.
 */
public class SingleLiveEvent<T> extends MutableLiveData<T> {

    private static final String TAG = "SingleLiveEvent";

    private final AtomicBoolean mPending = new AtomicBoolean(false);

    @MainThread
    public void observe(LifecycleOwner owner, final Observer<? super T> observer) {

        if (hasActiveObservers()) {
            Log.w(TAG, "Multiple observers registered but only one will be notified of changes.");
        }

        // Observe the internal MutableLiveData
        super.observe(owner, new Observer<T>() {
            @Override
            public void onChanged(@Nullable T t) {
                if (mPending.compareAndSet(true, false)) {
                    observer.onChanged(t);
                }
            }
        });
    }

    @MainThread
    public void setValue(@Nullable T t) {
        mPending.set(true);
        super.setValue(t);
    }

    /**
     * Used for cases where T is Void, to make calls cleaner.
     */
    @MainThread
    public void call() {
        setValue(null);
    }
}

MainActivityViewModel中使用SingleLiveEvent：

public class MainActivityViewModel extends ViewModel {
    private SingleLiveEvent<Boolean> _navigateToDetails = new SingleLiveEvent<>();

    public LiveData<Boolean> navigateToDetails(){

        return _navigateToDetails;
    }

    public void userClicksOnButton() {
        _navigateToDetails.setValue(true);
    }

}

MainActivity中监听：

@Override
public void onResume() {
    super.onResume();
    mViewModel.navigateToDetails().observe(this, new Observer<Boolean>() {
        @Override
        public void onChanged(Boolean aBoolean) {
            if (mViewModel.navigateToDetails().getValue()){
                NavigatorUser.starDetailActivity();
            }
        }
    });
}

官网针对SingleLiveEvent参考链接如下：

medium.com/androiddeve…

SingleLiveEvent 的问题在于：它仅限于一个观察者。如果你无意中添加了多个，则只会有一个收到回调，并且无法保证哪一个会收到。

3、LiveDataBus消息总线替代RxBus、EventBus

通过LiveDataBus可以实现如下需求：

基于 LiveData 组件；
保证内存不会泄漏；
不用反注册消息总线；

先看一下LiveDataBus用法：

注册订阅

LiveDataBus.get()
    .with("key_test", String.class)
    .observe(this, new Observer<String>() {
        @Override
        public void onChanged(@Nullable String s) {
        }
    });

发送消息：

LiveDataBus.get().with("key_test").setValue(s);

用法上和 EventBus 非常相像，但我们的优势不用手动反注册，不用担心内存泄漏了。

问题分析：

我们先前通过源码分析得知：消息分发核心方法：

void considerNotify(ObserverWrapper observer) {
  //观察者没有处于活跃状态,则不分发。
   if (!observer.shouldBeActive()) {
       observer.activeStateChanged(false);
       return;
   }
   //观察者接收的消息的次数>=livedata发送消息的次数,不分发。
   //如果之前已经发送过数据了，新注册的observer也能接收到最后一条数据。
   if (observer.mLastVersion >= mVersion) {
       return;
   }

  //根本原因在于ObserverWrapper的version字段在创建时=-1,没有主动和LiveData的mVersion字段对齐
   observer.mLastVersion = mVersion;
   observer.mObserver.onChanged((T) mData);
}

控制黏性事件的突破口在于观察者的 version字段，我们要在注册一个新的 Observer 时把它的 mLastVersion 字段和 LiveData.mVersion 字段主动保持一致就可以了。

但是上面这个 version 字段我们都是拿不到也无法修改的，LiveDataBus的解决方案是：

在调用observe的时候，通过反射拿到LifecycleBoundObserver，再把LifecycleBoundObserver的version设置成和LiveData一致。

看一下LiveDataBus的最终实现：

public final class LiveDataBus {

    private final Map<String, BusMutableLiveData<Object>> bus;

    private LiveDataBus() {
        bus = new HashMap<>();
    }

    private static class SingletonHolder {
        private static final LiveDataBus DEFAULT_BUS = new LiveDataBus();
    }

    public static LiveDataBus get() {
        return SingletonHolder.DEFAULT_BUS;
    }

    public <T> MutableLiveData<T> with(String key, Class<T> type) {
        if (!bus.containsKey(key)) {
            bus.put(key, new BusMutableLiveData<>());
        }
        return (MutableLiveData<T>) bus.get(key);
    }

    public MutableLiveData<Object> with(String key) {
        return with(key, Object.class);
    }

    private static class ObserverWrapper<T> implements Observer<T> {

        private Observer<T> observer;

        public ObserverWrapper(Observer<T> observer) {
            this.observer = observer;
        }

        @Override
        public void onChanged(@Nullable T t) {
            if (observer != null) {
                if (isCallOnObserve()) {
                    return;
                }
                observer.onChanged(t);
            }
        }

        private boolean isCallOnObserve() {
            StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
            if (stackTrace != null && stackTrace.length > 0) {
                for (StackTraceElement element : stackTrace) {
                    if ("android.arch.lifecycle.LiveData".equals(element.getClassName()) &&
                            "observeForever".equals(element.getMethodName())) {
                        return true;
                    }
                }
            }
            return false;
        }
    }

    private static class BusMutableLiveData<T> extends MutableLiveData<T> {

        private Map<Observer, Observer> observerMap = new HashMap<>();

        @Override
        public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
            super.observe(owner, observer);
            try {
                hook(observer);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        @Override
        public void observeForever(@NonNull Observer<T> observer) {
            if (!observerMap.containsKey(observer)) {
                observerMap.put(observer, new ObserverWrapper(observer));
            }
            super.observeForever(observerMap.get(observer));
        }

        @Override
        public void removeObserver(@NonNull Observer<T> observer) {
            Observer realObserver = null;
            if (observerMap.containsKey(observer)) {
                realObserver = observerMap.remove(observer);
            } else {
                realObserver = observer;
            }
            super.removeObserver(realObserver);
        }

        private void hook(@NonNull Observer<T> observer) throws Exception {
            //get wrapper's version
            Class<LiveData> classLiveData = LiveData.class;
            Field fieldObservers = classLiveData.getDeclaredField("mObservers");
            fieldObservers.setAccessible(true);
            Object objectObservers = fieldObservers.get(this);
            Class<?> classObservers = objectObservers.getClass();
            Method methodGet = classObservers.getDeclaredMethod("get", Object.class);
            methodGet.setAccessible(true);
            Object objectWrapperEntry = methodGet.invoke(objectObservers, observer);
            Object objectWrapper = null;
            if (objectWrapperEntry instanceof Map.Entry) {
                objectWrapper = ((Map.Entry) objectWrapperEntry).getValue();
            }
            if (objectWrapper == null) {
                throw new NullPointerException("Wrapper can not be bull!");
            }
            Class<?> classObserverWrapper = objectWrapper.getClass().getSuperclass();
            Field fieldLastVersion = classObserverWrapper.getDeclaredField("mLastVersion");
            fieldLastVersion.setAccessible(true);
            //get livedata's version
            Field fieldVersion = classLiveData.getDeclaredField("mVersion");
            fieldVersion.setAccessible(true);
            Object objectVersion = fieldVersion.get(this);
            //set wrapper's version
            fieldLastVersion.set(objectWrapper, objectVersion);
        }
    }
}

这样LiveDataBus的实现及其简单相对EventBus复杂的实现，LiveDataBus只需要一个类就可以实现。

该方案是美团技术团队提供的，并且通过演进，他们封装了LiveEventBus是一款Android消息总线，基于LiveData，具有生命周期感知能力，支持Sticky，支持AndroidX，支持跨进程，支持跨APP，感兴趣的可以看下具体实现：

github.com/JeremyLiao/…

可以看下他们针对常用消息总线对比：

4、UnPeekLiveData经过深度思考的解决粘性事件方案

UnPeekLiveData具有如下特性：

一条消息能被多个观察者消费

消息被所有观察者消费完毕后才开始阻止倒灌

可以通过 clear 方法手动将消息从内存中移除

让非入侵设计成为可能，遵循开闭原则

基于 “访问权限控制” 支持 "读写分离”，遵循唯一可信源的消息分发理念

UnPeekLiveData 提供了构造器模式，可通过构造器组装适合自己业务场景的 UnPeekLiveData。

UnPeekLiveData<Moment> test =
  new UnPeekLiveData.Builder<Moment>()
    .setAllowNullValue(false)
    .create();

具体是实现：

ProtectedUnPeekLiveData：

public class ProtectedUnPeekLiveData<T> extends LiveData<T> {

    protected boolean isAllowNullValue;

    private final HashMap<Integer, Boolean> observers = new HashMap<>();

    public void observeInActivity(@NonNull AppCompatActivity activity, @NonNull Observer<? super T> observer) {
        LifecycleOwner owner = activity;
        Integer storeId = System.identityHashCode(activity.getViewModelStore());
        observe(storeId, owner, observer);
    }

    public void observeInFragment(@NonNull Fragment fragment, @NonNull Observer<? super T> observer) {
        LifecycleOwner owner = fragment.getViewLifecycleOwner();
        Integer storeId = System.identityHashCode(fragment.getViewModelStore());
        observe(storeId, owner, observer);
    }

    private void observe(@NonNull Integer storeId,
                         @NonNull LifecycleOwner owner,
                         @NonNull Observer<? super T> observer) {

        if (observers.get(storeId) == null) {
            observers.put(storeId, true);
        }

        super.observe(owner, t -> {
            if (!observers.get(storeId)) {
                observers.put(storeId, true);
                if (t != null || isAllowNullValue) {
                    observer.onChanged(t);
                }
            }
        });
    }

    /**
     * 重写的 setValue 方法，默认不接收 null
     * 可通过 Builder 配置允许接收
     * 可通过 Builder 配置消息延时清理的时间
     * <p>
     * override setValue, do not receive null by default
     * You can configure to allow receiving through Builder
     * And also, You can configure the delay time of message clearing through Builder
     *
     * @param value
     */
    @Override
    protected void setValue(T value) {
        if (value != null || isAllowNullValue) {
            for (Map.Entry<Integer, Boolean> entry : observers.entrySet()) {
                entry.setValue(false);
            }
            super.setValue(value);
        }
    }

    protected void clear() {
        super.setValue(null);
    }
}

UnPeekLiveData

public class UnPeekLiveData<T> extends ProtectedUnPeekLiveData<T> {

    @Override
    public void setValue(T value) {
        super.setValue(value);
    }

    @Override
    public void postValue(T value) {
        super.postValue(value);
    }

    /**
     * TODO：Tip：请不要在 UnPeekLiveData 中使用 observe 方法。
     * 取而代之的是在 Activity 和 fragment 中分别使用 observeInActivity 和 observeInFragment 来观察。
     * <p>
     * 2020.10.15 背景缘由：
     * UnPeekLiveData 通过 ViewModelStore 来在各种场景下（如旋屏后）确定订阅者的唯一性和消息的消费状况，
     * 因而在 Activity 和 fragment 对 LifecycleOwner 的使用存在差异的现状下，
     * 我们采取注入局部变量的方式，来获取 store 和 owner。
     *
     * @param owner
     * @param observer
     */
    @Override
    @Deprecated
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        throw new IllegalArgumentException("请不要在 UnPeekLiveData 中使用 observe 方法。" +
                "取而代之的是在 Activity 和 Fragment 中分别使用 observeInActivity 和 observeInFragment 来观察。\n\n" +
                "Taking into account the normal permission of preventing backflow logic, " +
                " do not use observeForever to communicate between pages." +
                "Instead, you can use ObserveInActivity and ObserveInFragment methods " +
                "to observe in Activity and Fragment respectively.");
    }

    /**
     * TODO：Tip：请不要在 UnPeekLiveData 中使用 observeForever 方法。
     * <p>
     * 2020.8.1 背景缘由：
     * UnPeekLiveData 主要用于表现层的 页面转场 和 页面间通信 场景下的非粘性消息分发，
     * 出于生命周期安全等因素的考虑，不建议使用 observeForever 方法，
     * <p>
     * 对于数据层的工作，如有需要，可结合实际场景使用 RxJava 或 kotlin flow。
     *
     * @param observer
     */
    @Override
    @Deprecated
    public void observeForever(@NonNull Observer<? super T> observer) {
        throw new IllegalArgumentException("出于生命周期安全的考虑，请不要在 UnPeekLiveData 中使用 observeForever 方法。\n\n" +
                "Considering avoid lifecycle security issues," +
                " do not use observeForever for communication between pages.");
    }

    public static class Builder<T> {

        /**
         * 是否允许传入 null value
         */
        private boolean isAllowNullValue;

        public Builder<T> setAllowNullValue(boolean allowNullValue) {
            this.isAllowNullValue = allowNullValue;
            return this;
        }

        public UnPeekLiveData<T> create() {
            UnPeekLiveData<T> liveData = new UnPeekLiveData<>();
            liveData.isAllowNullValue = this.isAllowNullValue;
            return liveData;
        }
    }
}

具体源码实现见：

github.com/KunMinX/UnP…

总结：

LiveData实用性通过如上四种场景做了分析：

1、LiveData和ViewModel实现跨页面通信

2、SingleLiveEvent官方解决单次监听的方案

3、LiveDataBus消息总线替代RxBus、EventBus

4、UnPeekLiveData经过深度思考的解决粘性事件方案

可根据项目需求，选择使用。