Android Jetpack 架构组件

image

架构原则

关注分离点

要遵循的最重要的原则是分离关注点。一种常见的错误是在一个 Activity 或 Fragment 中编写所有代码。这些基于界面的类应仅包含处理界面和操作系统交互的逻辑。应尽可能使这些类保持精简，这样可以避免许多与生命周期相关的问题。

请注意，您并不拥有 Activity 和 Fragment 的实现，这些只是表示 Android 操作系统与应用之间关系的粘合类。操作系统可能会根据用户交互或因内存不足等系统条件随时销毁它们。为了提供令人满意的用户体验和更易于管理的应用维护体验，最好尽量减少对它们的依赖。

通过模型驱动界面

另一个重要原则是您应该通过模型驱动界面，最好是持久性模型。模型是负责处理应用数据的组件。它们独立于应用中的 View 对象和应用组件，因此不受应用的生命周期以及相关关注点的影响。

持久性是理想之选，原因如下：

如果 Android 操作系统销毁应用以释放资源，用户不会丢失数据。
当网络连接不稳定或不可用时，应用会继续工作。
应用所基于的模型类应明确定义数据管理职责，这样将使应用更可测试且更一致。

以上内容在摘自Google官方文档：应用架构指南

本文主要内容

Lifecycle : 管理您的 Activity 和 Fragment 生命周期

ViewModel : 以注重生命周期的方式管理界面相关的数据

LiveData : 在底层数据更改时通知视图

Lifecycle

生命周期管理（Lifecycles）组件，帮助开发者创建 “可感知生命周期的” 组件，让其自己管理自己的生命周期，从而减少内存泄露和崩溃的可能性。
android.arch.lifecycle组件提供一系列接口让开发者很容易自定义可监听生命周期的组件——根据生命周期组件的状态改变自定义组件的行为！

自定义LifecycleObserver

继承LifecycleObserver，通过注解自定义方法接收生命周期变更事件

注意这种方式被注解的方法最多可以有两个参数，并且需准守以下规则：

空参数 ()
一个参数(LifecycleOwer ower)
两个参数(LifecycleOwer ower， Lifecycle.Event event)，对应注解Lifecycle.Event.ON_ANY

例如给以下位置服务组件，添加响应生命周期组件事件

class LocationService implements LifecycleObserver{

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void start() {
        // do get location
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void stop(LifecycleOwer ower) {
        // do stop get location
    }
    
    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    public void onAny(LifecycleOwer ower, Lifecycle.Event event) {
        // do something
    }

    public void addListener(LocationListener listener) {
    }
}

创建Lifecycle对象，监听Lifecycle

public class MyActivity extends Activity implements LifecycleOwner {
    private LifecycleRegistry lifecycleRegistry;
    private LocationService locationService;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        lifecycleRegistry = new LifecycleRegistry(this);
        lifecycleRegistry.markState(Lifecycle.State.CREATED);
        
        locationService = new LocationService();
        getLifecycle().addObserver(locationService);
    }

    @Override
    public void onStart() {
        super.onStart();
        lifecycleRegistry.markState(Lifecycle.State.STARTED);
    }
    
    @Override
    public void onResume() {
        super.onResume();
        lifecycleRegistry.markState(Lifecycle.State.RESUMED);
    }
    
    // ...省略其他生命周期方法...

    @Override
    public Lifecycle getLifecycle() {
        return lifecycleRegistry;
    }
}

如果使用java8 则继承DefaultLifecycleObserver，并且添加依赖

 class TestObserver implements DefaultLifecycleObserver {
 *     Override
 *     public void onCreate(LifecycleOwner owner) {
 *         // your code
 *     }
 * }

implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

Activity生命周期对应 Lifecycle 状态

image

ViewModel

主要特点

帮助UI Controller准备数据给View展示，将数据获取从UI Controller分离出来
在横竖屏切换时数据不会被销毁
ViewModel独立于View和LifecycleOwner，便于测试
可以在不同Fragment中共享数据

ViewModel的生命周期

image

使用Demo

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

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

public class MyActivity extends AppCompatActivity {
    public void onCreate(Bundle savedInstanceState) {
        
        // 在第一次调用onCreate()时创建ViewModel
        // 重复调用onCreate()会获取到第一次创建的ViewModel
        MyViewModel model = ViewModelProviders.of(this).get(MyViewModel.class);
        model.getUsers().observe(this, users -> {
            // update UI
        });
    }
}

在同一个Activity中的Fragment之间共享ViewModel

有以下好处

不用在Activity里协调Fragment之间的数据
Fragment不用关心其他Fragment跟ViewModel之间的关系
每个Fragment都有自己的生命周期，不会受到其他Fragment的影响

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.
        });
    }
}

使用ViewModle替换Loaders

主要目的在于将数据获取从UI Controller中分离出来，让ViewModel持有数据(Model)

LiveData

是一种可观察的数据存储器。应用中的其他组件可以使用此存储器来监控对象的更改，而无需在它们之间创建明确且严格的依赖路径。LiveData 组件还遵循应用组件（如 Activity、Fragment 和 Service）的生命周期状态，并包括清理逻辑以防止对象泄漏和过多的内存消耗。

LiveData的优势

典型的观察者模式，保证UI展示跟数据同步
不用担心内存泄露，LiveData会在lifecycle生命周期结束时自动清理，不用手动remove观察者（observeForever()除外，需要手动调用removeObserver()方法移除）
不会因为Activity stoped而crash，LiveData会监听Activity的状态，在inactive状态时不会给组件发送事件
不用手动管理生命周期
总是会刷新数据（比如Activity在后台，这时数据更新了，当Activity回到前台时会接收到数据更新事件）
横竖屏切换时也会触发数据更新事件
共享数据，你可以使用单例模式实现自己的LiveData，不同的组件可以监听它达到数据共享的目的

使用方法

LiveData<T>是一个泛型类，通常结合ViewModel使用（ViewModel的目的是将数据和UI Controller组件分离），例如：

public class NameViewModel extends ViewModel {
    // Create a LiveData with a String
    private MutableLiveData<String> currentName;

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

通常在onCreate方法里添加观察者

不要在onResume()方法中重复添加
再者可以保证数据及时被显示出来

public class NameActivity extends AppCompatActivity {
    private NameViewModel model;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        model = ViewModelProviders.of(this).get(NameViewModel.class);
        final Observer<String> nameObserver = new Observer<String>() {
            @Override
            public void onChanged(@Nullable final String newName) {
                // Update the UI, in this case, a TextView.
                nameTextView.setText(newName);
            }
        };
        // Observe the LiveData, passing in this activity as the LifecycleOwner and the observer.
        model.getCurrentName().observe(this, nameObserver);
    }
}

在调用observe()方法之后，且LiveData有设置初始化数据，如果Activity是active状态，onChanged方法会立刻回调，或者当Activity状态改变为active状态时回调

使用LiveData来更新UI的好处

防止Fragment或Activity过于臃肿，他们的职责是用来展示数据，但不持有数据
将LiveData从UI Controller中分离，这样可以使得在configuration变更时数据不被销毁（所以一般将LiveData放在ViewModel对象里面使用，因为ViewModel独立于UI Controller）

更新数据

// 主线程回调
public void postValue(T value)

// 当前线程回调
public void setValue(T value)

自定义LiveData

主要重载下面三个方法：

onActive() 当LiveData有一个观察者处于active状态时回调
onInactive() 当所有观察者处于inactive状态时回调
setValue(T value) 设置数据并给对应处于active状态的观察者发送通知
例如下面获取地理位置信息LocationLiveData

public class LocationLiveData extends LiveData<Location> {
    // 地理位置服务
    private LocationService locationService = new LocationService();

    public LocationLiveData() {
        locationService.addListener(new LocationListener() {
            public void onLocation(Location location) {
                setValue(location);
            }
        });
    }

    @Override
    protected void onActive() {
        // 当有活跃状态观察者时开启地理位置获取
        locationService.start();
    }

    @Override
    protected void onInactive() {
        // 当有没有活跃状态观察者时开启地理位置获取
        locationService.stop();
    }
}

LiveData变换

public static <X, Y> LiveData<Y> map(LiveData<X> source, final Function<X, Y> mapFunction)

public static <X, Y> LiveData<Y> switchMap(LiveData<X> source, final Function<X, LiveData<Y>> switchMapFunction)

两个方法差不多，只是map转换函数返回具体数据对象，switchMap返回LiveData<T>

User --> userName

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

userId --> User

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

Lifecycle 和 LiveData 的区别

Lifecycle和LiveData都类似观察者模式

Lifecycle具有生命周期的概念，而LiveData没有生命周期，他是根据观察者(LifecycleOwner)的生命周期状态来决定要不要回调Observer.onChange()方法
Lifecycle添加观察者是LifecycleObserver，他是一个空接口，实际回调是LifecycleObserver实现类的注解方法
LiveData会根据LifecycleOwner的生命周期为ON_DESTROY时自动移除Observer

Android Jetpack 架构组件

Android Jetpack 架构组件