本文详细探讨了Android LiveData的内部实现，包括如何感知生命周期、如何处理setValue和postValue的区别，以及在设置相同值时观察者是否接收到通知。通过对源码的分析，揭示了LiveData的工作原理，并为面试提供了宝贵的准备资料。
if (existing != null) {
// 若 existing 不为 null，则忽略该调用。对应方法注释的第 12 点。
return;
}
// 将 owner 和 observer 的包装对象添加到 owner.getLifecycle()。对应方法注释的第 1 点。
owner.getLifecycle().addObserver(wrapper);
}
第一个问题中 LiveData 怎么感知生命周期感知？
我们可以回答了，调用 observe 方法时，会调用 owner.getLifecycle().addObserver 已达到感知生命周期的目的。 observe 方法的内容很少，接着看下 owner 和 observer 的包装对象 LifecycleBoundObserver
LiveData 的内部类
class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
@NonNull
final LifecycleOwner mOwner;
// 构造函数 owner 赋值给属性 mOwner， observer 则调用了 super
LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
super(observer);
mOwner = owner;
}
@Override
boolean shouldBeActive() {
return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}
/**
- 当 source (也就是 mOwner) 的生命周期改变时会回调此方法
*/
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
// 获取当前 mOwner 的生命周期状态
Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
if (currentState == DESTROYED) {
// 如果是已销毁状态，则调用 LiveData#removeObserver 方法进行移除 mObserver (mObserver 是 LifecycleBoundObserver 的父类 ObserverWrapper 的属性，通过 ObserverWrapper 的构造函数来赋值)，对应 LiveData#observe 方法注释的第 12 点。
removeObserver(mObserver);
return;
}
Lifecycle.State prevState = null;
while (prevState != currentState) {
prevState = currentState;
activeStateChanged(shouldBeActive());
currentState = mOwner.getLifecycle().getCurrentState();
}
}
@Override
boolean isAttachedTo(LifecycleOwner owner) {
return mOwner == owner;
}
@Override
void detachObserver() {
// 从 mOwner 中移除此观察者
mOwner.getLifecycle().removeObserver(this);
}
}
onStateChanged 方法中注释如果是已销毁状态，则调用 LiveData#removeObserver 方法进行移除 mObserver (mObserver 是 LifecycleBoundObserver 的父类 ObserverWrapper 的属性，通过 ObserverWrapper 的构造函数来赋值)，对应 LiveData#observe 方法注释的第 12 点。 同时第一个问题已经得到了解决： **LiveData 怎么感知生命周期感知？需要取消注册吗？**LiveData#observe 看完啦，该看 setValue 和 postValue 了。
/**
-
Sets the value. If there are active observers, the value will be dispatched to them.
-
设置值。如果存在活动的观察者，则会将值分派给他们。
-
-
This method must be called from the main thread. If you need set a value from a background
-
thread, you can use {@link #postValue(Object)}
-
必须从主线程调用此方法。如果需要从后台线程设置值，可以使用{@link#postValue（Object）}
-
@param value The new value
*/
@MainThread
protected void setValue(T value) {
// 检查当前线程是否是主线程，若非主线程则会抛异常
assertMainThread(“setValue”);
// 很关键的 mVersion ，在这里进行 + 1 操作
mVersion++;
// 将新值赋值给属性 mData
mData = value;
// 分发值 (后面再看它具体实现)
dispatchingValue(null);
}
关键哟：setValue 必须在主线程中调用
/**
-
Posts a task to a main thread to set the given value. So if you have a following code
-
executed in the main thread:
-
将任务发布到主线程以设置给定值。因此，如果在主线程中执行以下代码：
-
liveData.postValue(“a”);
-
liveData.setValue(“b”);
-
The value “b” would be set at first and later the main thread would override it with
-
the value “a”.
-
首先设置值“b”，然后主线程将用值“a”覆盖它。(等我们看完了 postValue 具体怎么做的，这个官方小示例就能明白了)
-
-
If you called this method multiple times before a main thread executed a posted task, only
-
the last value would be dispatched.
-
如果在主线程执行已发布任务之前多次调用此方法，则只会调度最后一个值。
-
@param value The new value
*/
protected void postValue(T value) {
boolean postTask;
synchronized (mDataLock) {
postTask = mPendingData == NOT_SET;
// 新值赋值给属性 mPendingData
mPendingData = value;
}
// 当 mPendingData == NOT_SET 时，才会往下走
if (!postTask) {
return;
}
ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}
ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable); 看似是把 mPostValueRunnable 这 Runnable 对象发送到主线程？
private final Runnable mPostValueRunnable = new Runnable() {
@SuppressWarnings(“unchecked”)
@Override
public void run() {
Object newValue;
synchronized (mDataLock) {
// 将刚赋值新值的 mPendingData 赋值给对象 newValue
newValue = mPendingData;
// 将 mPendingData 重置为 NOT_SET
// 回头看看 postValue 会明白为啥要这么做
mPendingData = NOT_SET;
}
// 嘶 ~ 在这儿调用了 setValue，
setValue((T) newValue);
}
};
这时候看出来 postValue 最终还是调用了 setValue 再看下 postToMainThread
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP_PREFIX)
public class ArchTaskExecutor extends TaskExecutor {
@NonNull
private TaskExecutor mDelegate;
private ArchTaskExecutor() {
mDefaultTaskExecutor = new DefaultTaskExecutor();
mDelegate = mDefaultTaskExecutor;
}
@Override
public void postToMainThread(Runnable runnable) {
mDelegate.postToMainThread(runnable);
}
}
由 DefaultTaskExecutor 对象调用的 postToMainThread
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP_PREFIX)
public class DefaultTaskExecutor extends TaskExecutor {
@Nullable
private volatile Handler mMainHandler;
@Override
public void postToMainThread(Runnable runnable) {
if (mMainHandler == null) {
synchronized (mLock) {
if (mMainHandler == null) {
// MainLooper 主线程的 Looper 呢
mMainHandler = createAsync(Looper.getMainLooper());
}
}
}
//noinspection ConstantConditions
mMainHandler.post(runnable);
}
private static Handler createAsync(@NonNull Looper looper) {
if (Build.VERSION.SDK_INT >= 28) {
return Handler.createAsync(looper);
}
if (Build.VERSION.SDK_INT >= 16) {
try {
return Handler.class.getDeclaredConstructor(Looper.class, Handler.Callback.class,
boolean.class)
.newInstance(looper, null, true);
} catch (IllegalAccessException ignored) {
} catch (InstantiationException ignored) {
} catch (NoSuchMethodException ignored) {
} catch (InvocationTargetException e) {
return new Handler(looper);
}
}
return new Handler(looper);
}
}
最终是通过 Handler 的 post ~~ 太熟悉了。
看代码得知 Handler 的 Looper 是 MainLooper
So LiveData#postValue 最终使用主线程将新 value 分发给观察者。意味着我们可以在任何线程调用 postValue，而不用担心线程问题。因为 LiveData 内部做好了线程转换。
第二个问题：2. setValue 和 postValue 有什么区别
简单来说：setValue 只能在主线程使用，而 postValue 不限制线程。
由上知道了：setValue 调用了 dispatchingValue， postValue 调用了 setValue 所以最终也是调用 dispatchingValue
void dispatchingValue(@Nullable ObserverWrapper initiator) {
// mDispatchingValue 是一个标记，为 true 表示正在分发 value，
if (mDispatchingValue) {
mDispatchInvalidated = true;
return;
}
mDispatchingValue = true;
do {
mDispatchInvalidated = false;
if (initiator != null) {
// 1.
considerNotify(initiator);
initiator = null;
} else {
// 2.
for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
considerNotify(iterator.next().getValue());
if (mDispatchInvalidated) {
break;
}
}
}
} while (mDispatchInvalidated);
mDispatchingValue = false;
}
从 setValue 中看到调用 dispatchingValue 时传入的参数是 null 所以我们先看注释第 2 点的情况，使用迭代器获取 ObserverWrapper 对象传到 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()) {
// 更改 ObserverWrapper 的 mActive 为 false 非活跃状态
observer.activeStateChanged(false);
return;
}
// 版本号来了~~！
if (observer.mLastVersion >= mVersion) {
return;
}
// 同步版本号，
observer.mLastVersion = mVersion;
// 这里终于调用了我们 LiveData.observe 方法传入的 Observer 对象的 onChanged 方法。
// 终于形成了闭环
observer.mObserver.onChanged((T) mData);
}
来看看版本号 LiveData#mVersion
static final int START_VERSION = -1;
private int mVersion;
// 当创建 LiveData 时传入了初始值，则 mVersion 的版本为 -1 + 1 也就是 0
public LiveData(T value) {
mData = value;
mVersion = START_VERSION + 1;
}
// 大多数我们会使用无参构造，这时候 mVersion 是 START_VERSION -1
/**
- Creates a LiveData with no value assigned to it.
*/
public LiveData() {
mData = NOT_SET;
mVersion = START_VERSION;
}
那 mVersion 的值是什么时候更改的呢？
其实在刚刚分析 setValue 时就 ++ 了，回顾一下
protected void setValue(T value) {
assertMainThread(“setValue”);
mVersion++;
mData = value;
dispatchingValue(null);
}
而且我们也知道 postValue 最后会调用 setValue，所以 mVersion 值更改的只是就到这儿了。 这时候是不是可以分析一下第三个问题
3. 设置相同的值，订阅的观察者们会收到同样的值吗 在分发值的过程中没有判断过新值是否等于老值的代码出现，只出现了一个判断 version，通过 demo 尝试也会发现，会收到同样的值的哟。
以下资料全部免费赠送，需要的可以点击这里：https://github.com/hunanmaniu/AndroidNotes
架构师筑基必备技能
目前Android APP开发主流语言就是Java语言，Java语言最大的特性就是提高了软件的交互可能性，可以说安卓手机几乎所有应用程序都是利用Java语言来进行编写的。
JAVA知识要点：
1、 Java序列化、泛型与反射
2、虚拟机底层原理
3、Android内存原理
4、 Java高级并发原理详解
5、 编译时技术掌握与实战
6、JDK高级动态代理
7、高级数据结构与算法
8、 Java IO操作
9、
。。。。
Android R FrameWork源码与UI
在Android中，Framework泛指系统架构层。Framework的中文意思是“框架”，在软件开发中通常指开发框架，在一个系统中处于内核层之上，为顶层应用提供接口，被设计用来帮助开发者快速开发顶层应用，而不必关心系统内核运行机制，通常Framework都会隐藏main函数等应用程序必须的组件，开发人员只需把精力放在功能代码的实现上。说简单点，Framework具体的工作也就是为android应用开发的开发人员提供了一系列的服务和API的接口。
UI其实并不是单纯指用户看到的效果。因为在Android开发中，每个控件背后都有一套深层次的体系在支撑，自然而然，会UI不单纯指的是会自定义控件，我们还应该知道自定义控件背后的执行流程，包括从Activity的创建，XML的解析，到每个控件的测量、布局、绘制。当然在中间还夹杂着比如动画、事件分发机制、嵌套滑动机制等知识点。还有谷歌提供的一些UI框架也使我们要掌握的对象，比如Jetpack组件库、Material Design等。
结尾
好了，今天的分享就到这里，如果你对在面试中遇到的问题，或者刚毕业及工作几年迷茫不知道该如何准备面试并突破现状提升自己，对于自己的未来还不够了解不知道给如何规划，可以来看看同行们都是如何突破现状，怎么学习的，来吸收他们的面试以及工作经验完善自己的之后的面试计划及职业规划。
这里放上一部分我工作以来以及参与过的大大小小的面试收集总结出来的一套进阶学习的视频及面试专题资料包，在这里免费分享给大家，主要还是希望大家在如今大环境不好的情况下面试能够顺利一点，希望可以帮助到大家~
rial Design等。
结尾
好了，今天的分享就到这里，如果你对在面试中遇到的问题，或者刚毕业及工作几年迷茫不知道该如何准备面试并突破现状提升自己，对于自己的未来还不够了解不知道给如何规划，可以来看看同行们都是如何突破现状，怎么学习的，来吸收他们的面试以及工作经验完善自己的之后的面试计划及职业规划。
这里放上一部分我工作以来以及参与过的大大小小的面试收集总结出来的一套进阶学习的视频及面试专题资料包，在这里免费分享给大家，主要还是希望大家在如今大环境不好的情况下面试能够顺利一点，希望可以帮助到大家~
[外链图片转存中…(img-D0o9fsaL-1645163673522)]
扫一扫
553
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
