潇湘剑雨个人页面-阿里云开发者社区

事件总线方案实践

liveData实现事件总线目录介绍 01.EventBus使用原理 02.RxBus使用原理 03.为何使用liveData 04.LiveDataBus的组成 05.LiveDataBus原理图 06.简单的实现案例代码 07.遇到的问题和分析思路 08.使用反射解决遇到问题 09.使用postValue的bug 10.如何发送延迟事件消息 11.如何发送轮训延迟事件 12.避免类型转换异常问题 13.如何实现生命周期感知 00.事件开源库事件总线开源库：https://github.com/yangchong211/YCLiveDataBus 01.EventBus使用原理框架的核心思想，就是消息的发布和订阅，使用订阅者模式实现，其原理图大概如下所示，摘自网络。发布和订阅之间的依赖关系，其原理图大概如下所示，摘自网络。订阅/发布模式和观察者模式之间有着微弱的区别，个人觉得订阅/发布模式是观察者模式的一种增强版。两者区别如下所示，摘自网络。具体使用可以看demo代码，demo开源地址 02.RxBus使用原理 RxBus不是一个库，而是一个文件，实现只有短短30行代码。RxBus本身不需要过多分析，它的强大完全来自于它基于的RxJava技术。在RxJava中有个Subject类，它继承Observable类，同时实现了Observer接口，因此Subject可以同时担当订阅者和被订阅者的角色，我们使用Subject的子类PublishSubject来创建一个Subject对象（PublishSubject只有被订阅后才会把接收到的事件立刻发送给订阅者），在需要接收事件的地方，订阅该Subject对象，之后如果Subject对象接收到事件，则会发射给该订阅者，此时Subject对象充当被订阅者的角色。完成了订阅，在需要发送事件的地方将事件发送给之前被订阅的Subject对象，则此时Subject对象作为订阅者接收事件，然后会立刻将事件转发给订阅该Subject对象的订阅者，以便订阅者处理相应事件，到这里就完成了事件的发送与处理。最后就是取消订阅的操作了，RxJava中，订阅操作会返回一个Subscription对象，以便在合适的时机取消订阅，防止内存泄漏，如果一个类产生多个Subscription对象，我们可以用一个CompositeSubscription存储起来，以进行批量的取消订阅。具体使用可以看demo代码，demo开源地址 03.为何使用liveData 为何使用liveData LiveData具有的这种可观察性和生命周期感知的能力，使其非常适合作为Android通信总线的基础构件。在一对多的场景中，发布消息事件后，订阅事件的页面只有在可见的时候才会处理事件逻辑。使用者不用显示调用反注册方法。LiveData具有生命周期感知能力，所以LiveDataBus只需要调用注册回调方法，而不需要显示的调用反注册方法。这样带来的好处不仅可以编写更少的代码，而且可以完全杜绝其他通信总线类框架（如EventBus、RxBus）忘记调用反注册所带来的内存泄漏的风险。该liveDataBus优势 1.该LiveDataBus的实现比较简单，支持发送普通事件，也支持发送粘性事件； 2.该LiveDataBus支持发送延迟事件消息，也可以用作轮训延迟事件(比如商城类项目某活动页面5秒钟刷一次接口数据)，支持stop轮训操作 3.该LiveDataBus可以减小APK包的大小，由于LiveDataBus只依赖Android官方Android Architecture Components组件的LiveData； 4.该LiveDataBus具有生命周期感知，这个是一个很大的优势。不需要反注册，避免了内存泄漏等问题；关于liveData深度解析，可以看我这篇博客：01.LiveData详细分析 04.LiveDataBus的组成消息：消息可以是任何的 Object，可以定义不同类型的消息，如 Boolean、String。也可以定义自定义类型的消息。消息通道： LiveData 扮演了消息通道的角色，不同的消息通道用不同的名字区分，名字是 String 类型的，可以通过名字获取到一个 LiveData 消息通道。消息总线：消息总线通过单例实现，不同的消息通道存放在一个 HashMap 中。订阅：订阅者通过 getChannel() 获取消息通道，然后调用 observe() 订阅这个通道的消息。发布：发布者通过 getChannel() 获取消息通道，然后调用 setValue() 或者 postValue() 发布消息。 05.LiveDataBus原理图为了方便理解，LiveDataBus原理图如下所示订阅和注册的流程图订阅注册原理图为何用LiveDataBus替代EventBus和RxBus LiveDataBus的实现极其简单 LiveDataBus可以减小APK包的大小，由于LiveDataBus只依赖Android官方Android Architecture Components组件的LiveData。 LiveDataBus具有生命周期感知。 06.简单的实现案例代码我这里先用最简单的代码实现liveDataBus，然后用一下，看一下会出现什么问题，代码如下所示： public final class LiveDataBus1 { private final Map<String, MutableLiveData<Object>> bus; private LiveDataBus1() { bus = new HashMap<>(); } private static class SingletonHolder { private static final LiveDataBus1 DATA_BUS = new LiveDataBus1(); } public static LiveDataBus1 get() { return SingletonHolder.DATA_BUS; } public <T> MutableLiveData<T> getChannel(String target, Class<T> type) { if (!bus.containsKey(target)) { bus.put(target, new MutableLiveData<>()); } return (MutableLiveData<T>) bus.get(target); } public MutableLiveData<Object> getChannel(String target) { return getChannel(target, Object.class); } } 那么如何发送消息和接收消息呢，注意两者的key需要保持一致，否则无法接收？具体代码如下所示： //发送消息 LiveDataBus1.get().getChannel("yc_bus").setValue(text); //接收消息 LiveDataBus1.get().getChannel("yc_bus", String.class) .observe(this, new Observer<String>() { @Override public void onChanged(@Nullable String newText) { // 更新数据 tvText.setText(newText); } }); 07.遇到的问题和分析思路遇到的问题： 1.LiveData 一时使用一时爽，爽完了之后我们发现这个简易的 LiveDataBus 存在一个问题，就是订阅者会收到订阅之前发布的消息，类似于粘性消息。对于一个消息总线来说，这是不可接受的。 2.多次调用了 postValue() 方法，只有最后次调用的值会得到更新。也就是此方法是有可能会丢失事件！ 7.1 先看第一个问题然后看一下LiveData的订阅方法observe源码看下面代码可知道，LiveData 内部会将传入参数包装成 wrapper ，然后存在一个 Map 中，最后通过 LifeCycle 组件添加观察者。 // 注释只能在主线程中调用该方法 @MainThread public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) { // 当前绑定的组件(activity or fragment)状态为DESTROYED的时候, 则会忽视当前的订阅请求 if (owner.getLifecycle().getCurrentState() == DESTROYED) { // ignore return; } // 转为带生命周期感知的观察者包装类 LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer); ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper); // 对应观察者只能与一个owner绑定，否则抛出异常 if (existing != null && !existing.isAttachedTo(owner)) { throw new IllegalArgumentException("Cannot add the same observer" + " with different lifecycles"); } if (existing != null) { return; } // lifecycle注册 owner.getLifecycle().addObserver(wrapper); } 紧接着，来看一下LiveData的更新数据方法 LiveData 更新数据方式有两个，一个是 setValue() 另一个是 postValue()，这两个方法的区别是，postValue() 在内部会抛到主线程去执行更新数据，因此适合在子线程中使用；而 setValue() 则是直接更新数据。 @MainThread protected void setValue(T value) { assertMainThread("setValue"); // 这里的 mVersion，它本问题关键，每次更新数据都会自增，默认值是 -1。 mVersion++; mData = value; dispatchingValue(null); } 跟进下 dispatchingValue() 方法，注意，这里需要重点看considerNotify代码： private void dispatchingValue(@Nullable ObserverWrapper initiator) { // mDispatchingValue的判断主要是为了解决并发调用dispatchingValue的情况 // 当对应数据的观察者在执行的过程中, 如有新的数据变更, 则不会再次通知到观察者。所以观察者内的执行不应进行耗时工作 if (mDispatchingValue) { mDispatchInvalidated = true; return; } mDispatchingValue = true; do { mDispatchInvalidated = false; if (initiator != null) { // 等下重点看这里的代码 considerNotify(initiator); initiator = null; } else { for (Iterator<Map.Entry<Observer<T>, ObserverWrapper>> iterator = mObservers.iteratorWithAdditions(); iterator.hasNext(); ) { // 等下重点看这里的代码 considerNotify(iterator.next().getValue()); if (mDispatchInvalidated) { break; } } } } while (mDispatchInvalidated); mDispatchingValue = false; } 然后看一下considerNotify() 方法做了什么，代码如下所示，这里有道词典翻译下注释： private void considerNotify(ObserverWrapper observer) { if (!observer.mActive) { return; } // 检查最新的状态b4调度。也许它改变了状态，但我们还没有得到事件。 // 我们还是先检查观察者。活动，以保持它作为活动的入口。 // 因此,即使观察者移动到一个活动状态，如果我们没有收到那个事件，我们最好不要通知一个更可预测的通知顺序。 if (!observer.shouldBeActive()) { observer.activeStateChanged(false); return; } if (observer.mLastVersion >= mVersion) { return; } observer.mLastVersion = mVersion; //noinspection unchecked observer.mObserver.onChanged((T) mData); } 为何订阅者会马上收到订阅之前发布的最新消息？如果 ObserverWrapper 的 mLastVersion 小于 LiveData 的 mVersion，那么就会执行的 onChange() 方法去通知观察者数据已更新。而 ObserverWrapper.mLastVersion 的默认值是 -1， LiveData 只要更新过数据，mVersion 就肯定会大于 -1，所以订阅者会马上收到订阅之前发布的最新消息！！ 7.2 然后看一下第二个问题首先看一下postValue源代码，如下所示：看代码注释中说，如果在多线程中同一个时刻，多次调用了 postValue() 方法，只有最后次调用的值会得到更新。也就是此方法是有可能会丢失事件！ postValue 只是把传进来的数据先存到 mPendingData，ArchTaskExecutor.getInstance()获取的是一个单利对象。然后往主线程抛一个 Runnable，在这个 Runnable 里面再调用 setValue 来把存起来的值真正设置上去，并回调观察者们。而如果在这个 Runnable 执行前多次 postValue，其实只是改变暂存的值 mPendingData，并不会再次抛另一个 Runnable。 protected void postValue(T value) { boolean postTask; synchronized (mDataLock) { postTask = mPendingData == NOT_SET; mPendingData = value; } if (!postTask) { return; } ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable); } private final Runnable mPostValueRunnable = new Runnable() { @Override public void run() { Object newValue; synchronized (mDataLock) { newValue = mPendingData; mPendingData = NOT_SET; } //noinspection unchecked setValue((T) newValue); } }; 08.使用反射解决遇到问题根据之前的分析，只需要在注册一个新的订阅者的时候把Wrapper的version设置成跟LiveData的version一致即可。能不能从Map容器mObservers中取到LifecycleBoundObserver，然后再更改version呢？答案是肯定的，通过查看SafeIterableMap的源码我们发现有一个protected的get方法。因此，在调用observe的时候，我们可以通过反射拿到LifecycleBoundObserver，再把LifecycleBoundObserver的version设置成和LiveData一致即可。 @Override public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) { super.observe(owner, observer); hook(observer); } private void hook(@NonNull Observer<T> observer) { try { 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) { Class<?> classObserverWrapper = objectWrapper.getClass().getSuperclass(); Field fieldLastVersion = null; if (classObserverWrapper != null) { fieldLastVersion = classObserverWrapper.getDeclaredField("mLastVersion"); fieldLastVersion.setAccessible(true); Field fieldVersion = classLiveData.getDeclaredField("mVersion"); fieldVersion.setAccessible(true); Object objectVersion = fieldVersion.get(this); fieldLastVersion.set(objectWrapper, objectVersion); } } } catch (Exception e){ e.printStackTrace(); } } 同时还需要注意，在实现MutableLiveData自定义类BusMutableLiveData中，需要重写这几个方法。代码如下所示： /** * 在给定的观察者的生命周期内将给定的观察者添加到观察者列表所有者。 * 事件是在主线程上分派的。如果LiveData已经有数据集合，它将被传递给观察者。 * @param owner owner * @param observer observer */ public void observeSticky(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) { super.observe(owner, observer); } /** * 将给定的观察者添加到观察者列表中。这个调用类似于{@link LiveData#observe(LifecycleOwner, Observer)} * 和一个LifecycleOwner, which总是积极的。这意味着给定的观察者将接收所有事件，并且永远不会被自动删除。 * 您应该手动调用{@link #removeObserver(Observer)}来停止观察这LiveData。 * @param observer observer */ public void observeStickyForever(@NonNull Observer<T> observer) { super.observeForever(observer); } 09.使用postValue的bug 9.1 模拟通过发送多个postValue消息出现丢失问题首先看看MutableLiveData源代码，如下所示，这里重点展示测试数据案例 public void postValue(T value) { super.postValue(value); } 然后使用for循环，使用postValue发送100条消息事件，代码如下所示： public void postValueCountTest() { sendCount = 100; receiveCount = 0; ExecutorService threadPool = Executors.newFixedThreadPool(2); for (int i = 0; i < sendCount; i++) { threadPool.execute(new Runnable() { @Override public void run() { LiveDataBus2.get().getChannel(Constant.LIVE_BUS3).postValue("test_1_data"+sendCount); } }); } new Handler().postDelayed(new Runnable() { @Override public void run() { BusLogUtils.d("sendCount: " + sendCount + " | receiveCount: " + receiveCount); Toast.makeText(ThirdActivity4.this, "sendCount: " + sendCount + " | receiveCount: " + receiveCount, Toast.LENGTH_LONG).show(); } }, 1000); } //接收消息 LiveDataBus2.get() .getChannel(Constant.LIVE_BUS3, String.class) .observe(this, new Observer<String>() { @Override public void onChanged(@Nullable String s) { receiveCount++; BusLogUtils.d("接收消息--ThirdActivity4------yc_bus---1-"+s+"----"+receiveCount); } }); 然后看一下打印日志，是不是发现了什么问题？发现根本没有100条数据…… 2020-03-03 10:25:51.397 4745-4745/com.ycbjie.yclivedatabus D/BusLogUtils: 接收消息--ThirdActivity4------yc_bus---1-test_1_data100----1 2020-03-03 10:25:51.397 4745-4745/com.ycbjie.yclivedatabus D/BusLogUtils: 接收消息--ThirdActivity4------yc_bus---1-test_1_data100----2 2020-03-03 10:25:51.397 4745-4745/com.ycbjie.yclivedatabus D/BusLogUtils: 接收消息--ThirdActivity4------yc_bus---1-test_1_data100----3 2020-03-03 10:25:51.403 4745-4745/com.ycbjie.yclivedatabus D/BusLogUtils: 接收消息--ThirdActivity4------yc_bus---1-test_1_data100----4 9.2 修改后使用handler处理postValue消息既然post是在子线程中发送消息事件，那么可不可以使用handler将它放到主线程中处理事件了，是可以的，代码如下所示 /** * 子线程发送事件 * @param value value */ @Override public void postValue(T value) { //注意，去掉super方法， //super.postValue(value); mainHandler.post(new PostValueTask(value)); } private BusWeakHandler mainHandler = new BusWeakHandler(Looper.getMainLooper()); private class PostValueTask implements Runnable { private T newValue; public PostValueTask(@NonNull T newValue) { this.newValue = newValue; } @Override public void run() { setValue(newValue); } } 然后再次使用for循环，发送100条消息事件，查看日志。发现就会刚好有100条数据。代码这里就不展示了，跟上面测试代码类似。 10.如何发送延迟事件消息可以知道，通过postValue可以在子线程发送消息，那么发送延迟消息也十分简单，代码如下所示： /** * 子线程发送事件 * @param value value */ @Override public void postValue(T value) { //注意，去掉super方法， //super.postValue(value); mainHandler.post(new PostValueTask(value)); } /** * 发送延迟事件 * @param value value * @param delay 延迟时间 */ @Override public void postValueDelay(T value, long delay) { mainHandler.postDelayed(new PostValueTask(value) , delay); //mainHandler.postAtTime(new PostValueTask(value) , delay); } 测试用例，延迟5秒钟发送事件，代码如下所示。具体可以看demo钟的案例！ LiveDataBus.get().with(Constant.LIVE_BUS4).postValueDelay("test_4_data",5000); 11.如何发送轮训延迟事件轮训延迟事件，比如有的页面需要实现，每间隔5秒钟就刷新一次页面数据，常常用于活动页面。在购物商城这类需求很常见 @Override public void postValueInterval(final T value, final long interval) { mainHandler.postDelayed(new Runnable() { @Override public void run() { setValue(value); mainHandler.postDelayed(this,interval); } },interval); } 测试用例，轮训延迟3秒钟发送事件，代码如下所示。具体可以看demo钟的案例！ LiveDataBus.get().with(Constant.LIVE_BUS5).postValueInterval("test_5_data",3000); 这里遇到了一个问题，假如有多个页面有这种轮训发送事件的需求，显然这个是实现不了的。那么可不可以把每个轮训runnable记录一个名称区别开来代码更更改如下 /** * 发送延迟事件，间隔轮训 * @param value value * @param interval 间隔 */ @Deprecated @Override public void postValueInterval(final T value, final long interval,@NonNull String taskName) { if(taskName.isEmpty()){ return; } IntervalValueTask intervalTask = new IntervalValueTask(value,interval); intervalTasks.put(taskName,intervalTask); mainHandler.postDelayed(intervalTask,interval); } private class IntervalValueTask implements Runnable { private T newValue; private long interval; public IntervalValueTask(T newValue, long interval) { this.newValue = newValue; this.interval = interval; } @Override public void run() { setValue(newValue); mainHandler.postDelayed(this,interval); } } 轮训总不可以一直持续下去吧，这个时候可以添加一个手动关闭轮训的方法。代码如下所示： /** * 停止轮训间隔发送事件 */ @Deprecated @Override public void stopPostInterval(@NonNull String taskName) { IntervalValueTask intervalTask = intervalTasks.get(taskName); if(intervalTask!= null){ //移除callback mainHandler.removeCallbacks(intervalTask); intervalTasks.remove(taskName); } } 12.避免类型转换异常问题代码如下所示 public class SafeCastObserver<T> implements Observer<T> { @NonNull private final Observer<T> observer; public SafeCastObserver(@NonNull Observer<T> observer) { this.observer = observer; } @Override public void onChanged(@Nullable T t) { //捕获异常，避免出现异常之后，收不到后续的消息事件 try { //注意为了避免转换出现的异常，try-catch捕获 observer.onChanged(t); } catch (ClassCastException e) { e.printStackTrace(); } catch (Exception e) { e.printStackTrace(); } } } 13.如何实现生命周期感知生命周期感知能力就是当在Android平台的LifecycleOwner（如Activity）中使用的时候，只需要订阅消息，而不需要取消订阅消息。LifecycleOwner的生命周期结束的时候，会自动取消订阅。这带来了两个好处：可以在任何位置订阅消息，而不是必须在onCreate方法中订阅避免了忘记取消订阅引起的内存泄漏具体已经对lifecycle源码作出了分析，具体可以看我上一篇的博客。Lifecycle详细分析参考内容 https://juejin.im/post/5dce5b16f265da0ba5279b11 https://mp.weixin.qq.com/s/sHXzbGZjZMsem6VMbrSP7A https://juejin.im/post/5d84a273e51d45620923892b https://github.com/JeremyLiao/SmartEventBus https://developer.android.com/topic/libraries/architecture/lifecycle 事件总线开源库：https://github.com/yangchong211/YCLiveDataBus

LiveData详细分析

目录介绍 01.LiveData是什么东西 02.使用LiveData的优势 03.使用LiveData的步骤 04.简单使用LiveData 05.observe()和observerForever() 06.LiveData原理介绍 07.observe订阅源码分析 08.setValue发送源码分析 09.observeForever源码 10.LiveData源码总结 00.使用LiveData实现bus事件总线利用LiveData实现事件总线，替代EventBus。充分利用了生命周期感知功能，可以在activities, fragments, 或者 services生命周期是活跃状态时更新这些组件。支持发送普通事件，也可以发送粘性事件；还可以发送延迟消息，以及轮训延迟消息等等。 https://github.com/yangchong211/YCLiveDataBus 01.LiveData是什么东西基于观察者模式 LiveData是一种持有可被观察数据的类。LiveData需要一个观察者对象，一般是Observer类的具体实现。当观察者的生命周期处于STARTED或RESUMED状态时，LiveData会通知观察者数据变化。感知生命周期和其他可被观察的类不同的是，LiveData是有生命周期感知能力的，这意味着它可以在activities, fragments, 或者 services生命周期是活跃状态时更新这些组件。那么什么是活跃状态呢？就是STARTED和RESUMED就是活跃状态，只有在这两个状态下LiveData是会通知数据变化的。自动解除数据订阅要想使用LiveData（或者这种有可被观察数据能力的类）就必须配合实现了LifecycleOwner的对象使用。在这种情况下，当对应的生命周期对象DESTORY时，才能移除观察者。这对Activity或者Fragment来说显得尤为重要，因为他们可以在生命周期结束的时候立刻解除对数据的订阅，从而避免内存泄漏等问题。 02.使用LiveData的优势 2.1 具有很明显的优点 UI和实时数据保持一致因为LiveData采用的是观察者模式，这样一来就可以在数据发生改变时获得通知，更新UI。不会发生内存泄露观察者被绑定到组件的生命周期上，当被绑定的组件销毁（onDestroy）时，观察者会立刻自动清理自身的数据。不会再产生由于Activity处于stop状态而引起的崩溃例如：当Activity处于后台状态时，是不会收到LiveData的任何事件的。不需要再解决生命周期带来的问题 LiveData可以感知被绑定的组件的生命周期，只有在活跃状态才会通知数据变化。实时数据刷新当组件处于活跃状态或者从不活跃状态到活跃状态时总是能收到最新的数据解决Configuration Change问题在屏幕发生旋转或者被回收再次启动，立刻就能收到最新的数据。数据共享如果对应的LiveData是单例的话，就能在app的组件间分享数据。这部分详细的信息可以参考继承LiveData 2.2 细节点补充组件和数据相关的内容能实时更新,组件在前台的时候能够实时收到数据改变的通知，当组件从后台到前台来时，LiveData能够将最新的数据通知组件，因此保证了组件中和数据相关的内容能够实时更新。如果横竖屏切换（configuration change）时，不需要额外的处理来保存数据,当屏幕方向变化时，组件会被recreate，然而系统并不能保证你的数据能够被恢复的。当我们采用LiveData保存数据时，因为数据和组件分离了。当组件被recreate，数据还是存在LiveData中，并不会被销毁。 03.使用LiveData的步骤创建一个持有某种数据类型的LiveData (通常是在ViewModel中) 创建一个定义了onChange()方法的观察者。这个方法是控制LiveData中数据发生变化时，采取什么措施 (比如更新界面)。通常是在UI Controller (Activity/Fragment) 中创建这个观察者。通过 observe()方法连接观察者和LiveData。observe()方法需要携带一个LifecycleOwner类。这样就可以让观察者订阅LiveData中的数据，实现实时更新。 04.简单使用LiveData 4.1 单独使用LiveData 举一个最简单的案例代码： liveData = new MutableLiveData<>(); liveData.observe(this, new Observer<String>() { @Override public void onChanged(@Nullable final String newText) { // 更新数据 tv3.setText(newText); } }); liveData.setValue("小杨真的是一个逗比么"); 那么上面这一段代码大概是什么意思呢？首先创建一个 MutableLiveData（LiveData是抽象类）对象，通过 observe 方法可以订阅修改数据的通知，通过 postValue()或者 setValue() 方法发送事件更新数据，已经订阅的 Observer 能够得到数据更改的通知，就会回调 onChanged() 方法。 4.2 使用LiveData配合ViewModel LiveData是一个数据的包装。具体的包装对象可以是任何数据，包括集合。它是一个抽象类，首先先创建一个类实现LiveData。代码如下所示： public class TextViewModel extends ViewModel { /** * LiveData是抽象类，MutableLiveData是具体实现类 */ private MutableLiveData<String> mCurrentText; public MutableLiveData<String> getCurrentText() { if (mCurrentText == null) { mCurrentText = new MutableLiveData<>(); } return mCurrentText; } } 创建一个观察的对象，观察LiveData中的数据。目前在组件的onCreate()方法中开始观察数据，代码如下所示：思考下，可以在onResume()中调用么，个人觉得不太好。因为系统会多次调用onResume()方法。 private void initLiveData() { // 创建一个持有某种数据类型的LiveData (通常是在ViewModel中) model = ViewModelProviders.of(this).get(TextViewModel.class); // 创建一个定义了onChange()方法的观察者 // 开始订阅 final Observer<String> nameObserver = new Observer<String>() { @Override public void onChanged(@Nullable final String newText) { // 更新数据 tvText.setText(newText); } }; // 通过 observe()方法连接观察者和LiveData，注意：observe()方法需要携带一个LifecycleOwner类 model.getCurrentText().observe(this, nameObserver); } 然后去创建更新对象数据内容的对象。如何去更新那个文本中的数据呢？代码如下所示：想要在UI Controller中改变LiveData中的值呢？（比如点击某个Button设置文本内容的更改）。 LiveData并没有提供这样的功能，但是Architecture Component提供了MutableLiveData这样一个类，可以通过setValue(T)和postValue(T)方法来修改存储在LiveData中的数据。MutableLiveData是LiveData的一个子类，从名称上也能看出这个类的作用。调用setValue()方法就可以把LiveData中的值改为 "小杨真的是一个逗比么" 。同样，通过这种方法修改LiveData中的值同样会触发所有对这个数据感兴趣的类。那么setValue()和postValue()有什么不同呢？区别就是setValue()只能在主线程中调用，而postValue()可以在子线程中调用。 findViewById(R.id.tv_click).setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { count++; String text; switch (count%5){ case 1: text = "小杨真的是一个逗比么"; break; case 2: text = "逗比赶紧来star吧"; break; case 3: text = "小杨想成为大神"; break; case 4: text = "开始刷新数据啦"; break; default: text = "变化成默认的数据"; break; } model.getCurrentText().setValue(text); } }); 05.observe()和observerForever() 一般我们使用 LiveData 的 observe()，当数据更新后，LiveData 会通知它的所有活跃的观察者。与 RxJava 不同的，LiveData 只会通知活跃的观察者，例如 Activity 位于 Destroyed 状态时是不活跃的，因此不会收到通知。当然我们也可以使用 LiveData 的 observerForever() 方法进行订阅，区别是 observerForever() 不会受到 Activity 等组件的生命周期的影响，只要数据更新就会收到通知。 06.LiveData原理介绍 6.1 简单的原理介绍 LiveData可对数据进行观测, 并具有生命周期感知能力, 这就意味着当liveData只会在生命周期处于活跃(inActive)的状态下才会去执行观测动作, 而他的能力赋予不能脱离LifeCycle的范围。需要注意的是，LiveData内维护的mVersion表示的是发送信息的版本,每次发送一次信息, 它都会+1, 而ObserverWrapper内维护的mLastVersion为订阅触发的版本号, 当订阅动作生效的时候, 它的版本号会和发送信息的版本号同步.他们初始值都为-1。 6.2 然后思考一些问题 a.liveData如何实现订阅者模式，如何处理发送事件？ b.如何做到感知生命周期的，怎么跟 LifecycleOwner 进行绑定的？ c.LiveData 只在 LifecycleOwner active 状态发送通知，是怎么处理的？ d.LiveData 会自动在 DESTROY 的状态下取消订阅，是怎么处理的？ e.生命周期变化后数据处理流程是怎么样的？ f.为什么观察者只能与一个LifecycleOwner绑定，而不是多个？ 07.observe订阅源码分析 7.1 首先看看observe方法源码直接查看源代码，如下所示：当前绑定的组件(activity或者fragment)状态为DESTROYED的时候, 则会忽视当前的订阅请求，也就是忽略owner的注册；如果需要与生命周期绑定, 则需要传入LifecycleOwner对象, 将我们的LiveData数据观测者(Observer)包装注册到生命周期的观测者中, 就是源码中创建wrapper对象过程；需要注意的问题是，不能添加具有不同生命周期的相同观察者，否则就会抛出IllegalArgumentException异常，但是owner可以add多个Observer；最后添加一个LifecycleObserver，它将在LifecycleOwner更改状态时得到通知，并做出及时的对应更新活动。 @MainThread public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) { //当前绑定的组件(activity或者fragment)状态为DESTROYED的时候, 则会忽视当前的订阅请求 if (owner.getLifecycle().getCurrentState() == DESTROYED) { // ignore return; } //创建生命周期感知的观察者包装类 LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer); //如果指定的键尚未与某个值关联，则将其与给定的值关联 ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper); //对应观察者只能与一个owner绑定 if (existing != null && !existing.isAttachedTo(owner)) { throw new IllegalArgumentException("Cannot add the same observer" + " with different lifecycles"); } if (existing != null) { return; } //lifecycle注册 //添加一个LifecycleObserver，它将在LifecycleOwner更改状态时得到通知 owner.getLifecycle().addObserver(wrapper); } 7.2 看看LifecycleBoundObserver源码然后看一下观察者类LifecycleBoundObserver的源代码 LifecycleBoundObserver对象, 它继承于ObserverWrapper, 并最终实现了GenericLifecycleObserver接口；在发生状态转换事件时，会调用onStateChanged方法，在这个方法中，如果是DESTROYED状态，则先要移除观察者，然后在取到生命周期状态变更事件 class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver { @NonNull final LifecycleOwner mOwner; LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<T> observer) { super(observer); mOwner = owner; } @Override boolean shouldBeActive() { return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED); } @Override public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) { if (mOwner.getLifecycle().getCurrentState() == DESTROYED) { // 当接收到 DESTROYED 的事件会自动解除跟 owner 的绑定 removeObserver(mObserver); return; } activeStateChanged(shouldBeActive()); } @Override boolean isAttachedTo(LifecycleOwner owner) { return mOwner == owner; } @Override void detachObserver() { mOwner.getLifecycle().removeObserver(this); } } //抽象类 private abstract class ObserverWrapper { final Observer<T> mObserver; boolean mActive; int mLastVersion = START_VERSION; ObserverWrapper(Observer<T> observer) { mObserver = observer; } abstract boolean shouldBeActive(); boolean isAttachedTo(LifecycleOwner owner) { return false; } void detachObserver() { } void activeStateChanged(boolean newActive) { if (newActive == mActive) { return; } // immediately set active state, so we'd never dispatch anything to inactive // owner mActive = newActive; boolean wasInactive = LiveData.this.mActiveCount == 0; LiveData.this.mActiveCount += mActive ? 1 : -1; if (wasInactive && mActive) { onActive(); } if (LiveData.this.mActiveCount == 0 && !mActive) { onInactive(); } if (mActive) { dispatchingValue(this); } } } //接口 public interface GenericLifecycleObserver extends LifecycleObserver { /** * Called when a state transition event happens. * * @param source The source of the event * @param event The event */ void onStateChanged(LifecycleOwner source, Lifecycle.Event event); } 通过上面的代码可以发现什么？ GenericLifecycleObserver是一个接口，ObserverWrapper是一个抽象类，而LifecycleBoundObserver则是ObserverWrapper的子类，并且重写了其中几个方法；在LifecycleBoundObserver的shouldBeActive()方法，在 owner 处于至少是 STARTED 的状态下认为是 active 状态；而且它也实现了 GenericLifecycleObserver 接口，可以监听 lifecycle 回调。在 onStateChanged() 方法里处理了生命周期改变的事件，在这个方法中，当接收到 DESTROYED 的事件会自动解除跟 owner 的绑定；将下个流程交给了 activeStateChanged()，这里具体可以看抽象类ObserverWrapper中的activeStateChanged源码；看一下ObserverWrapper抽象类中activeStateChanged方法中，onActive和onInactive分别干什么呢？对于onActive方法，当活动观察者的数量从0变为1时调用；对于onInactive方法，当活动观察者的数量从1变为0时调用 if (wasInactive && mActive) { onActive(); } if (LiveData.this.mActiveCount == 0 && !mActive) { onInactive(); } 看一下ObserverWrapper抽象类中activeStateChanged方法中，dispatchingValue是干什么呢？这个方法在分析下面setValue源码时还会说到，具体看下面的介绍！ 7.3 看看mObservers.putIfAbsent操作关于observe源码中这一行代码ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper)作用是什么呢？ mObservers.putIfAbsent(observer, wrapper)存入容器中，mObservers.putIfAbsent这个添加数据的方式比较少见。看了下面源代码可知，支持键值对存储，用链表实现，不是线程安全的。既然这里有存数据，那肯定有地方会取数据用到，这个后面会说到…… //mObservers是一个集合 private SafeIterableMap<Observer<T>, ObserverWrapper> mObservers = new SafeIterableMap<>(); //在SafeIterableMap类中的putIfAbsent方法 public V putIfAbsent(@NonNull K key, @NonNull V v) { Entry<K, V> entry = get(key); if (entry != null) { return entry.mValue; } put(key, v); return null; } protected Entry<K, V> put(@NonNull K key, @NonNull V v) { Entry<K, V> newEntry = new Entry<>(key, v); mSize++; if (mEnd == null) { mStart = newEntry; mEnd = mStart; return newEntry; } mEnd.mNext = newEntry; newEntry.mPrevious = mEnd; mEnd = newEntry; return newEntry; } 7.4 注册观察者流程那么注册观察者之后的触发流程是怎样的？调用 observe() 注册后，由于绑定了 owner，所以在 active 的情况下，使用LiveData中setValue发送数据，则 Observer 会立马接受到该数据修改的通知。 observe ——> onStateChanged ——> activeStateChanged ——> dispatchingValue ——> considerNotify ——> onChanged 至于最终走到了onChanged方法，这个方法则是交给外部开发者处理接收消息事件的逻辑 08.setValue发送源码分析 8.1 setValue源码分析 LiveData 更新数据方式有两个，一个是 setValue() 另一个是 postValue()，这两个方法的区别是，postValue() 在内部会抛到主线程去执行更新数据，因此适合在子线程中使用；而 setValue() 则是直接更新数据。 @MainThread protected void setValue(T value) { assertMainThread("setValue"); // 这里的 mVersion，它本问题关键，每次更新数据都会自增，默认值是 -1。 mVersion++; mData = value; dispatchingValue(null); } 跟进下 dispatchingValue() 方法，注意，这里需要重点看considerNotify代码： private void dispatchingValue(@Nullable ObserverWrapper initiator) { // mDispatchingValue的判断主要是为了解决并发调用dispatchingValue的情况 // 当对应数据的观察者在执行的过程中, 如有新的数据变更, 则不会再次通知到观察者。所以观察者内的执行不应进行耗时工作 if (mDispatchingValue) { //给分发失败打个标记 mDispatchInvalidated = true; return; } // 标记分发开始 mDispatchingValue = true; do { mDispatchInvalidated = false; //这里需要注意：区分ObserverWrapper对象为空，和不为空的逻辑是不一样的 if (initiator != null) { // 等下重点看这里的代码 considerNotify(initiator); initiator = null; } else { //可以发现这里用到mObservers集合，使用迭代器遍历数据 for (Iterator<Map.Entry<Observer<T>, ObserverWrapper>> iterator = mObservers.iteratorWithAdditions(); iterator.hasNext(); ) { // 等下重点看这里的代码 considerNotify(iterator.next().getValue()); if (mDispatchInvalidated) { break; } } } } while (mDispatchInvalidated); // 标记分发开始 mDispatchingValue = false; } 接下来看一下上面源码中initiator对象为空判断逻辑区别 dispatchingValue 这里分两种情况：ObserverWrapper不为null和ObserverWrapper为null ObserverWrapper不为null 的情况。LifecycleBoundObserver.onStateChanged 方法里调用了 activeStateChanged ，而该方法调用dispatchingValue(this);传入了 this ，也就是 LifecycleBoundObserver ，这时候不为 null 。也就是说生命周期改变触发的流程就是这种情况，这种情况下，只会通知跟该 Owner 绑定的 Observer。 ObserverWrapper为null 的情况。经过分析发现在setValue方法中调用dispatchingValue(null)传递了空对象，这个时候的流程则会通知 active 的mObservers 8.2 看一下considerNotify()做什么然后看一下considerNotify() 方法做了什么，代码如下所示，这里有道词典翻译下注释如果ObserverWrapper的mLastVersion小于LiveData的mVersion，就会去回调mObserver的onChanged方法。每个新的订阅者，其version都是-1，LiveData一旦设置过其version是大于-1的（每次LiveData设置值都会使其version加1），这样就会导致LiveDataBus每注册一个新的订阅者，这个订阅者立刻会收到一个回调，即使这个设置的动作发生在订阅之前。 private void considerNotify(ObserverWrapper observer) { if (!observer.mActive) { return; } // 检查最新的状态b4调度。也许它改变了状态，但我们还没有得到事件。 // 我们还是先检查观察者。活动，以保持它作为活动的入口。 // 因此,即使观察者移动到一个活动状态，如果我们没有收到那个事件，我们最好不要通知一个更可预测的通知顺序。 if (!observer.shouldBeActive()) { observer.activeStateChanged(false); return; } //注意认真看下面的代码 if (observer.mLastVersion >= mVersion) { return; } observer.mLastVersion = mVersion; //noinspection unchecked observer.mObserver.onChanged((T) mData); } 思考一下dispatchingValue除了setValue会调用，其他还有地方调用么？ dispatchingValue除了在我们主动更新数据的时候会触发, 当LifeCircleOwner的状态发生变化的时候，会调用LiveData.ObserverWrapper的activeStateChanged函数。在我们的观察者状态变更(inactive->active)的时候, 也会通知到, 这就导致了LiveData必然支持粘性事件。如果这个时候ObserverWrapper的状态是active，就会调用LiveData的dispatchingValue。它主要是处理分发通知逻辑，并且在分发通知前会判断 owner 的状态，再加上 LiveData 本身内部的版本管理，确保了只会发送最新的数据给 active 状态下的 Observer。 LiveData 对同时多次修改数据做了处理，如果同时多次修改，只会修改为最新的数据。 private abstract class ObserverWrapper { final Observer<T> mObserver; boolean mActive; int mLastVersion = START_VERSION; //省略部分代码 void activeStateChanged(boolean newActive) { if (newActive == mActive) { return; } // 当observer的状态从active->inactive, 或者inactive->active的时候走以下流程 // owner mActive = newActive; boolean wasInactive = LiveData.this.mActiveCount == 0; LiveData.this.mActiveCount += mActive ? 1 : -1; if (wasInactive && mActive) { onActive(); } if (LiveData.this.mActiveCount == 0 && !mActive) { onInactive(); } //当observer是从inactive->active的时候，需要通知到观察者 if (mActive) { dispatchingValue(this); } } } 8.3 发送消息事件流程那么发送消息事件之后的触发流程是怎样的？ setValue ——> dispatchingValue(null) ——> considerNotify（注意，这里是个for迭代器循环，表示通知所有观察者） ——> onChanged 09.observeForever源码这个方法是干什么用的呢？看一下源代码将给定的观察者添加到观察者列表中，意味着给定的观察者将接收所有事件，并且永远不会被自动删除，不管在什么状态下都能接收到数据的更改通知 @MainThread public void observeForever(@NonNull Observer<T> observer) { // 创建一个AlwaysActiveObserver对象 AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer); ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper); if (existing != null && existing instanceof LiveData.LifecycleBoundObserver) { throw new IllegalArgumentException("Cannot add the same observer" + " with different lifecycles"); } if (existing != null) { return; } //刷新数据 wrapper.activeStateChanged(true); } 10.LiveData源码总结 LiveData的观察者可以联动生命周期, 也可以不联动。在联动生命周期时，会自动在 DESTROYED 的状态下移除 Observer ，取消订阅，所以不用担心内存泄露； LiveData的观察者只能与一个LifecycleOwner绑定, 否则会抛出异常。而一个 owner 可以绑定多个 Observer 实例； LiveData 跟 LifecycleOwner 绑定，能感知生命周期变化，并且只会在 LifecycleOwner 处于 Active 状态（STARTED/RESUMED）下通知数据改变；如果数据改变发生在非 active 状态，数据会变化，但是不发送通知，等 owner 回到 active 的状态下，再发送通知；使用observeForever()方法，会注意AlwaysActiveObserver对象，意味着给定的观察者将接收所有事件，并且永远不会被自动删除，不管在什么状态下都能接收到数据的更改通知 LiveData 利用版本管理、绑定 Lifecycle 确保了只会发送最新的数据给 active 状态下的 Observer 参考博客 https://developer.android.com/reference/android/arch/lifecycle/LiveData https://juejin.im/post/5dce5b16f265da0ba5279b11 https://mp.weixin.qq.com/s/glbd3mzU_cUPGAlJMlQ5Hg https://github.com/googlesamples/android-architecture-components https://mp.weixin.qq.com/s/yzR2LAor7dUmZDctG2g7MQ 开源LiveData事件总线：https://github.com/yangchong211/YCLiveDataBus

潇湘剑雨个人页面-阿里云开发者社区

个人介绍

擅长的技术

uni组件传值注意

uni学习笔记分享

uni之this作用域

事件总线方案实践

LiveData详细分析

OkHttp请求耗时统计

Android端Charles抓包

Android网络收集和ping封装库

04.Android崩溃Crash库之Loop拦截崩溃和ANR

03.Android崩溃Crash库之ExceptionHandler分析

02.Android崩溃Crash库之App崩溃分析

01.Android崩溃Crash封装库

倒计时方案深入分析

OkHttp请求耗时统计

Android端Charles抓包

Android网络收集和ping封装库

04.Android崩溃Crash库之Loop拦截崩溃和ANR

03.Android崩溃Crash库之ExceptionHandler分析

02.Android崩溃Crash库之App崩溃分析

01.Android崩溃Crash封装库

倒计时方案深入分析

uni组件传值注意

uni学习笔记分享

uni之this作用域

事件总线方案实践

LiveData详细分析

Adapter分组封装

x5开源库后续知识点

RecyclerView瀑布流优化方案探讨

Android打造万能自定义阴影控件

PagerAdapter深度解析和实践优化

Android状态管理优化

反射改变TabLayout属性