目录
一、简介
1. Lifecycle是什么？
JetPack.Lifecycle是一个可以感知宿主生命周期变化的组件。常见的宿主包括 Activity/Fragment、Service、ViewModel 和 Application。LifeCycle 会持有宿主的生命周期状态的信息，当宿主生命周期发生变化时，会通知监听宿主的观察者。
Lifecycle的重要细节：
Lifecycle可以有效地避免内存泄漏和解决安卓生命周期的常见难题
Lifecycle 是一个表示安卓生命周期及状态的对象
LifecycleOwner用于连接有生命周期的对象，如Activity、Fragment
LifecycleObserver用于观察LifecycleOwner
Lifecycle 框架使用观察者设计模式实现观察者监听被观察者的生命周期的变化
LifeCycle 的出现主要是为了解决： 系统组件的生命周期与普通组件之间的耦合性。
系统组件指：Activity/Fragment、Service 和 Application。
普通组件指：将代码按照功能或者作用封装成的组件。
Lifecycle逻辑流程
2. Lifecycle使用
Jetpack 为我们提供了两个接口：
被观察者：LifecycleOwner
观察者：LifecycleObserver
被监听的系统组件需要去实现 LifecycleOwner 接口，观察者需要实现 LifecycleObserver 接口。
2.1 实现LifecycleObserver接口
导入此依赖，或者androidx系列。
//lifecycle依赖
implementation "androidx.lifecycle:lifecycle-extensions:2.2.0"
implementation "androidx.lifecycle:lifecycle-service:2.2.0"
implementation "androidx.lifecycle:lifecycle-process:2.2.0"
annotationProcessor "androidx.lifecycle:lifecycle-compiler:2.2.0"
LifeCycleActivity(被观察者)
public class LifeCycleActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_life_cycle);
getLifecycle().addObserver(new MyObserver());
}
}
观察者实现LifecycleObserver 接口，监听方法上添加与之对应的生命周期注解
@OnLifecycleEvent(Lifecycle.Event.xxxxxxx)
MyObserver（观察者）
public class MyObserver implements LifecycleObserver {
String Tag = "Henry";
@OnLifecycleEvent(Lifecycle.Event.ON_START)
public void onStart() {
Log.d(Tag, "---------------onStart");
}
@OnLifecycleEvent(Lifecycle.Event.ON_RESUME)//可见连接
public void connectListener() {
Log.d(Tag, "connectListener-----------run");
}
@OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)//不可见断开连接
public void disconnectListener() {
Log.d(Tag, "disconnectListener-----------run");
}
@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
public void onStop() {
Log.d(Tag, "---------------onStop");
}
}
是不是很简单？我们运行测试一下：Perfect!
2.2 实现DefaultLifecycleObserver接口
DefaultLifecycleObserver是对LifecycleObserver的二次封装，为了用户更方便使用
上面的 @OnLifecycleEventxxxx 注解还得用户自己手写，使用DefaultLifecycleObserver我们便可以直接像在Activity、Fragment里调用它的生命周期一样，还会自动提示，非常方便。
不仅仅使用方便，注意到方法中的LifecycleOwner了吗？ 后期我们还可以在方法中获取到这个被观察者。
MyObserver2 （观察者）
public class MyObserver2 implements DefaultLifecycleObserver {
//DefaultLifecycleObserver是对LifecycleObserver的二次封装，为了用户好用
String Tag = "Henry";
@Override
public void onCreate(@NonNull LifecycleOwner owner) {
DefaultLifecycleObserver.super.onCreate(owner);
Log.d(Tag, "DefaultLifecycleObserver--------onCreate");
}
@Override
public void onStart(@NonNull LifecycleOwner owner) {
DefaultLifecycleObserver.super.onStart(owner);
Log.d(Tag, "DefaultLifecycleObserver--------onStart");
}
@Override
public void onResume(@NonNull LifecycleOwner owner) {
DefaultLifecycleObserver.super.onResume(owner);
Log.d(Tag, "DefaultLifecycleObserver--------onResume");
}
@Override
public void onStop(@NonNull LifecycleOwner owner) {
DefaultLifecycleObserver.super.onStop(owner);
Log.d(Tag, "DefaultLifecycleObserver--------onStop");
}
@Override
public void onPause(@NonNull LifecycleOwner owner) {
DefaultLifecycleObserver.super.onPause(owner);
Log.d(Tag, "DefaultLifecycleObserver--------onPause");
}
}
添加方式不变，我们add进去，此时LifeCycleActivity已经拥有了两个观察者------MyObserver1和MyObserver2 。
LifeCycleActivity （被观察者）
public class LifeCycleActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_life_cycle);
getLifecycle().addObserver(new MyObserver());
getLifecycle().addObserver((new MyObserver2()));
}
}
运行测试一下：两个观察者都能监听到Activity的生命周期。
2.3 实现LifecycleEventObserver接口
通过实现 LifecycleEventObserver 接口，重写 onStateChanged 方法，在该方法内部判断 Lifecycle.Event 来实现具体的业务逻辑
public class MyObserver4 implements LifecycleEventObserver {
String Tag = "Henry";
@Override
public void onStateChanged(@NonNull LifecycleOwner lifecycleOwner, @NonNull Lifecycle.Event event) {
switch (event) {
case ON_CREATE:
Log.d(Tag, "initVideo");
break;
case ON_START:
Log.d(Tag, "startPlay");
break;
case ON_RESUME:
Log.d(Tag, "resumePlay");
break;
default:
break;
}
}
}
public class LifeCycleActivity extends AppCompatActivity {
IPresenter mypresenter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_life_cycle);
// getLifecycle().addObserver(new MyObserver());
// getLifecycle().addObserver((new MyObserver2()));
// getLifecycle().addObserver((new MyObserver3()));
getLifecycle().addObserver((new MyObserver4()));
................
测试一下：
3. 使用技巧
3.1 内部类观察者
MyObserver3 是 LifeCycleActivity 的内部类观察者，它实现了 DefaultLifecycleObserver 接口，对生命周期变化进行观察并在相应的生命周期事件中输出日志。
public class LifeCycleActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_life_cycle);
getLifecycle().addObserver(new MyObserver());
getLifecycle().addObserver((new MyObserver2()));
getLifecycle().addObserver((new MyObserver3()));
}
public class MyObserver3 implements DefaultLifecycleObserver {
//DefaultLifecycleObserver是对LifecycleObserver的二次封装，为了用户好用
String Tag = "Henry";
@Override
public void onCreate(@NonNull LifecycleOwner owner) {
DefaultLifecycleObserver.super.onCreate(owner);
Log.d(Tag, "DefaultLifecycleObserver--------onCreate");
}
@Override
public void onStart(@NonNull LifecycleOwner owner) {
DefaultLifecycleObserver.super.onStart(owner);
Log.d(Tag, "DefaultLifecycleObserver--------onStart");
}
@Override
public void onResume(@NonNull LifecycleOwner owner) {
DefaultLifecycleObserver.super.onResume(owner);
Log.d(Tag, "DefaultLifecycleObserver--------onResume");
}
@Override
public void onStop(@NonNull LifecycleOwner owner) {
DefaultLifecycleObserver.super.onStop(owner);
Log.d(Tag, "DefaultLifecycleObserver--------onStop");
}
@Override
public void onPause(@NonNull LifecycleOwner owner) {
DefaultLifecycleObserver.super.onPause(owner);
Log.d(Tag, "DefaultLifecycleObserver--------onPause");
}
}
}
使用内部类观察者的好处包括：
封装性：将观察者类定义为外部类的内部类，可以更好地组织代码结构，将相关的类放在一起，提高代码的可读性和可维护性。访问权限：内部类可以访问外部类的成员变量和方法，可以方便地获取外部类的状态或调用外部类的方法，从而更容易实现观察者与被观察者之间的交互。代码复用：内部类可以直接访问外部类的成员，避免了在不同类之间传递参数的复杂性，提高了代码的复用性。逻辑关联：将观察者类定义为内部类可以更好地表达观察者与被观察者之间的逻辑关联，代码结构更加清晰。
3.2 观察者接口
IPresenter 接口继承了 DefaultLifecycleObserver 接口，而 MyPresenter 类实现了 IPresenter 接口。然后在 Activity 中创建了 MyPresenter 实例，并通过 addObserver 方法将其添加为生命周期观察者。
接口IPresenter 实现DefaultLifecycleObserver
public interface IPresenter extends DefaultLifecycleObserver {
@Override
default void onStart(@NonNull LifecycleOwner owner) {
DefaultLifecycleObserver.super.onStart(owner);
}
@Override
default void onStop(@NonNull LifecycleOwner owner) {
DefaultLifecycleObserver.super.onStop(owner);
}
}
MyPresenter 实现IPresenter 接口，重写方法
public class MyPresenter implements IPresenter {
@Override
public void onStart(@NonNull LifecycleOwner owner) {
IPresenter.super.onStart(owner);
}
@Override
public void onStop(@NonNull LifecycleOwner owner) {
IPresenter.super.onStop(owner);
}
}
LifeCycleActivity 如果有多个观察者实现IPresenter接口，可以通过IPresenter接口+工厂模式实例化 具体观察者再注册监听。
public class LifeCycleActivity extends AppCompatActivity {
IPresenter mypresenter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_life_cycle);
getLifecycle().addObserver(new MyObserver());
getLifecycle().addObserver((new MyObserver2()));
getLifecycle().addObserver((new MyObserver3()));
mypresenter=new MyPresenter();
//多个接口 + 工厂设计模式
getLifecycle().addObserver(mypresenter);
}
}
这种接口观察者的设计有以下好处：
解耦：通过接口观察者模式，MyPresenter 类只需要实现 IPresenter 接口定义的方法，而不需要直接继承 DefaultLifecycleObserver，从而实现了观察者和被观察者的解耦。这样，在需要改变观察者实现的情况下，只需要修改实现了 IPresenter 接口的类，而不需要修改 DefaultLifecycleObserver 的实现。灵活性：接口观察者模式使得一个类可以同时实现多个接口，从而可以观察多个不同的生命周期事件。这种灵活性可以让不同的观察者类实现不同的接口，实现更加细粒度的生命周期管理。遵循设计原则：接口观察者模式符合面向接口编程的设计原则，使得代码更加灵活、可扩展和易于维护。工厂设计模式：通过工厂设计模式创建具体的观察者实例，可以更好地隐藏对象的创建细节，提高代码的可读性和可维护性。
参考链接：
Jetpack 之 LifeCycle 组件使用详解
Lifecycle 使用与源码分析——彻底搞懂Lifecycle原理