Android架构组件

最新推荐文章于 2025-10-21 15:12:11 发布

原创最新推荐文章于 2025-10-21 15:12:11 发布 · 664 阅读

1 ·

CC 4.0 BY-SA版权

android 同时被 2 个专栏收录

6 篇文章

订阅专栏

java

1 篇文章

订阅专栏

1为什么需要架构组件 ?

之前的开发过程中，我们会把所有的代码写在Activity或者Fragment中，包含网络请求，数据处理，UI更新，生命周期回调的处理。但是在后期不断的迭代和需求变多的情况下，会使得我们的代码变得臃肿不堪，难以维护。所以才出现了像mvp,mvvm这样不同的架构模式，这使得我们可以编写更健壮和可测试的代码，代码逻辑更加清晰，结构更加明确。

2 架构组件是什么？

一个新的库集合，可帮助我们设计更健壮的，可测试的和可维护的应用程序。从管理UI组件生命周期和处理数据持久性类开始，简而言之，这些库将帮助我们解决,配置更改，内存泄漏，怎么编写可测试的应用程序的常见问题,在维护架构的同时减少模块代码。

3 目前google提供的架构组件有哪些?

Lifecycle , ViewModel , LiveData , Room

4 Lifecycle

Lifecycle是什么？

Lifecycle 是一个生命周期组件，用于将系统组件(Activity , Fragment等等)的生命周期分离到Lifecycle类，并且允许其他类作为观察者，观察组件生命周期的变化。这些组件可以根据Activity和Fragment当前的生命周期自动调整自己的状态。

使用Lifecycle的好处

在日常开发中，我们经常需要封装一些自定义的view或者组件，有时需要她们的生命周期随着Activity或者Fragment的生命周期的变化而变化，还有一些是需要在生命周期的回掉方法回调之后所做的处理，如在onStop中处理一些释放资源的操作。还可以解决一些我们难以定位的问题，比如我们需要在onStart或者onResume中做一些比较耗时的操作，并且在onStop中释放相关的资源，可能出现这样的情况，用户刚进入这个页面，然后立马退出，onStart或者onResume中的耗时操作还没有执行完成，就开始执行onStop方法中的释放资源的相关操作，可能产生一些问题。但是最主要的作用还是在于解耦。

怎样使用Lifecycle ?

如果我们Activity继承自support library在26.1.0和之后包中的AppCompatActivity，则可以直接使用,否则需要我们的Activity实现LifeCycleOwner接口。

Activity继承自support library在26.1.0和之后包的AppCompatActivity:

//Activity继承自support library在26.1.0和之后包的AppCompatActivity:
getLifecycle().addObserver(new LifeCycleUtils());

Activity没有继承自support library在26.1.0和之后包的AppCompatActivity,则需要实现LifecycleOwner接口，并重写getLifeCycle方法。

 //Activity不是继承自support library在26.1.0和之后包的AppCompatActivity:
 lifecycleRegistry = new LifecycleRegistry(this);
 getLifecycle().addObserver(new LifeCycleUtils());

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

下面来看下LifecycleUtils的使用：

public class LifeCycleUtils implements LifecycleObserver {
    private static final String TAG = "LifeCycleTest";

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    void onCreate() {
        Log.e(TAG, "LifeCycleUtils onCreate: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    void onStart() {
        Log.e(TAG, "LifeCycleUtils onStart: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    void onResume() {
        Log.e(TAG, "LifeCycleUtils onResume: ");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    void onPause() {

    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    void onStop() {
        Log.e(TAG, "LifeCycleUtils onStop: ");
    }


    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    void onDestroy() {
        Log.e(TAG, "LifeCycleUtils onDestroy: ");
    }

    /**
     * 接收任意生命周期的变换
     * @param owner
     * @param event
     */
    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    void onAny(LifecycleOwner owner, Lifecycle.Event event) {
        Log.e(TAG, "onAny: "+event.name() );
    }

}

回调顺序:

ON_CREATE,ON_START,ON_RESUME 发生在LifecycleOwner相关的生命周期结束之后。

ON_PAUSE,ON_STOP,ON_DESTROY发生在LifecycleOwner相关的生命周期被调用之前。

与Fragment的生命周期回调一致。

5 LiveData:

LiveData是一个可以被观察的数据持有类，它可以感知并遵循Activity，Fragment等组件的生命周期，正是由于这一特点，LiveData可以做到仅在组件处于生命周期的激活状态才更新UI数据。也就是说，只有在activity或者fragment的生命周期处于STARTED或者RESUMED时，LiveData才会通知观察者数据变化。在activity处于其他状态时,即使LiveData的数据变化了，也不会通知。LiveData需要一个观察者对象，一般是Observer类的具体实现。使用如下方法注册观察者:

@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {}

下面是LiveData类中observer方法的源码：

@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer) {
        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);
    }

可以看到observer是运行在主线程当中,我们在拿到数据更新UI时,不必担心在子线程更新UI的问题，并且如果此时的lifecycleOwner已经被销毁，则直接return,注册观察者失败。

通过LiveData的observe方法进行关系绑定，就可以在组件的生命周期状态变为DESTROYED时移除观察者，这样Activity或Fragment就可以安全地观察LiveData而不用担心造成内存泄露。

LiveData使用步骤:

在ViewModel中创建LiveData，并持有某种类型的数据。一般在使用时，我们都是使用MutableLiveData,MutableLiveData继承自LiveData，表示可变数据，提供了数据设置方法。
创建一个Observer对象并实现其onChanged()回调，一般在Activity或Fragment中创建Observer。
在Activity或Fragment中通过LiveData的observe(@NonNull LifecycleOwner owner, @NonNull Observer<T> observer)方法建立观察关系。

MutableLiveData

MutableLiveData是LiveData的具体实现类之一，添加了公共方法setValue和postValue。

@SuppressWarnings("WeakerAccess")
public class MutableLiveData<T> extends LiveData<T> {
    @Override
    public void postValue(T value) {
        super.postValue(value);
    }

    @Override
    public void setValue(T value) {
        super.setValue(value);
    }
}

setValue必须在主线程调用。postValue可以在后台线程中调用。

下面用MultableLiveData 做一个后台刷新的例子，也是我们有时候经常需要使用到的需求。

public class MyLiveData extends MutableLiveData{
    private boolean isActive = false;
    private int count = 0;
    private LongTimeWork longTimeWork = new LongTimeWork();

    public MyLiveData(){
        longTimeWork.start();
    }

    /**
     * UI controllers可见时的回调
     */
    @Override
    protected void onActive() {
        super.onActive();
        isActive = true;
        longTimeWork.interrupt();
    }

    /**
     * UI controllers 不可见时的回调
     */
    @Override
    protected void onInactive() {
        super.onInactive();
        isActive = false;

    }


    /**
     * 开启一个线程，进行刷新任务
     */
    private class LongTimeWork extends Thread {
        @Override
        public void run() {
            while (true) {
                try {
                    if (!isActive) {
                        Thread.sleep(Long.MAX_VALUE);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
                
                count++;
                postValue(String.valueOf(count));

                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

MainActivity中的根据刷新结果更新ui的逻辑

/**
 * 根据刷新结果返回的数据更新ui
 */
private void refreshData(){
   new MyLiveData().observe(this, new Observer() {
       @Override
       public void onChanged(@Nullable Object o) {
            try {
                  tv_refesh.setText((String)o);
            } catch (Exception e) {
                  e.printStackTrace();
            }
        }
     });
}

重写了onInactive()和onActive()方法，onInactive()在UI controllers在前台调用，onActive()在UI controller在后台调用,在本例中，我们将刷新请求数据的逻辑放在MutableLiveData中,并且在UI controller处于后台时，停止刷新。在UI controller中即MainActivity中只需几行代码来更新UI。

6 ViewModel

ViewModel概念及用途

ViewModel用来存储和管理UI相关的数据，可于将一个Activity或Fragment组件相关的数据逻辑抽象出来，并能适配组件的生命周期，如当屏幕旋转Activity重建后，ViewModel中的数据依然有效。

引入ViewModel之前，存在如下几个问题：

通常Android系统来管理UI controllers（如Activity、Fragment）的生命周期，由系统响应用户交互或者重建组件，用户无法操控。当组件被销毁并重建后，原来组件相关的数据也会丢失，如果数据类型比较简单，同时数据量也不大，可以通过onSaveInstanceState()存储数据，组件重建之后通过onCreate()，从中读取Bundle恢复数据。但如果是大量数据，不方便序列化及反序列化，则上述方法将不适用。
UI controllers经常会发送很多异步请求，有可能会出现UI组件已销毁，而请求还未返回的情况，因此UI controllers需要做额外的工作以防止内存泄露。
当Activity因为配置变化而销毁重建时，一般数据会重新请求，其实这是一种浪费，最好就是能够保留上次的数据。
UI controllers其实只需要负责展示UI数据、响应用户交互和系统交互即可。但往往开发者会在Activity或Fragment中写许多数据请求和处理的工作，造成UI controllers类代码膨胀，也会导致单元测试难以进行。我们应该遵循职责分离原则，将数据相关的事情从UI controllers中分离出来。

ViewModel的使用

public class DataViewModel extends ViewModel{

    private MutableLiveData<MatchEntity> matchMutableLiveData;

    public MutableLiveData<MatchEntity> getUserMutableLiveData() {
        if(matchMutableLiveData  == null){
            matchMutableLiveData = new MutableLiveData<>();
        }
        return matchMutableLiveData;
    }
}

activity中使用viewmodel:

public class MainActivity extends AppCompatActivity { 
    private DataViewModel dataViewModel;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        dataViewModel = ViewModelProviders.of(this).get(DataViewModel.class);
        findViewById(R.id.loaduser_btn).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                initData();
            }
        });
    }

    private void initData(){
        dataViewModel.getUserMutableLiveData().observe(this, new Observer<MatchEntity>() {
            @Override
            public void onChanged(@Nullable MatchEntity matchEntity) {
                //此处更新ui 运行在主线程中
                if(matchEntity != null){
                }
            }
        });
        DataPresenter presenter = new DataPresenter(this);
        presenter.getMathDetail("231652");
    }
}

public class DataPresenter {

    private FragmentActivity activity;

    public DataPresenter(FragmentActivity activity){
        this.activity = activity;
    }

    public void getMathDetail(String matchId){
        new Retrofit.Builder()
                .baseUrl(ApiService.BASER_URL)
                .addConverterFactory(GsonConverterFactory.create())
                .build()
                .create(ApiService.class)
                .getMatchData(matchId)
                .enqueue(new Callback<MatchEntity>() {
                    @Override
                    public void onResponse(Call<MatchEntity> call, Response<MatchEntity> response) {
                        //接口请求完成后通知ui进行更新
                        ViewModelProviders.of(activity).get(DataViewModel.class).getUserMutableLiveData().setValue(response.body());
                    }

                    @Override
                    public void onFailure(Call<MatchEntity> call, Throwable t) {
                        //接口请求失败可以直接赋予一个空值 展示空页面
                        ViewModelProviders.of(activity).get(DataViewModel.class).getUserMutableLiveData().setValue(null);
                    }
                });
    }
}

public interface ApiService {

    String BASER_URL = "";

    /**
     * 获取比赛详情接口
     * @param matchId 比赛id
     * @return
     */
    @GET("lineup/detail.do")
    Call<MatchEntity> getMatchData(@Query("matchId") String matchId);

}

将android架构组件与mvp架构结合起来：

ApiService类用来我们定义接口，DataPresenter用来进行网络请求，DataViewModel相当于一个桥梁，来连接网络请求和UI controller来进行ui的更新。在代码中可以看到，我们在activity中拿到了DataPresenter和DataViewModel的对象，通过DataViewModel的对象获取Liv eData,并设置observer,即使更新ui。在DataPresenter数据请求完成后，通过调用MutableLiveData的setvalue方法,此方法相当于告诉观察者数据有更新，此时我们在activity中注册的observer会回调onChanged(@Nullable T t),并且返回更新后的数据，来更新ui。通过以上操作，将数据请求与处理，UI controllers的生命周期，ui更新完全解耦开来，使UI controllers中的代码不再臃肿，逻辑更加清晰，更加易于维护。

viewmodel除了可以与mvp架构结合起来还可以用来activity和fragment以及fragment与fragment之间的通信：

可能我们经常有这样的需求：

一个Fragment展示列表，另一个Fragment展示选中列表对应的详情信息，之前我们可能会利用宿主Activity并定义几个接口来实现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.
        });
    }
}

可以看到MasterFragment与DetailFragment都用如下代码来获取viewmodel：

SharedViewModel model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class);

getActivity()返回的是同一个宿主Activity，因此两个Fragment之间返回的是同一个SharedViewModel对象。

Fragment间共享ViewModel的优点有：

宿主Activity不需要做任何事情，也不需要关心Fragment间交互的内容。
Fragment只需要了解ViewModel的实现，而无需了解通信目标Fragment。即使一个Fragment已经销毁了，另一个Fragment也能正常工作。
每一个Fragment有自己的生命周期，并不受其他Fragment影响。
Fragment之间解耦。

ViewModel的生命周期:

ViewModel的生命周期依赖于对应的Activity或Fragment的生命周期。通常会在Activity第一次onCreate()时创建ViewModel，ViewModel的生命周期一直持续到Activity最终销毁或Frament最终detached，期间由于屏幕旋转等配置变化引起的Activity销毁重建并不会导致ViewModel重建。

ViewModel除了用来与UI相关的数据之外，还可以作为一个全局消息的功能，就之前做的项目遇到来说，在一个很复杂的Activity里面，包含多个Fragment,整个activity里面包含多个登录入口，为了解决从某一个登录入口登录成功返回，其他的登录入口也同时更新用户数据的问题，可以让每一个登录入口的UI Controllers成为登录成功状态返回的观察者，由于是在同一个activity中，持有的viewmodel为同一个对象。让每一个需要实现登录状态更新的UI controllers注册成为观察者，当多个登录入口中某一处登录成功返回之后，更新数据，使每一个注册了登录状态的观察者都能够及时更新数据。