非粘性的LiveData

原创 已于 2023-06-29 12:06:03 修改 · 352 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#android #java #开发语言

于 2022-12-26 11:46:07 首次发布

前言

liveData 数据更新是通过版本控制的，在每次setValue时version加1，

实现非粘性，

1、官网有推荐有SignLiveDdata，

2、网上也有反射更改版本的

这里介绍一个使用另一个，自定义版本，扩展生命周期监听

原理

1、版本

        新建类，继承liveDta，成员变量mValueVersion, 在setValue里面+1

public class OptionalMutableLiveData<T> extends MutableLiveData<T> {
    private static final int START_VERSION = -1;

    private int mValueVersion = START_VERSION;

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

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

liveDta源码中，版本与生命周期控制是使用了包装，和map， 那么为什么我们不能也使用这个尼??  开撸

先定义包装类，看看是不是有点像了：：


public class OptionalMutableLiveData<T> extends MutableLiveData<T> {
    private static final int START_VERSION = -1;

    /**
     * 装observer
     */
    private ArrayMap<Observer<T>,LTObserverWrapper> mObserverContainer = new ArrayMap<>();

......
......
......

    private class LTObserverWrapper implements Observer<T> {
        Observer<T> observer;
        int mVersion;

        /**
         *
         * @param observer
         * @param isStick 是否粘性
         */
        public LTObserverWrapper(Observer<T> observer, boolean isStick) {
            this.observer = observer;
            if(!isStick){
                mVersion = mValueVersion;
            }
        }

        @Override
        public void onChanged(T t) {
            if (mVersion >= mValueVersion) {
                return;
            }
            mVersion = mValueVersion;
            observer.onChanged(t);
        }
    }

}

继续看看怎么包装：

package com.ltcode.livedatabus;

public class OptionalMutableLiveData<T> extends MutableLiveData<T> {
    private static final int START_VERSION = -1;

    /**
     * 装observer
     */
    private ArrayMap<Observer<T>,LTObserverWrapper> mObserverContainer = new ArrayMap<>();

    private int mValueVersion = START_VERSION;

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

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


    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer, boolean isStick) {
        if (isStick) {

        }
        super.observe(owner, observer);
    }

    @Override
    public void observeForever(@NonNull Observer<? super T> observer) {
        super.observeForever(observer);
    }

    /**
     * 自定义包装
     */
    private class LTObserverWrapper implements Observer<T> {
        Observer<? super T> mObserver;
        int mVersion;

        /**
         *
         * @param observer
         * @param isStick 是否粘性
         */
        public LTObserverWrapper(Observer<? super T> observer, boolean isStick) {
            this.mObserver = observer;
            if(!isStick){
                mVersion = mValueVersion;
            }
        }

        @Override
        public void onChanged(T t) {
            if (mVersion >= mValueVersion) {
                return;
            }
            mVersion = mValueVersion;
            mObserver.onChanged(t);
        }
        boolean isAttachedTo(LifecycleOwner owner) {
            return false;
        }

        void detachObserver() {
        }
    }

    class LTLifecycleObserver extends LTObserverWrapper implements LifecycleEventObserver {
        @NonNull
        final LifecycleOwner mOwner;

        LTLifecycleObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer, boolean isStick) {
            super(observer, isStick);
            mOwner = owner;
        }

        @Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
        }

        @Override
        boolean isAttachedTo(LifecycleOwner owner) {
            return mOwner == owner;
        }

        @Override
        void detachObserver() {
            mOwner.getLifecycle().removeObserver(this);
        }
    }

    /**
     * ObserverForever 支持生命周期，主要用与onDestory移除
     */
    class LTLifecycleObserverForever extends LTLifecycleObserver {

        LTLifecycleObserverForever(@NonNull LifecycleOwner owner, Observer<? super T> observer, boolean isStick) {
            super(owner, observer, isStick);
        }
    }

    class LTObserverForever extends LTObserverWrapper {

        public LTObserverForever(Observer<? super T> observer, boolean isStick) {
            super(observer, isStick);
        }
    }
}

包装起上面准备好了， 接下来就是看我们怎么注册observer了, 方法重载，入参添加参数哈

public void observe( boolean isStick, @NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        if (isStick) {
            super.observe(owner, observer);
        } else {
            if (owner.getLifecycle().getCurrentState() == DESTROYED) {
                // ignore
                return;
            }
            LTLifecycleObserver wrapper = new LTLifecycleObserver(owner, observer, false);
            mObserverContainer.put(observer, wrapper);
            owner.getLifecycle().addObserver(wrapper);
            super.observe(owner, wrapper);
        }
    }

    public void observeForever(boolean isStick, LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        if (owner == null) {
            if (isStick) {
                super.observeForever(observer);
            } else {
                LTObserverForever wrapper = new LTObserverForever(observer, false);
                LTObserverWrapper existing = mObserverContainer.put(observer, wrapper);
                super.observeForever(wrapper);
            }
        } else {
            if (owner.getLifecycle().getCurrentState() == DESTROYED) {
                return;
            }
            LTLifecycleObserverForever wrapper = new LTLifecycleObserverForever(owner, observer, isStick);
            mObserverContainer.put(observer, wrapper);
            owner.getLifecycle().addObserver(wrapper);
            super.observeForever(wrapper);
        }
    }

写到这里， 其实监听基本已经OK 了，也支持非粘性了， 但是发现还没有做remove，我们继续

 @Override
    public void removeObserver(@NonNull Observer<? super T> observer) {
        IapObserverWrapper observerWrapper = mObserversContainer.remove(observer);
        if (observerWrapper != null) {
            observerWrapper.detachObserver();
            super.removeObserver(observerWrapper);
        } else {
            super.removeObserver(observer);
        }
    }

    @Override
    public void removeObservers(@NonNull LifecycleOwner owner) {
        Iterator<Map.Entry<Observer<? super T>, IapObserverWrapper>> iterator = mObserversContainer.entrySet()
                .iterator();
        while (iterator.hasNext()) {
            Map.Entry<Observer<? super T>, IapObserverWrapper> wrapper = iterator.next();
            if (wrapper.getValue().isAttachedTo(owner)) {
                wrapper.getValue().detachObserver();
                iterator.remove();
            }
        }
        super.removeObservers(owner);
    }

完成，最后上一份完整代码

package com.ltcode.livedatabus;

public class OptionalMutableLiveData<T> extends MutableLiveData<T> {
    private static final int START_VERSION = -1;

    /**
     * 装observer
     */
    private ArrayMap<Observer<? super T>, LTObserverWrapper> mObserverContainer = new ArrayMap<>();

    private int mValueVersion = START_VERSION;

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

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

    @Override
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        super.observe(owner, observer);
    }

    public void observeNoStick(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        observe(false, owner, observer);
    }

    public void observe(boolean isStick, @NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        if (isStick) {
            super.observe(owner, observer);
        } else {
            if (owner.getLifecycle().getCurrentState() == DESTROYED) {
                // ignore
                return;
            }
            LTLifecycleObserver wrapper = new LTLifecycleObserver(owner, observer, false);
            mObserverContainer.put(observer, wrapper);
            owner.getLifecycle().addObserver(wrapper);
            super.observe(owner, wrapper);
        }
    }

    @Override
    public void observeForever(@NonNull Observer<? super T> observer) {
        super.observeForever(observer);
    }

    public void observeForever(boolean isStick, @NonNull Observer<? super T> observer) {
        observeForever(isStick, null, observer);
    }

    public void observeForeverNoStick(@NonNull Observer<? super T> observer) {
        observeForever(false, null, observer);
    }

    public void observeForeverNoStick(LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        observeForever(false, owner, observer);
    }

    public void observeForever(boolean isStick, LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        if (owner == null) {
            if (isStick) {
                super.observeForever(observer);
            } else {
                LTObserverForever wrapper = new LTObserverForever(observer, false);
                LTObserverWrapper existing = mObserverContainer.put(observer, wrapper);
                super.observeForever(wrapper);
            }
        } else {
            if (owner.getLifecycle().getCurrentState() == DESTROYED) {
                return;
            }
            LTLifecycleObserverForever wrapper = new LTLifecycleObserverForever(owner, observer, isStick);
            mObserverContainer.put(observer, wrapper);
            owner.getLifecycle().addObserver(wrapper);
            super.observeForever(wrapper);
        }
    }


    @Override
    public void removeObserver(@NonNull Observer<? super T> observer) {
        LTObserverWrapper wrapper = mObserverContainer.remove(observer);
        if (wrapper != null) {
            wrapper.detachObserver();
            super.removeObserver(wrapper);
            return;
        }

        if (observer instanceof OptionalMutableLiveData.LTObserverWrapper) {
            wrapper = (OptionalMutableLiveData.LTObserverWrapper) observer;
            wrapper.detachObserver();
        }

        super.removeObserver(observer);
    }

    @Override
    public void removeObservers(@NonNull LifecycleOwner owner) {
        for (Map.Entry<Observer<? super T>, LTObserverWrapper> entry : mObserverContainer.entrySet()) {
            if (entry.getValue().isAttachedTo(owner)) {
                removeObserver(entry.getKey());
            }
        }
        super.removeObservers(owner);
    }

    /**
     * 自定义包装
     */
    private class LTObserverWrapper implements Observer<T> {
        Observer<? super T> mObserver;
        int mVersion = START_VERSION;

        /**
         * @param observer
         * @param isStick  是否粘性
         */
        public LTObserverWrapper(Observer<? super T> observer, boolean isStick) {
            this.mObserver = observer;
            if (!isStick) {
                mVersion = mValueVersion;
            }
        }

        @Override
        public void onChanged(T t) {
            if (mVersion >= mValueVersion) {
                return;
            }
            mVersion = mValueVersion;
            mObserver.onChanged(t);
        }

        boolean isAttachedTo(LifecycleOwner owner) {
            return false;
        }

        void detachObserver() {
        }
    }

    class LTLifecycleObserver extends LTObserverWrapper implements LifecycleEventObserver {
        @NonNull
        final LifecycleOwner mOwner;

        LTLifecycleObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer, boolean isStick) {
            super(observer, isStick);
            mOwner = owner;
        }

        @Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
        }

        @Override
        boolean isAttachedTo(LifecycleOwner owner) {
            return mOwner == owner;
        }

        @Override
        void detachObserver() {
            mOwner.getLifecycle().removeObserver(this);
        }
    }

    /**
     * ObserverForever 支持生命周期，主要用与onDestory移除
     */
    class LTLifecycleObserverForever extends LTLifecycleObserver {

        LTLifecycleObserverForever(@NonNull LifecycleOwner owner, Observer<? super T> observer, boolean isStick) {
            super(owner, observer, isStick);
        }
    }

    class LTObserverForever extends LTObserverWrapper {

        public LTObserverForever(Observer<? super T> observer, boolean isStick) {
            super(observer, isStick);
        }
    }
}

LiveData 非粘性消息的探索和尝试
GeeJoe 的博客
03-27 652
我们可以使用 LiveData 来发送事件吗？如何使用 LiveData 实现非粘性消息的发送呢？这里分享一些尝试和探索...
Android LiveDatabus非黏性事件
luotianyi_yi的博客
11-28 1358
Android LiveDataBus的使用这里不再赘述，网上有很多关于这个的文章。 网上大部分篇幅采用的hook方式经亲自验证不生效，所以，经过分析，自己使用了另一种方式 1.网上取消黏性事件的方法及实验结果 1.在Activity中 发射（set）数据，然后 在onResume中延迟3秒后在订阅 NonStickActivityDemo的部分代码为： ...
NonStickyLiveData:非粘性LiveData解决问题LiveData出现的问题
03-12
NonStickyLiveData 非粘性LiveData解决粘性LiveData出现的问题如果在使用中有问题，请给我留言。支持可以点一下小星星。
王学岗码牛jetPack系列之LiveData非粘性事件
qczg_wxg的博客
04-22 233
liveData
LiveData去除粘性
jzlhll123的专栏
10-10 219
而我们的业务代码注册监听的函数observe(owner, observer) 或者observeForever(observer)第一，反射很少，因为mObservers在LiveData是final的全局变量，不会变化。众所周知，LiveData是粘性的。想要破除粘性，我翻阅了一些代码，写的五花八门。直到removeObserver的时候，通过mObservers.remove(observer)来移除。第二，与源代码LiveData的思想高度统一，都是通过wrap用户的observer存起来的思路。
Jetpack面试官最爱问的LiveData粘性事件机制详解：从原理到实战方案
全栈
05-19 924
LiveData粘性事件机制通过版本号（mVersion）与观察者状态（mLastVersion）匹配实现数据分发，导致先发送后注册仍能触发回调。本文从底层原理到实战方案，详解粘性事件产生逻辑、典型问题（如数据重复上报）及四种非粘性实现（事件包装器、SingleLiveEvent、反射重置、Mediator优化），助你掌握面试高频考点与企业级避坑技巧。
【Jetpack系列】理解LiveData的粘性事件，并去除
成长的烧年
05-22 2153
理解LiveData粘性事件的原理，并通过原理解决问题。
livedata原理分析 (解除livedata粘性事件)
qq_44076155的博客
11-22 2026
先思考几个问题 livedata是怎么做的监听生命周期的 ? postValue和setValue有什么区别 ? 事件是如何发送和接收的？ livedata粘性事件是什么 ? livedata的粘性事件是怎样引起的 ? 首先需要知道注册监听和发送事件的几个方法 observe,postvalue,setvalue,我们主要是对这几个方法进行分析 发送事件 livedata发送事件的方法有两种 postValue和setValue 我们先来看setValue 直接调用到了MutableLiveData的
LiveData相关基本使用、去除粘性数据的方法和源码解析
xuyin1204的博客
08-25 1369
该方式使用的是黏性数据。
【Android】妙用LiveData实现EventBus
weixin_42473228的博客
03-27 480
【代码】【Android】妙用LiveData实现EventBus。
LiveData（2）聊聊数据粘性的问题
challenge51all的专栏
08-23 914
如果一个观察者在计数器的值已经增加之后才注册，它仍然会收到最新的计数器值通知，这就是数据粘性的体现。在使用 LiveData 时，开发者应该充分了解数据粘性的影响，并根据实际需求采取适当的措施来处理数据粘性，以确保应用的正确性和稳定性。在 LiveData 中，数据粘性是指当 LiveData 中的数据发生变化时，即使观察者在数据变化之后才注册，也能立即收到最新的数据变化通知。例如，可以添加一个标志位来表示数据是否已经被处理过，新注册的观察者只在标志位为特定值时才处理数据。
解决LiveData 的粘性问题 带来的 不可思意的bug
u014133383的博客
08-14 543
处理 DialogFragment + Viewmodel + Livedata 的一些bug
LiveData详解（实战+源码+粘性事件解决方案）
XJ200012的博客
05-05 2095
Jetpack之LiveData详解，加对原理的分析以及设计思想的分析
LiveData那些事情，看我一篇就够了
qq_34178710的博客
06-19 545
总结：方案2要比方案1功能更全。方案二：粘性和非粘性。
Android~LiveData原理
2401_83641491的博客
04-04 854
通信方案 | 优点 | 缺点 || Handler | 系统原生，能实现线程间通信 | 高耦合不利于维护容易导致内存泄漏和NullPointer || Broadercast | 简单 | 性能差传播数据有限打乱代码的执行逻辑 || interface | 接口速度快，容易理解 | 实现起来复杂，不好维护 || rxBus | 效率高，无内存泄漏 | 基于RxJava，学习成本高且依赖包太大，rxJava2.2M || EventBus | 使用简单 | 混淆问题。
SingleLiveData：解决LiveData『数据倒灌』的问题（方案二）
何武昭的专栏
03-06 2904
解决LiveData数据倒灌的问题
Jetpack系列-LiveData二次封装，去除粘性数据
m0_59162559的博客
05-11 578
LiveData默认带有粘性数据特征，但是很多情况下并不需要粘性数据，这时候可以通过反射去修改mLastVersion和mVersion的值，使他们相等，就可以去掉粘性数据。 封装一个单例NoStickLiveData。 object NoStickLiveData { private val map: MutableMap<String, NoStickMutableLiveData<Any>> by lazy { HashMap() } @Synchroniz
UnStickLiveData-非粘性的LiveData，解决粘性
jinchen_boke的博客
04-01 215
【代码】UnStickLiveData-非粘性的LiveData，解决粘性。
如何处理LiveData的粘性事件？
最新发布
10-18
处理LiveData粘性事件通常可以采用以下几种方法： #### 重写LiveData的方法（Hook方式） 为了使 `mLastVersion >= mVersion`，可以重写LiveData中的方法，这就需要用到Hook。通过反射机制修改LiveData内部的状态，从而避免粘性事件的发生。以下是一个简单的示例代码： ```kotlin import androidx.lifecycle.LiveData import androidx.lifecycle.Observer import java.lang.reflect.Field import java.lang.reflect.Method class NonStickyLiveData<T> : LiveData<T>() { override fun observe(owner: androidx.lifecycle.LifecycleOwner, observer: Observer<in T>) { super.observe(owner, observer) try { // 获取LiveData的mObservers字段 val observersField: Field = LiveData::class.java.getDeclaredField("mObservers") observersField.isAccessible = true val observers = observersField.get(this) // 获取SafeIterableMap的get方法 val methodGet: Method = observers.javaClass.getDeclaredMethod("get", Any::class.java) methodGet.isAccessible = true val entry = methodGet.invoke(observers, observer) // 获取ObserverWrapper的mLastVersion字段 if (entry != null) { val observerWrapperClass = entry.javaClass.superclass val lastVersionField: Field = observerWrapperClass!!.getDeclaredField("mLastVersion") lastVersionField.isAccessible = true // 获取LiveData的mVersion字段 val versionField: Field = LiveData::class.java.getDeclaredField("mVersion") versionField.isAccessible = true val version = versionField.get(this) // 设置mLastVersion等于mVersion lastVersionField.set(entry, version) } } catch (e: Exception) { e.printStackTrace() } } } ``` 使用时，将原来的 `LiveData` 替换为 `NonStickyLiveData`： ```kotlin val nonStickyLiveData = NonStickyLiveData<String>() nonStickyLiveData.observe(this, Observer { value -> // 处理数据 }) ``` #### 使用SingleLiveEvent `SingleLiveEvent` 是一种特殊的 `LiveData`，它只能发送一次事件，发送后会自动重置，从而避免粘性事件。以下是一个简单的 `SingleLiveEvent` 实现： ```kotlin import androidx.lifecycle.LiveData import androidx.lifecycle.MutableLiveData import androidx.lifecycle.Observer import java.util.concurrent.atomic.AtomicBoolean class SingleLiveEvent<T> : MutableLiveData<T>() { private val mPending = AtomicBoolean(false) override fun observe(owner: androidx.lifecycle.LifecycleOwner, observer: Observer<in T>) { super.observe(owner, Observer { t -> if (mPending.compareAndSet(true, false)) { observer.onChanged(t) } }) } override fun setValue(t: T?) { mPending.set(true) super.setValue(t) } override fun postValue(value: T?) { mPending.set(true) super.postValue(value) } } ``` 使用时： ```kotlin val singleLiveEvent = SingleLiveEvent<String>() singleLiveEvent.observe(this, Observer { value -> // 处理数据 }) singleLiveEvent.value = "新数据" ``` #### 使用第三方库 除了手动实现，还可以使用一些第三方库来处理粘性事件，例如 `LiveEvent` 库，它提供了更方便的方式来处理 `LiveData` 的粘性问题。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值