【绝非标题党】Lifecycle的原理及使用，看这篇就够了

一、Lifecycle 的核心作用

Jetpack Lifecycle 是 Android 架构组件中用于感知和管理生命周期 的核心工具，它通过观察者模式将 Activity/Fragment 的生命周期事件解耦到独立组件中。传统开发模式需要在 Activity 中直接调用业务组件的生命周期方法，导致代码臃肿且难以维护，而 Lifecycle 通过以下机制解决这个问题：

生命周期拥有者（LifecycleOwner）：Activity/Fragment 实现该接口，成为生命周期事件源
生命周期观察者（LifecycleObserver）：业务组件实现该接口，接收生命周期事件
事件分发机制：自动将生命周期事件传递给已注册的观察者

二、核心源码解析

1. 事件分发机制

1.1 原理

LifeCycle作为大部分jetpack组件库的基石，有理由要掌握其原理及其灵活使用。原理感觉很简单.

实现LifecycleOwner接口
在生命周期回调方法中，调用handleLifecycleEvent(event)转交给LifeCycleRegistry
LifecycleRegistry支持addObserver()方法，并取出所有的观察者回调给上层。

1.2 事件分发流程

java 复制代码

// ReportFragment 示例
@Override 
public void onStart() {
    super.onStart();
    dispatch(Lifecycle.Event.ON_START);
}

private void dispatch(Lifecycle.Event event) {
    Activity activity = getActivity();
    if (activity instanceof LifecycleOwner) {
        LifecycleRegistry registry = ((LifecycleOwner) activity).getLifecycle();
        registry.handleLifecycleEvent(event); // 核心分发方法
    }
}

2. LifecycleRegistry 工作原理

2.1 观察者管理

java 复制代码

public class LifecycleRegistry extends Lifecycle {
    private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap = 
        new FastSafeIterableMap<>();

    public void addObserver(@NonNull LifecycleObserver observer) {
        // 将观察者包装为 ObserverWithState
        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
        mObserverMap.putIfAbsent(observer, statefulObserver);
    }
}

使用 FastSafeIterableMap 维护观察者列表
ObserverWithState 封装观察者及其当前状态

2.2 状态同步算法

java 复制代码

void sync() {
    while (!isSynced()) {
        // 计算目标状态
        State targetState = calculateTargetState();
        // 通过事件触发状态迁移
        moveToState(targetState);
    }
}

通过 State 的枚举值（CREATED/STARTED/RESUMED 等）管理生命周期阶段
事件（Event）驱动状态迁移，例如：ON_START 事件将状态从 CREATED 迁移到 STARTED

3. 状态与事件关系

当前状态	触发事件	新状态
INITIALIZED	ON_CREATE	CREATED
CREATED	ON_START	STARTED
STARTED	ON_RESUME	RESUMED
RESUMED	ON_PAUSE	STARTED
STARTED	ON_STOP	CREATED
CREATED	ON_DESTROY	DESTROYED

三、使用实践

1. 基本使用方式

1.1 实现观察者（三选一）

kotlin 复制代码

// 方式1：注解式（即将废弃）
class MyObserver : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun connect() { /* 连接资源 */ }
}

// 方式2：接口式（推荐）
class MyObserver : DefaultLifecycleObserver {
    override fun onResume(owner: LifecycleOwner) { /* 连接资源 */ }
}

// 方式3：统一事件处理
class MyObserver : LifecycleEventObserver {
    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        when(event) {
            Lifecycle.Event.ON_RESUME -> { /* 连接资源 */ }
            Lifecycle.Event.ON_PAUSE -> { /* 释放资源 */ }
        }
    }
}

1.2 注册观察者

kotlin 复制代码

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycle.addObserver(MyObserver()) // 自动绑定生命周期
    }
}

2. 高级用法

2.1 状态查询

kotlin 复制代码

if (lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
    // 安全执行需要 Activity 可见的操作
}

2.2 自定义 LifecycleOwner

java 复制代码

public class MyService extends Service implements LifecycleOwner {
    private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

    @Override
    public void onCreate() {
        super.onCreate();
        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
    }

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

四、设计优势

解耦性：业务组件不再需要持有 Activity/Fragment 引用
内存安全：弱引用防止内存泄漏
状态一致性：保证观察者状态与宿主同步
扩展性：支持自定义 LifecycleOwner（如 Service）