Glide与架构组件LifeCycle的生命周期管理

最近在看Glide的源码的时候，发现Glide的生命周期的绑定居然跟Google的架构组件LifeCycle实现原理一模一样，都是通过创建一个隐形的Fragment来实现生命周期控制的。简单看下两者的实现方式（网上详细的写了一大堆，也写得非常好，这里只简单带下流程）
Glide的生命周期绑定：
Glide.with(context)入口

 public static RequestManager with(Context context) {
        RequestManagerRetriever retriever = RequestManagerRetriever.get();
        return retriever.get(context);//通过单例RequestManagerRetriever获取一个RequestManager
    }

**这个get方法才是重点**
RequestManagerRetriever类里面
根据context的类型去创建一个或者获取一个RequestManager对象
    public RequestManager get(Context context) {
        if (context == null) {
            throw new IllegalArgumentException("You cannot start a load on a null Context");
        } else if (Util.isOnMainThread() && !(context instanceof Application)) {
            if (context instanceof FragmentActivity) {
                return get((FragmentActivity) context);
            } else if (context instanceof Activity) {
                return get((Activity) context);
            } else if (context instanceof ContextWrapper) {
            //递归调用，获取上层Context的类型
                return get(((ContextWrapper) context).getBaseContext());
            }
        }
        //如果都不是上面类型，会创建一个Application级别的RequestManager对象
        return getApplicationManager(context);
    }

直接看下get((Activity) context)方法里面做了什么

public RequestManager get(Activity activity) {
        if (Util.isOnBackgroundThread() || Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB) {
            return get(activity.getApplicationContext());
        } else {
            assertNotDestroyed(activity);
            	//重点就是在这了，通过activity去拿到FragmentManager，FM的作用就是负责管理Fragment
            	//如果第一次看这个过程，会比较迷糊，为什么要拿一个FM呢
            android.app.FragmentManager fm = activity.getFragmentManager();
            return fragmentGet(activity, fm);
        }
    }

接着看fragmentGet(activity, fm)

 RequestManager fragmentGet(Context context, android.app.FragmentManager fm) {
 //这个RequestManagerFragment对象就是那个隐形的Fragment
        RequestManagerFragment current = getRequestManagerFragment(fm);
        //获取与当前fragment绑定的RequestManager
        RequestManager requestManager = current.getRequestManager();
        if (requestManager == null) {
        //如果没绑定，讲RequestManagerFragment与RequestManager绑定
            requestManager = new RequestManager(context, current.getLifecycle(), current.getRequestManagerTreeNode());
            current.setRequestManager(requestManager);
        }
        return requestManager;
    }

先看下这个隐形的Fragment是如何获取的

RequestManagerFragment current = getRequestManagerFragment(fm);

RequestManagerFragment getRequestManagerFragment(final android.app.FragmentManager fm) {
			//首先在FragmentManager里面去找一个带FRAGMENT_TAG标签的Fragment
        RequestManagerFragment current = (RequestManagerFragment) fm.findFragmentByTag(FRAGMENT_TAG);
        if (current == null) {
        //如果没找到就到缓存pendingRequestManagerFragments里面去找
        //为什么要加这个缓存呢，
        //因为高并发情况下，新创建的fragment还没有添加进去，导致current一直是空，
        //加个缓存防止多次创建，这也是为什么下面的代码中要发个消息去移除掉刚刚新建的Fragment
            current = pendingRequestManagerFragments.get(fm);
            if (current == null) {
            //缓存里面还没有就new一个
                current = new RequestManagerFragment();
                //先放到缓存里
                pendingRequestManagerFragments.put(fm, current);
                //将新建的隐形Fragment添加到activity中
                fm.beginTransaction().add(current, FRAGMENT_TAG).commitAllowingStateLoss();
                //添加完成后，移除缓存里面的Fragment对象，这个时候已经可以从FM中拿到Fragment了
                handler.obtainMessage(ID_REMOVE_FRAGMENT_MANAGER, fm).sendToTarget();
            }
        }
        return current;
    }

这里有一点要明白的是如果一个activity里多次使用Glide加载图片，这些图片加载的生命周期都是与同一个隐形的Fragment生命周期绑定的
看下RequestManagerFragment

public class RequestManagerFragment extends Fragment {
    private final ActivityFragmentLifecycle lifecycle;
 @Override
    public void onStart() {
        super.onStart();
        lifecycle.onStart();
    }

    @Override
    public void onStop() {
        super.onStop();
        lifecycle.onStop();
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        lifecycle.onDestroy();
    }

}


class ActivityFragmentLifecycle implements Lifecycle { 
//一个列表保存所有需要监听生命周期变化的对象，然后进行生命周期的分发
    private final Set lifecycleListeners =
            Collections.newSetFromMap(new WeakHashMap());
    private boolean isStarted;
    private boolean isDestroyed;


    @Override
    public void addListener(LifecycleListener listener) {
    //注意这个add方法,RequestManager就是一个实现LifecycleListener的对象,下面会调用
        lifecycleListeners.add(listener);

        if (isDestroyed) {
            listener.onDestroy();
        } else if (isStarted) {
            listener.onStart();
        } else {
            listener.onStop();
        }
    }

    void onStart() {
        isStarted = true;
        for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {
            lifecycleListener.onStart();
        }
    }

    void onStop() {
        isStarted = false;
        for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {
            lifecycleListener.onStop();
        }
    }

    void onDestroy() {
        isDestroyed = true;
        for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {
            lifecycleListener.onDestroy();
        }
    }
}

这几个方法就是生命周期的控制了，lifecycle对象会对生命周期进行分发，从而控制Glide的加载生命周期
这里已经有隐形的Fragment了，回到fragmentGet（）方法，看看是如何关联起来的，

 RequestManager fragmentGet(Context context, android.app.FragmentManager fm) {
 //这个RequestManagerFragment对象就是那个隐形的Fragment
        RequestManagerFragment current = getRequestManagerFragment(fm);
        //获取与当前fragment绑定的RequestManager
        RequestManager requestManager = current.getRequestManager();
        if (requestManager == null) {
        //如果没绑定，讲RequestManagerFragment与RequestManager绑定
			//这里new了一个新对象，将RequestManagerFragment中的lifecycle添加到requestManager中
            requestManager = new RequestManager(context, current.getLifecycle(), current.getRequestManagerTreeNode());
            current.setRequestManager(requestManager);
        }
        return requestManager;
    }

看下RequestManager构造器

  RequestManager(Context context, final Lifecycle lifecycle, RequestManagerTreeNode treeNode,
            RequestTracker requestTracker, ConnectivityMonitorFactory factory) {
...
        this.lifecycle = lifecycle;
....

        ConnectivityMonitor connectivityMonitor = factory.build(context,
                new RequestManagerConnectivityListener(requestTracker));
        if (Util.isOnBackgroundThread()) {
            new Handler(Looper.getMainLooper()).post(new Runnable() {
                @Override
                public void run() {
                //将当前LifecycleListener对象添加到上文提到的Fragment中的ActivityFragmentLifecycle列表中去，
                //到了这一步就完成生命周期绑定了，
                //任何隐形Fragment生命周期的变化在RequestManager中都可以监听到了
                    lifecycle.addListener(RequestManager.this);
                }
            });
        } else {
            lifecycle.addListener(this);//同上
        }
.....
    }

总结下就是在Activity中创建一个空白的Fragment或者说隐形Fragment，Glide通过监听该Fragment的生命周期变化来控制自身加载的生命周期变化。
而Google推出的架构组件中的LifeCycle也是一样的道理。上面写的太长了，这里真的只是简单说下，

在activity或者Fragment中都有可以添加一个生命周期的监听者

 getLifecycle().addObserver(new LifecycleObserver() {
            
      。。。。
        });

就这么简单，主要看下getLifeCycle（）
在SupportActivity里面

public class SupportActivity extends Activity implements LifecycleOwner, Component {

    private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);

    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //在activity创建的时候，注入一个ReportFragment，
        //这里其实就是跟Glide一样了，创建一个依附于当前activity的隐形activity 
        ReportFragment.injectIfNeededIn(this);    }
    public Lifecycle getLifecycle() {
        return this.mLifecycleRegistry;
    }

}

看下injectIfNeededIn这个方法，比较有意思的是里面的注释

 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.
            //希望，嗯，我们是第一个去做事务提交的。。。。。 Who konws? God may knon
            manager.executePendingTransactions();
        }
    }

关于LifeCycle的生命周期原理就这样简短说下了，网上一大堆优秀文章。
Glide的生命周期绑定就跟LifeCycle原理一样了，以后如果要做什么生命周期管理的不妨试下这种创建隐形Fragment的方法，毕竟Google都在用了。