Android Arch LifeCycle用法详解与源码解析

谁借莪１个温暖的怀抱￠ 2022-04-23 12:38 201阅读 0赞

自从Google IO 大会提出 Android Architecture Components，越来越多的使用组件加入其中。其中   
Handling lifecycles with lifecycle-aware components 这篇文章就向我介绍了LifeCycle这个超实用组件。

二.LifeCycle简介

2.1为什么我们要使用LifeCycle？

我们写代码的时候难免会写写一些Presenter或者Mananger或者一些业务性很强的View。来把很一些业务逻辑从Activity中分解掉。但是不免遇到的问题就是。上述这些辅助类不像Activity和Fragment一样拥有比较完善的生命周期。

当然我们我们也可以这样写：

public interface IPresenter \{  
    void onCreate();

void onStart();

void onResume();

void onPause();

void onStop();

void onDestroy();  
\}  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
public class MainPresenter implements IPresenter \{

public MainPresenter(Context context)\{

@Override  
    public void onCreate() \{

@Override  
    public void onStart() \{

@Override  
    public void onResume() \{

@Override  
    public void onPause() \{

@Override  
    public void onStop() \{

@Override  
    public void onDestroy() \{

\}  
\}  
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  
public class MainActivity extends AppCompatActivity \{  
    private static final String TAG = "MainActivity";  
    private IPresenter mPresenter;  
    @Override  
    protected void onCreate(Bundle savedInstanceState) \{  
        super.onCreate(savedInstanceState);  
        Log.d(TAG, "onCreate: ");  
        setContentView(R.layout.activity\_main);  
        mPresenter = new MainPresenter(this);  
        mPresenter.onCreate();  
    \}

@Override  
    protected void onStart() \{  
        super.onStart();  
        Log.d(TAG, "onStart: ");  
        mPresenter.onStart();  
    \}

@Override  
    protected void onResume() \{  
        super.onResume();  
        Log.d(TAG, "onResume: ");  
        mPresenter.onResume();  
    \}

@Override  
    protected void onPause() \{  
        super.onPause();  
        Log.d(TAG, "onPause: ");  
        mPresenter.onPause();  
    \}

@Override  
    protected void onStop() \{  
        super.onStop();  
        Log.d(TAG, "onStop: ");  
        mPresenter.onStop();  
    \}

@Override  
    protected void onDestroy() \{  
        super.onDestroy();  
        Log.d(TAG, "onDestroy: ");  
        mPresenter.onDestroy();  
    \}  
\}  
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  
这个例子很简单。我们当然可以这么写。但是如果对于一个复杂Activity和Fragment来说。可能绑定了多个Presenter，Manager，或者View。那这个代码写起来就会很复杂。尤其是当这些东西被其他人复用的时候，很难让别人也注意到这些细节。（就是在他们的Activity中的对应生命周期要调用这些）

2.2 隆重推出LifeCycle

Google也发现了这样的问题。所以在support包 26.1.0版本后 ，android.support.v4.app中的FragmentActivity和Fragment中已经集成了Lifecycle相关的功能。

简单说一下LifeCycle的原理吧：

假定一个需要观察生命周期的Presenter实例

首先通过Fragment或者FragmentActivity中getLifeCycle方法返回的LifecycleRegistry实例的addObserver()方法，加入到FastSafeIterableMap中。  
然后将Presenter的生命周期快进到现在的节点:例如现在LifecycleOwner的状态是STARTED。Presenter将会连续收到ON\_CREATE，ON\_START两事件。  
剩下的交给LifeCycle，自此之后Presenter的生命周期将和宿主保持一致。  
关键类介绍：

FastSafeIterableMap 管理观察者的数据结构，对于在迭代的时候进行修改做了一些优化。  
LifecycleRegistry LifeCycle业务核心类，完成观察者增减，观察者STATE切换等核心逻辑  
LifecycleOwner 宿主Activity实现这个接口，android.support.v4.app 中的Fragment，FragmentActivity已经实现这个接口了。我们也可以给我们自己的Activity实现这个，详情请看3.2章节。  
ClassesInfoCache 通过运行时注解的方式找到Presenter中想观测的生命周期。  
三.简单用法

3.1 Presenter实现LifecycleObserver

public class MainPresenter implements LifecycleObserver \{

public static final String TAG = "MainActivity";  
  public String name;

public MainPresenter(String name) \{  
    this.name = name;  
  \}  
  //通过运行时注解的方式实现生命周期，是不是很像EventBus  
  @OnLifecycleEvent(Lifecycle.Event.ON\_CREATE) public void onCreate() \{  
    Log.d(TAG, name + "onCreate");  
  \}

@OnLifecycleEvent(Lifecycle.Event.ON\_START) public void onStart() \{  
    Log.d(TAG, name + "onStart");  
  \}

@OnLifecycleEvent(Lifecycle.Event.ON\_RESUME) public void onResume() \{  
    Log.d(TAG, name + "onResume");  
  \}

@OnLifecycleEvent(Lifecycle.Event.ON\_PAUSE) public void onPause() \{  
    Log.d(TAG, name + "onPause");  
  \}

@OnLifecycleEvent(Lifecycle.Event.ON\_STOP) public void onStop() \{  
    Log.d(TAG, name + "onStop");  
  \}  
  //比较特殊的一个回调会在任何生命周期回调的时候都回调这里  
  //@OnLifecycleEvent(Lifecycle.Event.ON\_ANY) public void onDestroy() \{  
  //  Log.d(TAG, "ON\_ANY");  
  //\}  
\}  
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  
Activity只需要把实现了LifecycleObserver的MainPresenter交给LifeCycle管理即可

public class MainActivity extends AppCompatActivity \{

public static final String TAG = "MainActivity";

@Override protected void onCreate(Bundle savedInstanceState) \{  
    super.onCreate(savedInstanceState);  
    Log.d(TAG, "onCreate");  
    setContentView(R.layout.activity\_main);  
    MainPresenter mainPresenter = new MainPresenter(TAG);  
    //把MainPresenter交给LifeCycle管理就OK了  
    getLifecycle().addObserver(mainPresenter);  
  \}  
  @Override protected void onStart() \{  
    super.onStart();  
    Log.d(TAG, "onStart");  
  \}

@Override protected void onRestart() \{  
    super.onRestart();  
    Log.d(TAG, "onRestart");  
  \}

@Override protected void onResume() \{  
    super.onResume();  
    Log.d(TAG, "onResume");  
  \}

@Override protected void onPause() \{  
    super.onPause();  
    Log.d(TAG, "onPause");  
  \}

@Override protected void onStop() \{  
    super.onStop();  
    Log.d(TAG, "onStop");  
  \}

@Override protected void onDestroy() \{  
    super.onDestroy();  
    Log.d(TAG, "onDestroy");  
  \}  
\}  
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  
输出结果如下

当然值得注意的

启动阶段 先回调Activity的生命周期再回调LifeCycle的生命周期  
结束阶段 先回调LifeCycle的生命周期再回调Activity的生命周期  
发挥一下想象力，只要是附着在Activity或者Fragment上的任何实例都可以采用这样的管理方式，让其达到一个自生自灭的问题。是不是就少去了很多内存泄漏的问题。

3.2当然也可以这样用

创建一个自定义的LifeCycle

public class MainActivity1 extends Activity implements LifecycleOwner \{  
 private LifecycleRegistry mLifecycleRegistry;

@Override protected void onCreate(Bundle savedInstanceState) \{  
    super.onCreate(savedInstanceState);  
    Log.d(TAG, "Activity->onCreate");  
    setContentView(R.layout.activity\_main);  
    mLifecycleRegistry = new LifecycleRegistry(this);  
  \}  
 @NonNull @Override public Lifecycle getLifecycle() \{  
    return mLifecycleRegistry;  
  \}  
\}  
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
附上一张LifeCycle的SATE状态流转图

四.最佳实践

当然这么好用的东西已经和Arch中的其他组件，例如DataBinding以及ViewModel可以有一些配合。以后有机会会尝试一下。