LiveData原理

2022-05-24 本文已影响0人沪漂意哥哥

了解LiveData

LiveData 是一种可观察的数据存储器类。与常规的可观察类不同，LiveData 具有生命周期感知能力，意指它遵循其他应用组件（如 Activity、Fragment 或 Service）的生命周期。这种感知能力可确保 LiveData 仅更新处于活跃生命周期状态的应用组件观察者。
LiveData本身是观察者，观察组件的Lifecycle，也是被观察者，数据变化时要通知数据的观察者。

简单使用

首先在ViewModel 里面添加 MutableLiveData ，一般我们网络请求，或者数据库之类的返回后，如果要发送数据，可以用 postValue ，这个方法会利用Handler切换到主线程再setValue，如果已经在主线程了，就使用普通的 setValue 方法。

class TestViewModel : ViewModel() {

    val  livedata = MutableLiveData<String>("bao")

    init {
        livedata.postValue("bao_post")
    }

    fun initData(){
        livedata.value = "bao_set"
    }
}

/* 观察数据变化 */
viewModel.livedata.observe(TestFragment@this, object : Observer<String> {
    override fun onChanged(t: String?) {
        t?.let {
            Log.d(TAG,it)
        }
    }
})

对组件Lifecycle生命周期感知分析

observe 方法

首先这个方法只能在主线程注册观察。
官方文档说LiveData仅处于活跃生命周期才有效，所以一开始就开始判断是否为 Lifecycle.Stete.DESTROYED，是的话就没有然后了，直接return。
接下来就是创建 LifecycleBoundObserver ，生命周期变化逻辑在这里面。
然后就是最后一行注册观察。

    //map 的 key 为LiveData数据观察者，value为组件的Lifecycle观察者
    private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers =
            new SafeIterableMap<>();

    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        assertMainThread("observe");
        //判断当前生命周期的状态
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        //Lifecycle的生命周期变化逻辑在这里
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        //mObservers 保存
        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;
        }
        //感知lifecycle的生命周期变化
        owner.getLifecycle().addObserver(wrapper);
    }

LifecycleBoundObserver 做了什么

LifecycleBoundObserver 继承 ObserverWrapper ，实现 LifecycleEventObserver 接口。
ObserverWrapper 用于判断组件当前是否活跃。
LifecycleEventObserver 就是 Lifecycle 的观察者了，重写了 onStateChanged 方法，当Lifecycle 生命周期发生变化时，就会在此方法接收到，LiveData 也就能感知到，如果组件的生命周期是 DESTROYED ，那也就移除观察。
到这里 LiveData 对组件的生命周期感知就注册完成了，可以开始发送数据。

    class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
        @NonNull
        //一般组件，比如Activity、fragment可以会实现LifecycleOwner ，可以拿到lifecycle
        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(@NonNull LifecycleOwner source,
                @NonNull Lifecycle.Event event) {
            //获取当前生命周期状态
            Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
            //如果组件已销毁了，就移除观察
            if (currentState == DESTROYED) {
                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.getLifecycle().removeObserver(this);
        }
    }

activeStateChanged 方法

ObserverWrapper 这个类里面有个方法，后面的粘性事件会用到，先看看。

        void activeStateChanged(boolean newActive) {
            //组件状态如果不变返回
            if (newActive == mActive) {
                return;
            }
            // immediately set active state, so we'd never dispatch anything to inactive
            // owner
            mActive = newActive;
            changeActiveCounter(mActive ? 1 : -1);
            //如果是活动的就发送数据
            if (mActive) {
                dispatchingValue(this);
            }
        }

简易流程图 image.png

发送数据分析

postValue 发送数据到主线程

这个方法最核心的就是利用主线程Handler发送数据，一步步拆开分析，看看他是怎么写的。

    protected void postValue(T value) {
        boolean postTask;
        //加锁
        synchronized (mDataLock) {
            postTask = mPendingData == NOT_SET;
            //保存要发送的数据value
            mPendingData = value;
        }
        if (!postTask) {
            return;
        }
        //利用主线程Handler发送
        ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
    }

postValue 其实就是 setValue

在postValue 要发送的 Runnable ，可以看到最后一行就是 setValue 方法，数据也即是之前保存的mPendingData ，只是在这又给 newValue。

    private final Runnable mPostValueRunnable = new Runnable() {
        @SuppressWarnings("unchecked")
        @Override
        public void run() {
            Object newValue;
            synchronized (mDataLock) {
                newValue = mPendingData;
                mPendingData = NOT_SET;
            }
            setValue((T) newValue);
        }
    };

postToMainThread 主线程Handler

ArchTaskExecutor 类 postToMainThread 方法，实际就是 DefaultTaskExecutor 类执行 postToMainThread 方法。

public class ArchTaskExecutor extends TaskExecutor {
    @NonNull
    private TaskExecutor mDelegate;

    @NonNull
    private TaskExecutor mDefaultTaskExecutor;
    
    private ArchTaskExecutor() {
        mDefaultTaskExecutor = new DefaultTaskExecutor();
        mDelegate = mDefaultTaskExecutor;
    }
    ...
    @Override
    public void postToMainThread(Runnable runnable) {
        mDelegate.postToMainThread(runnable);
    }
    ...
}

DefaultTaskExecutor 类

我们知道是 DefaultTaskExecutor. postToMainThread，就直接看这个方法，哎呀，太熟悉的代码，创建 Handler ,传入的是 Looper.getMainLooper() ，就是主线程Handler ,然后就 post 消息。

public class DefaultTaskExecutor extends TaskExecutor {
    @Nullable
    private volatile Handler mMainHandler;

    @Override
    public void postToMainThread(Runnable runnable) {
        if (mMainHandler == null) {
            synchronized (mLock) {
                if (mMainHandler == null) {
                    mMainHandler = createAsync(Looper.getMainLooper());
                }
            }
        }
        //noinspection ConstantConditions
        mMainHandler.post(runnable);
    }
}

setValue 方法

mVersion 在初始化的构造方法里就赋值了，为-1，每次setValue，版本号就会变一次。
setValue 也就是用 mData 保存一下 value ,然后交给 dispatchingValue 方法处理。

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

dispatchingValue 方法

setValue走该方法，传的 initiator为空，那就遍历 mObservers 保存的观察者发送数据。

    @SuppressWarnings("WeakerAccess") /* synthetic access */
    void dispatchingValue(@Nullable ObserverWrapper initiator) {
        if (mDispatchingValue) {
            mDispatchInvalidated = true;
            return;
        }
        mDispatchingValue = true;
        do {
            mDispatchInvalidated = false;
            if (initiator != null) {
                //粘性事件，就单个观察者接受数据
                considerNotify(initiator);
                initiator = null;
            } else {
                //setvalue 传过来 initiator 为空，执行这里
                // mObservers 拿出来，逐个发送数据
                for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
                        mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                    considerNotify(iterator.next().getValue());
                    if (mDispatchInvalidated) {
                        break;
                    }
                }
            }
        } while (mDispatchInvalidated);
        mDispatchingValue = false;
    }

considerNotify 判断发送数据

这里先判断组件是否活动。
在判断粘性事件。
然后用 mVersion ，判断是否发送过数据。
最后才是给观察者发送数据。

    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;
        //发送数据
        observer.mObserver.onChanged((T) mData);
    }

简易流程图

image.png

粘性事件

粘性事件分析

粘性事件就是先发送数据，后面再注册观察者，还能收到消息。
我们就从LiveData.observe 开始，新的页面注册LiveData观察者，也注册Lifecycle观察。
当新页面生命周期变化，就会执行 LifecycleBoundObserver.onStateChanged 的方法
接下来 activeStateChanged 方法，因为是新页面，组件状态是活动的，就走到 dispatchingValue 方法
dispatchingValue 传进来当前新页面的 initiator 是不为空的，就只会给当前观察者发送数据。

简易流程图

image.png

解决方案

反射修改mVersion

public class NonStickyMutableLiveData<T> extends MutableLiveData {

    private boolean stickFlag=false;

    @Override
    public void observe( LifecycleOwner owner,  Observer observer) {
        super.observe(owner, observer);
        if(!stickFlag) {
            hook(observer);
            stickFlag=true;
        }
    }

    //在这里去改变onChange的流程
    private void hook(Observer<? super T> observer) {
        try {
            //1.得到mLastVersion
            //获取到LiveData的类中的mObservers对象
            //SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers
            Class<LiveData> liveDataClass = LiveData.class;
            Field mObserversField = liveDataClass.getDeclaredField("mObservers");
            mObserversField.setAccessible(true);


            //获取到这个成员变量的对象
            Object mObserversObject = mObserversField.get(this);
            //得到map对应的class对象
            Class<?> mObserversClass = mObserversObject.getClass();
            //获取到mObservers对象的get方法   entry
            Method get = mObserversClass.getDeclaredMethod("get", Object.class);
            get.setAccessible(true);
            //执行get方法   mObservers.get(observer)
            Object invokeEntry=get.invoke(mObserversObject,observer);
            //定义一个空的对象
            Object observerWraper=null;
            if(invokeEntry!=null && invokeEntry instanceof Map.Entry){
                observerWraper=((Map.Entry)invokeEntry).getValue();//ObserverWrapper
            }
            if(observerWraper==null){
                throw new NullPointerException("observerWraper is null");
            }
            //得到ObserverWrapper的类对象  编译擦除问题会引起多态冲突所以用getSuperclass
            //TODO:getClass()返回对应的当前正在运行时的类所对应的对
            Class<?> superclass = observerWraper.getClass().getSuperclass();//mLastVersion
            Field mLastVersion = superclass.getDeclaredField("mLastVersion");
            mLastVersion.setAccessible(true);
            //2.得到mVersion
            Field mVersion = liveDataClass.getDeclaredField("mVersion");
            mVersion.setAccessible(true);
            //3.把mVersion的数据填入到mLastVersion中
            Object mVersionValue=mVersion.get(this);
            mLastVersion.set(observerWraper,mVersionValue);



        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

LiveDataBus

public class LiveDataBus {

    //存放订阅者
    private Map<String, MutableLiveData<Object>> bus;

    private static LiveDataBus liveDataBus = new LiveDataBus();

    private LiveDataBus() {
        bus = new HashMap<>();
    }

    public static LiveDataBus getInstance() {
        return liveDataBus;
    }


    //注册订阅者，（存入map）
    public synchronized <T> MutableLiveData<T> with(String key,Class<T> type,boolean sticky){
        if(!bus.containsKey(key)){
            if(sticky){
                bus.put(key, new MutableLiveData<Object>());
            }else {
                bus.put(key, new NonStickyMutableLiveData<Object>());
            }
        }
        return (MutableLiveData<T>) bus.get(key);
    } 

}

发送数据

LiveDataBus.getInstance().with("msg",String.class,true).setValue("111111111");```
* 接受数据
```javascript
 LiveDataBus.getInstance().with("msg", String.class,true)
                .observe(this, new Observer<String>() {
                    @Override
                    public void onChanged(String s) {
                        Log.i("MainActivity","bus->"+s);
                    }
                });

observeForever

 LiveDataBus.getInstance().with("msg", String.class,true).observeForever(new Observer<String>() {
      @Override
      public void onChanged(String s) {
        Log.i("MainActivity","bus->"+s);
      }
    });

LiveData原理

了解LiveData

简单使用

对组件Lifecycle生命周期感知分析

observe 方法

LifecycleBoundObserver 做了什么

activeStateChanged 方法

简易流程图 image.png

发送数据分析

postValue 发送数据到主线程

postValue 其实就是 setValue

postToMainThread 主线程Handler

DefaultTaskExecutor 类

setValue 方法

dispatchingValue 方法

considerNotify 判断发送数据

简易流程图

粘性事件

粘性事件分析

简易流程图

解决方案

LiveDataBus

observeForever

猜你喜欢

热点阅读