基本用法
先来说一下 Lifecycles 的基本用法：观察者模式
1. 如果想要某一个类监听 Activity 或者 Fragment 的生命周期，我们需要让这个类 实现 LifcycleObserver这个接口，然后再把 @OnLifecycleEvent(Lifecycle.Event.ON_CREATE) @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)....这些注解标识在你自己定义的对应的方法上，一旦我们的 Activity(Fragment)发生对应的生命周期状态的变化的时候，那么这些自己定义的方法就会对应跟着执行了
2. Activity上怎么用？ 很简单，只要一个绑定，调用一下下面的方法
getLifecycle().addObserver(presenter);绑定我需要绑定的那个对象(observer),这样监听就完成了
所以Lifecycle 的用法很简单
在这里实现了 LifecycleObserver 接口的类就是观察者，而被观察者一般为 Activity 或者 Fragment 这些具有生命周期的一类组件，下面来一个MVP 的例子
用法实例
首先这里用 Presenter 来作为观察者：
public class BasePresenter<T extends IBaseView> implements LifecycleObserver {
WeakReference<T> iGoodsView;
......
@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
void onCreateX(LifecycleOwner owner) {
//自定义的包含注解onLifeccleEvent的方法
}
......
@OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
void onDestory(LifecycleOwner owner) {
}
@OnLifecycleEvent(Lifecycle.Event.ON_ANY)
void onAny(LifecycleOwner owner) {
}
}
public class GoodsPresenter<T extends IGoodsView> extends BasePresenter{
IGoodsModel iGoodsModel=new GoodsModel();
......
@Override
void onCreateX(LifecycleOwner owner) {
super.onCreateX(owner);
Log.i("jett","create");
}
@Override
void onDestory(LifecycleOwner owner) {
super.onDestory(owner);
Log.i("jett","destroy");
}
}被观察者是一个Activity，这里就不贴代码了，Activity中调用了下面这句代码用来绑定观察者与被观察者，Activity默认就是被观察者，因为其父类 ComponentActivity 实现了 LifecycleOwner 这个接口
getLifecycle().addObserver(presenter);源码解析
任何一个类只要实现了 LifecycleObserver 就可以用来作为观察者，看一下这个类
public interface LifecycleObserver {
}
是一个空的接口，我们实现这个接口之后，需要在我们自定义的方法添加下面类型的注解：
@OnLifecycleEvent(Lifecycle.Event.ON_START)@OnLifecycleEvent(Lifecycle.Event.ON_STOP)再来看一下被观察者实现的接口，这个接口不需要我们自己实现，系统已帮我们实现
public interface LifecycleOwner {
Lifecycle getLifecycle();
}可以看到接口里只有一个返回 Lifecycle 的方法，看一下 Lifecycle是个什么东西
public abstract class Lifecycle {
.....
//添加一个观察者，将观察者与被观察者进行绑定
@MainThread
public abstract void addObserver(@NonNull LifecycleObserver observer);
//删除一个观察者
@MainThread
public abstract void removeObserver(@NonNull LifecycleObserver observer);
......
//重要枚举，对应于观察者(presenter)的状态
public enum Event {
ON_CREATE,
ON_START,
ON_RESUME,
......
}
//重要枚举，对应了被观察者(Activity Fragment)的生命周期状态
public enum State {
DESTROYED,
INITIALIZED,
CREATED,
......
}
}
这里有两个重要方法，两个重要的枚举，代码中已经加了注释，接下来一步步分析源码
首先从 Activity 的 addObserver 方法开始入手，LifecycleRegistry实现了该方法
LifecycleRegistry.java//在我们的MVP的这个实例中，这里传的observer参数就是观察者的实现类 GoodsPresenter
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
//一进来的状态就是 初始化的状态
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
//包装了一个状态类，并且把状态一起保存进去了，所以现在表示层(观察者Goodspresenter)
//就附带了它的状态信息,ObserverWithState 这个类就是观察者和它的状态
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
//以自己为键又做了一个包装，自己为键，把上面的statefulObserver 作为值存进了一个Map里面
//mObserverMap这个Map是 FastSafeIterableMap，点进去看下它的put方法，发现就是一个hashmap
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
以上三行代码，完成了一个绑定功能
......ComponentActivity实现了LifecycleOwner接口，Activity一启动就会执行它的onCreate方法
CompontentActivity.java
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mSavedStateRegistryController.performRestore(savedInstanceState);
//执行注入,进入这个方法
ReportFragment.injectIfNeededIn(this);
if (mContentLayoutId != 0) {
setContentView(mContentLayoutId);
}
}ReportFragment.java
public static void injectIfNeededIn(Activity activity) {
//实际上就是添加了一个Fragment ReportFragment，这个Fragment没有任何的界面
//所以在 Activity上面绑定个Fragment，但是没有UI,类似Glide，绑定上这个Fragement
//之后就可以监听这个Fragment的生命周期
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();
}
}接下来看一下这个 ReportFragment的生命周期方法，每个生命周期方法里都会调用dispatch进行事件分发， 一旦Activity生命周期发生变化的时候，就会触发观察者中添加注解的方法
@Override
public void onStart() {
super.onStart();
dispatchStart(mProcessListener);
dispatch(Lifecycle.Event.ON_START);
}
@Override
public void onResume() {
super.onResume();
dispatchResume(mProcessListener);
dispatch(Lifecycle.Event.ON_RESUME);
}private void dispatch(Lifecycle.Event event) {
//做类型判断，LifecycleRegistryOwner。。这些类最后都是实现了LifecycleOwner,
//可以直接获取到一个Lifecycle，这里需要看的是 handleLifecycleEvent 这个功能
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);
}
}
}看一下LifecycleRegistry.java 里的 handleLifecycleEvent 这个功能,这个类实现了Lifecycle
我们通过getLifecycle()方法赶回的就是这个实现类
public class LifecycleRegistry extends Lifecycle {public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
//首先要获取到 我们状态的下一个状态，
//什么叫 下一个状态？getStateAfter 点进去看一下
State next = getStateAfter(event);
moveToState(next);
}//case语句是按照用户的行为习惯来编写的
//比如说现在我们Activity的生命周期是ON_CREATE: 或者ON_STOP:
//那么下面出现的就只有CREATED;后边也都是同样的道理
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);
}moveToState 方法里会执行一个重要的方法：同步 sync();
同步的作用就是：因为一开始执行的时候上面提到，presenter(就是观察者)一开始的状态是INITIALIZED(就是和Activity建立绑定关联时的状态) 我们这里做一个同步期望就是 presenter的状态和被观察(Activity)的状态做一个同步,把他们的状态处理成相同的,当走到sync方时，Activity或者Fragment之前一直在运行，哪个状态都有可能，而presenter(就是观察者)在和Activity建立绑定关联时 一直到sync方法，一直都是 INITIALIZED 状态，没有发生变化，所以要把它们的状态进行一个同步
private void sync() {
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
.....
//如果他们的状态没有同步就会执行两种操作：一种是往前面推，一种是往后面推(正推，逆推)
while (!isSynced()) {
mNewEventOccurred = false;
// no need to check eldest for nullability, because isSynced does it for us.
//这里的 mObserverMap 就是之前存了初始化状态的那个Map FastSafeIterableMap
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;
}private void forwardPass(LifecycleOwner lifecycleOwner) {
//拿到存储presenter状态的迭代器，mObserverMap 就是之前addObserver时存储 presenter状态的Map
Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
mObserverMap.iteratorWithAdditions();
while (ascendingIterator.hasNext() && !mNewEventOccurred) {
Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
//把 observer 一个一个拿出来，之前分析过是把 observer作为key放到Map里的
//注意：因为这里可能会有多个观察者，比如当前有十个类观察 Activity 的生命周期
ObserverWithState observer = entry.getValue();
while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
//把状态保存下来，就是用一个数组保存起来了，后边dispatchEvent出问题了
//可以回退找到原来的状态,就是做了一个记录,这里不是用的栈，不需要仔细了解
pushParentState(observer.mState);
//核心代码，分发事件
observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
popParentState();//dispatch之后再把状态弹出
}
}
}disPatchEvent方法是 LifecycleRegistry 的内部类 ObserverWithState 的方法
//开始的时候 observer和它的状态值是保存在 ObserverWithState 里的，之前的addObserver 方法里有
static class ObserverWithState {//封装了观察者和它的状态
State mState;
LifecycleEventObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
//lifecycleEventObserver这个方法里判断了是不是不同类型的 observer，
//最后可以认为是同一个observer，所以可以先忽略下面这句
//注意这个方法里传入的是观察者observer
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}
void dispatchEvent(LifecycleOwner owner, Event event) {
//这里调用 getStateAfter 又回到了之前的那个方法
State newState = getStateAfter(event);
mState = min(mState, newState);
//取到一个状态值后执行 onStateChanged
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}看一下 mLifecycleObserver.onStateChanged 这个接口方法，它的实现类有很多，但是所有实现类绕来绕去最后都会到一个地方来
ReflectiveGenericLifecycleObserver 实现类中
public interface LifecycleEventObserver extends LifecycleObserver {
void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}
class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
//这个类的执行时序是：先执行构造方法，再去执行 onStateChanged 方法
private final Object mWrapped;
private final CallbackInfo mInfo;
ReflectiveGenericLifecycleObserver(Object wrapped) {
//这里mWrapped是上面传进来的观察者obserber
mWrapped = wrapped;
//mWrapped.getClass() 返回的 class 对象 对应着我们之前自己写的观察者类，
//这里是指 Basepresenter的class对象 它是观察者所以 mWrapped.getClass()
//返回的是 Basepresenter.class 这里返回的方法 mInfo 就是包含Basepresenter
//里面所有包含 OnLifecycleEvent 注解的方法
mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
}
@Override
public void onStateChanged(LifecycleOwner source, Event event) {
mInfo.invokeCallbacks(source, event, mWrapped);
}
}
至于 mWrapped 为什么就是观察者 obaserver，我们看一下Lifecycling.lifecycleEventObserver 这个方法调用时传入的参数就是观察者 observer
static LifecycleEventObserver lifecycleEventObserver(Object object) {
......
return new ReflectiveGenericLifecycleObserver(object);
}
看最后返回时new了一个ReflectiveGenericLifecycleObserver，传入的参数就是观察者
我们接下来看一下ClassesInfoCache的 getInfo里的实现过程
CallbackInfo getInfo(Class klass) {
CallbackInfo existing = mCallbackMap.get(klass);
if (existing != null) {
return existing;
}
existing = createInfo(klass, null);
return existing;
}private CallbackInfo createInfo(Class klass, @Nullable Method[] declaredMethods) {
Class superclass = klass.getSuperclass();
......
// 这里把 Basepresenter 里的方法 全部反射到了，注意Basepresenter里面有注解方法，
//注解类型为 OnLifecycleEvent
Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
boolean hasLifecycleMethods = false;
for (Method method : methods) {
//遍历每一个方法看这个方法是否存在 OnLifecycleEvent注解
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;
.....
}
//这个value方法返回的值对应了Lifecycle.Event.ON_DESTROY 等这些值，
//也就是Activity的生命周期
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后会在onStateChange中执行 invokeCallbacks 方法
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://执行没有参数的情况
//根据注解信息反射执行对应的方法，之后通过native方法执行，先暂时不用关注
//根据反射信息，只判断了参数的个数我们这个例子是需要执行 GoodsPresenter 里的
//onCreateX(LifecycleOwner owner) 和 onDestory(LifecycleOwner owner)方法
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);
}
}
时序图
最后来一个时序图，来帮我们理清思路
至此分析完毕
