先上图,Glide代码太多，所以 就整理了一下简单流程讲解
这就是Glide大概的流程图。
Glide整体简化图.png
首先写下Glide基本用法比较简单
final String url = "https://img1.baidu.com/it/u=4186787118,517350218&fm=26&fmt=auto&gp=0.jpg";
Glide.with(this).load(url).into(iv_image1);
主要是with,load,into方法，Glide整体主流程也是围绕着这个方法，现在就按照这三个方向来分析一下Glide主流程
1.with() 方法
with()方法有很多参数，这里只看Activity作为参数的情况。
public static RequestManager with(Activity activity) {
RequestManagerRetriever retriever = RequestManagerRetriever.get();
return retriever.get(activity);
}
RequestManagerRetriever 是一个单例类，可以理解为一个工厂类， 负责创建RequestManager，或者从Activity或Fragment找出RequestManager
@NonNull
private static RequestManagerRetriever getRetriever(@Nullable Context context) {
return Glide.get(context).getRequestManagerRetriever();
}
这里的Glide.get()方法中主要是通过GlideBuilder.build方法初始化Glide
@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(),
animationExecutor,
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,
defaultRequestOptionsFactory,
defaultTransitionOptions,
defaultRequestListeners,
isLoggingRequestOriginsEnabled,
isImageDecoderEnabledForBitmaps);
}
- 网络监听
前面我们知道了 Glide通过GlideBuilder完成了初始化，在初始化中有ConnectivityMonitorFactory 这个类
public class DefaultConnectivityMonitorFactory implements ConnectivityMonitorFactory {
private static final String TAG = "ConnectivityMonitor";
private static final String NETWORK_PERMISSION = "android.permission.ACCESS_NETWORK_STATE";
@NonNull
@Override
public ConnectivityMonitor build(
@NonNull Context context, @NonNull ConnectivityMonitor.ConnectivityListener listener) {
int permissionResult = ContextCompat.checkSelfPermission(context, NETWORK_PERMISSION);
boolean hasPermission = permissionResult == PackageManager.PERMISSION_GRANTED;
if (Log.isLoggable(TAG, Log.DEBUG)) {
Log.d(
TAG,
hasPermission
? "ACCESS_NETWORK_STATE permission granted, registering connectivity monitor"
: "ACCESS_NETWORK_STATE permission missing, cannot register connectivity monitor");
}
return hasPermission
? new DefaultConnectivityMonitor(context, listener)
: new NullConnectivityMonitor();
}
}
在ConnectivityMonitorFactory中接收一个 ConnectivityListener 根据是否有监控网络状态的权 限来创建相应的网络监控器。 DefaultConnectivityMonitor 也比较简单，就是内部定义了一个广播 接收者，并且也实现了 lifeCycleListener
//监听网络广播
private final BroadcastReceiver connectivityReceiver =
new BroadcastReceiver() {
@Override
public void onReceive(@NonNull Context context, Intent intent) {
boolean wasConnected = isConnected;
isConnected = isConnected(context);
if (wasConnected != isConnected) {
if (Log.isLoggable(TAG, Log.DEBUG)) {
Log.d(TAG, "connectivity changed, isConnected: " + isConnected);
}
listener.onConnectivityChanged(isConnected);
}
}
};
private void register() {
if (isRegistered) {
return;
}
// Initialize isConnected.
isConnected = isConnected(context);
try {
// 这里注册了广播
context.registerReceiver(
connectivityReceiver, new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION));
isRegistered = true;
} catch (SecurityException e) {
// See #1417, registering the receiver can throw SecurityException.
if (Log.isLoggable(TAG, Log.WARN)) {
Log.w(TAG, "Failed to register", e);
}
}
}
- 绑定生命周期
接下来就是RequestManagerRetriever 类，它是一个单例类，可以理解为一个工厂类， 通过 get 方法接收不同的参数，来创建 RequestManager
public RequestManager get(@NonNull Activity activity) {
if (Util.isOnBackgroundThread()) {
return get(activity.getApplicationContext());
} else {
assertNotDestroyed(activity);
android.app.FragmentManager fm = activity.getFragmentManager();
return fragmentGet(activity, fm, /*parentHint=*/ null, isActivityVisible(activity));
}
@SuppressWarnings({"deprecation", "DeprecatedIsStillUsed"})
@Deprecated
@NonNull
private RequestManager fragmentGet(
@NonNull Context context,
@NonNull android.app.FragmentManager fm,
@Nullable android.app.Fragment parentHint,
boolean isParentVisible) {
RequestManagerFragment current = getRequestManagerFragment(fm, parentHint, isParentVisible);
//获取 RequestManagerFragment，并获取绑定到这个 fragment 的 RequestManager
RequestManager requestManager = current.getRequestManager();
if (requestManager == null) {
//如果获取 RequestManagerFragment 还没有绑定过 RequestManager，那么就创建 RequestManager 并绑定到 RequestManagerFragment
Glide glide = Glide.get(context);
requestManager =
factory.build(
glide, current.getGlideLifecycle(), current.getRequestManagerTreeNode(), context);
current.setRequestManager(requestManager);
}
return requestManager;
}
这里以Activity为例，通过with方法在当前Activity中增加了一个空白的RequestManagerFragment，同时也实例了RequestManager请求管理类，同时也将RequestManagerFragment的lifecycle生命周期的监听传给了RequestManager,这是主要的实现代码
private RequestManagerFragment getRequestManagerFragment(
@NonNull final android.app.FragmentManager fm,
@Nullable android.app.Fragment parentHint,
boolean isParentVisible) {
RequestManagerFragment current = (RequestManagerFragment) fm.findFragmentByTag(FRAGMENT_TAG);
if (current == null) {
current = pendingRequestManagerFragments.get(fm);
if (current == null) {
current = new RequestManagerFragment();
current.setParentFragmentHint(parentHint);
if (isParentVisible) {
current.getGlideLifecycle().onStart();
}
pendingRequestManagerFragments.put(fm, current);
fm.beginTransaction().add(current, FRAGMENT_TAG).commitAllowingStateLoss();
handler.obtainMessage(ID_REMOVE_FRAGMENT_MANAGER, fm).sendToTarget();
}
}
return current;
}
这里需要关注一下RequestManagerFragment 构造方法
public RequestManagerFragment() { this(new ActivityFragmentLifecycle()); }
直接创建一个 ActivityFragmentLifecycle，这个类实际是一个生命周期回调的管理类，实现了 Lifecycle 接口。所有的 LifecycleListener 会 添加到一个集合中，当 RequestManagerFragment 生命周期方法触 发时，会调用 ActivityFragmentLifecycle 相应生命周期方法，这个方 法然后再遍历调用所有 LifecycleListener 的生命周期方法，以 onStart 生命周期方法为例，RequestManagerFragment 中：
public void onStart() { super.onStart(); lifecycle.onStart(); }
这是在中在ActivityFragmentLifecycle 中：
void onStart() {
isStarted = true;
for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {
lifecycleListener.onStart();
} }
到了这里我们看下RequestManager类，这个请求管理类构造方法
RequestManager(
Glide glide,
Lifecycle lifecycle,
RequestManagerTreeNode treeNode,
RequestTracker requestTracker,
ConnectivityMonitorFactory factory,
Context context) {
this.glide = glide;
this.lifecycle = lifecycle;
this.treeNode = treeNode;
this.requestTracker = requestTracker;
this.context = context;
connectivityMonitor =
factory.build(
context.getApplicationContext(),
new RequestManagerConnectivityListener(requestTracker));
//这里只是添加生命周期监听，Fragment 传递过来的
// This should be entirely safe.
if (Util.isOnBackgroundThread()) {
mainHandler.post(addSelfToLifecycle);
} else {
lifecycle.addListener(this);
}
//添加网络变化的监听
lifecycle.addListener(connectivityMonitor);
defaultRequestListeners =
new CopyOnWriteArrayList<>(glide.getGlideContext().getDefaultRequestListeners());
setRequestOptions(glide.getGlideContext().getDefaultRequestOptions());
glide.registerRequestManager(this);
}
到这里请求管理类 RequestManager + Fragment 已经绑定成功了，生命周期监听也设置了。
这样子整个生命周期是从发起Fragment 到LifeCycle 再传给RequestManager 再到RequestTracker，RequestTracker 即所有请求操作的真正处理者，所有 Request 的暂停 取消执行操作都由 RequestTracker 来完成。
@Override
public synchronized void onStart() {
resumeRequests();
targetTracker.onStart();
}
@Override
public synchronized void onStop() {
pauseRequests();
targetTracker.onStop();
}
/**
* Lifecycle callback that cancels all in progress requests and clears and recycles resources for
* all completed requests.
*/
@Override
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);
}
这个RequestManager LifecycleListener中的onStart，onStop，onDestroy方法，这里主要是通过对RequestManagerFragment的生命周期监听来做对应的请求策略。
2.load方法
RequestBuilder : 这是一个通用请求构建类，可以处理通用资源类型的设置选项和启动负载。
load 函数加载相对于比较简单。我们看下具体代码实现
public class RequestBuilder<TranscodeType> extends BaseRequestOptions<RequestBuilder<TranscodeType>>
implements Cloneable, ModelTypes<RequestBuilder<TranscodeType>> {
public RequestBuilder<Drawable> load(@Nullable String string) {
//这里调用 Drawable 图片加载请求器为其加载
return asDrawable().load(string);
}
public RequestBuilder<TranscodeType> load(@Nullable String string) {
return loadGeneric(string);
}
// 描述加载的数据源-这里可以看做是我们刚刚传递进来http://xxxx.png
@Nullable private Object model;
// 描述这个请求是否已经添加了加载的数据源
private boolean isModelSet;
private RequestBuilder<TranscodeType> loadGeneric(@Nullable Object model) {
this.model = model; isModelSet = true; return this;
} }
到这里 RequestBuilder 就构建好了， RequestBuilder构建出来后，都是为了后面的into方法
3. into方法
public ViewTarget<ImageView, TranscodeType> into(@NonNull ImageView view) {
Util.assertMainThread();
//调用 into 重载函数，创建一个 ViewTarget
return into(
//调用 buildImageViewTarget 构建一个 ImageView 类型的Target(Bitmap/Drawable)，
glideContext.buildImageViewTarget(view, transcodeClass),
/*targetListener=*/ null,
requestOptions,
Executors.mainThreadExecutor());
}
这里是构建ViewTarget，它集成自BaseTarget，相当于是Glide处理完结果的回调，负责处理最后的结果，并且带有生命周期。在load()方法中传入的string url ，所以buildImageViewTarget会构建出DrawableImageViewTarget。接下来看重载的into()方法
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 请求
Request request = buildRequest(target, targetListener, options, callbackExecutor);
// 获取target之前的request，上次请求存在target.getTag中
Request previous = target.getRequest();
//判断是否要开始这一次的请求
if (request.isEquivalentTo(previous)
&& !isSkipMemoryCacheWithCompletePreviousRequest(options, previous)) {
if (!Preconditions.checkNotNull(previous).isRunning()) {
//开始上一次的请求
previous.begin();
}
return target;
}
//先清除本次的target，再track开始此次请求
requestManager.clear(target);
//重新为目标设置一个 Glide request 请求
target.setRequest(request);
//最后是调用 RequestManager 的 track 来执行目标的 Glide request 请求,启动、追踪
requestManager.track(target, request);
return target;
}
这里buildRequest会为target 创建了一个Request请求，方法内部会根据情况创建一个SingleRequest 目标图片请求（目标图片请求，在请求开始启动)。
requestManager.track(target, request) 开始此次真正的请求
////这里对当前 class 加了一个同步锁避免线程引起的安全性
synchronized void track(@NonNull Target<?> target, @NonNull Request request) {
//添加一个目标任务
targetTracker.track(target);
//执行 Glide request
requestTracker.runRequest(request);
}
public void runRequest(@NonNull Request request) {
requests.add(request);
if (!isPaused) {
//没有暂停，开始调用 Request begin 执行
request.begin();
} else {
//如果调用了 暂停，清理请求
request.clear();
if (Log.isLoggable(TAG, Log.VERBOSE)) {
Log.v(TAG, "Paused, delaying request");
}
pendingRequests.add(request);
}
}
上面的逻辑是先为 requests 添加一个请求，看看是否是停止状态，如果不是就调用request.begin(); 执行。
这里的 Request 是一个接口，通过之前我们讲到 buildRequest 函数可知 Request 的实现类是SingleRequest 我们就直接看它的 begin 函数.
@Override
public void begin() {
synchronized (requestLock) {
assertNotCallingCallbacks();
stateVerifier.throwIfRecycled();
startTime = LogTime.getLogTime();
if (model == null) {
//检查外部调用的尺寸是否有效
if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
width = overrideWidth;
height = overrideHeight;
}
//失败的回调
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)) {
// 已经拿到了size，可以开始异步请求
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));
}
}
}
这里就直接看onSizeReady()方法，
public void onSizeReady(int width, int height) {
stateVerifier.throwIfRecycled();
synchronized (requestLock) {
//....一些初始化动作
//这个是加载方法
loadStatus =
engine.load(
glideContext,
model,
requestOptions.getSignature(),
this.width,
this.height,
requestOptions.getResourceClass(),
transcodeClass,
priority,
requestOptions.getDiskCacheStrategy(),
requestOptions.getTransformations(),
requestOptions.isTransformationRequired(),
requestOptions.isScaleOnlyOrNoTransform(),
requestOptions.getOptions(),
requestOptions.isMemoryCacheable(),
requestOptions.getUseUnlimitedSourceGeneratorsPool(),
requestOptions.getUseAnimationPool(),
requestOptions.getOnlyRetrieveFromCache(),
this,
callbackExecutor);
if (status != Status.RUNNING) {
loadStatus = null;
}
if (IS_VERBOSE_LOGGABLE) {
logV("finished onSizeReady in " + LogTime.getElapsedMillis(startTime));
}
}
}
//这是Engine.load方法
public <R> LoadStatus load(
GlideContext glideContext,
Object model,
Key signature,
int width,
int height,
Class<?> resourceClass,
Class<R> transcodeClass,
Priority priority,
DiskCacheStrategy diskCacheStrategy,
Map<Class<?>, Transformation<?>> transformations,
boolean isTransformationRequired,
boolean isScaleOnlyOrNoTransform,
Options options,
boolean isMemoryCacheable,
boolean useUnlimitedSourceExecutorPool,
boolean useAnimationPool,
boolean onlyRetrieveFromCache,
ResourceCallback cb) {
// 根据图像类型、原始宽高、目标宽高、转换等各种因素创建一个Key
EngineKey key = keyFactory.buildKey(model, signature, width, height, transformations,
resourceClass, transcodeClass, options);
// 从当前活跃资源里面获取
EngineResource<?> active = loadFromActiveResources(key, isMemoryCacheable);
if (active != null) {
// 获取成功，直接回调返回
cb.onResourceReady(active, DataSource.MEMORY_CACHE);
return null;
}
// 从LruCache资源获取
EngineResource<?> cached = loadFromCache(key, isMemoryCacheable);
if (cached != null) {
// 获取成功，直接回调返回
cb.onResourceReady(cached, DataSource.MEMORY_CACHE);
return null;
}
// 从DiskLruCache资源获取
EngineJob<?> current = jobs.get(key, onlyRetrieveFromCache);
if (current != null) {
// 获取成功，需要进一步转码
current.addCallback(cb);
return new LoadStatus(cb, current);
}
EngineJob<R> engineJob =
engineJobFactory.build(
key,
isMemoryCacheable,
useUnlimitedSourceExecutorPool,
useAnimationPool,
onlyRetrieveFromCache);
DecodeJob<R> decodeJob =
decodeJobFactory.build(
glideContext,
model,
key,
signature,
width,
height,
resourceClass,
transcodeClass,
priority,
diskCacheStrategy,
transformations,
isTransformationRequired,
isScaleOnlyOrNoTransform,
onlyRetrieveFromCache,
options,
engineJob);
// 添加engineJob到jobs中管理
jobs.put(key, engineJob);
engineJob.addCallback(cb);
// 开始加载
engineJob.start(decodeJob);
return new LoadStatus(cb, engineJob);
}
通过 engine.load 这个函数里面的逻辑，可以知道：
- 先构建请求或者缓存 KEY ;
- 根据 KEY 从内存缓存中查找对应的资源数据(ActiveResources（活动缓存，内部是一个 Map 用弱引用持有）,LruResourceCache)，如果有就回调 对应监听的onResourceReady 表示数据准备好了。
- 从执行缓存中查找对应 key 的任务
- 如果找到了，就说明已经正在执行了，不用重复执行。
- 没有找到，通过 EngineJob.start 开启一个新的请求任务执行。
现在跟一下engineJob.start(decodeJob)具体执行
public synchronized void start(DecodeJob<R> decodeJob) {
this.decodeJob = decodeJob;
//拿到 Glide 执行的线程池
GlideExecutor executor = decodeJob.willDecodeFromCache() ? diskCacheExecutor : getActiveSourceExecutor();
//开始执行
executor.execute(decodeJob); }
通过 DecodeJob 源码得知，它是实现的 Runnable 接口，这里GlideExecutor 线程池开始执行，就会
启动 DecodeJob 的 run 函数
@Override
public void run() {
DataFetcher<?> localFetcher = currentFetcher;
...
runWrapped();
...
}
private void runWrapped() {
switch (runReason) {
case INITIALIZE:
//获取资源状态
stage = getNextStage(Stage.INITIALIZE);
//根据当前资源状态，获取资源执行器
currentGenerator = getNextGenerator();
//执行
runGenerators();
break;
... } }
private DataFetcherGenerator getNextGenerator() {
switch (stage) {
case RESOURCE_CACHE:
//从资源缓存执行器
return new ResourceCacheGenerator(decodeHelper, this);
case DATA_CACHE:
//源数据磁盘缓存执行器
return new DataCacheGenerator(decodeHelper, this);
case SOURCE:
//什么都没有配置，源数据的执行器
return new SourceGenerator(decodeHelper, this);
case FINISHED:
return null;
default:
throw new IllegalStateException("Unrecognized stage: " + stage);
}
}
在runWrapped中还使用了状态者模式，对应有三种资源：
Data: 原始的图片缓存数据
Resource： 经过处理的图片缓存数据（例如旋转裁剪转换）
Source：无缓存数据
代码会依次走DataCacheGenerator、ResourceCacheGenerator、SourceGenerator，如果一个无法处理就传递给下一个Generator。
这里假定是首次加载数据，就会走到 SourceGenerator ，并且runGenerators()方法调用SourceGenerator. startNext()
SourceGenerator.java
@Override
public boolean startNext() {
// dataToCache 表示已经获取到的资源
if (dataToCache != null) {
Object data = dataToCache;
dataToCache = null;
// 将数据缓存
cacheData(data);
}
if (sourceCacheGenerator != null && sourceCacheGenerator.startNext()) {
return true;
}
sourceCacheGenerator = null;
// 这里就是根据缓存策略和各个ModelLoader去加载对应的资源
loadData = null;
boolean started = false;
while (!started && hasNextModelLoader()) {
loadData = helper.getLoadData().get(loadDataListIndex++);
if (loadData != null
&& (helper.getDiskCacheStrategy().isDataCacheable(loadData.fetcher.getDataSource())
|| helper.hasLoadPath(loadData.fetcher.getDataClass()))) {
started = true;
startNextLoad(loadData);
}
}
return started;
}
在这里就看到熟悉的Http 请求了，这里是 HttpURLConnection 作为 Glide 底层成网络请求的。请求成功之后直接返回的是一个输入流，最后会通过 onDataReady 回调到 DecodeJob的onDataFetcherReady 函数中。这里就是Glide网络请求地方，通过HttpURLConnection拿到了图片的InputStream。后面就是解析输入流的InputStream，进行图片压缩，最终拿到Bitmap，对Bitmap进行转换，构建磁盘缓存和内存缓存，最后设置到ImageViewTarget中。
