Glide源码解析之山清水秀疑无路（一）

本篇主要由以下内容构成：
1、框架结构简介
2、按照glide源码使用的时序图进行深入简述的方式讲解
3、核心类和核心模块总结
ps:本人博客写的太少，逻辑有时会走火入魔，希望你看到我的文章，可以理清自己的思路，哈哈，开玩笑。闲话少说，我们来开车，希望老司机来飙车，本篇主要记录自己学习的内容，如果能帮助其他的司机更是好极了。

废话太多，我们开车。

1. 框架结构
   

好了：我这里项目用的是glie-3.7.0的源码，虽然每个源码，有点出入，但是结构上还是没有什么区别的。
它分为：加载策略： load包>data>
主要有：HttpUrlFetcher 网络加载
LocalUriFetcher 本地加载
MediaStoreThumbFetcher 媒体加载 童鞋们可以自己对着看一下

缓存策略： engine>cache
里面有：MemoryCache DiskCache 这里先不说这些
转发策略占和上面的放到下一篇再说。

2.好了我们来根据常用的代码来进一步分析：

Glide.with(mApplication).load(url).into(target);

我们主要来分析一下常用的功能: 先从with下手，`
 public static RequestManager with(Context context) {
        RequestManagerRetriever retriever = RequestManagerRetriever.get();
        return retriever.get(context);
    }

    /**
     * Begin a load with Glide that will be tied to the given {@link android.app.Activity}'s lifecycle and that uses the
     * given {@link Activity}'s default options.
     *
     * @param activity The activity to use.
     * @return A RequestManager for the given activity that can be used to start a load.
     */
    public static RequestManager with(Activity activity) {
        RequestManagerRetriever retriever = RequestManagerRetriever.get();
        return retriever.get(activity);
    }

    /**
     * Begin a load with Glide that will tied to the give {@link android.support.v4.app.FragmentActivity}'s lifecycle
     * and that uses the given {@link android.support.v4.app.FragmentActivity}'s default options.
     *
     * @param activity The activity to use.
     * @return A RequestManager for the given FragmentActivity that can be used to start a load.
     */

//我们主要看这个代码
public static RequestManager with(FragmentActivity activity) { RequestManagerRetriever retriever = RequestManagerRetriever.get(); return retriever.get(activity);

    }

/**
 * Begin a load with Glide that will be tied to the given {@link android.app.Fragment}'s lifecycle and that uses
 * the given {@link android.app.Fragment}'s default options.
 *
 * @param fragment The fragment to use.
 * @return A RequestManager for the given Fragment that can be used to start a load.
 */
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
public static RequestManager with(android.app.Fragment fragment) {
    RequestManagerRetriever retriever = RequestManagerRetriever.get();
    return retriever.get(fragment);

我们看到有很多重载方法，glide已经给你考虑非常周全了，我们只看这个重载方法

public static RequestManager with(FragmentActivity activity) { RequestManagerRetriever retriever = RequestManagerRetriever.get(); return retriever.get(activity);

    }

ok 我们点入 retriever.get(activity),进入  RequestManagerRetriever 这个类，

好了我们接着往下走：

//调用这个方法
  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) {
                return get(((ContextWrapper) context).getBaseContext());
            }
        }

        return getApplicationManager(context);
    }

我们接着看，supportFragmentGet(fragment.getActivity(), fm);做了什么诡秘的操作：

RequestManager supportFragmentGet(Context context, FragmentManager fm) {

//OK 瞪着我们大眼和记住这个类  SupportRequestManagerFragment 这个就是一个空的Fragment
        SupportRequestManagerFragment current = getSupportRequestManagerFragment(fm);
        RequestManager requestManager = current.getRequestManager();
        if (requestManager == null) {
            requestManager = new RequestManager(context, current.getLifecycle(), current.getRequestManagerTreeNode());
            current.setRequestManager(requestManager);
        }
        return requestManager;
    }

我们看到上面的代码，取出一个 SupportRequestManagerFragment 我们进入代码看看它是什么，还都有什么：

//这个一个fragment
public class SupportRequestManagerFragment extends Fragment {
   //还要记住这个成员变量 它是观察者
    private RequestManager requestManager;
    //记住这个成员变量 ActivityFragmentLifecycle lifecycle  它是一个被观察者，它接管了fragemnt
   //的生命周期
    private final ActivityFragmentLifecycle lifecycle;
    private final RequestManagerTreeNode requestManagerTreeNode =
            new SupportFragmentRequestManagerTreeNode();
    private final HashSet<SupportRequestManagerFragment> childRequestManagerFragments =
        new HashSet<SupportRequestManagerFragment>();
    private SupportRequestManagerFragment rootRequestManagerFragment;

    public SupportRequestManagerFragment() {
        this(new ActivityFragmentLifecycle());
    }

    // For testing only.
    @SuppressLint("ValidFragment")
    public SupportRequestManagerFragment(ActivityFragmentLifecycle lifecycle) {
        this.lifecycle = lifecycle;
    }

    /**
     * Sets the current {@link com.bumptech.glide.RequestManager}.
     *
     * @param requestManager The manager to set.
     */
    public void setRequestManager(RequestManager requestManager) {
        this.requestManager = requestManager;
    }

    ActivityFragmentLifecycle getLifecycle() {
        return lifecycle;
    }

    /**
     * Returns the current {@link com.bumptech.glide.RequestManager} or null if none is set.
     */
    public RequestManager getRequestManager() {
        return requestManager;
    }

    /**
     * Returns the {@link RequestManagerTreeNode} that provides tree traversal methods relative to the associated
     * {@link RequestManager}.
     */
    public RequestManagerTreeNode getRequestManagerTreeNode() {
        return requestManagerTreeNode;
    }

    private void addChildRequestManagerFragment(SupportRequestManagerFragment child) {
        childRequestManagerFragments.add(child);
    }

    private void removeChildRequestManagerFragment(SupportRequestManagerFragment child) {
        childRequestManagerFragments.remove(child);
    }
}

好的，先只要记住我注释的几个类，待会一一揭开他们的面目，我们来看看getSupportRequestManagerFragment(final FragmentManager fm)这个方法都做了什么？

SupportRequestManagerFragment getSupportRequestManagerFragment(final FragmentManager fm) {
        SupportRequestManagerFragment current = (SupportRequestManagerFragment) fm.findFragmentByTag(


            FRAGMENT_TAG);
        if (current == null) {
            current = pendingSupportRequestManagerFragments.get(fm);
            if (current == null) {
                current = new SupportRequestManagerFragment();
                pendingSupportRequestManagerFragments.put(fm, current);
                //看到这里是不是知道，我们上面创造的SupportRequestManagerFragment如何当前页面绑定的就是在这里开始绑定的,通过添加事务的方法。
                fm.beginTransaction().add(current, FRAGMENT_TAG).commitAllowingStateLoss();
                handler.obtainMessage(ID_REMOVE_SUPPORT_FRAGMENT_MANAGER, fm).sendToTarget();
            }
        }
        return current;
    }

我们再会到supportFragmentGet(Context context, FragmentManager fm)这个方法；

RequestManager supportFragmentGet(Context context, FragmentManager fm) {
        SupportRequestManagerFragment current = getSupportRequestManagerFragment(fm);
        RequestManager requestManager = current.getRequestManager();
        if (requestManager == null) {
            requestManager = new RequestManager(context, current.getLifecycle(), current.getRequestManagerTreeNode());
            current.setRequestManager(requestManager);
        }
        return requestManager;
    }

我们来在说说 SupportRequestManagerFragment 里面的生命周期方法是如何被 ActivityFragmentLifecycle lifecycle;接管的

    @Override
    public void onStart() {
        super.onStart();
//看见没有   ActivityFragmentLifecycle    lifecycle
        lifecycle.onStart();
    }

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

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

那你肯定要问了 ActivityFragmentLifecycle lifecycle到底是个什么玩意呢？
我们来看看：

 //实现了 Lifecycle 接口， 然后又有 addListener(LifecycleListener listener)方法，一看就像观察者套路
class ActivityFragmentLifecycle implements Lifecycle {
    private final Set<LifecycleListener> lifecycleListeners =
            Collections.newSetFromMap(new WeakHashMap<LifecycleListener, Boolean>());
    private boolean isStarted;
    private boolean isDestroyed;

    /**
     * Adds the given listener to the list of listeners to be notified on each lifecycle event.
     *
     * <p>
     *     The latest lifecycle event will be called on the given listener synchronously in this method. If the
     *     activity or fragment is stopped, {@link LifecycleListener#onStop()}} will be called, and same for onStart and
     *     onDestroy.
     * </p>
     *
     * <p>
     *     Note - {@link com.bumptech.glide.manager.LifecycleListener}s that are added more than once will have their
     *     lifecycle methods called more than once. It is the caller's responsibility to avoid adding listeners
     *     multiple times.
     * </p>
     */
    @Override
    public void addListener(LifecycleListener listener) {
        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 这个接口有啥宝贝：我们要记住这个LifecycleListener 这个接口

**
 * An interface for listening to Activity/Fragment lifecycle events.
 */
public interface Lifecycle {
    /**
     * Adds the given listener to the set of listeners managed by this Lifecycle implementation.
     */
    void addListener(LifecycleListener listener);
}

好了，我们还是去看看LifecycleListener 这个接口有啥好东西，好像里面就是一些感觉定义的是生命周期的方法，但是它是如何和ActivityFragmentLifecycle lifecycle 完成这个订阅的观察者模式呢？

/**
 * An interface for listener to {@link android.app.Fragment} and {@link android.app.Activity} lifecycle events.
 */
public interface LifecycleListener {

    /**
     * Callback for when {@link android.app.Fragment#onStart()}} or {@link android.app.Activity#onStart()} is called.
     */
    void onStart();

    /**
     * Callback for when {@link android.app.Fragment#onStop()}} or {@link android.app.Activity#onStop()}} is called.
     */
    void onStop();

    /**
     * Callback for when {@link android.app.Fragment#onDestroy()}} or {@link android.app.Activity#onDestroy()} is
     * called.
     */
    void onDestroy();
}

好，还记得这个方法么？

 RequestManager supportFragmentGet(Context context, FragmentManager fm) {
 //对就是这个 
        SupportRequestManagerFragment current = getSupportRequestManagerFragment(fm);
        RequestManager requestManager = current.getRequestManager();
        if (requestManager == null) {
            requestManager = new RequestManager(context, current.getLifecycle(), current.getRequestManagerTreeNode());
            current.setRequestManager(requestManager);
        }
        return requestManager;
    }


//我们把2个方法放在一起看一下  
 SupportRequestManagerFragment getSupportRequestManagerFragment(final FragmentManager fm) {
        SupportRequestManagerFragment current = (SupportRequestManagerFragment) fm.findFragmentByTag(


            FRAGMENT_TAG);
        if (current == null) {
            current = pendingSupportRequestManagerFragments.get(fm);
            if (current == null) {
                current = new SupportRequestManagerFragment();
                pendingSupportRequestManagerFragments.put(fm, current);
                fm.beginTransaction().add(current, FRAGMENT_TAG).commitAllowingStateLoss();
                handler.obtainMessage(ID_REMOVE_SUPPORT_FRAGMENT_MANAGER, fm).sendToTarget();
            }
        }
        return current;
    }
//它会new SupportRequestManagerFragment(); 

//最后在SupportRequestManagerFragment内 中实例一个

 public SupportRequestManagerFragment() {
        this(new ActivityFragmentLifecycle());
    }

到了本篇最重要的一个类了RequestManager，我们在上面代码可以看见 ，将ActivityFragmentLifecycle作为参数，传入到RequestManager 构造方法里了。

  if (requestManager == null) {
            requestManager = new RequestManager(context, current.getLifecycle(), current.getRequestManagerTreeNode());
            current.setRequestManager(requestManager);
        }

那既然这样，我们就去RequestManager里面看看，我们先看看这个类都有啥，代码太多我们只看关键的

//惊喜的发现，RequestManager 居然实现LifecycleListener 接口，如果不记得了请自己在看下源码
public class RequestManager implements LifecycleListener {
    private final Context context;
    private final Lifecycle lifecycle; 
    private final RequestManagerTreeNode treeNode;
    private final RequestTracker requestTracker;
    private final Glide glide;
    private final OptionsApplier optionsApplier;
    private DefaultOptions options;

    public RequestManager(Context context, Lifecycle lifecycle, RequestManagerTreeNode treeNode) {
        this(context, lifecycle, treeNode, new RequestTracker(), new ConnectivityMonitorFactory());
    }

    RequestManager(Context context, final Lifecycle lifecycle, RequestManagerTreeNode treeNode,
            RequestTracker requestTracker, ConnectivityMonitorFactory factory) {
        this.context = context.getApplicationContext();
        this.lifecycle = lifecycle;
        this.treeNode = treeNode;
        this.requestTracker = requestTracker;
        this.glide = Glide.get(context);
        this.optionsApplier = new OptionsApplier();

        ConnectivityMonitor connectivityMonitor = factory.build(context,
                new RequestManagerConnectivityListener(requestTracker));

        if (Util.isOnBackgroundThread()) {
            new Handler(Looper.getMainLooper()).post(new Runnable() {
                @Override
                public void run() {
                    lifecycle.addListener(RequestManager.this);
                }
            });
        } else {
            lifecycle.addListener(this);  //看到这里没有，将RequestManager作为观察者，添加到集合里了
        }
        lifecycle.addListener(connectivityMonitor);
    }
}

   lifecycle.addListener(this);  看到这里没有，将RequestManager作为观察者，添加到集合里了。

我们来看看RequestManager如何处理生命周期的？如何解决glide生命周期和activity、fragment等进行同步的，

 @Override
    public void onStart() {
        // onStart might not be called because this object may be created after the fragment/activity's onStart method.
        resumeRequests();
    }

    /**
     * Lifecycle callback that unregisters for connectivity events (if the android.permission.ACCESS_NETWORK_STATE
     * permission is present) and pauses in progress loads.
     */
    @Override
    public void onStop() {
        pauseRequests();
    }

    /**
     * Lifecycle callback that cancels all in progress requests and clears and recycles resources for all completed
     * requests.
     */
    @Override
    public void onDestroy() {
        requestTracker.clearRequests();

我们这里在在看看 resumeRequests();方法，其他的实现，请同学自己看下源码，

 public void resumeRequests() {
        Util.assertMainThread();
        requestTracker.resumeRequests();
    }

接着往下看

  /**
          开始执行请求
     * Starts any not yet completed or failed requests.
     */
    public void resumeRequests() {
        isPaused = false;
        for (Request request : Util.getSnapshot(requests)) {
            if (!request.isComplete() && !request.isCancelled() && !request.isRunning()) {
                request.begin();
            }
        }
        pendingRequests.clear();
    }

好了，到目前为止我们将with的方法说完了，不知道你看懂没有，没有看懂的话，我建议按照这个源码自己多走几遍就好了。

我们来总结下一些关键的类：
RequestManagerRetriever SupportRequestManagerFragment RequestManager

关键的接口： Lifecycle ActivityFragmentLifecycle LifecycleListener

我们在走一遍流程：
Glide.with–> RequestManagerRetriever retriever.get(context)—>retriever.supportFragmentGet(activity, fm)—>retriever.getSupportRequestManagerFragment(FragmentManager fm)

推荐一个比较好的建模工具powerdesigner

附上glide的调用时序图：