LifeCycle原理分析

简述

解耦是永恒不变的话题，但是又不得不做。平时在onCreate方法中初始化，在onDestory中回收资源，这样会使页面和组件之间的耦合度增加，不这样做又会造成内存泄漏。
我们希望对组件的管理，不仅仅是依赖生命周期函数的管理方法。LifeCycle正是因此出现的，组件就能够在内部自己管理自己的生命周期，从而降低模块间的耦合度，并降低内存泄漏的可能性。

LifeCycle的原理

LifeCycle是通过观察者模式，实现对页面生命周期的监听。Jetpack提供了两个类：

• LifecycleObserver：观察者，BasePresenter等需要监控生命周期函数的地方
• LifecycleOwner：被观察者，Activity、Fragment等

作为被观察者，Activity默认实现了LifecycleOwner接口，且该接口中只有一个getLifecycle(LifecycleObserver observer)方法。该方法是实现观察者模式的关键！

1.绑定观察者、被观察者

通过以下代码完成观察者、被观察者之间的绑定：

getLifecycle().addObserver(listener);

addObserver是LifeCycle.java的抽象方法：

@MainThread
public abstract void addObserver(@NonNull LifecycleObserver observer);

其实现在LifecycleRegistry.java中：

@Override
public void addObserver(@NonNull LifecycleObserver observer) {
  	//得到初始化状态，刚进来肯定是INITIALZED
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
  	//observer就是表示层，谁实现了LifecycleObserver接口，谁就是Observer，谁就是观察者
  	//将观察者observer、初始化状态，封装到ObserverWithState中
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
  	//将observer、刚刚封装的ObserverWithState对象，添加到Map中去
    ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

    省略......
}

上面做的就是将初始化状态、观察者都封装到一个ObserverWithState对象中，并将其存储到Map中去。添加到Map的操作：

@Override
public V putIfAbsent(@NonNull K key, @NonNull V v) {
    Entry<K, V> current = get(key);
    if (current != null) {
        return current.mValue;
    }
  	//以observer为K,将封装好的对象存储到HashMap中去
    mHashMap.put(key, put(key, v));
    return null;
}

//这里的mHashMap就是一个HashMap
private HashMap<K, Entry<K, V>> mHashMap = new HashMap<>();
//K：observer
//V：Entry<Observer,ObserverWithState对象>

经过这样的绑定，就能建立起观察者Observer和ObserverWithState的关联关系。

2.被观察者实现LifecycleOwn接口

作为被观察者，Activity、Fragment自身都实现了LifecycleOwner接口。以Activity的父类ComponentActivity为例，它的onCreate方法中有一个行为很显眼：

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mSavedStateRegistryController.performRestore(savedInstanceState);
  	//干了啥？跟Glide一样，添加了一个无UI的空Fragment来搞定生命周期问题
    ReportFragment.injectIfNeededIn(this);
    if (mContentLayoutId != 0) {
        setContentView(mContentLayoutId);
    }
}


//在ReportFragment中，利用FragmentManager添加了一个无UI的空Fragment(和Glide的骚操作一样)。
public static void injectIfNeededIn(Activity activity) {
        // ProcessLifecycleOwner should always correctly work and some activities may not extend
        // FragmentActivity from support lib, so we use framework fragments for activities
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            // Hopefully, we are the first to make a transaction.
            manager.executePendingTransactions();
        }
    }

这样就很明显了，通过添加空Fragment达到掌控生命周期的目的。换句话说，监听这个空Fragment，就能解决生命周期的问题！
这样焦点就落在了这个Fragment的各个生命周期身上了。它们都干了一件事，就是分发事件dispatch(Lifecycle.Event.xxx)：

//因为作为子类的Activity、Fragment都实现了LifecycleObserver接口，所以这里要用 instance of 判断
//一下到底实现了哪个接口。判断完事后，干的事都一样，继续分发事件
//这里dispatch接收的参数，就是被观察者当前所处的状态(ON_CREATE/ON_RESUME等)
private void dispatch(Lifecycle.Event event) {
    Activity activity = getActivity();
    if (activity instanceof LifecycleRegistryOwner) {
        ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
        return;
    }

    if (activity instanceof LifecycleOwner) {
        Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
        if (lifecycle instanceof LifecycleRegistry) {
            ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
        }
    }
}

handleLifecycleEvent分发分发事件：

//何为事件分发？只要页面处于/到达某个状态，Activity、Fragment的就会处于某个状态，即它们的生命周期
//也会相应的到达onCreate或onDestory...
//但凡被观察者要离开onCreate了，那么接下来必然要CREATED
//这里想都不要想，所以表示层观察者Observer也要随机进入到CREATED状态。
//所以，这里要获取当前状态的下一个状态，并将其移动到下一个状态
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
  	//获取当前状态的下一个状态
    State next = getStateAfter(event);
  	//将表示层Observer移动到下一个状态
    moveToState(next);
}


//获取当前状态的下一个状态：
static State getStateAfter(Event event) {
        switch (event) {
            case ON_CREATE:
            case ON_STOP:
                return CREATED;
            case ON_START:
            case ON_PAUSE:
                return STARTED;
            case ON_RESUME:
                return RESUMED;
            case ON_DESTROY:
                return DESTROYED;
            case ON_ANY:
                break;
        }
        throw new IllegalArgumentException("Unexpected event value " + event);
    }


//移动到下一个状态
private void moveToState(State next) {
        if (mState == next) {
            return;
        }
        mState = next;
        if (mHandlingEvent || mAddingObserverCounter != 0) {
            mNewEventOccurred = true;
            // we will figure out what to do on upper level.
            return;
        }
        mHandlingEvent = true;
  			//关键行为：同步！
        sync();
        mHandlingEvent = false;
    }

在移动状态至下一个状态中，有一个关键行为，sync()同步：

// 被观察者Activity、Fragment生命周期	<------>	观察者Observer(BasePresenter)存的初始化状态INITIALIZED
//目的：让观察者（BasePresenter）的状态值和被观察者的生命周期保持一致
private void sync() {
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null) {
        throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
                + "garbage collected. It is too late to change lifecycle state.");
    }
    while (!isSynced()) {
        mNewEventOccurred = false;
        // no need to check eldest for nullability, because isSynced does it for us.
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
          	//向后推
            backwardPass(lifecycleOwner);
        }
        Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) {
          	//向前推
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

为了让观察者和被观察者的生命周期保持同步，需要在sync同步方法中根据情况适宜的向前推、向后推。以向后推为例：

private void backwardPass(LifecycleOwner lifecycleOwner) {
  	//从mObserverMap中取出所有的Entry<observer,ObserverWithState对象>
    Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
            mObserverMap.descendingIterator();
    while (descendingIterator.hasNext() && !mNewEventOccurred) {
        Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
      	//取出Value:ObserverWithState对象
        ObserverWithState observer = entry.getValue();
        while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                && mObserverMap.contains(entry.getKey()))) {
            Event event = downEvent(observer.mState);
          	//先push当前状态，备份保存
            pushParentState(getStateAfter(event));
          	//事件分发的精髓在这！
            observer.dispatchEvent(lifecycleOwner, event);
          	//最后pop状态，恢复，防异常
            popParentState();
        }
    }
}

事件分发的精髓，observer.dispatchEvent(lifecycleOwner, event)分发：

//静态类ObserverWithState，里面封装了观察者Observer、页面状态State
static class ObserverWithState {
    State mState;
    LifecycleEventObserver mLifecycleObserver;

    ObserverWithState(LifecycleObserver observer, State initialState) {
        mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
        mState = initialState;
    }

    void dispatchEvent(LifecycleOwner owner, Event event) {
      	//获取下一个状态，最新值
        State newState = getStateAfter(event);
      	//用ObserverWithState中存的状态，和刚拿到的新状态，取最小
        mState = min(mState, newState);
      	//去修改状态了
        mLifecycleObserver.onStateChanged(owner, event);
      	//更新当前状态值
        mState = newState;
    }
}

在比较完状态后，就要去修改状态了mLifecycleObserver.onStateChanged(owner, event)。onStateChanged是接口LifecycleEventObserver中的接口方法，实现在ReflectiveGenericLifecycleObserver中：

class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
  	//mWrapped ---> LifecycleObserver 指的就是观察者
    private final Object mWrapped;
    private final CallbackInfo mInfo;

    ReflectiveGenericLifecycleObserver(Object wrapped) {
        mWrapped = wrapped;
        mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
    }

    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Event event) {
        mInfo.invokeCallbacks(source, event, mWrapped);
    }
}

getInfo —> createInfo(mWrapped.getClass):

private CallbackInfo createInfo(Class<?> klass, @Nullable Method[] declaredMethods) {
    Class<?> superclass = klass.getSuperclass();
    Map<MethodReference, Lifecycle.Event> handlerToEvent = new HashMap<>();
    if (superclass != null) {
        CallbackInfo superInfo = getInfo(superclass);
        if (superInfo != null) {
            handlerToEvent.putAll(superInfo.mHandlerToEvent);
        }
    }

    Class<?>[] interfaces = klass.getInterfaces();
    for (Class<?> intrfc : interfaces) {
        for (Map.Entry<MethodReference, Lifecycle.Event> entry : getInfo(
                intrfc).mHandlerToEvent.entrySet()) {
            verifyAndPutHandler(handlerToEvent, entry.getKey(), entry.getValue(), klass);
        }
    }

  	//拿到表示层BasePresenter所有的方法，放在Method[]数组中
    Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
    boolean hasLifecycleMethods = false;
  	//迭代遍历这个数组
    for (Method method : methods) {
      	//拿到每个方法的注解
        OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
      	//没写注解的，不理你
        if (annotation == null) {
            continue;
        }
        hasLifecycleMethods = true;
      	//有注解，就取方法的参数
        Class<?>[] params = method.getParameterTypes();
        int callType = CALL_TYPE_NO_ARG;
        if (params.length > 0) {
            callType = CALL_TYPE_PROVIDER;
            if (!params[0].isAssignableFrom(LifecycleOwner.class)) {
                throw new IllegalArgumentException(
                        "invalid parameter type. Must be one and instanceof LifecycleOwner");
            }
        }
        Lifecycle.Event event = annotation.value();

        if (params.length > 1) {
            callType = CALL_TYPE_PROVIDER_WITH_EVENT;
            if (!params[1].isAssignableFrom(Lifecycle.Event.class)) {
                throw new IllegalArgumentException(
                        "invalid parameter type. second arg must be an event");
            }
            if (event != Lifecycle.Event.ON_ANY) {
                throw new IllegalArgumentException(
                        "Second arg is supported only for ON_ANY value");
            }
        }
        if (params.length > 2) {
            throw new IllegalArgumentException("cannot have more than 2 params");
        }
        MethodReference methodReference = new MethodReference(callType, method);
        verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
    }
    CallbackInfo info = new CallbackInfo(handlerToEvent);
    mCallbackMap.put(klass, info);
    mHasLifecycleMethods.put(klass, hasLifecycleMethods);
    return info;
}

在拿到mInfo后，就调用mInfo.invokeCallbacks(source, event, mWrapped)：

void invokeCallbacks(LifecycleOwner source, Lifecycle.Event event, Object target) {
    invokeMethodsForEvent(mEventToHandlers.get(event), source, event, target);
    invokeMethodsForEvent(mEventToHandlers.get(Lifecycle.Event.ON_ANY), source, event,
            target);
}

private static void invokeMethodsForEvent(List<MethodReference> handlers,
                LifecycleOwner source, Lifecycle.Event event, Object mWrapped) {
            if (handlers != null) {
                for (int i = handlers.size() - 1; i >= 0; i--) {
                  	//根据参数的个数，反射执行注解方法
                    handlers.get(i).invokeCallback(source, event, mWrapped);
                }
            }
        }

void invokeCallback(LifecycleOwner source, Lifecycle.Event event, Object target) {
            //noinspection TryWithIdenticalCatches
            try {
                switch (mCallType) {
                    case CALL_TYPE_NO_ARG:
                        mMethod.invoke(target);
                        break;
                    case CALL_TYPE_PROVIDER:
                        mMethod.invoke(target, source);
                        break;
                    case CALL_TYPE_PROVIDER_WITH_EVENT:
                        mMethod.invoke(target, source, event);
                        break;
                }
            } catch (InvocationTargetException e) {
                throw new RuntimeException("Failed to call observer method", e.getCause());
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            }
        }

3.总结

LifeCycle提供了两个类LifecycleObserver、LifecycleOwner分别充当观察者、被观察者，通过观察者模式，完成对页面生命周期的监听。

作为被观察者（以Activity为例），ComponentActivity已经实现了LifecycleOwner接口，因为我们只需要负责观察者部分的代码即可。

addObserver就是对各对象、状态的封装保存。将观察者Observer、初始化状态封装为ObserverWithState对象，并以键值对（K：observer对象 V:Entry<Observer,ObserverWithState对象>）的形式将其保存到HashMap中。

被观察者Activity、Fragment等它们自身都实现了LifecycleOwner接口。有一个显眼动作，和Glide一样，添加了一个无UI的空Fragment，通过监听这个Fragment来搞定生命周期的监听问题！在这个空Fragment的各个生命周期函数中都执行了dispatch方法用来分发事件。dispatch方法接收的参数就是这个无UI的ReportFragment所处的状态（ON_CREATE、ON_START、ON_RESUME等）。当页面处于某个状态，Activity、Fragment也会到达响应的状态，它们的生命周期也会相应的执行onCreate、onDestory等。拿到被观察者的状态后，就sync同步观察者的状态（向前推、向后推），为的就是让观察者、被观察者保持一致。在sync的向前/后推的过程中，就用到了最初封装保存在HashMap中的对象、状态了。①先push当前状态，以做备份保存 ②执行状态分发 ③最后pop状态，恢复、防异常

携带状态、做状态分发的过程：获取下一个状态的最新值，和从ObserverWithState取出的状态值比较取小,修改并更新状态值。修改状态时，会拿到观察者所有的方法，并放到Method数组中。迭代遍历这个Method数组，拿到每个方法的注解（没写注解的就不鸟它），并拿到所有的参数。根据参数的个数，反射执行注解方法。这样一来，被观察者有点风吹草动，观察者就能立马响应并作出应变！