jetPack全家桶（MVVM部分）

jetPack全家桶

1.LifeCycle

简述（DefaultLifecycleObserver）

关于LiseCycle的作用，一句话就是让组件感知生命周期，降低组件中生命周期方法的代码耦合。对于LifeCycle，在早先使用方法是继承lifeCycleObserver这个类，使用注解的方式，注明方法在那一个生命周期中使用，然后通过getLifecycle().addObserver()来将其添加进观察者。（早先的实现方法已经被废弃了，不再使用，主要是因为在java7之前接口中不允许有默认方法，而在java8后，接口中就可以存在默认方法了，于是使用注解的方式会导致性能等一些问题的原因就被废弃了）目前使用的是DefaultLifecycleObserver。在学习这个之前需要学习一下观察者，后面总结附上链接：

导包

导包可以直接去官网查找最新的库，使用androidx

    implementation "androidx.lifecycle:lifecycle-viewmodel:2.5.1"
    implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'

使用

1. 先建立一个类实现DefaultLifecycleObserver，然后重写生命周期方法，在方法内建立自己需要的业务

package com.example.mvvmtest;

import android.content.Context;
import android.util.Log;

import androidx.annotation.NonNull;
import androidx.lifecycle.DefaultLifecycleObserver;
import androidx.lifecycle.LifecycleOwner;

public class BasePeople implements DefaultLifecycleObserver {
    private final Context mContext;
	
	//注意构造方法，需要Context
    public BasePeople(Context context) {
        this.mContext = context;
    }

    @Override
    public void onCreate(@NonNull LifecycleOwner owner) {
    	//you do（以下类似）
        Log.e("len.hu", "onCreate");
    }

    @Override
    public void onStart(@NonNull LifecycleOwner owner) {
        Log.e("len.hu", "onStart");
    }

    @Override
    public void onResume(@NonNull LifecycleOwner owner) {
        Log.e("len.hu", "onResume");
    }

    @Override
    public void onPause(@NonNull LifecycleOwner owner) {
        Log.e("len.hu", "onPause");
    }

    @Override
    public void onStop(@NonNull LifecycleOwner owner) {
        Log.e("len.hu", "onStop");
    }

    @Override
    public void onDestroy(@NonNull LifecycleOwner owner) {
        Log.e("len.hu", "onDestroy");
    }

}

2. 将其添加到需要的组件中，注意需要注销

package com.example.mvvmtest;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

    private BasePeople basePeople;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //在onCreate绑定
        basePeople = new BasePeople(this);
        getLifecycle().addObserver(basePeople);
    }


    @Override
    protected void onDestroy() {
        super.onDestroy();
        getLifecycle().removeObserver(basePeople);
    }
}

这就是在Activity中的使用，解耦Activity，比较简单，对于Fragment和service基本是类似的。

原理解析参考

点击跳转查看LifeCycle原理

2. viewModel

简述

上面已经介绍过lifeCycle，主要用来感知组件的生命周期，那么关于viewModel，它的作用一句话就是：将和UI交互的数据抽离出来，使用viewModel单独管理，设置，取出和保存。

使用viewModel经常被提起的一个好处就是，在屏幕进行旋转的时候，Activity重建，但数据会保留下来。

使用

导包在上面已经包含在内了
首先使用非常的简单，只需要继承ViewModel就好了，然后在内实现业务操作，然后在组件中使用

1. 继承viewmodel，实现业务，这里以保存student的信息为例子

public class myViewModel extends ViewModel {
    private MutableLiveData<List<Student>> data = new MutableLiveData<>();
    private List<Student> mData = new ArrayList<>();

    public void setData(List<Student> list){
        if (list != null) {
            if (mData != null) {
                mData.clear();
            }
            mData.addAll(list);
            data.postValue(mData);
        }
    }

    public MutableLiveData<List<Student>>  getStudentList(){
        return data;
    }
}

这重间需要使用LiveDatat，具体可以参考liveData

2. 在组件中使用（Activity为例）
   这里开启一个子线程，去不断地new Student，这其中每一次间隔一秒，然后通过viewModel不停的将数据set进去，然后observer观察到，就会通知刷新

package com.example.mvvmtest;

import androidx.appcompat.app.AppCompatActivity;
import androidx.lifecycle.Observer;
import androidx.lifecycle.ViewModelProvider;

import android.os.Bundle;
import android.util.Log;

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

public class MainActivity extends AppCompatActivity {

    private BasePeople basePeople;
    private myViewModel viewModel;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //在onCreate绑定
        basePeople = new BasePeople(this);
        getLifecycle().addObserver(basePeople);

        viewModel = new ViewModelProvider(this).get(myViewModel.class);
        viewModel.getStudentList().observe(this, new Observer<List<Student>>() {
            @Override
            public void onChanged(List<Student> students) {
                Log.e("len.hu","students.size>>>"+students.size());
            }
        });

        new Thread(new Runnable() {
            @Override
            public void run() {
                List<Student> studentList = new ArrayList<>();
                for (int i = 0; i < 10; i++) {
                    Student student = new Student();
                    studentList.add(student);
                    viewModel.setData(studentList);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        getLifecycle().removeObserver(basePeople);
    }
}

3.运行的结果

上面这个是在Activity中，viewModel结合LiveData实现数据交互的小例子。

viewModel = new ViewModelProvider(this).get(myViewModel.class);

注意：在Activity中获得viewModel用
viewModel = new ViewModelProvider(this).get(myViewModel.class);注意这个this，在Fragment中同样使用的是Activity。（使用getActivity）

3.DataBinding

这个东西不打算详细说，首先第一点DataBinding都知道是用来实现数据UI之前绑定的，虽然说是比较方便，自动感知数据的变化，但是对于命名，绑定的耦合度，尤其是双向绑定，第二点是以目前的项目经验来看，实际使用并不是特别的多。

暂时先记录这些，后续再补充吧