非粘性的LiveData

已于 2023-06-29 12:06:03 修改
阅读量213 收藏
点赞数 1
分类专栏： liveData 文章标签： android java 开发语言
于 2022-12-26 11:46:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/e10010e/article/details/128441123
版权

前言

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);
        }
    }
}

HhongChun
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
LiveData 非粘性消息的探索和尝试
GeeJoe 的博客
03-27 482
我们可以使用 LiveData 来发送事件吗？如何使用 LiveData 实现非粘性消息的发送呢？这里分享一些尝试和探索...
Android LiveDatabus非黏性事件
luotianyi_yi的博客
11-28 1126
Android LiveDataBus的使用这里不再赘述，网上有很多关于这个的文章。 网上大部分篇幅采用的hook方式经亲自验证不生效，所以，经过分析，自己使用了另一种方式 1.网上取消黏性事件的方法及实验结果 1.在Activity中 发射（set）数据，然后 在onResume中延迟3秒后在订阅 NonStickActivityDemo的部分代码为： ...
NonStickyLiveData:非粘性LiveData解决问题LiveData出现的问题
03-12
NonStickyLiveData 非粘性LiveData解决粘性LiveData出现的问题如果在使用中有问题，请给我留言。支持可以点一下小星星。
王学岗码牛jetPack系列之LiveData非粘性事件
qczg_wxg的博客
04-22 115
liveData
LiveData相关基本使用及去除黏性数据的方法
xuyin1204的博客
08-25 1027
该方式使用的是黏性数据。
LiveEventBus:EventBus for Android，消息总线，基于LiveData，具有生命周期感知能力，支持Sticky，支持AndroidX，支持跨进程，支持跨APP
05-11
LiveEventBus是一款Android消息总线，基于LiveData，具有生命周期感知能力，支持Sticky，支持AndroidX，支持跨进程，支持跨APP 为什么要用LiveEventBus 生命周期感知 消息随时订阅，自动取消订阅 告别消息总线造成...
LiveDataBus:基于LiveData实现事件消息总线，具备生命周期感知，支持粘性，简洁稳定，没有多余的事件包装，不依赖于反射，轻量级 LiveData based event message bus, with life cycle awareness, support viscosity, simple and stable, no redundant event packaging, does not depend on reflection, lightweight
05-29
支持粘性，消息发送后订阅也能收到发出的消息，但是只能收到订阅前发送的最后一条消息 Event bus based on LiveData, with life cycle awareness, awareness to ensure that LiveData only updates the observer of ...
YCLiveDataBus:该库代码量少，利用LiveData实现事件总线，替代EventBus。充分利用了生命周期感知功能，可以在activitie, fragment, 或者 service生命周期是活跃状态时更新这些组件。支持发送普通事件，也可以发送粘性事件；还可以发送延迟消息，以及轮训延迟消息等等
05-06
目录介绍 01.该库是做什么用的 02.项目组件通信流程 03.老版组件通信实践 04.封装库有何特点 05.如何使用该库Api 06.关于封装思路分析 07.关于其他知识点 08.关于添加混淆代码 09.关于几个重要问题 ...
粘性 Tabbar 效果，可以看代码学习如何做类似效果.zip
09-24
5. **响应式编程**：为了确保 Tabbar 与页面内容之间的无缝交互，开发者可能会使用响应式编程框架，如 RxSwift（iOS）或 LiveData（Android），来处理用户交互和视图状态的同步。 6. **事件处理**：Tabbar 的点击...
【Android】妙用LiveData实现EventBus
weixin_42473228的博客
03-27 314
【代码】【Android】妙用LiveData实现EventBus。
SingleLiveData：解决LiveData『数据倒灌』的问题（方案二）
何武昭的专栏
03-06 2589
解决LiveData数据倒灌的问题
LiveData去除粘性
最新发布
jzlhll123的专栏
10-10 139
而我们的业务代码注册监听的函数observe(owner, observer) 或者observeForever(observer)第一，反射很少，因为mObservers在LiveData是final的全局变量，不会变化。众所周知，LiveData是粘性的。想要破除粘性，我翻阅了一些代码，写的五花八门。直到removeObserver的时候，通过mObservers.remove(observer)来移除。第二，与源代码LiveData的思想高度统一，都是通过wrap用户的observer存起来的思路。
数据结构 - 伸展树的Java实现
尘世中迷途小码农的专栏
09-05 1231
数据结构 - 伸展树的Java实现 阅读本节前请先阅读上一篇文章：https://blog.csdn.net/funnyrand/article/details/81745518，该文章讲述了AVL树的原理和Java实现。需要理解AVL树的4种旋转方式及原理。 一、简介 伸展树(Splay Tree)是特殊的非平衡二叉查询树，它的特殊性是指，它除了本身是棵二叉查询树之外，它还具备一个特点: ...
Jetpack - LiveData 唯一可信源
weixin_41733225的博客
07-01 173
Activity和3个Fragment同时绑定一个数据源LiveData，点击更新按钮，同时更新这四处。 1、Fragment BaseFragment abstract public class BaseFragment extends Fragment { private MyViewModel myViewModel; protected TextView tvShowData; protected String initParam; @Override
java运行时构建实体_实现服务端功能之——Java实体对象
weixin_36307086的博客
02-26 406
in 开发on 2007-09-02|tags: oracleebsoaf|comments实体对象包含了业务逻辑和对表的DML操作。对象模型和关键类oracle.apps.fnd.framework.server.OAEntityCache：这个缓冲用于存储特殊实体的查询过的行。映射到同样的实体的多个视图对象共享相同的实体缓存。EOImpl继承oracle.apps.fnd.fr...
踩坑之路：LiveData之粘性事件
chuyouyinghe的专栏
05-16 1986
前言 何为粘性事件？ 即发射的事件如果早于注册，那么注册之后依然可以接收到的事件称为粘性事件 背景 最近接手了一个公司的项目，采用了目前比较新的技术:LiveData+ViewModel的事件通知框架。该框架拥有大量的优点包括但不仅限于以下：1.实时感知生命周期。2.无需手动回收，解绑,即不会出现内存泄漏的情况。3.数据变化可进行实时通知 等等...... 本人对于这个框架也只是一知半解，奈何项目比较紧急，接手以后马上就要开始干活，所以只能是边干活边了解内部实现原理。 结果项目中就碰到了一个让我头疼了
基于LiveData实现事件总线
yufumatou的博客
04-26 549
前言：提及事件总线常常使用org.greenrobot:eventbus框架，而本文通过LiveData即可轻松实现Eventbus。实现：这里只定义了1个LiveData，通过TAG作事件的区分。 1、定义事件基类 data class BaseEvent<T>( val tag: Int, val msg: T ) 2、定义事件操作类 object EventBus{ val onEventLiveData = MutableLiveData<Base
livedata使用详解_不要在存储库中使用LiveData
weixin_26739079的博客
08-23 872
livedata使用详解 重点 (Top highlight)We recently joined a new project with heavy LiveData usage, everywhere. The search for main thread blockages led us down a rabbit hole of removing a significant portion ...
LiveData 监听
05-23
LiveData 是用于在 Android 应用程序中观察数据的一个组件。LiveData 是一个可观察的数据持有者类，它具有生命周期感知能力，因此它会自动管理它与 Activity 和 Fragment 生命周期的关系，从而可以避免内存泄漏和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值