Android Architecture Components的

作者: 进击的小强 | 来源:发表于2018-03-26 00:09 被阅读87次

浅谈Android Architecture Component
Android 开源库之架构组件
Android Jetpack组件系列之Architecture
Room ORM 数据库框架
Android Architecture Components
史上最强总结Android Architecture Compo
Android Architecture Components
Android架构之AAC
2018-03-20
AAC 的 Lifecycle 结合 Kotlin Corout

Android Architecture Components 是一个由Google官方推出的库，它能够帮助你去构建一个健壮，易测，可维护的应用。用于管理UI组件生命周期以及处理数据持久性等问题。

架构原则

应用中的关注点分离。
Activity或Fragment内只处理UI相关逻辑，任何与此无关的代码都不该堆在其内。
也就是类的单一职责化。尽可能保持精简可以避免许多生命周期相关的问题。基于用户交互或其他因素（如低内存），Android系统可能随时销毁它们。最好尽量减少对它们的依赖，以提供好的用户体验。
数据模型驱动 UI
做到数据持久化，这样至少有两个好处：
1.用户不会因为系统销毁我们的应用而导致丢失数据。
2.我们的应用可以在网络状况不好甚至断网的情况下继续工作。

主要模块

包含Lifecycles, LiveData, ViewModel, Room, and Paging.
下面主要讲解一下Lifecycles,LiveData以及ViewModel

Lifecycles

在 android.arch.lifecycle 包中提供了可以构建生命周期感知的组件的类和接口，这些组件可以根据 Activity/Fragment 的生命周期自动调整它的行为。

Lifecycle.jpg
从图中我们可以看到 LifecycleOwner 是 Lifecycle 的持有者，通常是一个 Activity 或 Fragment。想要获取 Lifecycle 只能通过 LifecycleOwner 的 getLifecycle 方法。Lifecycle 是可观察的，它可以持有多个 LifecycleObserver。

Lifecycle：它是一个持有 Activity/Fragment 生命周期状态信息的类，并且允许其他对象观察此状态。Lifecycle 内部维护了两个枚举，一叫 Event，另一个叫 State。Event 是对 Android 组件（Activity 或 Fragment）生命周期函数的映射，当 Android Framework 回调生命周期函数时，Lifecycle 会检查当前事件和上一个事件是否一致，如果不一致，就根据当前事件计算出当前状态，并通知它的观察者（LifecycleObserver）生命状态已经发生变化。观察者收到通知后，通过 Lifecycle 提供的 getCurrentSate 方法来获取刚刚 Lifecycle 计算出来的当前状态，观察者根据这个状态来决定要不要执行某些操作
lifecycle-states.png

LifecycleOwner

LifecycleOwner：是一个具有单一方法的接口。如果一个类实现了此接口，则该类中需要持有一个 Lifecycle 对象，并通过LifecycleOwner#getLifecycle() 方法返回该对象。Support Library 26.1+ 已经集成了此组件。

并不是只有 Activity 和 Fragment 才可以实现 LifecycleOwner 接口的，任何和 Activity/Fragment 生命周期有关系的类都可以实现此接口。通过实现此接口，该类完全是生命周期可感知的，只需要对它进行初始化，它就可以进行自己的初始化和清理操作，而不受其 Activity/Fragment 的管理。详细可以参看官方文档说明：LifecycleOwner 实践

LifecycleObserver
可以使用 Lifecycle 的类被称为生命周期感知组件。（也就是继承实现LifecycleObserver 的类）。

谷歌提倡那些需要和 Android 生命周期协作的类库提供生命周期感知组件，这样客户端代码就可以很容易集成这些类库，而不需要客户端手动管理类库中和 Android 生命周期相关的代码。

class MyObserver implements LifecycleObserver {
    private boolean enabled = false;
    public MyObserver(Context context, Lifecycle lifecycle, Callback callback) {
       ...
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    void start() {
        if (enabled) {
           // connect
        }
    }

    public void enable() {
        enabled = true;
        if (lifecycle.getCurrentState().isAtLeast(STARTED)) {
            // connect if not connected
        }
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    void stop() {
        // disconnect if connected
    }
}

通过注解就可以监听对应的生命周期事件，同时别忘了调用 owner.getLifecycle().addObserver() 把观察者（MyObserver）注册到 Lifecycle.

LiveData

LiveData 是一个 observable 数据的持有类，和普通的 observable 不同，LiveData 是生命周期感知的，意味着它代表其它应用组件譬如 Activity、Fragment、Service 的生命周期。这确保了 LiveData 只会更新处于活跃状态的组件。

LiveData 通过内部类的形式实现了 LifecycleObserver，它整个工作流程大概是这样的：

将实现了 LifecycleObserver 的内部类注册到 owner 的 Lifecycle。
LifecycleObserver 监听了 Lifecycle 所有的生命周期事件
当有生命周期事件发生时，检查 Lifecycle 的状态是否至少是 STARTED 来判断 lifecycle 是否处于活跃状态
当维护的值被改变时，如果 Lifecycle 处于活跃状态，通知观察者(实现了 android.arch.lifecycle.Observer 接口的对象)，否则什么也不做
当 Lifecycle 从非活跃状态恢复到活跃状态时，检查维护的值是否在非活跃期间有更新过，如果有，通知观察者
当 Lifecycle 处于完结状态 DESTROYED 时，从 Lifecycle 中移除 LifecycleObserver。

很显然，LiveData 是响应式的，令人惊艳的是，它有效解决了后台回调和 Android 生命周期的上古谜题。

LiveData 使用起来是这样的：

public class NameViewModel extends ViewModel {

// Create a LiveData with a String
private MutableLiveData<String> mCurrentName;

    public MutableLiveData<String> getCurrentName() {
        if (mCurrentName == null) {
            mCurrentName = new MutableLiveData<String>();
        }
        return mCurrentName;
    }

// Rest of the ViewModel...
}

现在，Activity 可以访问这个列表如下：

public class MyActivity extends AppCompatActivity {
    public void onCreate(Bundle savedInstanceState) {
        MyViewModel model = ViewModelProviders.of(this).get(MyViewModel.class);
        model.getUsers().observe(this, users -> {
            // update UI
        });
    }
}

它还提供了 Transformations 来帮助我们转换 LiveData 所持有的数据。

Transformations.map()
在LiveData数据的改变传递到观察者之前，在数据上应用一个方法：

LiveData<User> userLiveData = ...;
LiveData<String> userName = Transformations.map(userLiveData, user -> {
    user.name + " " + user.lastName
});

Transformations.switchMap()
与Transformations.map()类似，只不过这里传递个switchMap()的方法必须返回一个LiveData对象。

private LiveData<User> getUser(String id) {
  ...;
}

LiveData<String> userId = ...;
LiveData<User> user = Transformations.switchMap(userId, id -> getUser(id) );

ViewModel

看到 ViewModel 这个词，就会让人想起 MVVM，ViewModel 正是 MVVM 架构里面的一个重要角色。

MVVM 按职责把类分为三种角色，分别是 View，ViewModel，Model。ViewModel 正好处于中间，是连接 View 和 Model 的桥梁。

View 只做两件事情，一件是根据 ViewModel 中存储的状态渲染界面，另外一件是将用户操作转发给 ViewModel。用一个公式来表述是这样的：view = render(state) + handle(event)。
ViewModel 也只做两件事。一方面提供 observable properties 给 View 观察，一方面提供 functions 给 View 调用，通常会导致 observable properties 的改变，以及带来一些额外状态。observable properties 是指 LiveData、Observable(RxJava) 这种可观察属性。View 正是订阅了这些属性，实现模型驱动视图。functions 是指可以用来响应用户操作的方法或其它对象，ViewModel 不会也不应该自己处理业务，它通过 functions 把业务逻辑的处理委派给 Model。用一个公式来表述是这样的：viewmodel = observable properties + functions。
Model 是整个应用的核心。它包含数据以及业务逻辑，网络访问、数据持久化都是它的职责。用一个公式来表述是这样的：model = data + state + business logic。

在 Android 中，View 包含 Activity 和 Fragment，由于 Activity 和 Fragment 可以销毁后重建，因此要求 ViewModel 在这个过程中能够存活下来，并绑定到新的 Activity 或 Fragment。架构组件提供了 ViewModel 来帮我们实现这点。

ViewModel的生命周期跟着传递给ViewModelProvider的LifeCycle走，当生成了ViewModel的实例后，它会一直待在内存中，直到对应的LifeCycle彻底结束。下面是ViewModel与Activity对应的生命周期图：

viewmodel-lifecycle.png

ViewModel将数据从UI中分离出来。并且当Activity或Fragment重构的时候，ViewModel会自动保留之前的数据并给新的Activity或Fragment使用。

public class MyViewModel extends ViewModel {
    private MutableLiveData<List<User>> users;
    public LiveData<List<User>> getUsers() {
        if (users == null) {
            users = new MutableLiveData<List<Users>>();
            loadUsers();
        }
        return users;
    }

    private void loadUsers() {
        // Do an asynchronous operation to fetch users.
    }
}

接着在我们的Activity中就能这样使用了：

public class MyActivity extends AppCompatActivity {
    public void onCreate(Bundle savedInstanceState) {
        // Create a ViewModel the first time the system calls an activity's onCreate() method.
        // Re-created activities receive the same MyViewModel instance created by the first activity.

        MyViewModel model = ViewModelProviders.of(this).get(MyViewModel.class);
        model.getUsers().observe(this, users -> {
            // update UI
        });
    }
}

当 Activity 或 Fragment 真正 finish 的时候，框架会调用 ViewModel 中的 onCleared 方法，在这个方法里面清除不再使用的资源。

如果 ViewModel需要 Application上下文，例如查找系统服务，则可以扩展 AndroidViewModel 该类并在构造函数中接收Application 。

Fragment之间的数据共享
在Activity中包好多个Fragment并且需要相互通信是非常常见的，这时就需要这些Fragment定义一些接口，然后让Activity来进行协调。
上面这个问题可以被ViewModel轻易解决，假设有这么一个Activity，它包含FragmentA和FragmentB，其中A是用户列表，B是用户的详细数据，点击列表上的某个用户，在B中显示相应的数据。如以下示例代码所示：

public class SharedViewModel extends ViewModel {
    private final MutableLiveData<Item> selected = new MutableLiveData<Item>();

    public void select(Item item) {
        selected.setValue(item);
    }

    public LiveData<Item> getSelected() {
        return selected;
    }
}

public class MasterFragment extends Fragment {
    private SharedViewModel model;
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class);
        itemSelector.setOnClickListener(item -> {
            model.select(item);
        });
    }
}

public class DetailFragment extends Fragment {
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        SharedViewModel model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class);
        model.getSelected().observe(this, { item ->
           // Update the UI.
        });
    }
}

这里要注意的是两个Fragment都使用了getActivity作为参数来获得ViewModel实例。这表示这两个Fragment获得的ViewModel对象是同一个SharedViewModel。

使用了ViewModel的好处如下：

Activity不需要做任何事情，不需要干涉这两个Fragment之间的通信。
Fragment不需要互相知道，即使一个消失不可见，另一个也能很好的工作。
Fragment有自己的生命周期，它们之间互不干扰，即便你用一个FragmentC替代了B，FragmentA也能正常工作，没有任何问题。

参考：
https://developer.android.com/topic/libraries/architecture/guide.html
https://developer.android.com/topic/libraries/architecture/lifecycle.html
https://developer.android.com/topic/libraries/architecture/livedata.html
https://developer.android.com/topic/libraries/architecture/viewmodel.html
https://listenzz.github.io/android-lifecyle-works-perfectly-with-rxjava.html
http://www.cnblogs.com/zqlxtt/p/6888507.html

浅谈Android Architecture Component
浅谈Android Architecture Components 浅谈Android Architecture ...
Android 开源库之架构组件
Android Architecture Components Android Architecture Comp...
Android Jetpack组件系列之Architecture
Android Jetpack组件系列之Architecture Components Architecture ...
Room ORM 数据库框架
Room Persistence Library Android Architecture Components ...
Android Architecture Components
一、前言 1.1、Android Architecture Components 介绍 Android Archi...
史上最强总结Android Architecture Compo
一、前言 1.1、Android Architecture Components 介绍 Android Archi...
Android Architecture Components
本文仅是阅读Android Architecture Components的个人总结。 Android App开发...
Android架构之AAC
一、AAC简介 AAC全称Android Architecture Components，是Android官方推出...
2018-03-20
Android Architecture Components 架构组件官方示例 GithubBrowserSam...
AAC 的 Lifecycle 结合 Kotlin Corout
一. Lifecycle 目前，AAC(Android Architecture Components简称) 已...