Jetpack架构组件库

前言

三种架构模式区别

MVC（Model-View-Controller）

MVC将应用抽象为数据层（Model）、视图（View）、逻辑（Controller） ，这样数据、视图、逻辑的代码各自汇聚。

MVC的目的就是将M和V的代码分离，且MVC是单向通信，必须通过Controller来承上启下。

问题：但是在MVC模式中，Model和View可能有耦合

MVP（Model-View-Presenter）

在MVC框架中，View层可以通过访问Model层来更新，但在MVP框架中，View层不能再直接访问Model层，必须通过Presenter层提供的接口，然后Presenter层再去访问Model层。各部分之间的通信是双向。

问题：Presenter的负担很重，Presenter需要知道View和Model的结构，并且在Model变化时候需要手动操作View，增加编码负担，降低代码维护性。

MVVM（Model-View-ViewModel）

MVVM设计了VM层，即ViewModel层，ViewModel自动同步数据到视图，用VM代替P之后，MVVM自动从Model映射到View（实现方式是模板渲染），不需要用户手动操作视图。

一，了解Jetpack

Jetpack是众多优秀组件的集合。是谷歌推出的一套引领Android开发者逐渐统一开发规范的架构。

Jetpack的优势

基于生命周期感知的能力，可以减少崩溃,，内存泄露，模板代码。为我们开发出健壮且高质量的程序提供保障。
组件可以单独使用，也可以搭配使用，搭配Kotlin语言特性可进一步加速开发。

二，Jetpack组件库介绍

1，Navigation

• 特性：Activity，Fragment，Dialog提供路由能力的组件，导航时可携带参数，指定转场动画，支持deepline页面直达，fragment回退栈管理能力。
• 不足：十分依赖xml文件，不利于模块化，组件化开发。

添加依赖

api "android.arch.navigation:navigation-fragment:2.0.0"
api "android.arch.navigation:navigation-ui:2.0.0"
1
2

路由跳转，可携带参数，指定转场动画

NavController navController；
navControll.navigate(int resId，Bundle args，NavOptions navOptions)
1
2

deepLink实现页面直达能力

navController.handleDeepLink("/detail/main")
1

管理Fragment回退栈

navController.popBackStack(int destinationId,boolean inclusive)
1

2，Lifecycle:具备宿主声明后期感知能力的组件

特性：它持有组件（如Activity或Fragment）生命周期状态的信息，并且允许其他对象观察此状态。

添加依赖

api "androidx.appcompat:appcompat:1.3.0"
api "androidx.lifecycle:lifecycle-common:2.3.1"
1
2

Fragment源码，经典用法

public class Fragment implements xxx,LifecycleOwner{
   LifecycleRegistry mLifecycleRegistry=new LifecycleRegistry(this);
   @Override
   public Lifecycle getLifecycle(){
          return mLifecycleRegistry;
   }
   class MyPresenter extends LifecycleObserver{
        @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
        ovid onCreate(@NotNull LifecycleOwner owner){}
        
        @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
        ovid onCreate(@NotNull LifecycleOwner owner){}
   }
}

getLifecycle().addObserver(mPresenter);//注册观察者,观察者宿主声明周期状态变化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3，ViewModel:具备生命周期感知能力的数据存储组件

特性：页面配置更改数据不丢失，生命周期感应，数据共享

api "androidx.appcompat:appcompat:1.3.0"
api "androidx.lifecycle:lifecycle-viewmodel:2.3.1"
api "androidx.lifecycle:lifecycle-livedata:2.3.1"
1
2
3

ViewModel的使用

class MyViewModel extends ViewModel {
    @Override
    protected void onCleared() {
        super.onCleared();
        //宿主销毁时执行，可自我清理释放资源
    }

    MutableLiveData<ItemData> liveData = new MutableLiveData<>();
    public void getItemData(LifecycleOwner owner, Observer<ItemData> observer) {
        liveData.observe(owner, observer);
        liveData.setValue(itemData);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

ViewModel数据共享

//构建ViewModel实力，需要使用ViewModelProvider来获取ViewModeld对象。
//不同Fragment中获取同一个ViewModel实力，实现数据共享。
class FragmentA extends Fragment {
    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        MyViewModel myViewModel = new ViewModelProvider(getActivity().getViewModelStore(),
                new ViewModelProvider.NewInstanceFactory())
                .get(MyViewModel.class);
    }
}
1
2
3
4
5
6
7
8
9
10
11

4，LiveData:具备生命周期感知能力的数据订阅，分发组件

• 特性：支持共享资源，支持黏性事件的分发，不再需要手动处理生命周期，确保界面符合数据状态。
• 不足：黏性事件不支持取消。

    MutableLiveData<T> liveData=new MutableLiveData<T>()
    //注册一个跟宿主生命周期绑定的观察者，宿主销毁，会自动接触注册
    observe(LifecycleOwner owner, Observer<? super T> observer)
    //观察不到宿主生命周期，不会自动解除
    observeForever(Observer<? super observer>)
    
    //分发数据 只能用在主线程
    setValue(T value);
    //分发数据 子线程 主线程都可以使用
    postValue(T value)
1
2
3
4
5
6
7
8
9
10

5，Room:轻量级orm数据库，本质上是一个SQLite抽象层

特性：使用更加简单，通过注解的方式实现相关功能。编译时自动生成实现类impl

api "android.arch.persistence.room:runtime:1.1.1"
kapt "android.arch.persistence.room:compiler:1.1.1"
1
2

Room使用

//创建操作数据库的实体层
@Dao
public interface UserDao{
   @Query("SELECT * FROM user")
   List<User> getAll();
   @update("update table user set desc=:desc and where user_id = :userId")
   User updateUser(String desc,String userId);
   @Insert
   void insertAll(User...users);
   @Delete
   void delete(User user);
}
1
2
3
4
5
6
7
8
9
10
11
12

//创建数据库
@Database(entities={User.class,version=1})
public abstract class MyDatabase extends RoomDatabase{
    public static MyDatabase myDatabase;
    static{
      myDatabase=Room.databaseBuilder(getApplicationContext(),AppDatabase.class,"database-name").build();
    }
    public abstract UserDao userDao();
}

//通过数据库单例对象，获取userDao数据操作对象
myDatabase.userDao().getAll();
1
2
3
4
5
6
7
8
9
10
11
12

6，DataBinding:dataBinding只是一种工具，它解决的是View和数据之间的双向绑定。MVVM是一种架构模式

特性：数据与视图双向绑定，数据绑定空安全，减少模板代码，释放Activity/Fragment

使用DataBinding

android{
     dataBinding{
        enabled=true
     }
}
1
2
3
4
5

布局中绑定数据

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android"
    <data>
      <variable name="user" type="com.test.app.model.User"/>
      <import type="com.test.app.user.UserManager"></import>
    </data>
    <androidx.constraintlayout.widget.ConstraintLayout>
        <TextView 
            android:layout_width="200dp"//不能使用dataBinding动态绑定
            android:text="@{user.name}"//单向绑定数据变更自动通知UI
            android:testSize="@{dimen/16sp}"//资源引用
            android:text="@{user.name+@string/suffix}"//字符串的拼接需要引用资源
            android:test="@{UserManager.getUserName()}"//调用静态方法，类必须先导入
            android:onClick="@{()->UserManager.login()}"
        />
        <EditText
            //双向绑定数据变更自动更新UI，UI变更了也能自动更新user中的name数据
            android:text="@={user.name}"
        />
    </androidx.constraintlayout.widget.ConstraintLayout>
</layout>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

7，WorkManager:新一代后台任务管理组件，功能十分丰富。service能做的事情它也能做。

支持周期性任务调度，链式任务调度，丰富的任务约束条件，即便程序退出，依旧能保证任务的执行

api "android.arch.work:work-runtime:1.0.1"
1

执行任务

//构建任务
class UploadFileWorker extends Worker{
     //执行文件上传
     public Result doWork(){
         return Result.success()
     }
}
//执行任务的request对象
OneTimeWorkRequest request=new OneTimeWorkRequest.Builder(UploadFileWorker.class).build()
//把任务加入调度队列
WorkContinuation workContinuation=WorkManager.getInstance(context).beginWith(request)
workContinuation.then(workB).then(workC).enqueue()
1
2
3
4
5
6
7
8
9
10
11
12

8，Paging:列表分页组件，可以轻松完成分页预加载已达到无限滑动的效果

特性：巧妙融合LiveData，提供多种数据源加载方式
不足：不支持列表数据增删改。列表添加HeaderView，FooterView定位不准确。

api “android.arch.paging:runtime:1.0.1”

//1 使用PagedList.Config对象，用以声明以何种方式分页
PagedList.Config config=new PagedList.Config.Builder()
.setPageSize(10)//指定每次分页加载的条目数量
.setInitialLoadSizeHint(12)//指定初始化数据加载的条目数量
.build();
//2 创建数据源工厂类，用来创建数据提供者
DataSource.Factory factory=new DataSource.Factory(){
       public DataSource create(){
          return new ItemKeyedDataSource();
       }
};
//3 构建一个能够触发加载页面初始化数据的LiveData对象，并且把上面创建的DataSource.Factory和PagedList
LiveData<PagedList<T>> pageData=new LivePagedListBuilder(factory,config).build();
//4 拿到构建出来的LiveData对象注册一个Observer观察者，触发页面数据变化
mViewModel.getPageData().observe(this,pagedList->submitList(pagedList));

class MyItemKeyedDataSource extends ItemKeyedDataSource<GoodsModel>{
    
    public abstract void loadInitial  省略....{
        //页面数据加载
        callback.onResult(list)
    }
      public abstract void loadAfter  省略....{
        //向后分页数据加载
        callback.onResult(list)
    }
      public abstract void loadBefore  省略....{
        //向前页面数据加载
        callback.onResult(list)
    }
}
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
29
30
31

三，使用Jetpack架构开发模式

四，Lifecycle源码分析

1，Lifecycle的使用

使用1

//1.自定义的LifecycleObserver观察者，用注解声明每个方法观察的宿主状态
//用注解的方式给方法添加对应的事件
public class LocationObserver  implements LifecycleObserver{
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    void onStart(LifecycleOwner owner){
        //开启定位
    }
    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    void onStop(LifecycleOwner owner){
         //停止定位
    }
}
//2. 注册观察者 观察宿主生命周期状态变化
public class LocationFragment extends Fragment{
     @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        LocationObserver  observer=new LocationObserver();
        getLifecycle().addObserver(observer);
     }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

使用2

public interface FullLifecycleObserver extends LifecycleObserver {
    void onCreate(LifecycleOwner owner);
    void onStart(LifecycleOwner owner);
    void onResume(LifecycleOwner owner);
    void onPause(LifecycleOwner owner);
    void onStop(LifecycleOwner owner);
    void onDestroy(LifecycleOwner owner);
}
class LocationObserver extends FullLifecycleObserver{
    void onStart(LifecycleOwner owner){}
    void onStop(LifecycleOwner owner){}
}
1
2
3
4
5
6
7
8
9
10
11
12

使用3

public interface LifecycleEventObserver extends LifecycleObserver {
    /**
     * Called when a state transition event happens.
     *
     * @param source The source of the event
     * @param event The event
     */
    void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}

public class LocationObserver implements LifecycleEventObserver {
    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
        //监听宿主生命周期状态
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2，Lifecycle在Fragment源码中的实现

//Fragment源码中部分片段
//Fragment实现了LifecycleOwner注册到LifecycleRegistry 在各个生命周期中调用handleLifecycleEvent
public class Fragment implements LifecycleOwner{
    LifecycleRegistry mLifecycleRegistry=new LifecycleRegistry(this);
    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
    void onCreate(){
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
    }
    void performStart(){
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
    }
    void performResume(){
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
    }
    ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Fragment源码中涉及到了三个类LifecycleOwner，Lifecycle，LifecycleRegistry，它们三者的关系如下图：
3，Lifecycle在ComponentActivity源码中的实现

//ComponentActivity 源码中部分片段
public class ComponentActivity implements LifecycleOwner{
    LifecycleRegistry mLifecycleRegistry=new LifecycleRegistry(this);
    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
   protected void onCreate(Bundle bundle){
        super.onCreate(bundle);
        //往Activity上添加一个fragment,用以报告生命周期的变化
        //目的是为了兼顾不是继承自AppCompactActivity的场景
        ReportFragment.injectIfNeededIn(this);
      
    }

}

//ReportFragment 代码片段
public class ReportFragment extends Fragment {
    private static final String REPORT_FRAGMENT_TAG = "androidx.lifecycle"
            + ".LifecycleDispatcher.report_fragment_tag";

    public static void injectIfNeededIn(Activity activity) {
        // ProcessLifecycleOwner should always correctly work and some activities may not extend
        // FragmentActivity from support lib, so we use framework fragments for activities
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            // Hopefully, we are the first to make a transaction.
            manager.executePendingTransactions();
        }
    }
     @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        dispatchCreate(mProcessListener);
        dispatch(Lifecycle.Event.ON_CREATE);
    }

    @Override
    public void onStart() {
        super.onStart();
        dispatchStart(mProcessListener);
        dispatch(Lifecycle.Event.ON_START);
    }
    private void dispatch(Lifecycle.Event event) {
        Activity activity = getActivity();
        if (activity instanceof LifecycleRegistryOwner) {
            ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
            return;
        }

        if (activity instanceof LifecycleOwner) {
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) {
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }
 }
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

从ComponentActivity 源码中可以看出LifecycleRegistry并没有在各个生命周期中去分发事件，而是通过ReportFragment 去实现，目的是为了兼顾不是继承自ComponentActivity 的场景。

如果继承了Activity自己实现了Lifecycle，这时会有个类LifecycleDispatcher，在此类DispatcherActivityCallback中又看到了ReportFragment的身影。

这就说明，如果没有继承ComponentActivity ，只要实现了LifecycleOwner接口，也能感知生命周期变化。

class LifecycleDispatcher {

    private static AtomicBoolean sInitialized = new AtomicBoolean(false);

    static void init(Context context) {
        if (sInitialized.getAndSet(true)) {
            return;
        }
        ((Application) context.getApplicationContext())
                .registerActivityLifecycleCallbacks(new DispatcherActivityCallback());
    }

    @SuppressWarnings("WeakerAccess")
    @VisibleForTesting
    static class DispatcherActivityCallback extends EmptyActivityLifecycleCallbacks {

        @Override
        public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
            ReportFragment.injectIfNeededIn(activity);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

4，LifecycleRegistry 源码分析

addObserver方法分析

   @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        //注释1 State 
        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

        if (previous != null) {
            return;
        }
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            // it is null we should be destroyed. Fallback quickly
            return;
        }

        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
        State targetState = calculateTargetState(observer);
        mAddingObserverCounter++;
        //注释2 while 循环
        while ((statefulObserver.mState.compareTo(targetState) < 0
                && mObserverMap.contains(observer))) {
            pushParentState(statefulObserver.mState);
            statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
            popParentState();
            // mState / subling may have been changed recalculate
            targetState = calculateTargetState(observer);
        }

        if (!isReentrance) {
            // we do sync only on the top level.
            sync();
        }
        mAddingObserverCounter--;
    }
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
29
30
31
32
33
34
35

注释1 State ： 当前宿主的状态，并不是宿主的生命周期状态。两者的关系如下图：
对于两者的状态又是怎么通过代码实现的呢，我们主要来分析一下while中的代码。

注释2 while 循环：
while用到的几个关键方法：

• calculateTargetState()：计算observer应该到达的状态，也就是当前宿主的状态。
• upEvent()：根据当前观察者的状态，判断应该接受哪个事件。
• getStateAfter()：根据分发的事件，判断当前观察者的状态。

while循环代码中的逻辑处理，是让观察者收到宿主完整的生命周期状态。例如：宿主在onResume生命周期注册一个observer，需要把宿主的onCreate，onStart，onResume都分发给observer。

再来看LifecycleRegistry 中的sync方法，用于同步生命周期状态。

 private void sync() {
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
                    + "garbage collected. It is too late to change lifecycle state.");
        }
        while (!isSynced()) {
            mNewEventOccurred = false;
            // no need to check eldest for nullability, because isSynced does it for us.
            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
                backwardPass(lifecycleOwner);
            }
            Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
            if (!mNewEventOccurred && newest != null
                    && mState.compareTo(newest.getValue().mState) > 0) {
                forwardPass(lifecycleOwner);
            }
        }
        mNewEventOccurred = false;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

状态分发如何区分观察者类型，也就是如何区分LifecycleObserver ，FullLifecycleObserver ，LifecycleEventObserver 。

  static class ObserverWithState {
        State mState;
        LifecycleEventObserver mLifecycleObserver;

        ObserverWithState(LifecycleObserver observer, State initialState) {
            mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
            mState = initialState;
        }

        void dispatchEvent(LifecycleOwner owner, Event event) {
            State newState = getStateAfter(event);
            mState = min(mState, newState);
            mLifecycleObserver.onStateChanged(owner, event);
            mState = newState;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在Lifecycling类中的方法，在这里进行了类型的区分。

@NonNull
    static LifecycleEventObserver lifecycleEventObserver(Object object) {
        boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
        boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
        if (isLifecycleEventObserver && isFullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                    (LifecycleEventObserver) object);
        }
        if (isFullLifecycleObserver) {
            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
        }

        if (isLifecycleEventObserver) {
            return (LifecycleEventObserver) object;
        }

        final Class<?> klass = object.getClass();
        int type = getObserverConstructorType(klass);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

五，LiveData源码分析

概念：LiveData组件是JetPack推出的基于观察者的消息订阅/分发组件，具有宿主（Activity，Fragment）生命周期感知能力，可以确保LiveData仅分发消息给处于活跃状态的观察者，即只有处于活跃状态的观察者才能收到消息。

1，基础介绍

LiveData简单使用

//1.注册观察者
 liveData.observer(this,new Observer<User>{
     void onChanged(User user){
     }
 })
 //2.发送消息
 liveData.postValue(data);
1
2
3
4
5
6
7

MutableLiveData： 在使用LiveData做消息分发的时候，需要使用此类。只有拿到MutableLiveData对象才可以发送消息，LiveData对象只能接收消息，避免拿到LiveData对象既能发消息也能收消息。

public class MutableLiveData<T> extends LiveData<T> {
    public MutableLiveData(T value) {
        super(value);
    }
    public MutableLiveData() {
        super();
    }

    @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
13
14
15
16
17
18

MediatorLiveData： 可以统一观察多个LiveData发射的数据进行统一处理，同时也可以做为一个liveData，被其他observer观察。

//创建两个LiveData对象
LiveData<String> liveData1=new MutableLiveData();
LiveData<String> liveData2=new MutableLiveData();

//创建一个聚合类MediatorLiveData
MediatorLiveData<String> liveDataMerger=new MediatorLiveData<>();
liveDataMerger.addSource(liveData1,observer);
liveDataMerger.addSource(liveData2,observer);

Observer observer=new Observer<String>(){
  @Override
  public void onChanged(String string){
      
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Transformations.map操作符： 可以对liveData进行变化，返回一个新的liveData对象。

MutableLiveData<Integer> liveData=new MutableLiveData();
//数据转换
LiveData<Integer> transformData=Transformations.map(data,input -> String.valueOf(input))
//使用转换后的transformData去观察数据
transformData.observe(this,output ->{

});

//发送数据
liveData.setValue(10);
1
2
3
4
5
6
7
8
9
10

LiveData核心方法

2，LiveData消息分发原理

黏性消息分发流程

普通消息分发流程
LiveData源码中的observe方法：

    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        assertMainThread("observe");
        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);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

LifecycleBoundObserver源码，LifecycleBoundObserver实现了LifecycleEventObserver接口。在onStateChanged方法中，首先会判断当前宿主生命周期状态，如果是DESTROYED会移除当前消息。

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

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

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

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

    }
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
29
30
31

再看considerNotify方法中的mLastVersion 和mVersion。mLastVersion 和mVersion默认值都是-1。当调用setValue方法时mVersion会加1，这时mVersion就大于mLastVersion ，从而执行onChanged方法。

 private void considerNotify(ObserverWrapper observer) {
        if (!observer.mActive) {
            return;
        }
        if (!observer.shouldBeActive()) {
            observer.activeStateChanged(false);
            return;
        }
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        observer.mLastVersion = mVersion;
        observer.mObserver.onChanged((T) mData);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

基于LiveData的改造

在源码中，我们知道在LiveData和Observer中有个version字段，当发送一条消息，和接收一条消息，通过version判断，以免消息重复发送。但是如果是黏性事件，先发送消息，后注册事件，那么就会有问题。

那么我们基于LiveData来实现一个不用反注册，且支持黏性事件的消息总线。

object HiDataBus {
    private val eventMap = ConcurrentHashMap<String, StickyLiveData<*>>()
    fun <T> with(eventName: String): StickyLiveData<T> {

        var liveData = eventMap[eventName]
        if (liveData == null) {
            liveData = StickyLiveData<T>(eventName)
            eventMap[eventName] = liveData
        }
        return liveData as StickyLiveData<T>
    }

    class StickyLiveData<T>(private val eventName: String) : LiveData<T>() {
        var mStickyData: T? = null
        var mVersion = 0
        fun setStickyData(stickyData: T) {
            mStickyData = stickyData
            setValue(stickyData)
        }

        fun postStickyData(stickyData: T) {
            mStickyData = stickyData
            postValue(stickyData)
        }

        override fun setValue(value: T) {
            mVersion++
            super.setValue(value)
        }

        override fun postValue(value: T) {
            mVersion++
            super.postValue(value)
        }

        override fun observe(owner: LifecycleOwner, observer: Observer<in T>) {
            observerSticky(owner, false, observer)
        }

        private fun observerSticky(
            owner: LifecycleOwner,
            sticky: Boolean,
            observer: Observer<in T>
        ) {
            owner.lifecycle.addObserver(LifecycleEventObserver { source, event ->
                if (event == Lifecycle.Event.ON_DESTROY) {
                    eventMap.remove(eventName)
                }
            })
            super.observe(owner, StickyObserver(this, sticky, observer))
        }
    }

    class StickyObserver<T>(
        private val stickyLiveData: StickyLiveData<T>,
        private val sticky: Boolean,
        private val observer: Observer<in T>
    ) : Observer<T> {
        private var lastVersion = stickyLiveData.mVersion
        override fun onChanged(t: T) {
            if (lastVersion >= stickyLiveData.mVersion) {
                if (sticky && stickyLiveData.mStickyData != null) {
                    observer.onChanged(stickyLiveData.mStickyData)
                }
                return
            }
            lastVersion = stickyLiveData.mVersion
            observer.onChanged(t)
        }

    }
}
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

使用方法

 //发送消息
 HiDataBus.with<String>("sticky").setStickyData("hello word")
 //接受消息  sticky=true 可以接收黏性消息
 HiDataBus.with<String>("sticky").observerSticky(this,true, Observer {
      Toast.makeText(this,it,Toast.LENGTH_LONG).show()
 })
1
2
3
4
5
6

六，ViewModel源码分析

概念：ViewModel具备宿主生命周期感知能力，保存数据在页面因配置变更导致页面销毁重建之后依然存在。

1，ViewModel的用法

常规用法： 存储数据，仅仅只能当页面因为配置变更导致的销毁再重建时可复用。复用的是ViewModel的实例对象整体。

class TestViewModel():ViewModel(){
  val liveData=MutableLiveData<List<GoodsModel>>()
  fun loadInitData():LiveData<List<GoodsModel>>{
     if(liveData.value=null){
        val remoteData=fetchDataFromRemote()
        liveData.postValue(remoteData)
     }
     return liveData
  }
}

//通过ViewModelProvider来获取ViewModel对象
val viewModel=ViewModelProvider(this).get(TestViewModel::class.java)
viewModel.loadPageData().observer(this,Observer{
 
})
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

进阶用法： 存储的数据，无论是配置变更，还是内存不足，电量不足等系统原因导致页面被回收再重建，都可以复用。即便ViewModel不是同一个实例，它存储的数据也能做到复用。需要引入savedstate组件。

api 'androidx.lifecycle:lifecycle-viewmodel-savedstate:2.2.0'
1

class TestViewModel(val savedState:SavedStateHandle):ViewModel(){
   private val KEY_HOME_PAGE_DATA="key_home_page_data"
   private val liveData=MutableLiveData<List<GoodsModel>>()
   fun loadInitData():LiveData<List<GoodsModel>>{

      if(liveData.value=null){
          val memoryData=savedState.get<List<GoodsModel>>(KEY_HOME_PAGE_DATA)
          liveData.postValue(memoryData)
          return liveData
      }
      
      val remoteData=fetchDataFromRemote()
      savedState.set(KEY_HOME_PAGE_DATA,remoteData)
      liveData.postValue(remoteData)
   }
   return liveData
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

跨页面数据共享

class MyApp:Application(),ViewModelStoreOwner{
     private val appViewModelStore:ViewModelStore by lazy{
        ViewModelStore()
     }
     override fun getViewModelStore():ViewModelStore{
         return appViewModelStore
     }
}

val viewmodel=ViewProvider(application).get(TestViewModel::class.java)
1
2
3
4
5
6
7
8
9
10

2，配置变更ViewModel复用原理

获取ViewModel实例

al viewModel=ViewModelProvider(this).get(TestViewModel::class.java)
1

在ViewModelProvider存在一个ViewModelStore 类用于存储ViewModel对象。

  public ViewModelProvider(@NonNull ViewModelStore store, @NonNull Factory factory) {
        mFactory = factory;
        mViewModelStore = store;
    }

1
2
3
4
5

get方法获取当前实例，如果实例不存在ViewModelStore， 那么会通过Factory去创建实例。

   public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
        ViewModel viewModel = mViewModelStore.get(key);

        if (modelClass.isInstance(viewModel)) {
            if (mFactory instanceof OnRequeryFactory) {
                ((OnRequeryFactory) mFactory).onRequery(viewModel);
            }
            return (T) viewModel;
        } else {
            //noinspection StatementWithEmptyBody
            if (viewModel != null) {
                // TODO: log a warning.
            }
        }
        if (mFactory instanceof KeyedFactory) {
            viewModel = ((KeyedFactory) mFactory).create(key, modelClass);
        } else {
            viewModel = mFactory.create(modelClass);
        }
        mViewModelStore.put(key, viewModel);
        return (T) viewModel;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在ComponentActivity中获取ViewModelStore 对象

    public ViewModelStore getViewModelStore() {
        if (getApplication() == null) {
            throw new IllegalStateException("Your activity is not yet attached to the "
                    + "Application instance. You can't request ViewModel before onCreate call.");
        }
        if (mViewModelStore == null) {
            NonConfigurationInstances nc =
                    (NonConfigurationInstances) getLastNonConfigurationInstance();
            if (nc != null) {
                // Restore the ViewModelStore from NonConfigurationInstances
                mViewModelStore = nc.viewModelStore;
            }
            if (mViewModelStore == null) {
                mViewModelStore = new ViewModelStore();
            }
        }
        return mViewModelStore;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在ComponentActivity中存储ViewModelStore对象，这里就是关键，通过onRetainNonConfigurationInstance这个方法存储ViewModel对象，从而实现Activity配置变化后对ViewModel的复用。

    public final Object onRetainNonConfigurationInstance() {
        Object custom = onRetainCustomNonConfigurationInstance();

        ViewModelStore viewModelStore = mViewModelStore;
        if (viewModelStore == null) {
            // No one called getViewModelStore(), so see if there was an existing
            // ViewModelStore from our last NonConfigurationInstance
            NonConfigurationInstances nc =
                    (NonConfigurationInstances) getLastNonConfigurationInstance();
            if (nc != null) {
                viewModelStore = nc.viewModelStore;
            }
        }

        if (viewModelStore == null && custom == null) {
            return null;
        }

        NonConfigurationInstances nci = new NonConfigurationInstances();
        nci.custom = custom;
        nci.viewModelStore = viewModelStore;
        return nci;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

ViewModel数据复用savedState组件

• SavedStateHandle的数据存储与恢复。即便ViewModel不是同一个实例，它存储的数据也能做到复用。
• SavedStateRegistryController：用于创建SavedStateRegistry。
• SavedStateRegistry：数据存储和恢复。
• SavedStateHandle：单个ViewModel数据存储和恢复。

SavedStateRegistry模型： 一个总Bundle，key-value存储着每个ViewModel对应字bundle
SavedState数据存储流程： 逐一调用每个SavedStateHandle保存自己的数据。汇总成一个总的Bundle，再存储到Activity的SavedState对象中。

SavedState数据复用流程（1）： 从Activity的saveState恢复所有ViewModel数据到SavedStateRegistry
SavedState数据复用流程（2）： 创建ViewModel并传递恢复的SavedStateHandle

Room搭配LiveData监听数据变更自动刷新页面实现原理

第一次向LiveData注册Observer时触发onActive，从而触发首次数据的懒加载。数据的加载在RefreshRunnable中完成，首次加载数据时会向InvalidationTracker注册监听表数据变更的observer，一旦表数据变更了，则会再次触发RefreshRunnable加载最新数据。

增删改三种操作开始之前会向一张表中写入本次操作的表的成名，并将状态置为1，操作完成后会触发InvalidationTracker.endTranstions。进而查询出所有数据变更了的表。然后回调给每一个RoomTracklingLiveData再次执行refreshRunnable重新加载数据，并发送到UI层的observer刷新页面。

七，面试思维导图

由于面试过程中往往不知道从何数起，这就需要把琐碎的知识点，汇总一下，理解着分步骤去记忆，这样更有条理，也方便复习。