Jetpack揭秘系列（二）----Lifecycle

洲汐

于 2021-04-05 23:54:25 发布

阅读量260

点赞数

分类专栏： Android系列 Java系列文章标签： java android jetpack

本文链接：https://blog.youkuaiyun.com/weixin_48968045/article/details/115423581

版权

Android系列同时被 2 个专栏收录

17 篇文章

订阅专栏

Java系列

15 篇文章

订阅专栏

本文介绍了如何使不具备生命周期感知能力的普通类能够监听Activity/Fragment的生命周期变化。通过创建一个“桥梁”类或者使用LifecycleObserver接口结合注解，可以在不同生命周期阶段执行相应逻辑。这两种方法有助于降低业务逻辑的耦合性，使得代码更加优雅和可维护。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

有时候有些逻辑需要在对应的生命周期中处理，比如app打开后界面的绘制就需要在onCreate中执行（为啥不在onResume中？app在整个生命周期中只会执行一次onCreate）setContentView，对于其他的一些逻辑操作可以写在对应的生命周期方法中（onCreate，onStart，onResume，onPause，onStop，onRestart，onDestroy），例如下面打日志的操作。

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "Lifecycle_MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.i(TAG, "onCreate in MainActivity");  //执行onCreate的逻辑
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.i(TAG, "onResume in MainActivity");  //执行onResume的逻辑
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.i(TAG, "onStop in MainActivity");   //执行onStop的逻辑
    }
}

但是只有Activity/Fragment具有生命周期感知，对于普通的类来说无法感应到生命周期的变化，而又免不了针对不同生命周期的逻辑操作

使用“桥梁”感知生命周期变化

这个时候当然可以将该类中对应的各生命周期逻辑都写到Activity/Fragment中也能完成任务，然而对应的业务逻辑之间就会有很强的耦合性，这个时候可以通过一个“桥梁”来连接Activity/Fragment和普通类，该“桥梁”作为观察者来观察Activity/Fragment对用的生命周期变化，同时来通知其他普通类，例如下面的MyObserver类就充当了“桥梁”的作用

public class MyObserver {
    private static final String TAG = "Lifecycle_MyObserver";

    public void activityCreated() {
        Log.i(TAG, "activityCreated in MyObserver");
    }

    public void activityResume() {
        Log.i(TAG, "activityResume in MyObserver");
    }

    public void activityStop() {
        Log.i(TAG, "activityStop in MyObserver");
    }
}

[番外知识点]

通常来说，上述的MyObserver可以通过更优雅的方式来实现，因为MyObserver中不一定只有生命周期方法，可能还有别的函数需要调用的接口（比如getTag），这个时候如果通过全写死的方式来实现，模块之间的耦合性又会提高，因此，可以通过提取接口来实现
public interface IObserverLifecycle {
    void activityCreated();

    void activityResume();

    void activityStop();
}
public interface IClassTag {
    String getTag();
}
public class MyObserver implements IObserverLifecycle, IClassTag{
    private static final String TAG = "Lifecycle_MyObserver";

    @Override
    public void activityCreated() {
        Log.i(TAG, "activityCreated in MyObserver");
    }

    @Override
    public void activityResume() {
        Log.i(TAG, "activityResume in MyObserver");
    }

    @Override
    public void activityStop() {
        Log.i(TAG, "activityStop in MyObserver");
    }

    @Override
    public String getTag() {
        return TAG;
    }
}

Activity/Fragment中只需要在onCreate新建“桥梁”对象，然后在对应的生命周期方法中执行“桥梁”对象对应的方法，普通类各生命周期的逻辑只需要写在“桥梁”中即可

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "Lifecycle_MainActivity";

    private MyObserver myObserver;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        myObserver = new MyObserver();
        Log.i(TAG, "onCreate in MainActivity");
        myObserver.activityCreated();
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.i(TAG, "onResume in MainActivity");
        myObserver.activityResume();
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.i(TAG, "onStop in MainActivity");
        myObserver.activityStop();
    }
}

//输出结果
2021-04-04 00:35:37.167 8517-8517/com.zhouxi.lifecycledemo I/Lifecycle_MainActivity: onCreate in MainActivity
2021-04-04 00:35:37.168 8517-8517/com.zhouxi.lifecycledemo I/Lifecycle_MyObserver: activityCreated in MyObserver
2021-04-04 00:35:37.172 8517-8517/com.zhouxi.lifecycledemo I/Lifecycle_MainActivity: onResume in MainActivity
2021-04-04 00:35:37.172 8517-8517/com.zhouxi.lifecycledemo I/Lifecycle_MyObserver: activityResume in MyObserver
2021-04-04 00:35:47.007 8517-8517/com.zhouxi.lifecycledemo I/Lifecycle_MainActivity: onStop in MainActivity
2021-04-04 00:35:47.007 8517-8517/com.zhouxi.lifecycledemo I/Lifecycle_MyObserver: activityStop in MyObserver

使用注解感知生命周期变化

除了上述通过“桥梁”的方式来感知外，可以使用更优雅的注解来实现普通类对生命周期的感知，操作方式和“桥梁”方式类似

普通类继承LifecycleObserver接口，通过注解建立各生命周期方法和事件的对应关系
Activity/Fragment中作为被观察者，将观察者加入到自己的观察队列中

public class MyLifecycleObserver implements LifecycleObserver {  //普通类继承LifecycleObserver接口
    private static final String TAG = "Lifecycle_MyLifecycleObserver";

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)  //通过注解建立各生命周期方法和事件的对应关系
    public void activityCreated() {
        Log.i(TAG, "activityCreated in MyLifecycleObserver");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)  //通过注解建立各生命周期方法和事件的对应关系
    public void activityResume() {
        Log.i(TAG, "activityResume in MyLifecycleObserver");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)  //通过注解建立各生命周期方法和事件的对应关系
    public void activityStop() {
        Log.i(TAG, "activityStop in MyLifecycleObserver");
    }
}

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "Lifecycle_MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.i(TAG, "onCreate in MainActivity");
        MyLifecycleObserver myLifecycleObserver = new MyLifecycleObserver();
        getLifecycle().addObserver(myLifecycleObserver);  //将观察者加入到自己的观察队列中
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.i(TAG, "onResume in MainActivity");
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.i(TAG, "onStop in MainActivity");
    }
}

//输出结果
2021-04-04 00:47:49.632 13374-13374/com.zhouxi.lifecycledemo I/Lifecycle_MainActivity: onCreate in MainActivity
2021-04-04 00:47:49.634 13374-13374/com.zhouxi.lifecycledemo I/Lifecycle_MyLifecycleObserver: activityCreated in MyLifecycleObserver
2021-04-04 00:47:49.638 13374-13374/com.zhouxi.lifecycledemo I/Lifecycle_MainActivity: onResume in MainActivity
2021-04-04 00:47:49.638 13374-13374/com.zhouxi.lifecycledemo I/Lifecycle_MyLifecycleObserver: activityResume in MyLifecycleObserver
2021-04-04 00:47:56.168 13374-13374/com.zhouxi.lifecycledemo I/Lifecycle_MyLifecycleObserver: activityStop in MyLifecycleObserver
2021-04-04 00:47:56.170 13374-13374/com.zhouxi.lifecycledemo I/Lifecycle_MainActivity: onStop in MainActivity

由于AppCompatActivity实现了LifecycleOwner接口，该方法实际返回了一个LifecycleRegistry对象，该对象中保存了对应的观察者队列。

注解中的生命周期事件定义在枚举类Event中

public enum Event {

    ON_CREATE,

    ON_START,

    ON_RESUME,

    ON_PAUSE,

    ON_STOP,

    ON_DESTROY,

    ON_ANY
}

普通类主动感知当前生命周期

上述无论是通过“桥梁”还是注解，都是Activity/Fragment作为主动方，执行对应的生命周期状态转换才会触发普通类中对用的逻辑。

如果需要让普通类作为主动方来感知当前的生命周期状态，则需要普通类拿到LifecycleOwner对象，因此观察者中只需要持有一个LifecycleOwner对象（例如mLifecycleOwner）即可，逻辑中需要获得当前生命周期只需要执行mLifecycleOwner.getCurrentState来获取状态即可

public class MyLifecycleObserver implements LifecycleObserver {
    private static final String TAG = "Lifecycle_MyLifecycleObserver";

    private Lifecycle mLifecycleOwner;

    public MyLifecycleObserver(Lifecycle lifecycle) {
        mLifecycleOwner = lifecycle;
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void activityCreated() {
        Log.i(TAG, "current state is " + mLifecycleOwner.getCurrentState());
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    public void activityResume() {
        Log.i(TAG, "current state is " + mLifecycleOwner.getCurrentState());
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void activityStop() {
        Log.i(TAG, "current state is " + mLifecycleOwner.getCurrentState());
    }
}

从上面也可以知道LifecycleRegistry保存了生命周期相关的大多数信息，包括当前状态，观察者队列，具体源码分析后续分析。

其中getCurrentState返回的状态值定义在枚举类State中

public enum State {
    
    DESTROYED,

    INITIALIZED,

    CREATED,

    STARTED,

    RESUMED;
}

需要注意的是，上述的生命周期状态和事件的对应关系如下

Activity生命周期状态和事件的关系