glide

Glide.with(this).load(URL).into(imageView)

with流程

就是返回RequestManager

//Glide.java
private final RequestManagerRetriever requestManagerRetriever;
//此处有context、FragmentActivity、Fragment、View 的类似方法...
//with方法最终返回RequestManager对象
public static RequestManager with(@NonNull FragmentActivity activity) {
    return getRetriever(activity).get(activity);
}
private static RequestManagerRetriever getRetriever(@Nullable Context context) {
    ...
    //其中，Glide.get(context) 基于 DCL 单例
    return Glide.get(context).getRequestManagerRetriever();
}

public RequestManagerRetriever getRequestManagerRetriever() {
	return requestManagerRetriever;
}

RequestManagerRetriever.get(context)

//RequestManagerRetriever.java
//最终返回RequestManager对象。
//会根据传入context不同，分别调用不同的get方法。如果传入的是application，调用getApplicationManager方法。
public RequestManager get(@NonNull 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
                   && ((ContextWrapper) context).getBaseContext().getApplicationContext() != null) {
            return get(((ContextWrapper) context).getBaseContext());
        }
    }

    return getApplicationManager(context);
}

public RequestManager get(@NonNull FragmentActivity activity) {
    //如果不是主线程，就会调用application作用域的get方法
    if (Util.isOnBackgroundThread()) {
        return get(activity.getApplicationContext());
    } else {
        assertNotDestroyed(activity);
        //不同的参数，调用对应的方法获取FragmentManager传入supportFragmentGet方法中获取RequestManager。FragmentManager fm = fragment.getChildFragmentManager(); android.app.FragmentManager fm =activity.getFragmentManager(); 
        FragmentManager fm = activity.getSupportFragmentManager();
        return supportFragmentGet(activity, fm, /*parentHint=*/ null, isActivityVisible(activity));
    }
}
//放回和RequestManagerRetriever绑定的RequestManager applicationManager
private volatile RequestManager applicationManager;
private RequestManager getApplicationManager(@NonNull Context context) {
	return applicationManager;
}

第一种是作用域Application，它的生命周期是全局 的，不搞空白Fragment就绑定Activity/Fragment
第二种是作用域非Application，它的生命周期是，专门搞空白Fragment就绑定 Activity/Fragment

//RequestManagerRetriever.java
// 用于【记录保存】FragmentManager SupportRequestManagerFragment 的映射关系
final Map<FragmentManager, SupportRequestManagerFragment> pendingSupportRequestManagerFragments = new HashMap<>();

private RequestManager supportFragmentGet(Context context,l FragmentManager fm,
    Fragment parentHint, boolean isParentVisible) {
    //从 map中获取 SupportRequestManagerFragment
    SupportRequestManagerFragment current =
        getSupportRequestManagerFragment(fm, parentHint, isParentVisible);
    //从该 Fragment 中获取 RequestManage
    RequestManager requestManager = current.getRequestManager();
    if (requestManager == null) {
        Glide glide = Glide.get(context);
        //实例化的requestManager，要传入fragment中的Lifecycle
        requestManager =factory.build(glide,current.getGlideLifecycle(),
                                      current.getRequestManagerTreeNode(), context);
        //将requestManager设置到fragment中
        current.setRequestManager(requestManager);
    }
    return requestManager;
}
//为了保证一个activity/fragment只创建一个空白的fragment,先通过FragmentManager获取fragment，如果失败，再通过map获取，如果再失败，才new一个fragment。最后发送一个handler是为了删除map中存的fragment
private SupportRequestManagerFragment getSupportRequestManagerFragment(
      @NonNull final FragmentManager fm, ...) {
    SupportRequestManagerFragment current =
        (SupportRequestManagerFragment) fm.findFragmentByTag(FRAGMENT_TAG);
    if (current == null) {
      	current = pendingSupportRequestManagerFragments.get(fm);
     	 if (current == null) {
         	current = new SupportRequestManagerFragment();
        	current.setParentFragmentHint(parentHint);
             //如果父层可见，则调用 onStart() 生命周期
        	if (isParentVisible) {
          		current.getGlideLifecycle().onStart();
        	}
        	pendingSupportRequestManagerFragments.put(fm, current);
            fm.beginTransaction().add(current, FRAGMENT_TAG).commitAllowingStateLoss();
            handler.obtainMessage(ID_REMOVE_SUPPORT_FRAGMENT_MANAGER, fm).sendToTarget();
          }
    }
    return current;
}

// SupportRequestManagerFragment.java
private final ActivityFragmentLifecycle lifecycle;
@Nullable private RequestManager requestManager;

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

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

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

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

ActivityFragmentLifecycle getGlideLifecycle() {
	return lifecycle;
}
//Lifecycle接口有两个实现类ActivityFragmentLifecycle和ApplicationLifecycle分别代表了两个作用域
//ActivityFragmentLifecycle.java
class ActivityFragmentLifecycle implements Lifecycle {
    //用集合Set<LifecycleListener>存储LifecycleListener，当生命周期发生变化，会遍历集合通知监听者，这些监听者就是RequestManager
  private final Set<LifecycleListener> lifecycleListeners =
      Collections.newSetFromMap(new WeakHashMap<LifecycleListener, Boolean>());
 
  @Override
  public void addListener(@NonNull LifecycleListener listener) {
    lifecycleListeners.add(listener);

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

  @Override
  public void removeListener(@NonNull LifecycleListener listener) {
    lifecycleListeners.remove(listener);
  }

  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();
    }
  }


//RequestManager.java
//实例化 RequestManager 时需要一个 Lifecycle对象，这个对象是在无界面 Fragment 中创建的，当 Fragment 的生命周期变化时，就是通过这个Lifecycle 对象将事件分发到 RequestManager
//
public class RequestManager implements LifecycleListener, ... {
    final Lifecycle lifecycle;
    private final RequestTracker requestTracker;
    
    RequestManager(Glide glide, Lifecycle lifecycle, ...){
        ...
        this.lifecycle = lifecycle;
        //添加监听
        lifecycle.addListener(this);
    }
    @Override
    public synchronized void onDestroy() {
        ...
        //移除监听
        lifecycle.removeListener(this);
    }
    
   //重写LifecycleListener 暂停任务（页面不可见）
    public synchronized void onStop() {
        pauseRequests();
        targetTracker.onStop();
    }
  //重写LifecycleListener 恢复任务（页面可见）
    public synchronized void onStart() {
		resumeRequests();
        targetTracker.onStart();
    }
    //重写LifecycleListener 销毁任务（页面销毁）
    public synchronized void onDestroy() {
        targetTracker.onDestroy();
        for (Target<?> target : targetTracker.getAll()) {
        	clear(target);
        }
        targetTracker.clear();
        requestTracker.clearRequests();
        lifecycle.removeListener(this);
        lifecycle.removeListener(connectivityMonitor);
        mainHandler.removeCallbacks(addSelfToLifecycle);
        glide.unregisterRequestManager(this);
    }
    public synchronized void pauseRequests() {
    	requestTracker.pauseRequests();
    }
    public synchronized void resumeRequests() {
    	requestTracker.resumeRequests();
    }
}

Glide.get(context)

//Glide.java
public static Glide get(@NonNull Context context) {
    if (glide == null) {
        GeneratedAppGlideModule annotationGeneratedModule =
            getAnnotationGeneratedGlideModules(context.getApplicationContext());
        synchronized (Glide.class) {
            if (glide == null) {
                checkAndInitializeGlide(context, annotationGeneratedModule);
            }
        }
    }

    return glide;
}
private static void checkAndInitializeGlide(@NonNull Context context) {
    ...
    //是否初始化标志
    isInitializing = true;
    //开始进行初始化
    initializeGlide(context);
    isInitializing = false;
}
private static void initializeGlide(@NonNull Context context)	{
    //实例化一个 GlideBuilder 传入
    initializeGlide(context, new GlideBuilder());
}

private static void initializeGlide(@NonNull Context context,@NonNull GlideBuilder builder){
    Context applicationContext =context.getApplicationContext();
    //这里拿到 @GlideModule 标识的注解处理器生成的GeneratedAppGlideModuleImpl、
    //GeneratedAppGlideModuleFactory ...等等。
    GeneratedAppGlideModule annotationGeneratedModule =getAnnotationGeneratedGlideModules();
    .....
    //通过注解生成的代码拿到 RequestManagerFactory
    RequestManagerFactory factory = annotationGeneratedModule!= null ?							annotationGeneratedModule.getRequestManagerFactory() : null;
    //将拿到的工厂添加到 GlideBuilder
    builder.setRequestManagerFactory(factory);
    ....
    //这里通过 Builder 建造者模式，构建出 Glide 实例对象
    Glide glide = builder.build(applicationContext);
    Iterator var13 = manifestModules.iterator();
    //开始注册组件回调
    while(var13.hasNext()) {
        GlideModule module = (GlideModule)var13.next();
        module.registerComponents(applicationContext, glide,
                                  glide.registry);
    }
    if (annotationGeneratedModule != null) {
        annotationGeneratedModule.registerComponents(applicationContext,
                                                     glide, glide.registry);
    }
    applicationContext.registerComponentCallbacks(glide);
    //将构建出来的 glide 赋值给 Glide 的静态变量
    Glide.glide = glide;
}

//Glide构造方法：将GlideBuilder中初始化的属性保存在自己的成员中；创建了ImageViewTargetFactory；创建了GlideContext （GlideContext extends ContextWrapper）；

//GlideBuilder.java
public final class GlideBuilder {
    //管理线程池
    private Engine engine;
    //对象池(享元模式)，这样做避免重复创建对象，对内存开销有一定效果
    private BitmapPool bitmapPool;
    private ArrayPool arrayPool;
    //GlideExecutor 线程池
    private GlideExecutor sourceExecutor;
    private GlideExecutor diskCacheExecutor;
    //本地磁盘缓存
    private DiskCache.Factory diskCacheFactory;
    //内存缓存
    private MemorySizeCalculator memorySizeCalculator;
    private MemoryCache memoryCache;
    private ConnectivityMonitorFactory connectivityMonitorFactory;
    private int logLevel = Log.INFO;
    private RequestOptions defaultRequestOptions = new RequestOptions();
    @Nullable
    private RequestManagerFactory requestManagerFactory;
    private GlideExecutor animationExecutor;
    private boolean isActiveResourceRetentionAllowed;
    @Nullable
    private List<RequestListener<Object>> defaultRequestListeners;
    private boolean isLoggingRequestOriginsEnabled;
    //都是一些配置信息，用到了 开闭原则。
    ....
        //开始构建，同学们注意：重点留意我写的注释
    @NonNull
    Glide build(@NonNull Context context) {
        //实例化一个网络请求的线程池
        if (sourceExecutor == null) {
            sourceExecutor = GlideExecutor.newSourceExecutor();
        }
        //实例化一个本地磁盘缓存的线程池
        if (diskCacheExecutor == null) {
            享学课堂diskCacheExecutor = GlideExecutor.newDiskCacheExecutor();
        }
        //实例化一个加载图片动画的一个线程池
        if (animationExecutor == null) {
            animationExecutor = GlideExecutor.newAnimationExecutor();
        }
        //实例化一个对图片加载到内存的一个计算
        if (memorySizeCalculator == null) {
            memorySizeCalculator = new
                MemorySizeCalculator.Builder(context).build();
        }
        //实例化一个默认网络连接监控的工厂
        if (connectivityMonitorFactory == null) {
            connectivityMonitorFactory = new
                DefaultConnectivityMonitorFactory();
        }
        //实例化一个 Bitmap 对象池
        if (bitmapPool == null) {
            int size = memorySizeCalculator.getBitmapPoolSize();
            //如果池子里还有可用的，直接加入 最近最少使用的 LruBitmap 容器里
            if (size > 0) {
                bitmapPool = new LruBitmapPool(size);
            } else {
                //如果池子已经满了，那么就装在 BitmapPoolAdapter
                bitmapPool = new BitmapPoolAdapter();
            }
        }
        //实例化一个数组对象池
        if (arrayPool == null) {
            arrayPool = new
                LruArrayPool(memorySizeCalculator.getArrayPoolSizeInBytes());
        }
        //资源内存缓存
        if (memoryCache == null) {
            memoryCache = new
                LruResourceCache(memorySizeCalculator.getMemoryCacheSize());
        }
        //磁盘缓存的工厂
        if (diskCacheFactory == null) {
            diskCacheFactory = new
                InternalCacheDiskCacheFactory(context);
        }
      
        //构建执行缓存策略跟线程池的引擎
        if (engine == null) {
            engine =
                new Engine(
                memoryCache,
                diskCacheFactory,
                diskCacheExecutor,
                sourceExecutor,
                GlideExecutor.newUnlimitedSourceExecutor(),
                GlideExecutor.newAnimationExecutor(),
                isActiveResourceRetentionAllowed);
        }
        if (defaultRequestListeners == null) {
            defaultRequestListeners = Collections.emptyList();
        } else {
            defaultRequestListeners =
                Collections.unmodifiableList(defaultRequestListeners);
        }
        //实例化一个 RequestManagerRetriever 请求管理类
        RequestManagerRetriever requestManagerRetriever =
            new RequestManagerRetriever(requestManagerFactory);
        //实例化 Glide 的地方
        return new Glide(
            context,
            engine,
            memoryCache,
            bitmapPool,
            arrayPool,
            requestManagerRetriever,
            connectivityMonitorFactory,
            logLevel,
            defaultRequestOptions.lock(),
            defaultTransitionOptions,
            defaultRequestListeners,
            isLoggingRequestOriginsEnabled);
    }
}

load流程

就是创建了RequestBuilder 对象

RequestBuilder : 这是一个通用请求构建类，可以处理通用资源类型的设置选项 和启动负载

//RequestManager.java
public RequestBuilder<Drawable> load(@Nullable String string) {
    return asDrawable().load(string);
}

public RequestBuilder<Drawable> load(@Nullable Uri uri) {
    return asDrawable().load(uri);
}

public RequestBuilder<Drawable> load(@Nullable File file) {
    return asDrawable().load(file);
}

public RequestBuilder<Drawable> asDrawable() {
    return as(Drawable.class);
}

public <ResourceType> RequestBuilder<ResourceType> as(@NonNull Class<ResourceType> resourceClass) {
    return new RequestBuilder<>(glide, this, resourceClass,context);
}

//RequestBuilder.java
// 描述加载的数据源-这里可以看做是我们刚刚传递进来的 http://xxxx.png
@Nullable private Object model;
// 描述这个请求是否已经添加了加载的数据源
private boolean isModelSet;

public RequestBuilder<TranscodeType> load(@Nullable String string) {
    return loadGeneric(string);
}

private RequestBuilder<TranscodeType> loadGeneric(@Nullable Object model) {
    this.model = model;
    isModelSet = true;
    return this;
}

into流程

//RequestBuilder.java
public ViewTarget<ImageView, TranscodeType> into(@NonNull ImageView view) {
    Util.assertMainThread();
    Preconditions.checkNotNull(view);
    // 根据 ImageView 布局中的 scaleType 来重构 requestOptions;如果在 xml ImageView 节点中 没有设置 scaleType 那么默认在构造函数中进行了初始化为 mScaleType = ScaleType.FIT_CENTER;  
    BaseRequestOptions<?> requestOptions = this;
    if (!requestOptions.isTransformationSet() && requestOptions.isTransformationAllowed()
        && view.getScaleType() != null) {
    
      switch (view.getScaleType()) {
       .....
        case FIT_CENTER:
        case FIT_START:
        case FIT_END:
          //这里用到了克隆（原型设计模式），选择一个 居中合适 的方案.
          requestOptions = requestOptions.clone().optionalFitCenter();
          break;
       ....
      }
    }
    //调用 into 重载函数，创建一个 ViewTarget
    return into(
        glideContext.buildImageViewTarget(view, transcodeClass),
        /*targetListener=*/ null,
        requestOptions,
        Executors.mainThreadExecutor());
}

//GlideContext.java
public <X> ViewTarget<ImageView, X> buildImageViewTarget(
    @NonNull ImageView imageView, @NonNull Class<X> transcodeClass) {
    return imageViewTargetFactory.buildTarget(imageView, transcodeClass);
}

//ImageViewTargetFactory.java
public <Z> ViewTarget<ImageView, Z> buildTarget(@NonNull ImageView view,
                                                @NonNull Class<Z> clazz) {
    //根据目标的编码类型不同 创建不同的的 ImageViewTarget
    if (Bitmap.class.equals(clazz)) {
        return (ViewTarget<ImageView, Z>) new BitmapImageViewTarget(view);
    } else if (Drawable.class.isAssignableFrom(clazz)) {
        return (ViewTarget<ImageView, Z>) new DrawableImageViewTarget(view);
    } else {
        throw new IllegalArgumentException(
            "Unhandled class: " + clazz + ", try .as (Class).transcode(ResourceTranscoder)");
    }
}
//上面生产 Target 的时候只有调用了  `asBitmap` 才会执行生产 BitmapImageViewTarget ,所以这里我们关注 DrawableImageViewTarget；DrawableImageViewTarget 继承的是 ImageViewTarget 重写的 setResource 函数，实现了显示 Drawable 图片的逻辑，

//DrawableImageViewTarget.java
protected void setResource(@Nullable Drawable resource) {
    view.setImageDrawable(resource);
}

继续into重载

//RequestBuilder.java
private <Y extends Target<TranscodeType>> Y into(
    @NonNull Y target,
    @Nullable RequestListener<TranscodeType> targetListener,
    BaseRequestOptions<?> options,
    Executor callbackExecutor) {
    Preconditions.checkNotNull(target);
    //这里的 isModelSet 是在 load 的时候赋值为 true 的，所以不会抛异常
    if (!isModelSet) {
        throw new IllegalArgumentException("You must call #load() before calling #into()");
    }
    //为这个 http://xxx.png 生成一个 Glide request 请求
    //最后会调用到obtainRequest()方法返回SingleRequest.obtain()，最后就是new了一个SingleRequest
    Request request = buildRequest(target, targetListener, options, callbackExecutor);
    Request previous = target.getRequest();
    ...
    requestManager.clear(target);
    target.setRequest(request);
    //最后是调用 RequestManager 的 track 来执行目标的 Glide request 请求
    requestManager.track(target, request);
    return target;
}

//RequestManager.java
//这里对当前 class 加了一个同步锁避免线程引起的安全性  
synchronized void track(@NonNull Target<?> target, @NonNull Request request) {
    //添加一个目标任务  
    targetTracker.track(target);
    //执行 Glide request
    requestTracker.runRequest(request);
}

//RequestTracker.java
public void runRequest(@NonNull Request request) {
    //先为 `requests` 添加一个请求，看看是否是停止状态，如果不是就调用 `request.begin();`执行
    requests.add(request);
    if (!isPaused) {  
        request.begin();
    } else {
        request.clear();
        pendingRequests.add(request);
    }
}

//SingleRequest.java
public synchronized void begin() {
    assertNotCallingCallbacks();
    stateVerifier.throwIfRecycled();
    startTime = LogTime.getLogTime();
    if (model == null) {
        //检查外部调用的尺寸是否有效
        if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
            width = overrideWidth;
            height = overrideHeight;
        }
        //失败的回调
        int logLevel = getFallbackDrawable() == null ? Log.WARN : Log.DEBUG;
        onLoadFailed(new GlideException("Received null model"), logLevel);
        return;
    }
    if (status == Status.RUNNING) {
        throw new IllegalArgumentException("Cannot restart a running request");
    }

    if (status == Status.COMPLETE) {
        //表示资源准备好了
        onResourceReady(resource, DataSource.MEMORY_CACHE);
        return;
    }


    status = Status.WAITING_FOR_SIZE;
    //这里表示大小已经准备好了
    if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
        //开始
        onSizeReady(overrideWidth, overrideHeight);
    } else {
        target.getSize(this);
    }

    //这里是刚刚开始执行的回调，相当于显示开始的进度
    if ((status == Status.RUNNING || status == Status.WAITING_FOR_SIZE)
        && canNotifyStatusChanged()) {
        target.onLoadStarted(getPlaceholderDrawable());
    }
    if (IS_VERBOSE_LOGGABLE) {
        logV("finished run method in " + LogTime.getElapsedMillis(startTime));
    }
}

…烂尾了

缓存机制

数据封装：key:根据图片地址，长宽等信息生成一个key，可以让磁盘缓存使用
value：对bitmap的封装

活动缓存：整显示在屏幕上的图片
内存缓存：Lru算法实现的缓存
磁盘缓存：DiskLruCache实现的缓存
网络本地：

活动缓存与内存缓存是互斥的