Glide是如何通过RequestManager来管理生命周期的？

我们来看一下glide加载网络图片的基本使用

ImageView imageView = view.findViewById(R.id.image_view);
Glide.with(this).
        load(网络图片地址).
        into(imageView);

任何一个优秀的框架对于内存泄漏的问题都做的很好，要想避免内存泄漏就要在页面的生命周期中做一下事情，那么glide是如何管理和监听页面生命周期的呢，答案就在Glide.with方法中，下面我们来跟一下源码吧，本文以glide3.7.0的源码为例子，有什么分析的不好或者说的错误的地方欢迎指正

glide1.png

经过简单粗暴的操作我们来到了一个重要的方法fragmentGet，我们这里框起来两个重要的对象，一个是RequestManagerFragment，RequestManagerFragment其实是一个空的fragment，RequestManagerFragment具体的代码是这样的

@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
RequestManagerFragment getRequestManagerFragment(final android.app.FragmentManager fm) {
    RequestManagerFragment current = (RequestManagerFragment) fm.findFragmentByTag(FRAGMENT_TAG);
    if (current == null) {
        current = pendingRequestManagerFragments.get(fm);
        if (current == null) {
            current = new RequestManagerFragment();
            pendingRequestManagerFragments.put(fm, current);
            fm.beginTransaction().add(current, FRAGMENT_TAG).commitAllowingStateLoss();
            handler.obtainMessage(ID_REMOVE_FRAGMENT_MANAGER, fm).sendToTarget();
        }
    }
    return current;
}

其实也很简单就是创建出一个RequestManagerFragment通过FragmentManager提交事务的方式将这个fragment添加到页面上，既然RequestManagerFragment可以监听生命周期，我们继续看一下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();
    }
    // 代码略...
}

我们看到如果页面的生命周期发生改变的时候，那么肯定会走RequestManagerFragment的onStart，onStop，onDestroy，这三个方法中都有一个ActivityFragmentLifecycle对象分别执行onStart，onStop，onDestroy，那么我们来看一下ActivityFragmentLifecycle的onStart，onStop，onDestroy这三个方法

class ActivityFragmentLifecycle implements Lifecycle {
    // 存放观察者集合
    private final Set<LifecycleListener> lifecycleListeners =
            Collections.newSetFromMap(new WeakHashMap<LifecycleListener, Boolean>());
            
    @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();
        }
    }
}

我们看到ActivityFragmentLifecycle内部

有一个lifecycleListeners集合，有一个addListener方法可以给lifecycleListeners集合添加数据，onStart，onStop，onDestroy分别会遍历lifecycleListeners集合，这很明显是利用了观察者模式，我们可以先这么理解，ActivityFragmentLifecycle属于RequestManagerFragment，那么被观察者就是RequestManagerFragment，ActivityFragmentLifecycle内部维护了一个被观察者集合lifecycleListeners，观察者就是LifecycleListener，添加观察者的方法就是addListener,比如RequestManagerFragment的生命周期onStart方法执行的时候，会调用到ActivityFragmentLifecycle的onStart方法，ActivityFragmentLifecycle的onStart方法内部就会通知到每一个观察者，那么这个观察者LifecycleListener是什么呢，

public interface LifecycleListener {
    void onStart();
    void onStop();
    void onDestroy();
}

可以看出是个接口，那么接口的实现类是哪个呢，我们继续回到上面框起来的第二个对象RequestManager来看一下

public class RequestManager implements LifecycleListener {
    // Lifecycle是一个接口，实现类是ActivityFragmentLifecycle
    private final Lifecycle lifecycle;
   
    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;
       
        if (Util.isOnBackgroundThread()) {
            new Handler(Looper.getMainLooper()).post(new Runnable() {
                @Override
                public void run() {
                    // 将自身加入到实现了Lifecycle接口的被观察者ActivityFragmentLifecycle中
                    lifecycle.addListener(RequestManager.this);
                }
            });
        } else {
            lifecycle.addListener(this);
        }
        lifecycle.addListener(connectivityMonitor);
    }
    // 实现LifecycleListener中的方法
    @Override
    public void onStart() {
        resumeRequests();
    }

    @Override
    public void onStop() {
        pauseRequests();
    }

    @Override
    public void onDestroy() {
        requestTracker.clearRequests();
    }

}

RequestManager类实现了LifecycleListener接口，并且实现了接口中定义的方法，很显然RequestManager就是上面说的实现了LifecycleListener接口的观察者对象,那么他就

也就是ActivityFragmentLifecycle中所指出的观察者对象，RequestManager的构造函数传入了一个Lifecycle接口，这个Lifecycle接口就是通过传入了一个Lifecycle实现类，这个实现类就是ActivityFragmentLifecycle，RequestManagerFragment通过getLifecycle方法获取的ActivityFragmentLifecycle对象，将其传入RequestManager的构造方法中，通过这样就把RequestManagerFragment、ActivityFragmentLifecycle、RequestManager联系在了一起，当承载RequestManagerFragment的页面生命周期比如onStart执行的时候，RequestManagerFragment的onStart方法会被调用，然后ActivityFragmentLifecycle中的onStart方法会被调用，然后会调用到RequestManager的onStart

glide2.png

至此，RequestManager为什么可以管理生命周期状态的原因分析差不多了。