参考链接：
https://blog.csdn.net/gdutxiaoxu/article/details/86660760
https://www.cnblogs.com/guanxinjing/p/11544273.html

一、LiveData

首先LiveData其实与数据实体类（Plain OrdinaryJava Object）是一样的东西,它负责暂存数据。其次LiveData也是一个观察者模式的数据实体类,它的观察者可以回调数据是否已经更新.

它可以做到在组件处于激活状态的时候才会回调相应的方法，从而刷新相应的 UI。
不用担心发生内存泄漏
当 config 导致 activity 重新创建的时候，不需要手动取处理数据的储存和恢复。它已经帮我们封装好了。
LiveData还能知晓它绑定的Activity或者Fragment的生命周期，当 Actiivty 不是处于激活状态的时候，如果你想 livedata setValue 之后立即回调 obsever 的 onChange 方法，而不是等到 Activity 处于激活状态的时候才回调 obsever 的 onChange 方法，你可以使用 observeForever 方法，但是你必须在 onDestroy 的时候 removeObserver。

二、LiveData与MutableLiveData区别

LiveData与MutableLiveData的其实在概念上是一模一样的，唯一几个的区别如下:

MutableLiveData的父类是LiveData
LiveData在实体类里可以通知指定某个字段的数据更新.
MutableLiveData则是完全是整个实体类或者数据类型变化后才通知，不会细节到某个字段

三、LiveData简单使用Demo

1.创建LiveData

public class DemoData extends LiveData<DemoData> {
    private int tag1;
    private int tag2;
    
    public int getTag1() {
        return tag1;

    }
    public void setTag1(int tag1) {
        this.tag1 = tag1;
        postValue(this);
    }

    public int getTag2() {
        return tag2;
    }

    public void setTag2(int tag2) {
        this.tag2 = tag2;
        postValue(this);
    }
}

继承LiveData并且在泛型里写下你的实体类
postValue(this)这个方法是用于回调数据更新的方法. 你可以在你需要被观察的数据里添加.

2.创建ViewModel

public class DemoViewModel extends ViewModel {
    // TODO: Implement the ViewModel
    private DemoData mDemoData = new DemoData();

    public DemoData getDemoData() {
        return mDemoData;
    }
}

3.在Activity或者Fragment绑定

public class Demo2Activity extends AppCompatActivity {
    private static final String TAG = "Demo2Activity";
    private Button mBtnAddData;
    private DemoViewModel mDemoViewModel;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_demo2);
        mBtnAddData = findViewById(R.id.btn_add_data);
        mDemoViewModel = ViewModelProviders.of(this).get(DemoViewModel.class);//获取ViewModel,让ViewModel与此activity绑定
        mDemoViewModel.getDemoData().observe(this, new Observer<DemoData>() { //注册观察者,观察数据的变化
            @Override
            public void onChanged(DemoData demoData) {
                Log.e(TAG, "onChanged: 数据有更新");
            }
        });
        
        mBtnAddData.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.e(TAG, "onClick: 已经点击");
                mDemoViewModel.getDemoData().setTag1(123); //这里手动用按键点击更新数据

            }
        });
    }
}

4.初始化ViewModel时传递参数

调用 ViewModelProvider of(@NonNull Fragment fragment, @Nullable Factory factory) 方法，只不过，需要多传递一个 factory 参数。
我们的做法是：实现 Factory 接口，重写 create 方法，在create 方法里面调用相应的构造函数，返回相应的实例。

public class TestViewModel extends ViewModel {

    private final String mKey;
    private MutableLiveData<String> mNameEvent = new MutableLiveData<>();

    public MutableLiveData<String> getNameEvent() {
        return mNameEvent;
    }

    public TestViewModel(String key) {
        mKey = key;
    }

    public static class Factory implements ViewModelProvider.Factory {
        private String mKey;

        public Factory(String key) {
            mKey = key;
        }

        @Override
        public <T extends ViewModel> T create(Class<T> modelClass) {
            return (T) new TestViewModel(mKey);
        }
    }

    public String getKey() {
        return mKey;
    }
}

四、MutableLiveData简单使用Demo

1.创建MutableLiveData

MutableLiveData只是作用于变量所以我们直接就可以在ViewModel里实例化它,并且在泛型里标注变量的类型.

public class DemoViewModel extends ViewModel {
    // TODO: Implement the ViewModel
    private MutableLiveData<String> myString = new MutableLiveData<>();

    public MutableLiveData<String> getMyString(){
        return myString;
    }

    public void setMyString(String string) {
        this.myString.setValue(string);
    }
}

2.在Activity或者Fragment绑定

public class Demo1Activity extends AppCompatActivity {
    private static final String TAG = "Demo1Activity";
    private DemoViewModel mDemoViewModel;
    private Button mBtn1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_demo);
        mBtn1 = findViewById(R.id.btn_1);
        mDemoViewModel = ViewModelProviders.of(this).get(DemoViewModel.class);//获取ViewModel,让ViewModel与此activity绑定
        mDemoViewModel.getMyString().observe(this, new Observer<String>() { //注册观察者
            @Override
            public void onChanged(String s) {
                Log.e(TAG, "onChanged: 值有变化="+s);
            }
        });

        mBtn1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                mDemoViewModel.setMyString("测试"); //用手动按键点击改变值
            }
        });
    }
}

五、共享数据

1.Fragment Activity 之间共享数据

我们回过头来再来看一下 ViewModelProvider 的 of 方法，他主要有四个方法，分别是

ViewModelProvider of(@NonNull Fragment fragment)
ViewModelProvider of(@NonNull FragmentActivity activity)
ViewModelProvider of(@NonNull Fragment fragment, @Nullable Factory factory)
ViewModelProvider of(@NonNull FragmentActivity activity, @Nullable Factory factory)

1,2 方法之间的主要区别是传入 Fragment 或者 FragmentActivity。而我们知道，通过 ViewModel of 方法创建的 ViewModel 实例，对于同一个 fragment 或者 fragmentActivity 实例，ViewModel 实例是相同的，因而我们可以利用该特点，在 Fragment 中创建 ViewModel 的时候，传入的是 Fragment 所依附的 Activity。因而他们的 ViewModel 实例是相同的，从而可以做到共享数据。

// Fragment 依赖的 Activity
mTestViewModel = ViewModelProviders.of(this,new TestViewModel.Factory(mkey)).get(TestViewModel.class);
mTestViewModel.getMyString().observe(this, new Observer<String>() {
    @Override
    public void onChanged(@Nullable String s) {
       Log.i(TAG, "onChanged: s = " + s);
        mTvName.setText(s);
    }
});


// TestFragment 中
mViewModel = ViewModelProviders.of(mActivity).get(TestViewModel.class);
mTestViewModel.getMyString().observe(this, new Observer<String>() {
    @Override
    public void onChanged(@Nullable String s) {
        Log.d(TAG, "onChanged: s =" + s + " mViewModel.getKey() =" + mViewModel.getKey());
        mTvName.setText(s);
        boolean result = mViewModel == ((LiveDataSampleActivity) mListener).mTestViewModel;
        Log.d(TAG, "onChanged: s result =" + result);
    }
});

2.全局共享数据

说到全局共享数据，我们想一下我们的应用全景，比如说我的账户数据，这个对于整个 App 来说，肯定是全局共享的。有时候，当我们的数据变化的时候，我们需要通知我们相应的界面，刷新 UI。如果用传统的方式来实现，那么我们一般才采取观察者的方式来实现，这样，当我们需要观察数据的时候，我们需要添加 observer，在界面销毁的时候，我们需要移除 observer。

但是，如果我们用 LiveData 来实现的话，它内部逻辑都帮我们封装好了，我们只需要保证LiveData 是单例的就ok，在需要观察的地方调用 observer 方法即可。也不需要手动移除 observer，不会发生内存泄漏，方便快捷。

六、API全解

1.postValue()

postValue的特性如下：

此方法可以在其它线程中调用
如果在主线程执行发布的任务之前多次调用此方法，则仅将分配最后一个值。
如果同时调用.postValue(“a”)和.setValue(“b”)，一定是值b被值a覆盖。

2.setValue()

setValue()的特性如下：

此方法只能在主线程里调用

3.getValue()

返回当前值。注意，在后台线程上调用此方法并不能保证将接收到最新的值。

4.removeObserver(@NonNull final Observer<? super T> observer)

移除指定的观察者

Observer<String> observer = new Observer<String>() {
    @Override 
    public void onChanged(String s) {
        mText.setText("内容改变=" + s);
    }
};
mMainViewModel.getContent().observe(this, observer);//绑定
mMainViewModel.getContent().removeObserver(observer);//解除</pre>

5.hasActiveObservers()

如果此LiveData具有活动（Activity或者Fragment在前台,当前屏幕显示）的观察者，则返回true。其实如果这个数据的观察者在最前台就返回true，否则false。

6.onActive ()

当活动观察者的数量从0变为1时调用。这个回调可以用来知道这个LiveData正在被使用，因此应该保持最新。

7.onInactive ()

当活动观察者的数量从1变为0时调用。即观察者的生命周期状态没有STARTED or RESUMED

8.hasObservers()

如果此LiveData具有观察者，则返回true。

9.observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer)

设置此LiveData数据当前activity或者Fragment的观察者，会给此activity或者Fragment在前台时回调数据。

10.observeForever(@NonNull Observer<? super T> observer)

设置永远观察者，永远不会被自动删除。您需要手动调用removeObserver（Observer）以停止观察此LiveData，
设置后此LiveData，一直处于活动状态，不管是否在前台哪里都会获得回调。

11.removeObservers(@NonNull final LifecycleOwner owner)

移除当前Activity或者Fragment的全部观察者,在使用了observeForever 时调用，即监听了应用在前台状态时的LiveData值变化

Android LiveData和MutableLiveData使用详解