详解Android JetPack之LiveData的工作原理

前言

本篇文章主要讲解LiveData工作的原理,如果还不知道LiveData如何用的话,请参考官方文档。 LiveData的讲解涉及到了Lifecycle的知识,如果你还不了解LifeCycle,请参考文档LifeCycle介绍。

介绍

LiveData是一个数据持有类,它可以通过添加观察者被其他组件观察其变更。不同于普通的观察者,它最重要的特性就是遵从应用程序的生命周期,如在Activity中如果数据更新了但Activity已经是destroy状态,LivaeData就不会通知Activity(observer)。当然。LiveData的优点还有很多,如不会造成内存泄漏等。

LiveData通常会配合ViewModel来使用,ViewModel负责触发数据的更新,更新会通知到LiveData,然后LiveData再通知活跃状态的观察者。

原理分析

下面直接看代码:

public class UserProfileViewModel extends ViewModel {
 private String userId;
 private MutableLiveData<User> user;
 private UserRepository userRepo;

 public void init(String userId) {
  this.userId = userId;
  userRepo = new UserRepository();
  user = userRepo.getUser(userId);
 }

 public void refresh(String userId) {
  user = userRepo.getUser(userId);
 }

 public MutableLiveData<User> getUser() {
  return user;
 }

}

上面UserProfileViewModel内部持有 UserRepository 中 MutableLiveData的引用,并且提供了获取 MutableLiveData 的方法 getUser(),UserRepository 负责从网络或数据库中获取数据并封装成 MutableLiveData 然后提供给 ViewModel。

我们在 UserProfileFragment 中为 MutableLiveData 注册观察者,如下:

@Override
public void onActivityCreated(@Nullable Bundle savedInstanceState) {
 super.onActivityCreated(savedInstanceState);
 String userId = getArguments().getString(UID_KEY);
 viewModel = ViewModelProviders.of(this).get(UserProfileViewModel.class);
 viewModel.init(userId);
 //标注1
 viewModel.getUser().observe(UserProfileFragment.this, new Observer<User>() {
  @Override
  public void onChanged(@Nullable User user) {
   if (user != null) {
    tvUser.setText(user.toString());
   }
  }
 });
}

看标注1处,viewModel.getUser()获取到 MutableLiveData 也就是我们的 LiveData,然后调用 LiveData的observer方法,并把UserProfileFragment作为参数传递进去。observer() 方法就是我们分析的入口了,接下来我们看LiveData的observer()方法都做了什么:

@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
 //标注1
 if (owner.getLifecycle().getCurrentState() == DESTROYED) {
  // ignore
  return;
 }
 //标注2
 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);
}

可以看到,UserProfileFragment 是作为 LifeCycleOwner 参数传进来的,如果你的support包版本大于等于26.1.0,support包中的 Fragment 会默认继承自 LifecycleOwner,而 LifecycleOwner 可获取到该组件的 LifeCycle,也就知道了 UserProfileFragment 组件的生命周期(在这里默认大家已经了解过LifeCycle了)。

看标注1处,如果我们的 UserProfileFragment 组件已经是destroy状态的话,将直接返回,不会被加入观察者行列。如果不是destroy状态,就到标注2处,新建一个 LifecycleBoundObserver 将我们的 LifecycleOwner 和 observer保存起来,然后调用 mObservers.putIfAbsent(observer, wrapper) 将observer和wrapper分别作为key和value存入Map中,putIfAbsent()方法会判断如果 value 已经能够存在,就返回,否则返回null。 如果返回existing为null,说明以前没有添加过这个观察者,就将 LifecycleBoundObserver 作为 owner 生命周期的观察者,也就是作为 UserProfileFragment 生命周期的观察者。

我们看下LifecycleBoundObserver 源码:

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) {
   removeObserver(mObserver);
   return;
  }
  activeStateChanged(shouldBeActive());
 }

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

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

代码并不多,LifecycleBoundObserver 继承自 ObserverWrapper 并实现了 GenericLifecycleObserver接口,而 GenericLifecycleObserver 接口又继承自 LifecycleObserver 接口,那么根据 Lifecycle 的特性,实现了LifecycleObserver接口并且加入 LifecycleOwner 的观察者里就可以感知或主动获取 LifecycleOwner 的状态。

好了,看完了观察者,那么我们的LiveData什么时候会通知观察者呢?不用想,肯定是数据更新的时候,而数据的更新是我们代码自己控制的,如请求网络返回User信息后,我们会主动将User放入MutableLiveData中,这里我在UserRepository中直接模拟网络请求如下:

public class UserRepository {
 final MutableLiveData<User> data = new MutableLiveData<>();

 public MutableLiveData<User> getUser(final String userId) {
  if ("xiasm".equals(userId)) {
   data.setValue(new User(userId, "夏胜明"));
  } else if ("123456".equals(userId)) {
   data.setValue(new User(userId, "哈哈哈"));
  } else {
   data.setValue(new User(userId, "unknow"));
  }
  return data;
 }
}

当调用getUser()方法的时候,我们调用MutableLiveData的setValue()方法将数据放入LiveData中,这里MutableLiveData实际上就是继承自LiveData,没有什么特别:

public class MutableLiveData<T> extends LiveData<T> {
 @Override
 public void postValue(T value) {
  super.postValue(value);
 }

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

setValue()在放入User的时候必须在主线程,否则会报错,而postValue则没有这个检查,而是会把数据传入到主线程。我们直接看setValue()方法:

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

首先调用assertMainThread()检查是否在主线程,接着将要更新的数据赋给mData,然后调用 dispatchingValue()方法并传入null,将数据分发给各个观察者,如我们的 UserProfileFragment。看 dispatchingValue()方法实现:

private void dispatchingValue(@Nullable ObserverWrapper initiator) {
 if (mDispatchingValue) {
  mDispatchInvalidated = true;
  return;
 }
 mDispatchingValue = true;
 do {
  mDispatchInvalidated = false;
  //标注1
  if (initiator != null) {
   considerNotify(initiator);
   initiator = null;
  } else {
   //标注2
   for (Iterator<Map.Entry<Observer<T>, ObserverWrapper>> iterator =
     mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
    considerNotify(iterator.next().getValue());
    if (mDispatchInvalidated) {
     break;
    }
   }
  }
 } while (mDispatchInvalidated);
 mDispatchingValue = false;
}

从标注1可以看出,dispatchingValue()参数传null和不传null的区别就是如果传null将会通知所有的观察者,反之仅仅通知传入的观察者。我们直接看标注2,通知所有的观察者通过遍历 mObservers ,将所有的 ObserverWrapper 拿到,实际上就是我们上面提到的 LifecycleBoundObserver,通知观察者调用considerNotify()方法,这个方法就是通知的具体实现了。

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

如果观察者不是活跃状态,将不会通知此观察者,看最后一行,observer.mObserver.onChanged((T) mData),observer.mObserver就是我们调用LiveData的observer()方法传入的 Observer,然后调用 Observer 的 onChanged((T) mData)方法,将保存的数据mData传入,也就实现了更新。在看下我们实现的Observer:

viewModel.getUser().observe(UserProfileFragment.this, new Observer<User>() {
 @Override
 public void onChanged(@Nullable User user) {
  if (user != null) {
   tvUser.setText(user.toString());
  }
 }
});

如果哪个控件要根据user的变更而及时更新,就在onChanged()方法里处理就可以了。到这里,LiveData已经能够分析完了,其实LiveData的实现还是要依赖于Lifecycle。

以上就是详解Android JetPack之LiveData的工作原理的详细内容,更多关于Android JetPack之LiveData的工作原理的资料请关注我们其它相关文章!

(0)

相关推荐

  • Android Jetpack- Paging的使用详解

    Google 推出 Jetpack 组件化已经有相当一段时间了.各种组件也层出不穷. Jetpack 的东西也不少, 今天就搞一下这个  Paging Paging 的出现,就是用作列表的分页加载.其实现在已经有非常多成熟高效的开源列表加载控件了,比如:Smartrefreshlayout等.但Google推出的,必然有它的有点,当然也有它的局限性. 先说优点吧,Paging 的使用,需要配合ViewModle,LiveData等控件,数据的请求感知并绑定页面的生命周期,避免了内存泄漏.还需要绑

  • Android Jetpack架构组件 ViewModel详解

    前言 前面两篇文章我们已经学习了Lifecycle和DataBind,本篇文章我们来学习Jetpack系列中比较重要的ViewModel,Jetpack的很多很多组件都是搭配使用的,所以单独的知识点可能会有些"无意义"但却是我们项目实战的基础! ViewModel的使用 ViewModel类旨在以注重生命周期的方式存储和管理界面相关的数据.ViewModel类让数据可在发生屏幕旋转等配置更改后继续存在.这句话很好理解,还记得我们在讲解Lifecycle的时候 举的例子吗,我们还是使用那

  • Android Jetpack架构组件Lifecycle详解

    前言 Lifecycle是Jetpack架构组件中用来感知生命周期的组件,使用Lifecycles可以帮助我们写出和生命周期相关更简洁更易维护的代码. 生命周期 生命周期这个简单而又重要的知识相信大家早已耳熟能详.假设我们现在有这样一个简单需求: 这个需求只是一个实例,在真实的开发中当然不可能有这样的需要: 在Activity 可见的时候,我们去做一个计数功能,每隔一秒 将计数加1 ,当Activity不可见的时候停止计数,当Activity被销毁的时候 将计数置为0 OK,So easy~ ,

  • Android-ViewModel和LiveData使用详解

    ViewModel类的设计目的是以一种关注生命周期的方式存储和管理与UI相关的数据. 例如:Activity在配置发生改变时(屏幕旋转),Activity就会重新创建,onCreate()方法也会重新调用.我们可以在onSaveInstanceState()方法中保存数据,并从onCreate()方法中通过Bundle恢复数据,但这种方法只适用于可以对其进行序列化的少量数据,而不适用于潜在的大量数据.使用ViewModel的话ViewModel会自动保留之前的数据并给新的Activity或Fra

  • 详解Android JetPack之LiveData的工作原理

    前言 本篇文章主要讲解LiveData工作的原理,如果还不知道LiveData如何用的话,请参考官方文档. LiveData的讲解涉及到了Lifecycle的知识,如果你还不了解LifeCycle,请参考文档LifeCycle介绍. 介绍 LiveData是一个数据持有类,它可以通过添加观察者被其他组件观察其变更.不同于普通的观察者,它最重要的特性就是遵从应用程序的生命周期,如在Activity中如果数据更新了但Activity已经是destroy状态,LivaeData就不会通知Activit

  • 详解Android.activity销毁流程的工作原理

    继续我们的源码解析,上一篇文章我们介绍了Activity的启动流程,一个典型的场景就是Activity a 启动了一个Activity b,他们的生命周期回调方法是: onPause(a) –> onCreate(b) –> onStart(b) –> onResume(b) –> onStop(a) 而我们根据源码也验证了这样的生命周期调用序列,那么Activity的销毁流程呢?它的生命周期的调用顺序又是这样的呢? 这里我们我做一个简单的demo,让一个Activity a启动A

  • 详解Android中Handler的内部实现原理

    本文主要是对Handler和消息循环的实现原理进行源码分析,如果不熟悉Handler可以参见博文<详解Android中Handler的使用方法>,里面对Android为何以引入Handler机制以及如何使用Handler做了讲解. 概括来说,Handler是Android中引入的一种让开发者参与处理线程中消息循环的机制.我们在使用Handler的时候与Message打交道最多,Message是Hanlder机制向开发人员暴露出来的相关类,可以通过Message类完成大部分操作Handler的功

  • 详解Android中实现热更新的原理

    这篇文章就来介绍一下Android中实现热更新的原理. 一.ClassLoader 我们知道Java在运行时加载对应的类是通过ClassLoader来实现的,ClassLoader本身是一个抽象来,Android中使用PathClassLoader类作为Android的默认的类加载器,PathClassLoader其实实现的就是简单的从文件系统中加载类文件.PathClassLoade本身继承自BaseDexClassLoader,BaseDexClassLoader重写了findClass方法

  • 详解nginx+php执行请求的工作原理

    php工作原理 首先先了解下常听说的cgi,php-cgi,fastcgi,php-fpm到底是什么关系,帮助了解php的工作原理 cgi协议 cgi协议用来确定webserver(例如nginx),也就是内容分发服务器传递过来什么数据,什么样格式的数据 php-cgi进程解释器 php-cgi是php的cgi协议进程解释器,每次启动时,需要经历加载php.ini文件->初始化执行环境->处理请求->返回内容给webserver->php-cgi进程退出的流程 fastcgi协议

  • 实例详解Android文件存储数据方式

    总体的来讲,数据存储方式有三种:一个是文件,一个是数据库,另一个则是网络.下面通过本文给大家介绍Android文件存储数据方式. 1.文件存储数据使用了Java中的IO操作来进行文件的保存和读取,只不过Android在Context类中封装好了输入流和输出流的获取方法. 创建的存储文件保存在/data/data/<package name>/files文件夹下. 2.操作. 保存文件内容:通过Context.openFileOutput获取输出流,参数分别为文件名和存储模式. 读取文件内容:通

  • 详解Android中的Service

    Service简介: Service是被设计用来在后台执行一些需要长时间运行的操作. Android由于允许Service在后台运行,甚至在结束Activity后,因此相对来说,Service相比Activity拥有更高的优先级. 创建Service: 要创建一个最基本的Service,需要完成以下工作:1)创建一个Java类,并让其继承Service 2)重写onCreate()和onBind()方法 其中,onCreate()方法是当该Service被创建时执行的方法,onBind()是该S

  • 详解Android中fragment和viewpager的那点事儿

    在之前的博文<Android 中使用 ViewPager实现屏幕页面切换和页面轮播效果>和<详解Android中Fragment的两种创建方式>以及<Android中fragment与activity之间的交互(两种实现方式)>中我们介绍了ViewPager以及Fragment各自的使用场景以及不同的实现方式. 那如果将他们两结合起来,会不会擦出点火花呢,答案是肯定的.之前在介绍ViewPager时,我们实现了多个ImageView的切换,并配合更新导航原点的状态.那我

  • 详解Android Bitmap的常用压缩方式

    一.前言 已经好久没有更新博客,大概有半年了,主要是博主这段时间忙于找工作,Android岗位的工作真的是越来越难找,好不容易在广州找到一家,主要做海外产品,公司研发实力也不错,所以就敲定了三方协议.现在已经在公司实习了一个月多,目前主要是负责公司某个产品的内存优化,刚好就总结了一下Android Bitmap常用的优化方式. Android中的图片是以Bitmap方式存在的,绘制的时候也是Bitmap,直接影响到app运行时的内存,在Android,Bitmap所占用的内存计算公式是:图片长度

  • 详解Android的四大应用程序组件

    Android的一个核心特性就是一个应用程序可作为其他应用程序中的元素,可为其他应用程序提供数据.例如,如果程序需要用某些控件来加载一些图片,另一个程序已经开发出了此项功能,且可供其他程序使用,就可以直接使用跨进程通信方式调用那个程序的功能,而不是自己再开发一个.为了实现这样的功能,Android系统必须能够在需要应用程序中的任何一部分时启动它的进程,并且实例化那部分的Java对象.所以,不像大多数其他系统中的程序,Android程序不是只有单一的进入点,而是它们拥有系统实例化和运行必须的组件,

随机推荐