LiveData的使用及原理

可观察的数据持有类

1.LiveData的使用

使用添加依赖项grale.build(:app)

dependencies { ... def lifecycle_version = "2.2.0" implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version" implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version"
}

在Activity中使用

...
LiveData<String> liveData
@Override
protected void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	setContentView(R.layout.activity_main);
	LiveData<String> liveData = new LiveData<String>;
	liveData.postValue("Hello");// 发消息
	liveData.setValue("world");// 发消息
	button.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { liveData.observe(MainActivity.this, new Observer<String>() { @Override public void onChanged(String s) { Log.i("接收到数据",s+""); if (id == binding.button.getId()) { binding.button.setText(s); } if (id == binding.button2.getId()) { binding.button2.setText(s); } } });
	}
  });
}

２.原理

LiveData发送数据使用setValue和postValue，它们的区别是setValue直接在主线程中进行，postValue则是在子线程进行的。所以当你的数据要在子线程发出来的，应该选用postValue，否则使用setValue。

liveData.observe(LifecycleOwner, Observer<? super T> )这个方法是用来注册观察者的。注册的过程是这样的：
在这里插入图片描述

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

首先，注册所在的控件的生命状态是不是已销毁了，如是就不再注册，否则继续注册。
LifecycleBoundObserver wrapper将我们的观察者进行打包，打包成一个LifecycleEventObserver观察者，这个观察者专门用于组件生命周期的观察的。
最后，将观察者注册到组件的生命周期的可观察对象上。
也就是说，android本身是有这个生命周期观察机制的，这就给我们LiveData感知组件生命周期创造了条件，我们只是在这个机制上添加了一些我们的东西而已。

LifecycleBoundObserver的UML图：
在这里插入图片描述

LifecycleEventObserver接口中有一个方法onStateChanged，当组件的生命周期发生改变时，就会被调用：

public interface LifecycleEventObserver extends LifecycleObserver { /** * Called when a state transition event happens. * * @param source The source of the event * @param event The event */ void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}

LiveData对这个方法的实现是这样的：

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

也就是说，LiveData它会在这个方法里观察所在组件的生命状态，如果是已销毁的，那么它就将观察者移除，否则，它就会调用activeStateChanged方法，将数据分发出去：

void activeStateChanged(boolean newActive) {
...
	if (mActive) { dispatchingValue(this); }
}

具体分发数据是由dispatchingValue来实现的

void dispatchingValue(@Nullable ObserverWrapper initiator) {
... 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; } } }
...
}
private void considerNotify(ObserverWrapper observer) { ... if (observer.mLastVersion >= mVersion) { return; } observer.mLastVersion = mVersion; observer.mObserver.onChanged((T) mData); }

dispatchingValue分派事件是这样来进行的，传入的观察者initiator不为空，则执行该观察者的事件，否则就遍历所有观察者，并执行它的事件。我们刚刚是注册观察者，因此，会执行该观察者的事件onChanged，事件会把之前的数据拿过来，这就是所谓的粘性事件。postValue和setValue事件就会遍历所有的观察者，进行数据分发。

postValue和setValue事件都会直接去分派事件,postValue最后还是调回了setValue：

private final Runnable mPostValueRunnable = new Runnable() { @SuppressWarnings("unchecked") @Override public void run() { Object newValue; synchronized (mDataLock) { newValue = mPendingData; mPendingData = NOT_SET; } setValue((T) newValue); } };
protected void postValue(T value) { boolean postTask; synchronized (mDataLock) { postTask = mPendingData == NOT_SET; mPendingData = value; } if (!postTask) { return; } ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable); } protected void setValue(T value) { assertMainThread("setValue"); mVersion++; mData = value; dispatchingValue(null); }

正如上面所见的，postValue和setValue都会修改mData的值，mData是持有需要传递的数据的变量。因此：

liveData.postValue("Hello");// 发消息
liveData.setValue("world");// 发消息

结果是mData = “world”

３.自定义LiveData

我们自己实现一个WnLiveData:

package com.wong.livedatademo;

import android.annotation.SuppressLint;

import androidx.annotation.NonNull;
import androidx.arch.core.executor.ArchTaskExecutor;
import androidx.arch.core.internal.SafeIterableMap;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleEventObserver;
import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.LiveData;
import androidx.lifecycle.Observer;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;

import static androidx.lifecycle.Lifecycle.State.DESTROYED;
import static androidx.lifecycle.Lifecycle.State.STARTED;

public class WnLiveData<T> { private Object NOT_SET = new Object(); // 存入的数据 private T mData; // 生命周期 private LifecycleOwner owner; // 存放观察者对象 private Map<Observer<? super T>, WnLifecycleObserver> mObservers = new HashMap<>(); private int mVersion; volatile Object mPendingData = new Object(); final Object mDataLock = new Object(); private final Runnable mPostValueRunnable = new Runnable() { @SuppressWarnings("unchecked") @Override public void run() { Object newValue; synchronized (mDataLock) { newValue = mPendingData; mPendingData = NOT_SET; } setValue((T) newValue); } }; // 非主线程中使用 @SuppressLint("RestrictedApi") public void postValue(T value) { synchronized (mDataLock) { mPendingData = value; } ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable); } public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) { if (owner.getLifecycle().getCurrentState() == DESTROYED) { return; } WnLifecycleObserver wrapper = new WnLifecycleObserver(owner, observer); mObservers.put(observer,wrapper); owner.getLifecycle().addObserver(wrapper); } // 在主线程中使用 public void setValue(T value) { mVersion++; mData = value; dispatchingValue(null); } private class WnLifecycleObserver implements LifecycleEventObserver { final Observer<? super T> mObserver; boolean mActive; int mLastVersion = -1; @NonNull final LifecycleOwner mOwner; private WnLifecycleObserver(@NonNull LifecycleOwner mOwner,Observer<? super T> mObserver) { this.mObserver = mObserver; this.mOwner = mOwner; } @Override public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) { if (mOwner.getLifecycle().getCurrentState() == DESTROYED) { WnLifecycleObserver removed = mObservers.remove(mObserver); return; } boolean newActive = mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED); if (newActive == mActive) { return; } mActive = newActive; if (mActive) { dispatchingValue(this); } } } private void dispatchingValue(WnLifecycleObserver observer) { if (observer != null) { notify(observer); } else { for (Map.Entry<Observer<? super T>, WnLifecycleObserver> observerWnLifecycleObserverEntry : mObservers.entrySet()) { notify(observerWnLifecycleObserverEntry.getValue()); } } } private void notify(WnLifecycleObserver observer) { if (!observer.mActive) { return; } if (observer.mLastVersion >= mVersion) { return; } observer.mLastVersion = mVersion; observer.mObserver.onChanged((T) mData); }
}

Demo

文章来源: blog.csdn.net，作者：WongKyunban，版权归原作者所有，如需转载，请联系作者。

原文链接：blog.csdn.net/weixin_40763897/article/details/111396864

（完）