JetPack框架组件2——liveData的使用和源码分析

快来打我* 2022-10-05 06:52 155阅读 0赞

# JetPack框架组件2——liveData的使用和源码分析 #

### 文章目录 ###

*  JetPack框架组件2——liveData的使用和源码分析
 *   *   *  一.liveData的使用和概述
         *   *  1.概述
             *  2.使用
         *  二.liveData的注册
         *  三.liveData的事件分发
         *  四.liveData的粘性事件实现
         *  五.参考资料

### 一.liveData的使用和概述 ###

#### 1.概述 ####

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

具体来说：如果观察者（由 Observer 类表示）的生命周期处于 STARTED 或 RESUMED 状态，则 LiveData 会认为该观察者处于活跃状态。  
LiveData 只会将更新通知给活跃的观察者。为观察 LiveData 对象而注册的非活跃观察者不会收到更改通知。这个是具体是由上一节我们讲过的lifecycles

使用 LiveData 的优势如下:

1.  LiveData 遵循观察者模式。当底层数据发生变化时，LiveData 会通知 Observer 对象
2.  不会发生内存泄漏,观察者会绑定到 Lifecycle 对象，并在其关联的生命周期遭到销毁后进行自我清理。
3.  不会因 Activity 停止而导致崩溃.如果观察者的生命周期处于非活跃状态（如返回栈中的 Activity），则它不会接收任何 LiveData 事件。
4.  不再需要手动处理生命周期
5.  数据始终保持最新状态
6.  共享资源

#### 2.使用 ####

定义

class NameViewModel :ViewModel() {
        
        val currentName: MutableLiveData<String> by lazy {
        
            MutableLiveData<String>()
        }
    
    }

使用

class FirstFragment : Fragment() {
        
    
        private val model: NameViewModel by viewModels()
    
        override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        
            super.onViewCreated(view, savedInstanceState)
    
            //定义观察者
            val nameObserver = Observer<String> {
         newName ->
                textview_first.text = newName
            }
            //注册
            model.currentName.observe(this, nameObserver)
            view.findViewById<Button>(R.id.button_first).setOnClickListener {
        
                val anotherName = "John Doe"
                //发送事件
                model.currentName.setValue(anotherName)
            }
        }
    }

### 二.liveData的注册 ###

入口代码:

model.currentName.observe(this, nameObserver)

public abstract class LiveData<T> {
        
        private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers =
                    new SafeIterableMap<>();
    
        @MainThread
        public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        
            assertMainThread("observe");
            //判断所在的fragment或者activity是不是DESTROYED
            if (owner.getLifecycle().getCurrentState() == DESTROYED) {
        
                // ignore
                return;
            }
            LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
            //将<observer,wrapper>存入map中
            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;
            }
            //将LiveData和lifecycle进行绑定，此时LiveData可以关联的其生命周期
            owner.getLifecycle().addObserver(wrapper);
        }
    }

这里我们可以看出，最后将Observer放入一个map中，同时将Observer和lifecycle进行绑定

### 三.liveData的事件分发 ###

入口代码

model.currentName.setValue(anotherName)

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

继续进入

public abstract class LiveData<T> {
        
        @MainThread
        protected void setValue(T value) {
        
            assertMainThread("setValue");
            mVersion++;
            //保存
            mData = value;
            //进行分发
            dispatchingValue(null);
        }
    
        void dispatchingValue(@Nullable ObserverWrapper initiator) {
        
            if (mDispatchingValue) {
        
                mDispatchInvalidated = true;
                return;
            }
            mDispatchingValue = true;
            do {
        
                mDispatchInvalidated = false;
                if (initiator != null) {
        
                    considerNotify(initiator);
                    initiator = null;
                } else {
        
                    //遍历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;
        }
    
        private void considerNotify(ObserverWrapper observer) {
        
            if (!observer.mActive) {
        
                return;
            }
    
            //判断lifecycles否是活跃的
            if (!observer.shouldBeActive()) {
        
                observer.activeStateChanged(false);
                return;
            }
    
            //判断是否发送过
            if (observer.mLastVersion >= mVersion) {
        
                return;
            }
            observer.mLastVersion = mVersion;
            //发送事件
            observer.mObserver.onChanged((T) mData);
        }
    }

### 四.liveData的粘性事件实现 ###

粘性事件是指：在注册前发送的事件，注册后会收到。  
这个粘性事件的实现是在liveData注册的时候，通过lifecycles实现的  
入口代码

owner.getLifecycle().addObserver(wrapper);

这里面的代码。我们在上一篇已经分析过了

class LifecycleRegistry{
        
        @Override
        public void addObserver(@NonNull LifecycleObserver observer) {
        
            State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
            ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
            ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
    
            if (previous != null) {
        
                return;
            }
            LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
            if (lifecycleOwner == null) {
        
                // it is null we should be destroyed. Fallback quickly
                return;
            }
    
            boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
            State targetState = calculateTargetState(observer);
            mAddingObserverCounter++;
            while ((statefulObserver.mState.compareTo(targetState) < 0
                    && mObserverMap.contains(observer))) {
        
                pushParentState(statefulObserver.mState);
                //这里处理分发
                statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
                popParentState();
                // mState / subling may have been changed recalculate
                targetState = calculateTargetState(observer);
            }
    
            if (!isReentrance) {
        
                // we do sync only on the top level.
                sync();
            }
            mAddingObserverCounter--;
        }
        static class ObserverWithState {
        
            State mState;
            LifecycleEventObserver mLifecycleObserver;
    
            ObserverWithState(LifecycleObserver observer, State initialState) {
        
                mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
                mState = initialState;
            }
    
            void dispatchEvent(LifecycleOwner owner, Event event) {
        
                State newState = getStateAfter(event);
                mState = min(mState, newState);
                //这里在次进行分发
                mLifecycleObserver.onStateChanged(owner, event);
                mState = newState;
            }
        }
    }

liveData的mLifecycleObserver是LifecycleBoundObserver，是liveData的内部类

public abstract class LiveData<T> {
        
        class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
        
            //....
            @Override
            public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
        
                if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
        
                    removeObserver(mObserver);
                    return;
                }
                activeStateChanged(shouldBeActive());
            }
            //...
        }
    
        private abstract class ObserverWrapper {
        
            //....
            void activeStateChanged(boolean newActive) {
        
                if (newActive == mActive) {
        
                    return;
                }
                // immediately set active state, so we'd never dispatch anything to inactive
                // owner
                mActive = newActive;
                boolean wasInactive = LiveData.this.mActiveCount == 0;
                LiveData.this.mActiveCount += mActive ? 1 : -1;
                if (wasInactive && mActive) {
        
                    onActive();
                }
                if (LiveData.this.mActiveCount == 0 && !mActive) {
        
                    onInactive();
                }
                if (mActive) {
        
                    //和之前不同。这里不是传null。而是传了一个this
                    dispatchingValue(this);
                }
            }
        }
        @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 {
        
                    for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
                            mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
        
                        considerNotify(iterator.next().getValue());
                        if (mDispatchInvalidated) {
        
                            break;
                        }
                    }
                }
            } while (mDispatchInvalidated);
            mDispatchingValue = false;
        }
    
        private void considerNotify(ObserverWrapper observer) {
        
            if (!observer.mActive) {
        
                return;
            }
    
            if (!observer.shouldBeActive()) {
        
                observer.activeStateChanged(false);
                return;
            }
            if (observer.mLastVersion >= mVersion) {
        
                return;
            }
            observer.mLastVersion = mVersion;
            //传入之前缓存的data数据
            observer.mObserver.onChanged((T) mData);
        }
    
    
    }

总结:在livedata进行注册，同时也会将observer注册给lifecycles。  
在注册给lifecycle时，会检查lifecycle状态，如果有未发送的事件，在再次发送

### 五.参考资料 ###

[官方文档][Link 1]

[Link 1]: https://developer.android.google.cn/topic/libraries/architecture/livedata?hl=zh-cn