学习笔记LiveData

时间:2021-7-20 作者:qvyue

学习下LiveData
目录

  1. 如何使用
  2. 源码解析
  3. 粘性事件

1、使用

LiveData是Google的提供标准化开发的组件之一
主要就是在页面中传递数据在Activity的Fragment中,一个Fragment改变了数据,可以通知到另一个Fragment
当屏幕旋转时候,会自动通知组件推送最后一次数据
并且可以感知生命周期,帮开发者避免一些因Fragment销毁而导致的空指针问题
用法其实很简单

//定一个MutableLiveData
val name = MutableLiveData()

//在需要的地方进行订阅
userBean.observe(this,{ it->
  //显示数据
})

//在需要的地方 发送数据
name.value = "数据改变了"

通常会放在ViewModel中,贴一下部分代码

//定义一个ViewModel
class UserViewModel :ViewModel() {

    val name = MutableLiveData()

    fun setName(str: String) {
        name.value = str
    }
}
//定义2个Fragment 在同一个Activity上
//FragmentA
class FragmentA : Fragment() {
    //定义ViewModel
    private lateinit var model: UserViewModel

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        model = ViewModelProvider(requireActivity()).get(UserViewModel::class.java)
        //忽略xml界面,设置按钮点击事件
        btn.setOnClickListener {
            model.setName("abc")
        }
    }
}
//FragmentB
class FragmentB : Fragment() {
    //定义ViewModel
    private lateinit var model: UserViewModel

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        model = ViewModelProvider(requireActivity()).get(UserViewModel::class.java)
        //忽略xml,这里进行订阅数据有变化时候 执行onChanged方法
        model.name.observe(requireActivity(),object:Observer{
            override fun onChanged(t: String?) {
                tv_name.text = t
            }
        })

    }
}

当点击按钮的时候,setName 执行赋值方法通知订阅 执行 onChanged方法。
第一次看到会比较奇怪,为什么两个对象通过 ViewModelProvider 赋值,之后订阅就能执行了?
这两个Fragment的model肯定是同一个对象,可以用 toString 打印

System.out: com.demo.viewmodel.UserViewModel@d2f5b55
System.out: com.demo.viewmodel.UserViewModel@d2f5b55

确实同一个对象。至于回调 onChanged,这是观察者模式,这里不赘述了。
前面说了可以感知生命周期,这时候可以把屏幕旋转一下试试,看看值还在不在
用就这么简单

2、分析

(1)observe怎么感知生命周期
(2)怎么回调onChanged的

(1)、感知生命周期
//用的是MutableLiveData  继承了  抽象类 LiveDate
public class MutableLiveData extends LiveData
public abstract class LiveData {

  public void observe(@NonNull LifecycleOwner owner, @NonNull Observer super T> observer) {

      LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
      ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);

      owner.getLifecycle().addObserver(wrapper);
  }

}

删了一些判断的代码
这代码很少,new了 LifecycleBoundObserver 对象塞入了owner 也就是 activity对象,observer也就是观察者对象,里面是onChanged
然后把这个wrapper,put到了mObservers
这个mObservers是SafeIterableMap,看上去是个Map其实是 用Map的Key-Value,封装成了一个LinkedList
最后把wrapper对象,传到了activity里面,其实这里就已经将两者进行了绑定
再稍微深入一点点

//FragmentActivity
public class FragmentActivity extends ComponentActivity implements
        ActivityCompat.OnRequestPermissionsResultCallback,
        ActivityCompat.RequestPermissionsRequestCodeValidator {

    //new了一个对象
    final LifecycleRegistry mFragmentLifecycleRegistry = new LifecycleRegistry(this);

}

owner.getLifecycle().addObserver(wrapper);

//订阅的observer 会在这里被添加
//LifecycleRegistry
public class LifecycleRegistry extends Lifecycle {
  @Override
  public void addObserver(@NonNull LifecycleObserver observer) {
    //这里对 observer 进行了一些包装
    //塞入一个mObserverMap对象中
    //这个对象是FastSafeIterableMap本质也是一个Key-Value的LinkList
    while(){
        //循环分发 事件
        statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
    }
  }
}

所以当 model.name.observe(requireActivity(),object:Observer{..}订阅的时候执行了LifecycleRegistryaddObserver方法,包装对象,塞入链表。
ok这时,在ComponentActivitymLifecycleRegistry对象 管理所有的订阅。
现在已经绑定好了,然后感知生命周期,生命周期无非就onCreate…onDestroy。
前面也说了为防止空指针,直接看onDestroy()

protected void onDestroy() {
    super.onDestroy();
    mFragments.dispatchDestroy();
    //里面 修改了状态、同步状态
    mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
}
//不仅仅是destory做了处理
protected void onPause() {
    super.onPause();
    mResumed = false;
    mFragments.dispatchPause();
    mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
}
@Override
   protected void onSaveInstanceState(@NonNull Bundle outState) {
       super.onSaveInstanceState(outState);
       markFragmentsCreated();
       mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
}

总结一下
observe和activity绑定,放入了activity链表中,这个链表由activity管理,根据activity的生命周期,修改里面的状态

(2)、回调onChanged
LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
owner.getLifecycle().addObserver(wrapper);

//刚才说了订阅会调用addObserver(..)
//这里的observer 就是LifecycleBoundObserver对象
public void addObserver(@NonNull LifecycleObserver observer) {
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    while(){
          statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
    }
}
statefulObserver.dispatchEvent 调用了
   -> mLifecycleObserver.onStateChanged(owner, event);
      ->LifecycleBoundObserver的onStateChanged()   这里已经是LiveData了
        ->activeStateChanged
          ->最终dispatchingValue(@Nullable ObserverWrapper initiator) 分发

这个链比较长,可以点击源码走一圈
dispatchingValue(ObserverWrapper initiator) 这里面就是正真的观察者了,
for循环去走onChanged()方法

3、粘性事件

EventBus的粘性事件,在ActivityA发射了粘性时间,打开ActivityB之后会执行粘性事件
在这里也是一样的道理。
根据刚才的源码,订阅后会进行一次分发,为什么订阅后就会分发?这要根据Google对这个组件的“定义”了
我理解的“定义”是 存活的数据 LiveData ,也就是在Activity、Fragment生命周期内被分发,也就是说Activity、Fragment活着,这数据也得活着。
所以当你屏幕旋转Activity被销毁,又初始化了,这些数据还要再次显示出来,所以产生了粘性事件。
从分发开始看

name.value = str

protected void setValue(T value) {
    assertMainThread("setValue");
    mVersion++;
    mData = value;
    dispatchingValue(null);
}
//分发
void dispatchingValue(@Nullable ObserverWrapper initiator) {
    do {
        if (initiator != null) {
        } else {
            for (Iterator, ObserverWrapper>> iterator =
                    mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                considerNotify(iterator.next().getValue());
                if (mDispatchInvalidated) {
                    break;
                }
            }
        }
    } while (mDispatchInvalidated);
}
//观察者for循环去通知
private void considerNotify(ObserverWrapper observer) {
    if (!observer.shouldBeActive()) {
        observer.activeStateChanged(false);
        return;
    }
    if (observer.mLastVersion >= mVersion) {
        return;
    }
    observer.mLastVersion = mVersion;
    observer.mObserver.onChanged((T) mData);
}

这里会发现有个版本号
ObserverWrapper中 mLastVersion 默认-1
在 LiveData 初始化之后 mVersion 为 0 , 每次 赋值后 mVersion++
发送数据后 会 mLastVersion = mVersion
再根据 if判断 observer.mLastVersion >= mVersion 如果为false就会调用 onChanged 方法。
所以粘性事件有次而来。
这看上去像是个Bug,追本溯源,这个组件的目的,并不是总线消息通信。而是“存活的数据”,当Activity、Fragment,旋转,销毁重建时会及时得到最后一次数据。

学艺不精,如果内容有错误请及时联系我,我及时改正

声明:本文内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎发送邮件至:qvyue@qq.com 进行举报,并提供相关证据,工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。