Android Architecture Components系列之LiveData&ViewModel

最新推荐文章于 2021-12-23 17:23:07 发布

无心.

最新推荐文章于 2021-12-23 17:23:07 发布

阅读量298

点赞数

本文链接：https://blog.csdn.net/huxin1875/article/details/86597329

版权

上一篇咱们聊到了Android Architecture Components系列之Lifecicle，优雅解决了Activity生命周期方法的分离。不过也仅此而已，它并不是一种app架构，而我们今天的主角LiveData和ViewModel则是一种官方的、稳定的app架构方案，算是google给我们广大开发者的馈赠。

LiveData
LiveData是一个数据容器，专门用来存放数据的，不同的是它基于观察者模式。LiveData在这里既充当了被观察者的角色，又充当了观察者的角色。它所持有的数据发生任何变化，前台组件(Activity、Fragment等)都可以感知到，并及时对ui进行更新，此为被观察者的角色。同时它还可以持有组件的生命周期状态Lifecycle，意味着它会在界面代码（LifecycleOwner）的生命周期处于 Started 或 Resumed 时作出相应更新，而在 LifecycleOwner 被销毁时停止更新，因此避免了内存泄露的产生，此为观察者的角色。如果对Lifecycle组件还不熟悉的，可以去看一看上一篇博客Lifecycle。

总结一下：LiveData不会产生内存泄漏，可以通知前台组件数据的变化。

ViewModel
我们知道，传统的mvc模式，Activity或Fragment等前台组件，不仅充当了ui层，也充当了数据层，没有很好的分离，导致在业务逻辑很复杂的时候，Activity中的代码会变的异常臃肿，难以维护，以此衍生出来的诸如MVP、MVVM等app架构方案去实现app的ui和数据的分离。这里不去讨论这两种架构方案，我们的重点是ViewModel，重点是官方-。-

ViewModel是将前台页面的数据处理逻辑(比如联网获取数据、从数据库读数据)等代码分离出来。这样前台组件就能注重页面的显示，而数据处理的逻辑都交给ViewModel，然后ViewModel再交给LiveData，LiveData再去通知前台组件更新ui，大体就这么个流程。

不同的是，ViewModel中存储的数据只有当Activtiy或Fragment全部销毁时才会消失，就比如我们在旋转屏幕的时候，常常会通过onSaveInstanceState去保存数据，然后再onCreate中去恢复数据，但这个方案都知道有一定的局限性，比如存储的数据不能太大，写起来也比较麻烦。而使用ViewModel则完全不需要考虑这个问题，ViewModel中存储的数据不会随着诸如屏幕旋转等事件而消失。而且它是可以共享的，可以在Activity和Fragment中共享这些数据。总的来说，它是暂时永恒且共享的，可以省去我们不少麻烦。

注：LiveData和ViewModel配合使用才是最正确的打开方式。

好吧，扯完了理论，我们来个例子使用一下，就可以豁然开朗了。
例：我想要在MainActivity中动态请求一组数据。
往常的做法，我们肯定是在MainActivity中用网络框架去请求数据，请求成功后去更新界面，在正常不过的逻辑了。

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Retrofit retrofit = new Retrofit.Builder()
                //设置baseUrl,baseUrl+接口中配置的地址组成真正的请求地址。
                .baseUrl("http://wanandroid.com/")
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .addConverterFactory(GsonConverterFactory.create()) // 支持Gson解析
                .client(new OkHttpClient())
                .build();

        WanAndroidService service = retrofit.create(WanAndroidService.class);
        service.getPublicAccountList()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<PublicAccountBean>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(PublicAccountBean publicAccountBean) {
                        //请求成功
                        for (int i = 0; i < publicAccountBean.getData().size(); i++) {
                            Log.e("data----------", publicAccountBean.getData().get(i).getName());
                        }

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {
                    }
                });
        
    }

}

网络请求用的Retrofit和RxJava，请求地址是鸿洋的玩Android的api。 WanAndroidService代码如下:

public interface WanAndroidService {
    /**
     * 获取公众号列表
     * @return SessionBean
     */
    @GET("wxarticle/chapters/json")
    Observable<PublicAccountBean> getPublicAccountList();
}

PublicAccountBean：

public class PublicAccountBean {

  
    private int errorCode;
    private String errorMsg;
    private List<DataBean> data;

    public int getErrorCode() {
        return errorCode;
    }

    public void setErrorCode(int errorCode) {
        this.errorCode = errorCode;
    }

    public String getErrorMsg() {
        return errorMsg;
    }

    public void setErrorMsg(String errorMsg) {
        this.errorMsg = errorMsg;
    }

    public List<DataBean> getData() {
        return data;
    }

    public void setData(List<DataBean> data) {
        this.data = data;
    }

    public static class DataBean {

        private String courseId;
        private String id;
        private String name;
        private String order;
        private String parentChapterId;
        private boolean userControlSetTop;
        private String visible;
        private List<?> children;

        public String getCourseId() {
            return courseId;
        }

        public void setCourseId(String courseId) {
            this.courseId = courseId;
        }

        public String getId() {
            return id;
        }

        public void setId(String id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getOrder() {
            return order;
        }

        public void setOrder(String order) {
            this.order = order;
        }

        public String getParentChapterId() {
            return parentChapterId;
        }

        public void setParentChapterId(String parentChapterId) {
            this.parentChapterId = parentChapterId;
        }

        public boolean isUserControlSetTop() {
            return userControlSetTop;
        }

        public void setUserControlSetTop(boolean userControlSetTop) {
            this.userControlSetTop = userControlSetTop;
        }

        public String getVisible() {
            return visible;
        }

        public void setVisible(String visible) {
            this.visible = visible;
        }

        public List<?> getChildren() {
            return children;
        }

        public void setChildren(List<?> children) {
            this.children = children;
        }
    }

    @Override
    public String toString() {
        return "PublicAccountBean{" +
                "errorCode=" + errorCode +
                ", errorMsg='" + errorMsg + '\'' +
                ", data=" + data +
                '}';
    }
}

数据妥妥的有-。-

在这里插入图片描述

事实证明我们的逻辑没有任何问题，完美的无可挑剔~

现在我们运用ViewMode和LiveData配合，把数据请求的逻辑分离开。走你~
新建MainViewModel类，继承自ViewModel，使用之前要先引入依赖:

api "android.arch.lifecycle:extensions:1.1.1"

MainViewModel:

public class MainViewModel extends ViewModel {
    private MutableLiveData<PublicAccountBean> accountData;

    public LiveData<PublicAccountBean> getAccountData() {
        if (accountData == null) {
            accountData = new MutableLiveData<>();
            loadData();

        }
        return accountData;
    }

    private void loadData() {
        Retrofit retrofit = new Retrofit.Builder()
                //设置baseUrl,baseUrl+接口中配置的地址组成真正的请求地址。
                .baseUrl("http://wanandroid.com/")
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .addConverterFactory(GsonConverterFactory.create()) // 支持Gson解析
                .client(new OkHttpClient())
                .build();

        WanAndroidService service = retrofit.create(WanAndroidService.class);
        service.getPublicAccountList()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<PublicAccountBean>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(PublicAccountBean publicAccountBean) {
                        //请求成功
                        accountData.setValue(publicAccountBean);

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {
                    }
                });
    }
}

LiveData是抽象类，这里用LiveData的子类MutableLiveData

MainActivity代码:

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        MainViewModel model = ViewModelProviders.of(this).get(MainViewModel.class);
        model.getAccountData().observe(this, new android.arch.lifecycle.Observer<PublicAccountBean>() {
            @Override
            public void onChanged(@Nullable PublicAccountBean publicAccountBean) {
                for (int i = 0; i < publicAccountBean.getData().size(); i++) {
                    Log.e("data----------", publicAccountBean.getData().get(i).getName());
                }
            }
        });
    }

}

结果嘛，依旧有：

让我们来分析一下：MainViewModel是一个数据处理类，负责数据的请求和处理。请求成功后把数据放到LiveData数据容器中，在MainActivity中，我们通过ViewModelProviders类的静态方法获取到MainViewModel对象，并获取到ViewModel中的数据容器对象，为这个数据容器对象添加观察者(MainActivity)，数据请求成功后通知MainActivtiy更新数据，流程其实很简单，一点也不复杂。我们来看下源码，首先看下ViewModel的observe方法:

@MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        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;
        }
        owner.getLifecycle().addObserver(wrapper);
    }

可以看到LifecycleOwner(Activity、Fragment等拥有生命周期的组件)，如果组件的生命周期是onDestroy，则直接忽略，不再进行数据的观察和推送。而对组件生命周期和数据的观察则是通过LifecycleBoundObserver类来进行的:

 class LifecycleBoundObserver extends ObserverWrapper implements GenericLifecycleObserver {
        @NonNull final LifecycleOwner mOwner;

        LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<T> observer) {
            super(observer);
            mOwner = owner;
        }

        @Override
        boolean shouldBeActive() {
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }

        @Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
            activeStateChanged(shouldBeActive());
        }

        @Override
        boolean isAttachedTo(LifecycleOwner owner) {
            return mOwner == owner;
        }

        @Override
        void detachObserver() {
            mOwner.getLifecycle().removeObserver(this);
        }
    }

可以看到当组件的生命周期发生变化，会回调onStateChanged方法，如果组件的生命周期结束，则移除该观察者，不再监听数据的变化。否则调用activeStateChanged方法:

 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) {
                dispatchingValue(this);
            }
        }

这里重点看下dispatchingValue方法，其中会调用一个叫considerNotify的方法，这个方法实现了对数据的观察者模式，使得数据发生变化时，可以通知前台进行数据更新。

大体的流程就是这样，有兴趣的可以自己翻一翻源码，除了这个我们刚刚还提到了共享，通过ViewModel提供的数据是可以在不同的组件之间进行共享的，比如MainActivity代码不变，只是在activity中添加了一个Fragment，然后在Fragment中监听ViewModel中数据的变化，然后弹出一个Toast。
MainActivity:

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //添加一个Fragment。
        getSupportFragmentManager()
                .beginTransaction()
                .add(R.id.frame, new MyFrgment())
                .commit();


        MainViewModel model = ViewModelProviders.of(this).get(MainViewModel.class);
        model.getAccountData().observe(this, new android.arch.lifecycle.Observer<PublicAccountBean>() {
            @Override
            public void onChanged(@Nullable PublicAccountBean publicAccountBean) {
                for (int i = 0; i < publicAccountBean.getData().size(); i++) {
                    Log.e("data----------", publicAccountBean.getData().get(i).getName());
                }
            }
        });
    }

}

MyFragment:

public class MyFrgment extends Fragment {
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View root = inflater.inflate(R.layout.fragment_my, container, false);
        MainViewModel model = ViewModelProviders.of(this).get(MainViewModel.class);
        model.getAccountData().observe(this, new android.arch.lifecycle.Observer<PublicAccountBean>() {
            @Override
            public void onChanged(@Nullable PublicAccountBean publicAccountBean) {
                Toast.makeText(getActivity(),publicAccountBean.toString(),Toast.LENGTH_LONG).show();
            }
        });
        return root;
    }

}

R.layout.fragment_my是个空的布局，只不过加一个黄色的背景，运行后可以发现，除了打印出数据，还会以Toast的形式弹出数据，说明各组件之间是可以共享数据的。

到这里，LiveData和ViewModel的基本使用已经讲完了，其实这里负责请求数据的是ViewModel，负责数据处理的也是ViewModel，ViewModel承担了太多职责，因此可以把数据请求的逻辑再进一步剥离。使得ViewModel的代码更加简洁，把这个专门负责请求数据的类称为XXRepository。举个例子，我们把刚刚获取数据的逻辑放在另外一个类AccountRepository中。

public class AccountRepository {
    public MutableLiveData<PublicAccountBean> getAccountData() {
        final MutableLiveData<PublicAccountBean> accountData = new MutableLiveData<>();
        Retrofit retrofit = new Retrofit.Builder()
                //设置baseUrl,baseUrl+接口中配置的地址组成真正的请求地址。
                .baseUrl("http://wanandroid.com/")
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .addConverterFactory(GsonConverterFactory.create()) // 支持Gson解析
                .client(new OkHttpClient())
                .build();

        WanAndroidService service = retrofit.create(WanAndroidService.class);
        service.getPublicAccountList()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<PublicAccountBean>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(PublicAccountBean publicAccountBean) {
                        //请求成功
                        accountData.setValue(publicAccountBean);

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {
                    }
                });
        return accountData;
    }
}

ViewModel中的代码稍作修改，通过AccountRepository 去获取数据：

public class MainViewModel extends ViewModel {
    AccountRepository accountRepository = new AccountRepository();

    public LiveData<PublicAccountBean> getAccountData() {

        return accountRepository.getAccountData();
    }
}

效果是一样的，这里就不贴了，这样又减轻了ViewModel的负担，更加解耦，不过使得类的数量又增加了，具体该如何使用，还需要自己斟酌。附上几点总结：

1. ViewMode和LiveData通常配合使用，ViewModel负责提供LivaData，LiveData负责存储数据。
2. 开发者在开发时无需关心生命周期所带来的各种问题。
3. 组件之间可以共享数据。
4. LiveData基于观察者模式，可以将数据的变化及时通知给前台组件。
5. ViewModel可以进一步拆分，更加职责分离。

完~
下一篇：Android Architecture Components系列之Room数据持久化方案

无心.

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android Architecture Components系列之LiveData&ViewModel

Android Architecture Components系列之LiveData&amp;amp;amp;amp;ViewModel上一篇咱们聊到了Android Architecture Components系列之Lifecicle，优雅解决了Activity生命周期方法的分离。不过也仅此而已，它并不是一种app架构方案，而我们今天的主角LiveData和ViewModel则是一种官方的、稳定的app架构方案，算...
复制链接

扫一扫