LiveData 使用与源码解析

最新推荐文章于 2024-09-11 18:46:03 发布
最新推荐文章于 2024-09-11 18:46:03 发布
阅读量266 收藏
点赞数 1
分类专栏： Android 进阶教程 Android 入门教程 文章标签： android 安卓
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ryffic/article/details/106189820
版权

简介

开门见山，LiveData作为 Jetpack的组件之一，在项目中用到的频率已经越来越高了。
在谷歌官网上，关于 LiveData的介绍就简单贴一下：

LiveData is an observable data holder class. 
Unlike a regular observable, LiveData is lifecycle-aware, meaning it respects the lifecycle of other app components, such as activities, fragments, or services. 
This awareness ensures LiveData only updates app component observers that are in an active lifecycle state.

意思就是,有别于以前的 observable data，LiveData可以更好的感应 Acivity/Fragment生命周期的变化。使用 LiveData以下好处：

  1. 确保你的 UI 和你的数据状态一致
  2. 不会有内存泄露。因为 LiveData其实是绑定到 Lifecycle对象的。当LifeCycle生命周期走完时(通常情况下，是 onDestory)，LiveData也会自动清理。
  3. 不会因 Activity的停止布奔溃
  4. 不需要手动去处理生命周期
  5. 始终保持最新的数据
  6. 数据/资源共享
  7. …

简单使用

通常情况下，使用 liveData需要以下几个步骤

  1. 创建一个 ViewModel，去持有 LiveData
  2. 创建一个 Observer，监听 LiveData的数据变化(observe(LifecycleOwner , observer))，这里需要一个LifecycleOwner，通常情况下是一个 Activity/Fragment/Service。
  3. 更新数据

创建一个 LiveData 对象

public class NameViewModel extends ViewModel {

// Create a LiveData with a String
private MutableLiveData<String> currentName;

    public MutableLiveData<String> getCurrentName() {
        if (currentName == null) {
            currentName = new MutableLiveData<String>();
        }
        return currentName;
    }

// 
}

观察 LiveData对象

在官方文章里，是说在大多数情况下，在 OnCreate中创建 LiveData的观察者。个人认为也可以在 onResume生命周期中创建，前提是你得做一个初始化的判断（init = false）。

    public class NameActivity extends AppCompatActivity {

        private NameViewModel model;

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);

            // Other code to setup the activity...

            // Get the ViewModel.
            model = ViewModelProviders.of(this).get(NameViewModel.class);

            // Create the observer which updates the UI.
            final Observer<String> nameObserver = new Observer<String>() {
                @Override
                public void onChanged(@Nullable final String newName) {
                    // Update the UI, in this case, a TextView.
                    nameTextView.setText(newName);
                }
            };

            // Observe the LiveData, passing in this activity as the LifecycleOwner and the observer.
            model.getCurrentName().observe(this, nameObserver);
        }
    }

需要注意的是，通常情况下，LiveData仅在数据发生更改时才会发送更新。

更新数据

LiveData的两个更新数据的方法都是 protect的，所以我们通常使用的是他的子类
MutableLiveData，可以调用 setValue或者 postValue。

    button.setOnClickListener(new OnClickListener() {
        @Override
        public void onClick(View v) {
            String anotherName = "John Doe";
            model.getCurrentName().setValue(anotherName);
        }
    });

注意：如果是在非UI线程中，请调用 postValue方法。

源码解析

setValue

其实LiveData的源码阅读起来还是比较简单的。我们可以从 setValue开始，走一遍调用流程，大概也就知道整个 LiveData的工作原理了。

    @MainThread
    protected void setValue(T value) {
        assertMainThread("setValue");
        mVersion++;
        mData = value;
        dispatchingValue(null);
    }

可以看到，setValue方法主要是做了两个工作，一个是在 assertMainThread里判断该方法调用是否在主线程。
另一个其实就是将设置的 value进行分发。

    void dispatchingValue(@Nullable ObserverWrapper initiator) {
    //如果正在发送，返回
        if (mDispatchingValue) {
            mDispatchInvalidated = true;
            return;
        }
        mDispatchingValue = true;
        do {
            mDispatchInvalidated = false;
            if (initiator != null) {
                considerNotify(initiator);
                initiator = null;
            } else {
                for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
                        mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                    considerNotify(iterator.next().getValue());
                    if (mDispatchInvalidated) {
                        break;
                    }
                }
            }
        } while (mDispatchInvalidated);
        mDispatchingValue = false;
    }

这个 dispatchingValue方法其实也比较简单，就是做一些判断，如果正在处理 value的发送，就返回。（这个主要是为了防止暴力点击）。最终会开始一个do{}while()循环，这个循环里，最终调用的是considerNotify方法。（mObservers对象是SafeIterableMap的一个实例，用来存放观察者对象，后面会说到。）

    private void considerNotify(ObserverWrapper observer) {
        if (!observer.mActive) {
            return;
        }
        // Check latest state b4 dispatch. Maybe it changed state but we didn't get the event yet.
        //
        // we still first check observer.active to keep it as the entrance for events. So even if
        // the observer moved to an active state, if we've not received that event, we better not
        // notify for a more predictable notification order.
        if (!observer.shouldBeActive()) {
            observer.activeStateChanged(false);
            return;
        }
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        observer.mLastVersion = mVersion;
        //noinspection unchecked
        observer.mObserver.onChanged((T) mData);
    }

这个方法是重点，就是我们最终在监听的时候，收到的回调。我们一行行往下看。

mActive

这个判断的意思，就是 mActive 为 false，就返回了。那这个值怎么来的？
这个值是ObserverWrapper的一个成员变量，他是一个抽象类，在 LiveDate中，使用的是他的一个实现类LifecycleBoundObserver。

  class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
        @NonNull
        final LifecycleOwner mOwner;

        LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super 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) {
                removeObserver(mObserver);
                return;
            }
            activeStateChanged(shouldBeActive());
        }

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

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

我们看一下onStateChanged方法。该方法其实是由LifecycleRegistry.addObserver方法发送出来的事件，其实，他的最上游，是个 Activity（ReportFragment，所以，才会对生命周期进行感应，具体的代码在ndroidx.lifecycle.ReportFragment）

    void dispatchEvent(LifecycleOwner owner, Event event) {
            State newState = getStateAfter(event);
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }

也就是上面的 onStateChanged(owner,event)。我们回到onStateChange()方法。

            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
             activeStateChanged(shouldBeActive());

可以看到，如果 owner的生命周期为DESTROYED时，会自动解绑，移除观察者对象，否则，就会调用父类ObserverWrapper中的activeStateChanged的代码。

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

绕了一圈，终于看到了mActive了。可以看到，这个就是为 mActive赋值的方法了，而真正的 mActive的计算，其实是mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED) 。
这个其实就是枚举的比较，下面会说到。

shouldBeActive()

其实就是：

    @Override
        boolean shouldBeActive() {
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }

在 Lifecycle类下面有一个枚举类，定义了 Android的生命周期的几种状态，isAtLeast就是枚举的比较，比较简单。

observer.mLastVersion >= mVersion

这个其实没啥好说的，在 setValue时，会将mVersion + 1,那如果当前的版本号mVersion 比上一次操作的版本号都小，就不发送事件。

observe()

在 observe方法中，我们需要传入一个LifecycleOwner，一个是Observer，
看单词也明白，一个是生命周期的拥有者，一个就是观察者了。

    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        assertMainThread("observe");
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        if (existing != null && !existing.isAttachedTo(owner)) {
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        }
        if (existing != null) {
            return;
        }
        owner.getLifecycle().addObserver(wrapper);
    }

老规矩，如果不在主线程，报异常。如果生命周期都已经走到 DESTORYED ，直接返回。
然后就是刚才分析的LifecycleBoundObserver类了，通过这个类将 owner与observer绑定，通过 mObservers.putIfAbsent(observer, wrapper)，将 observer的对像存到 map中，在前面dispatchingValue方法里取。

总结

LiveData的重要类有几个：

  1. LiveData，数据本身（这是废话）
  2. LifecycleBoundObserver 生命周期的监听，observer自动移除
  3. LifecycleOwner ，生命周期拥有者
Yul丶Wu
关注
专栏目录
Android Jetpack架构组件之 LiveData（使用、源码篇）
浅谈Android
10-10 7311
1、前言 最近简单看了下google推出的框架Jetpack，感觉此框架的内容可以对平时的开发有很大的帮助，也可以解决很多开发中的问题，对代码的逻辑和UI界面实现深层解耦，打造数据驱动型UI界面。 Android Architecture组件是Android Jetpack的一部分，它们是一组库，旨在帮助开发者设计健壮、可测试和可维护的应用程序，包含一下组件： 带你领略Android Je...
Jetpack ——LiveData初识到源码解析（一）
lmq121210的博客
05-15 429
上篇博客分享了下Lifecycle，使用的技术也就是：观察者模式+注解+反射。本篇博客继续学习Jetpack的LiveData，其实这个东西是一种可观察的数据存储类。 LiveData自己可以作为观察者，观察到数据变化，并回调给开发者。 它是可以监听到Activity（Fragment）生命周期的变化，并且在Activity处于活跃状态下，才发送时间通知开发者处理业务逻辑。 LiveData官网 这个LiveData不是数据，是数据存储类。 LiveData的使用 示例：一个按钮，一个TextView
Android LiveData使用
fomin
01-17 3557
LiveData是一个可观察的数据持有者类。 与常规observable不同，LiveData是生命周期感知的，当生命周期处于STARTED或RESUMED状态，则LiveData会将其视为活动状态，这意味着它尊重其他应用程序组件的生命周期，例如Activity，Fragment或Service。 LiveData具有以下优点： UI和数据保持一致：遵循观察者模式，生命周期状态更改时，LiveD...
安卓开发中LiveData的使用
m0_66843126的博客
09-11 1114
LiveData 是 Android Jetpack 架构组件库中的一个关键组件，它被设计用来在应用的不同组件之间安全地共享数据。LiveData 是一种可观察的数据持有者类，它遵循观察者模式，允许组件订阅数据的变化，并在数据发生变化时得到通知。
Android Jetpack 之 LiveData
明年今日zhich
11-25 332
概述 LiveData 是一个持有数据的类，它持有的数据是可以被观察者订阅的，当数据被修改时就会通知观察者。观察者可以是 Activity、Fragment、Service 等。 LiveData 能够感知观察者的生命周期，只有当观察者处于激活状态（STARTED、RESUMED）才会接收到数据更新的通知，在未激活时会自动解注册观察者，以减少内存泄漏。 使用 LiveData 保存数据时，由于数...
android LiveData 详细说明
xgw的专栏
01-30 854
概述 LiveData 是一种可观察的数据存储器类。与常规的可观察类不同，LiveData 具有生命周期感知能力，意指它遵循其他应用组件（如 Activity、Fragment 或 Service）的生命周期。这种感知能力可确保 LiveData 仅更新处于活跃生命周期状态的应用组件观察者。 如果观察者（由 Observer 类表示）的生命周期处于 STARTED 或 RESUMED 状态，则 LiveData 会认为该观察者处于活跃状态。LiveData 只会将更新通知给活跃的观察者。为观察 LiveDa
Android的LiveData
qq_44016573的博客
02-22 1802
LiveData 是一种可观察的数据存储器类。与常规的可观察类不同，LiveData 具有生命周期感知能力，意指它遵循其他应用组件（如 activity、fragment 或 service）的生命周期。这种感知能力可确保。若观察者（Observer）的生命周期处于或状态，则LiveData会认为该Observer处于活跃状态。LiveData只会将更新通知给活跃的Observer。您可以注册与实现接口的对象配对的观察者。有了这种关系，当相应的对象的状态变为时，便可移除此观察者。
基于Android架构组件的ViewModel和LiveData设计源码解析与示例
最新发布
10-10
本项目深入解析了Android架构组件中的ViewModel和LiveData，提供源码分析和示例代码。项目文件共40个，涵盖Java源代码、XML布局、PNG资源、Gradle构建脚本等多种类型，旨在帮助开发者更好地理解和应用Android架构...
Jetpack-LiveData源码解析
weixin_55362248的博客
12-03 627
LiveData源码解析 源码版本：2.4.0 需先了解：Lifecycle 使用 监听值 liveData.observe(LifecycleOwner, Observer) liveData.observeForever(Observer) 设置值 liveData.setValue(value) liveData.postValue(value) 移除监听 liveData.removeObserver(Observer) liveData.removeObservers(
4. Jetpack源码解析—LiveData的使用及工作原理
Hankkin的博客小园
07-10 704
1. 背景 上一篇我们分析了Lifecycles组件的源码，本篇我们将继续分析LiveData组件 相关系列文章： 1. Jetpack源码解析—看完你就知道Navigation是什么了？ 2. Jetpack源码解析—Navigation为什么切换Fragment会重绘？ 3. Jetpack源码解析—用Lifecycles管理生命周期 2. 基础 2.1 简介 LiveData是一个可观察...
LiveData-原理全解析
qq_21349039的博客
07-11 5937
LiveData 是 Jetpack 推出的基于观察者的消息订阅/分发的可观察数据组件，具有宿主（Activity、Fragment）生命周期感知能力，这种感知能力可确保 LiveData 仅分发消息给处于活跃状态的观察者，即只有处于活跃状态的观察者才能收到消息。而LiveData 的事件分发机制，会根据监听者的活跃状态来判断是否分发数据源变化事件，这样的话，我们就能避免当前页面在后台时，响应了事件，做出一些无用的逻辑浪费性能。LiveData 遵循观察者模式。当生命周期状态发生变化时，LiveData 会
Android-LiveData
BLOG OF PETERMAOSX.
10-20 229
LiveData 是将数据和UI分离。将数据独立到一个ViewModel里面 ViewModelTest类 定义了一个变量item package com.example.viewmodel02; import androidx.lifecycle.MutableLiveData; import androidx.lifecycle.ViewModel; public class ViewMo...
android LiveData
lmjssjj的专栏
05-24 2842
LiveData是数据holder类,并支持数据可被监听（观察）。和传统的观察者模式中的被观察者不一样，LiveData是一个生命周期感知组件，因此观察者可以指定某一个LifeCycle给LiveData，并对数据进行监听。如果观察者的生命周期处于STARTED or RESUMED状态，LiveData认为观察者处于活动状态。public class LocationLiveData extend
Android之LiveData
LVXIANGAN的专栏
07-03 384
LiveData本身很简单，但其代表却正是MVVM模式最重要的思想，即数据驱动视图（也有叫观察者模式、响应式等）——这也是摆脱顺序性编程思维的重要一步。 回顾LiveData：从处境尴尬到咸鱼翻身 我们都知道Google在去年的 I/O 大会非常隆重地推出了一系列的架构组件，本文的主角，LiveData正是其中之一，和Lifecycle、ViewModel、Room比较起来，LiveD...
Android LiveData 使用
dingjianlun的专栏
12-14 424
LiveData是一个可观察的数据持有类，自动处理生命周期，防止内存泄漏，同步数据更新。 MutableLiveData：观察对象变化 Transformations.map和Transformations.switchMap：间接观察对象，map观察普通对象，switchMap观察LiveData的子类 例子 class MainActivity : AppCompatActivity...
Android架构之LiveData组件
2401_84149814的博客
05-03 442
/关闭定时器@Override//通过LiveData.setValue()/LiveData.postValue()//完成对ViewModel中数据的更新//关闭定时器});//计时开始在页面中，通过LiveData.observe()方法对LivaData所包装的数据进行观察。
Android LiveData 介绍
我怀里的猫的博客
09-30 1200
本系列根据官网介绍Jetpack中的数据通信组件，本文介绍LiveData。在介绍LiveData之前，我们需要知道安卓官方推荐我们在viewmodel中处理业务或者数据的一些运算和网络请求，并通过观察数据的变化，来通知activity或者fragment数据更新。以上就是今天要讲的内容，本文简单介绍了LiveData是什么及其使用，通过创建观察更新六字口诀初步掌握LiveData的使用。
Android架构组件—LiveData
qq_24442769的博客
03-02 4230
概述 简单地说，LiveData是一个数据持有类。它具有以下特点： 数据可以被观察者订阅； 能够感知组件（Fragment、Activity、Service）的生命周期； 只有在组件出于激活状态（STARTED、RESUMED）才会通知观察者有数据更新； LiveData的优点 没有内存泄漏：因为 Observer 被绑定到它们自己的 Lifecycle 对象上，所以，当它们的 ...
Android 图片缓存加载技术与源码解析
使用Handler、AsyncTask或者更高级的库如RxJava、LiveData等可以实现异步加载。 #### 编程实践 - **资源文件的组织与管理**：在Android项目中，资源文件（如图片）需要合理组织。通常资源文件会放在`res/drawable`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值