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
网友评论