LiveData与MutableLiveData详解_mutablelivedata livedata

前言

​ LiveData与ViewMode是经常搭配在一起使用的,但是为了不太混乱,我还是拆分开来说明,此篇博客只讲解 LiveData 与 MutableLiveData的概念与使用方式(但是会涉及到ViewMode的部分代码).

LiveData是干什么的?

​ 由于LiveData和MutableLiveData都是一个概念的东西(只是作用范围不同)所以就不重复解释了,直接理解LiveData就可以明白MutableLiveData

直接理解LiveData的字面意思是前台数据,其实这其实是很准确的表达.下面我们来说说LiveData的几个特征:

1. 首先LiveData其实与数据实体类(POJO类)是一样的东西,它负责暂存数据.

2. 其次LiveData其实也是一个观察者模式的数据实体类,它可以跟它注册的观察者回调数据是否已经更新.

3. LiveData还能知晓它绑定的Activity或者Fragment的生命周期,它只会给前台活动的activity回调(这个很厉害).这样你可以放心的在它的回调方法里直接将数据添加到View,而不用担心会不会报错.(你也可以不用费心费力判断Fragment是否还存活)

LiveData与MutableLiveData区别

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

1. MutableLiveData的父类是LiveData;

2. LiveData的postValue和setValue方法是protected，而MutableLiveData这两个方法则是public，也就是说Livedata只允许调用observe方法被动监听数据变化，而MutableLiveData除了监听变化外，还可以用postValue和setValue方法发射数据。

看看LiveData 和 MutableLiveData之间的一个最直接关系
LiveData 类的源文件

public abstract class LiveData<T> {
protected void postValue(T value) {}
@MainThread
protected void setValue(T value) {}
}
1
2
3
4
5

MutableLiveData 类的源文件

public class MutableLiveData<T> extends LiveData<T> {
	// code snippet
    @Override
    public void postValue(T value) {
        super.postValue(value);
    }

    @Override
    public void setValue(T value) {
        super.setValue(value);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

一句话总结就是: MutableLiveData 实现了LiveData的setValue(T value) 和postValue(T value) 这两个接口.仅此而已.

LiveData 解析

/**
 * LiveData是一个可以被生命周期观察的持有数据的类,
 * 换句话来说就是: 在`Observer` 去观察了 `LifecycleOwner` 的状态后(需要是在STARTED 和 RESUMED状态),当数据发生变化的时候`Observer` 会收到通知.
 * {@link #observeForever(Observer)} is considered as always active and thus will be always notified
 * about modifications. For those observers, you should manually call
 * {@link #removeObserver(Observer)}.
 *
 * 被添加到LifecycleOwner的Observer会在LivecycleOwner状态变为DESTROYED时被立即移除. 这一点在fragment 和 activity中最为有用,并且不必担心内存溢出问题

 * 在这里需要注意两个函数
 * `onActive()` 当可用的Observer从0变为1的时候会被调用,具体到业务来说就是通过该回调可以知道这个LiveData被使用了
 * `onInactive()` 当可用的Observer从0变为1的时候会被调用,具体到业务来说就是一切数据改变的通知都准备好了,就等着lifecycle满足条件了;毕竟你不可能在PAUSE的时候去更新数据吧,更新数据只能是在STARTED 和 RESUMED状态时才可以
 */
1
2
3
4
5
6
7
8
9
10
11
12
13

LiveData简单使用Demo

创建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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

很简单,只要继承LiveData并且在泛型里写下你的实体类,**唯一需要注意的,postValue(this);**这个方法是用于回调数据更新的方法. 你可以在你需要被观察的数据里添加.

创建ViewModel

​ 我们需要在ViewModel实例化DemoData这个类. ViewModel(这个会在另一篇博客介绍)这个是用于管理多个Activity或者Fragment数据的类。ViewModel是MVVM的概念。你可以百度一下，google提供这套东西就是为了MVVM。

public class DemoViewModel extends ViewModel {
    // TODO: Implement the ViewModel
    private DemoData mDemoData = new DemoData();
 
    public DemoData getDemoData() {
        return mDemoData;
    }
}
1
2
3
4
5
6
7
8

在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); //这里手动用按键点击更新数据
 
            }
        });
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

当我们点击按键后就会有数据更新后的回调触发:

2019-09-18 19:45:53.821 6649-6649/demo.yt.com.demo E/Demo2Activity: onClick: 已经点击
2019-09-18 19:45:53.824 6649-6649/demo.yt.com.demo E/Demo2Activity: onChanged: 数据有更新
1
2

前面提过了,但是这里还是需要重新提一下! 注意! 这个数据只给前台的活动回调.

MutableLiveData简单使用Demo

前面已经解释了,所以我们这边直接看代码

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

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

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);
    }
}
1
2
3
4
5
6
7
8
9
10
11

在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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

结果:

2019-09-18 19:59:38.294 6961-6961/demo.yt.com.demo E/Demo1Activity: onChanged: 值有变化=测试
1

API全解

postValue()

可能你已经在上面看到几次调用此方法了。postValue的特性如下：

1.此方法可以在其他线程中调用

2.如果在主线程执行发布的任务之前多次调用此方法，则仅将分配最后一个值。

3.如果同时调用 .postValue(“a”)和.setValue(“b”)，一定是值b被值a覆盖。

setValue()

setValue()的特性如下：

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

getValue()

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

public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer)

• 在mainthread中将observer添加到observers列表中,如果LiveData已经被设置了数据,则数据会被传递给observer.
• observer当且仅当在livecycleowner的状态为STARTED和RESUME的时候才可以接收到数据.
• 当LifecycleOwner的状态为DESTROYED时,observer会被自动移除.
• 如果数据变动了,但是owner不具有接收数据的条件,则owner不会收到数据;但是如果一旦owner具备了接收数据的条件之后,会自动的将最新的数据更新到owner.
• LiveData 会持有一个observer的强引用,直到owner 变为DESTORYED状态.在owner变为DESTORYED时,会自动将该强引用移除.
• 如果重复给owner添加同一个observer,则该动作会被忽略.
• 如果尝试给owner更新observer,则会报出IllegalArgumentException

public void observeForever(@NonNull Observer<? super T> observer)

• 需要在MainThread中调用.
• 和observe类似,只不过这里的observer不会被自动remove,反之需要手动remove

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);//解除
1
2
3
4
5
6
7
8

removeObservers(@NonNull final LifecycleOwner owner)

移除当前Activity或者Fragment的全部观察者

mMainViewModel.getContent().removeObservers(this);
1

hasActiveObservers()

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

hasObservers()

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