JetPack之ViewModel+LiveData

一、概述
二、LiveData 使用
- 2.1 创建 LiveData 对象
- 2.2 观察 LiveData 对象
- 2.3 更新 LiveData 对象
三、编写 LiveData Demo
- 3.1 不使用 LiveData
- 3.2 使用 MutableLiveData
- 3.3 使用 MediatorLiveData
- - 3.3.1 监听 2 个数据源的变化
  - 3.3.2 编写模拟 2 个数据源更新的代码
四、ViewModel 使用
- 4.1 创建 ViewModel 类
- 4.2 在 Activity 中使用
五、ViewModel+LiveData
- 5.1 在 ViewModel 中增加 LiveData
- 5.2 在 ViewModel 中添加操作数据的逻辑
- 5.3 修改 MainActivity 中和 liveData 有关的代码
- 5.4 修改 MyViewModel
- 5.5 修改后
- - 5.5.1 修改后MainActivity
  - 5.5.2 修改后MyViewModel
六、总结

一、概述

之前单独介绍过ViewModel和LiveData，但是没有将两者结合使用。
JetPack之ViewModel
JetPack之LiveData
ViewModel 对象为特定的界面组件（如 Fragment 或 Activity）提供数据，并包含数据处理业务逻辑，会配合 LiveData 一起使用。
LiveData 是一种可观察的数据存储器类， LiveData 使用观察者模式，每当数据发生变化时， LiveData 会通知 Observer 对象，可以在这些 Observer 对象中更新 UI。
接下来，先介绍如果使用 LiveData，并编写一个 LiveData Demo，接着再结合ViewModel 对 LiveData Demo 的代码进行重构

二、LiveData 使用

LiveData< T>是一个抽象类，它有 2 个子类分别是： MutableLiveData和MediatorLiveData< T>，在编写代码时，是创建的子类。先来看MutableLiveData< T>使用方法，在后面的示例中再介绍如何使用 MediatorLiveData< T>

2.1 创建 LiveData 对象

如果要观察的对象类为 String，就通过如下代码创建一个 MutableLiveData 对象

MutableLiveData< String> liveData = new MutableLiveData<>();

2.2 观察 LiveData 对象

通过 observe 方法来监听 LiveData 的数据变化，每当 LiveData 发生变化时，都会回调
onChanged 方法，并返回值的内容 String s

liveData.observe(this, new Observer< String>() {
@Override
public void onChanged(String s) {
Log.i(TAG, "onChanged: " + s)
   	}
});

2.3 更新 LiveData 对象

通过 LiveData 的 setValue 方法，给 LiveData 赋值，每次赋完值后，都会回调 onChanged 方法

liveData.setValue("add for test");

当给 LiveData 赋值为"add for test"时， onChanged 会输出日志：

I/LiveDataDemo: onChanged: add for test

三、编写 LiveData Demo

创建一个 Demo，主界面只有一个 TextView， TextView 用作展示一个数字，这个数字会从 59 开始显示，然后每隔 1 秒数字会减 1，直到数字变为 0。

3.1 不使用 LiveData

代码说明：
1、在 MainActivity 增加一个 countDown 的方法，通过 CountDownTimer 创建一个倒计时器
2、 new CountDownTimer(1 * 60 * 1000, 1 * 1000)中 2 个参数的含义：第一个参数表示这个 Timer 的总时长为 60 秒；第 2 个参数表示每隔 1 秒中会更新一次，并回调 onTick方法
3、每次调用 onTick 方法，会调用 textView.setText(String.valueOf(l / 1000));设置一次TextView 的内容
对应代码如下：

public class MainActivity extends AppCompatActivity {

    private TextView textView;

    @SuppressLint("MissingInflatedId")
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textView = findViewById(R.id.textView);
        countDown();
    }

    private void countDown() {
        new CountDownTimer(1 * 60 * 1000, 1 * 1000) {
            @Override
            public void onTick(long l) {
                textView.setText(String.valueOf(l / 1000));
            }

            @Override
            public void onFinish() {
            }
        }.start();
    }
}

布局文件:

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout 
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

效果：
在这里插入图片描述
弊端：
业务逻辑(倒计时的功能)和 UI 逻辑(TextView 更新)没有分开，耦合到一起了

3.2 使用 MutableLiveData

为了方便演示，直接在 MainActivity 中操作 LiveData，实际项目中不要这样编写代码，应该把LiveData 放到 ViewModel 中
Google 推荐的使用 LiveData 的方法：
在这里插入图片描述

代码说明：
1、在 MainActivity 中增加一个 long 类型的 MutableLiveData
2、每次回调 onTick 方法时，调用 liveData.setValue(l);，把最新的值设置给 LiveData
3、调用 LivewData 的 observe 方法，设置一个监听器，每当 LiveData 的值变化时，会回调 onChanged 方法，在 onChanged 中设置 TextView 的内容
对应代码如下：

public class MainActivity extends AppCompatActivity {

    private final MutableLiveData<Long> liveData = new MutableLiveData<>();
    private TextView textView;

    @SuppressLint("MissingInflatedId")
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textView = findViewById(R.id.textView);
        countDown();
        // TODO：为了方便演示，直接在 MainActivity 中操作 LiveData，实际项目中不要这样编写代码，应该把 LiveData 放到 ViewModel 中
        liveData.observe(this, new Observer<Long>() {
            @Override
            public void onChanged(Long aLong) {
                textView.setText(String.valueOf(aLong / 1000));
            }
        });
        countDown();
    }


    public void countDown() {
        new CountDownTimer(1 * 60 * 1000, 1 * 1000) {
            @Override
            public void onTick(long l) {
                // TODO：为了方便演示，直接在 MainActivity 中操作 LiveData，实际项目中不要这样编写代码，应该把 LiveData 放到 ViewModel 中
                liveData.setValue(l);
            }

            @Override
            public void onFinish() {
            }
        }.start();
    }

}

效果与上面一样。

3.3 使用 MediatorLiveData

MediatorLiveData 可以合并多个 LiveData 源，只要任何原始的 LiveData 源对象发生更改，就会触发 MediatorLiveData 对象的观察者。
例如，如果界面中有可以从本地数据库或网络更新的 LiveData 对象，则可以向MediatorLiveData 对象添加以下源：

与存储在数据库中的数据关联的LiveData 对象。
与从网络访问的数据关联的LiveData 对象。

Activity 只需观察 MediatorLiveData 对象即可从这两个源接收更新。接下来，实现这个例子。

3.3.1 监听 2 个数据源的变化

代码说明如下：
1、创建 1 个 MediatorLiveData< String>对象
2、创建 2 个MutableLiveData： liveData1 表示网络数据源， liveData2 表示本地数据源
3、调用 MediatorLiveData 的 addSource 方法，分别将 liveData1 和 liveData2 加到 MediatorLiveData 要监听的数据源中
4、设置 MediatorLiveData 的监听，当 2 个数据源发生变化时，会回调onChanged 方法，并将变化的内容展示到 TextView 上

3.3.2 编写模拟 2 个数据源更新的代码

编写一个 mergeTes 的方法，里面创建了 2 个 Timer，用作模拟网络数据更新和本地数据更新的情况，每隔 3 秒会往网络数据 liveData1 设置值、每隔 10 秒会往本地数据liveData2 设置值。
完整代码如下

public class MainActivity extends AppCompatActivity {

    private TextView textView;
    private MutableLiveData< String> liveData1 = new MutableLiveData<>();
    private MutableLiveData< String> liveData2 = new MutableLiveData<>();
    final MediatorLiveData< String> liveDataMerger = new MediatorLiveData<>();
    @SuppressLint("MissingInflatedId")
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textView = findViewById(R.id.textView);

        liveDataMerger.addSource(liveData1, new Observer< String>() {
            @Override
            public void onChanged(String s) {
                liveDataMerger.setValue(s);
            }
        });
        liveDataMerger.addSource(liveData2, new Observer< String>() {
            @Override
            public void onChanged(String s) {
                liveDataMerger.setValue(s);
            }});
        liveDataMerger.observe(this, new Observer< String>() {
            @Override
            public void onChanged(String s) {
                textView.setText(s);
            }
        });
        mergeTest();
    }



    public void mergeTest() {
        new CountDownTimer(1 * 60 * 1000, 3 * 1000) {
            @Override
            public void onTick(long l) {
                liveData1.setValue("网络有数据更新了" + l/1000);
            }
            @Override
            public void onFinish() {
            }
        }.start();
        new CountDownTimer(1 * 60 * 1000, 10 * 1000) {
            @Override
            public void onTick(long l) {
                liveData2.setValue("本地数据库更新了" + l/1000);
            }
            @Override
            public void onFinish() {
            }
        }.start();
    }
}

运行效果

在这里插入图片描述

四、ViewModel 使用

4.1 创建 ViewModel 类

创建一个 MyViewModel 类，继承自 ViewModel

import androidx.lifecycle.ViewModel;
public class MyViewMode extends ViewModel {

}

4.2 在 Activity 中使用

    public class MainActivity extends AppCompatActivity {
        private MyViewModel viewModel;
        @Overrideprotected
        void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            viewModel = new ViewModelProvider(this).get(MyViewModel.class);
        }
    }

五、ViewModel+LiveData

5.1 在 ViewModel 中增加 LiveData

在 MyViewModel 中增加 3 个 MutableLiveData，分别对应在 MainActivity 中使用到的。
并编写这 3 个 LiveData 的 get 方法

public class MyViewModel extends ViewModel {

    private MutableLiveData<Long> liveData = new MutableLiveData<>();
    private MutableLiveData<String> liveData1 = new MutableLiveData<>();
    private MutableLiveData<String> liveData2 = new MutableLiveData<>();

    public MutableLiveData<Long> getLiveData() {
        return liveData;
    }

    public MutableLiveData<String> getLiveData1() {
        return liveData1;
    }

    public MutableLiveData<String> getLiveData2() {
        return liveData2;
    }

}

5.2 在 ViewModel 中添加操作数据的逻辑

countDown、 mergeTest 这 2 个方法在操作数据，从 MainActivity 中把这 2 个方法copy 到 MyViewModel 中

    public void countDown() {
        new CountDownTimer(1 * 60 * 1000, 1 * 1000) {
            @Override
            public void onTick(long l) {

                liveData.postValue(l);
            }

            @Override
            public void onFinish() {
            }
        }.start();
    }

    public void mergeTest() {
        new CountDownTimer(1 * 60 * 1000, 3 * 1000) {
            @Override
            public void onTick(long l) {
                liveData1.postValue("网络有数据更新了" + l / 1000);
            }

            @Override
            public void onFinish() {
            }
        }.start();
        new CountDownTimer(1 * 60 * 1000, 10 * 1000) {
            @Override
            public void onTick(long l) {
                liveData2.postValue("本地数据库更新了" + l / 1000);
            }

            @Override
            public void onFinish() {
            }
        }.start();
    }

5.3 修改 MainActivity 中和 liveData 有关的代码

1、删除 countDown，改用 viewModel.countDown();

    MyViewModel viewModel = new ViewModelProvider(this).get(MyViewModel.class);
    viewModel.countDown();

2、用 viewModel.getLiveData().observe 替换 liveData.observe

    viewModel.getLiveData().observe(this, new Observer<Long>() {
        @Override
        public void onChanged(Long aLong) {
            textView.setText(String.valueOf(aLong / 1000));
        }
    });

5.4 修改 MyViewModel

增加 liveDataMerger 字段，并编写 getLiveDataMerger()方法，这个方法里面的内容，是从 MainActivity 中 copy 过来的

public class MyViewModel extends ViewModel {

    private MediatorLiveData<String> liveDataMerger;

    private MutableLiveData<Long> liveData = new MutableLiveData<>();
    private MutableLiveData<String> liveData1 = new MutableLiveData<>();
    private MutableLiveData<String> liveData2 = new MutableLiveData<>();

    public MediatorLiveData<String> getLiveDataMerger() {
        if (liveDataMerger == null) {
            liveDataMerger = new MediatorLiveData<>();
        }
        liveDataMerger.addSource(liveData1, new Observer<String>() {
            @Override
            public void onChanged(String s) {

                liveDataMerger.setValue(s);
            }
        });
        liveDataMerger.addSource(liveData2, new Observer<String>() {
            @Override
            public void onChanged(String s) {

                liveDataMerger.setValue(s);
            }
        });
        return liveDataMerger;
    }
.........

5.5 修改后

5.5.1 修改后MainActivity

public class MainActivity extends AppCompatActivity {

    private TextView textView;
    private MyViewModel viewModel;

    @SuppressLint("MissingInflatedId")
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textView = findViewById(R.id.textView);
        viewModel = new ViewModelProvider(this).get(MyViewModel.class);

        viewModel.getLiveDataMerger().observe(this, new Observer<String>() {
            @Override
            public void onChanged(String s) {
                textView.setText(s);
            }
        });
        viewModel.mergeTest();
//        viewModel.getLiveData().observe(this, new Observer<Long>() {
//            @Override
//            public void onChanged(Long aLong) {
//                textView.setText(String.valueOf(aLong / 1000));
//            }
//        });
//        viewModel.countDown();
    }
}

5.5.2 修改后MyViewModel

public class MyViewModel extends ViewModel {
    private MutableLiveData<Long> liveData = new MutableLiveData<>();
    private MutableLiveData<String> liveData1 = new MutableLiveData<>();
    private MutableLiveData<String> liveData2 = new MutableLiveData<>();
    private MediatorLiveData<String> liveDataMerger;

    public MediatorLiveData<String> getLiveDataMerger() {
        if (liveDataMerger == null) {
            liveDataMerger = new MediatorLiveData<>();
        }
        liveDataMerger.addSource(liveData1, new Observer<String>() {
            @Override
            public void onChanged(String s) {
                liveDataMerger.setValue(s);
            }
        });
        liveDataMerger.addSource(liveData2, new Observer<String>() {
            @Override
            public void onChanged(String s) {

                liveDataMerger.setValue(s);
            }
        });
        return liveDataMerger;
    }

    public MutableLiveData<Long> getLiveData() {
        return liveData;
    }

    public MutableLiveData<String> getLiveData1() {
        return liveData1;
    }

    public MutableLiveData<String> getLiveData2() {
        return liveData2;
    }

    public void countDown() {
        new CountDownTimer(1 * 60 * 1000, 1 * 1000) {
            @Override
            public void onTick(long l) {

                liveData.postValue(l);
            }

            @Override
            public void onFinish() {
            }
        }.start();
    }

    public void mergeTest() {
        new CountDownTimer(1 * 60 * 1000, 3 * 1000) {
            @Override
            public void onTick(long l) {
                liveData1.postValue("网络有数据更新了" + l / 1000);
            }

            @Override
            public void onFinish() {
            }
        }.start();
        new CountDownTimer(1 * 60 * 1000, 10 * 1000) {
            @Override
            public void onTick(long l) {
                liveData2.postValue("本地数据库更新了" + l / 1000);
            }

            @Override
            public void onFinish() {
            }
        }.start();
    }
}

六、总结

ViewModel 和 LiveData 结合使用的一些好处：

生命周期感知：ViewModel 和 LiveData 都是生命周期感知的组件，它们可以在界面控制器（如 Activity 或 Fragment）的生命周期变化时自动调整其行为。这意味着可以在 ViewModel 中存储和管理数据，而 LiveData 可以通知观察者（如界面控制器）数据的变化。
数据持久性：ViewModel 和 LiveData 结合使用可以确保数据在配置更改（如屏幕旋转）时得以保留。ViewModel 会在界面控制器销毁和重新创建时保持数据不变，而 LiveData 可以通知观察者更新数据。
避免内存泄漏：ViewModel 和 LiveData 的结合使用有助于避免内存泄漏问题。ViewModel 不持有对界面控制器的引用，而 LiveData 会自动处理观察者的生命周期，从而避免因观察者未及时取消注册而导致的内存泄漏。
数据更新通知：LiveData 可以实现数据的观察和更新，当数据发生变化时，LiveData 会通知所有观察者进行相应的更新操作。这样可以确保界面与数据保持同步，提升用户体验。
简化异步操作：LiveData 可以结合 ViewModel 使用，帮助简化异步操作和数据加载过程。可以在 ViewModel 中处理异步操作，然后通过 LiveData 将结果传递给观察者，从而实现响应式编程。
解耦数据和界面：ViewModel 和 LiveData 的结合使用有助于将数据逻辑与用户界面分离，使代码更易于维护和测试。ViewModel 中的数据可以供多个界面控制器共享，避免重复加载数据。