Android 自定义LiveData

LiveData是什么？

1.livedata是一个数据持有类
2.数据可以被观察者订阅
3.能够感知组件（Fragment、Activity、Service）的生命周期
4.只有在组件处于激活状态（STARTED、RESUMED）才会通知观察者有数据更新

为什么需要LiveData

1.能够保证数据和UI统一：这个和LiveData采用了观察者模式有关，LiveData是被观察者，当数据有变化时会通知观察者（UI）
2.LiveData优点：
1）资源共享
2）减少内存泄漏
3）当Activity停止时不会引起崩溃
4）组件和数据相关的内容能实时更新
5）针对configuration change时，不需要额外的处理来保存数据。

自定义LiveData

1.分析源码可知，LiveData本身是没有感知生命周期功能的，它是通过lifecycle来实现的。ObserverWrapper这个观察者的封装类，包括：Observer，lifecycle,观察者版本号mLastVersion；自定义GLiveData代码如下：

package com.example.customlivedata;

import android.annotation.SuppressLint;
import android.util.Log;

import androidx.annotation.NonNull;
import androidx.lifecycle.GenericLifecycleObserver;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.Observer;

import java.util.ArrayList;
import java.util.List;


/**
 * 组件通信 ，数据共享
 * @param <T>
 */
public class GLiveData<T> {

    //数据持有类， 持有的数据
    private T mPendingData=null;
    //观察者的集合
    private List<ObserverWrapper>  mObservers=new ArrayList<>();
    private int mVersion = -1;

    /**
     * 注册观察者的方法
     * @param lifecycleOwner
     * @param observer
     */
    public void observer(LifecycleOwner lifecycleOwner,Observer<T>  observer){
        //如果当前传进来的组件的生命周期已经结束，就直接返回
        if(lifecycleOwner.getLifecycle().getCurrentState()== Lifecycle.State.DESTROYED){
            return;
        }
        ObserverWrapper mObserverWrapper=new ObserverWrapper();
        mObserverWrapper.observer=observer;
        //为了解决还没 注册的观察者 ，也能监听到的问题
        mObserverWrapper.mLastVersion=-1;
        mObserverWrapper.lifecycle=lifecycleOwner.getLifecycle();
        mObserverWrapper.myLifecycleBound=new MyLifecycleBound();

        mObservers.add(mObserverWrapper);
        lifecycleOwner.getLifecycle().addObserver(mObserverWrapper.myLifecycleBound);
        //有个问题
        //disPatingValue();
    }

    /**
     * 绑定数据 发送通知
     * @param vaule
     */
    public void postValue(T vaule){
        this.mPendingData=vaule;
        mVersion++;
         disPatingValue();
    }

    /**
     * 遍历所有的观察者
     */
    public void disPatingValue(){

        for (ObserverWrapper mObserverWrapper:mObservers) {
            toChanged(mObserverWrapper);
        }
    }
    /**
     * 回调所有的观察者
     */
    public void toChanged(ObserverWrapper mObserverWrapper){
        //判断生命周期
        if(mObserverWrapper.lifecycle.getCurrentState()!=Lifecycle.State.RESUMED){
            return;
        }
        //判断匹配版本号，为了防止生命周期改变的时候，观察者会被回调
        if (mObserverWrapper.mLastVersion >= mVersion) {
            return;
        }
        mObserverWrapper.mLastVersion = mVersion;
        mObserverWrapper.observer.onChanged(mPendingData);
    }

    /**
     * 组件的生命周期的回调类
     */
    @SuppressLint("RestrictedApi")
    class MyLifecycleBound implements GenericLifecycleObserver {
        @Override
        public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
            if(source.getLifecycle().getCurrentState()==Lifecycle.State.DESTROYED){
                remove(source.getLifecycle());
            }
            Log.e("TAG-----",source.getLifecycle().getCurrentState().toString());
            if(mPendingData!=null){
                disPatingValue();
            }
        }
    }
    /**
     *观察者的封装类
     *
     */
    private class ObserverWrapper{
        //观察者
        Observer<T> observer;
        Lifecycle lifecycle;
        int mLastVersion = -1;
        //绑定生命周期的回调接口
        MyLifecycleBound myLifecycleBound;

    }

    public void remove(Lifecycle lifecycle){
        for (ObserverWrapper mObserverWrapper:mObservers) {
             if(mObserverWrapper.lifecycle==lifecycle){
                 mObserverWrapper.lifecycle.removeObserver(mObserverWrapper.myLifecycleBound);
                 mObservers.remove(mObserverWrapper);
             }
        }
    }
}

重点就是observer这个方法以及重写回调MyLifecycleBound里面的操作，都有注释，大家应该能看懂，LiveData管理类代码：

package com.example.customlivedata;

import android.util.Log;

import java.util.HashMap;
import java.util.Map;




public class LiveDataManager {

     private static LiveDataManager liveDataManager;

     //应用中所有数据持有类的集合
     private Map<String,GLiveData<Object>> map;


     private LiveDataManager(){
         Log.e("TAG","LiveDataManager执行构造方法");
         map=new HashMap<>();

     }
     public static  LiveDataManager getInstance(){
         if(liveDataManager!=null){
             return liveDataManager;
         }
         synchronized (LiveDataManager.class){
             if(liveDataManager==null){
                 liveDataManager=new LiveDataManager();
             }
         }
         return liveDataManager;
     }
     public<T> GLiveData<T> with(String key,Class<T> clazz){
         if(!map.containsKey(key)){
             map.put(key,new GLiveData<Object>());
         }
         return (GLiveData<T>) map.get(key);
     }

//      public void remove(String key){
//         if(map.containsKey(key)){
//             map.remove(key);
//         }
//}

}

源码链接