Glide学习笔记之源码分析

一、基本用法：

Glide.with(context).load(url).into(imageview);

    with()方法：给glide添加生命周期的监听；返回的是一个RequestManager对象所以load()方法也是RequestManager的

    RequestManager-->RequestManagerRetriver-->RequestTracker(负责跟踪、取消、重启)

    RequestTracker可知其实就是在Glide内部维护了一个Request请求的list，不管你context传入的是Activity还是    FragmentActivitiy，都会在Activity的基础上创建一个Fragment，这是为什么呢？因为Glide无法监听到Activity的生命周期，所以往Activity中添加一个Fragment来监听Fragment的生命周期，因为如果Activity消亡了，Fragment当然也就消亡了，具体代码看下面，不过传入的参数跟之前Application的不同，这里的SupportRequestManagerFragment的current.getLifecycle()方法我们进去会发现这其实是一个继承了Fragment的类，也就是往Activity里添加的Fragment。

    load()方法：其实就是做一个状态的保存

public DrawableTypeRequest<String> load(String string) {
				return (DrawableTypeRequest<String>) fromString().load(string);
			}
			
			private <T> DrawableTypeRequest<T> loadGeneric(Class<T> modelClass) {
				//根据不同的class来创建不同的ModelLoader
				ModelLoader<T, InputStream> streamModelLoader = Glide.buildStreamModelLoader(modelClass, context);
				ModelLoader<T, ParcelFileDescriptor> fileDescriptorModelLoader =
						Glide.buildFileDescriptorModelLoader(modelClass, context);
				if (modelClass != null && streamModelLoader == null && fileDescriptorModelLoader == null) {
					throw new IllegalArgumentException("Unknown type " + modelClass + ". You must provide a Model of a type for"
							+ " which there is a registered ModelLoader, if you are using a custom model, you must first call"
							+ " Glide#register with a ModelLoaderFactory for your custom model class");
				}

				return optionsApplier.apply(
				//通过获取到的ModelLoadder来创建DrawableTypeRequest对象返回给上一级
						new DrawableTypeRequest<T>(modelClass, streamModelLoader, fileDescriptorModelLoader, context,
								glide, requestTracker, lifecycle, optionsApplier));
			}

    提供一个InputStream输入流

public static <T> ModelLoader<T, InputStream> buildStreamModelLoader(Class<T> modelClass, Context context) {
				return buildModelLoader(modelClass, InputStream.class, context);
			}
			
			public static <T, Y> ModelLoader<T, Y> buildModelLoader(Class<T> modelClass, Class<Y> resourceClass,
					Context context) {
				 if (modelClass == null) {
					if (Log.isLoggable(TAG, Log.DEBUG)) {
						Log.d(TAG, "Unable to load null model, setting placeholder only");
					}
					return null;
				}
				return Glide.get(context).getLoaderFactory().buildModelLoader(modelClass, resourceClass);
			}

public synchronized <T, Y> ModelLoader<T, Y> buildModelLoader(Class<T> modelClass, Class<Y> resourceClass) {
				ModelLoader<T, Y> result = getCachedLoader(modelClass, resourceClass);
				if (result != null) {
					// We've already tried to create a model loader and can't with the currently registered set of factories,
					// but we can't use null to demonstrate that failure because model loaders that haven't been requested
					// yet will be null in the cache. To avoid this, we use a special signal model loader.
					if (NULL_MODEL_LOADER.equals(result)) {
						return null;
					} else {
						return result;
					}
				}


				final ModelLoaderFactory<T, Y> factory = getFactory(modelClass, resourceClass);
				if (factory != null) {
					result = factory.build(context, this);
					cacheModelLoader(modelClass, resourceClass, result);
				} else {
					// We can't generate a model loader for the given arguments with the currently registered set of factories.
					cacheNullLoader(modelClass, resourceClass);
				}
				return result;
			}
			
			
			private <T, Y> ModelLoaderFactory<T, Y> getFactory(Class<T> modelClass, Class<Y> resourceClass) {
				Map<Class/*Y*/, ModelLoaderFactory/*T, Y*/> resourceToFactories = modelClassToResourceFactories.get(modelClass);
				ModelLoaderFactory/*T, Y*/ result = null;
				if (resourceToFactories != null) {
					result = resourceToFactories.get(resourceClass);
				}


				
				//   关于注册的   这块在Glide类的构造函数统一注册了
				if (result == null) {
					for (Class<? super T> registeredModelClass : modelClassToResourceFactories.keySet()) {
						// This accounts for model subclasses, our map only works for exact matches. We should however still
						// match a subclass of a model with a factory for a super class of that model if if there isn't a
						// factory for that particular subclass. Uris are a great example of when this happens, most uris
						// are actually subclasses for Uri, but we'd generally rather load them all with the same factory rather
						// than trying to register for each subclass individually.
						if (registeredModelClass.isAssignableFrom(modelClass)) {
							Map<Class/*Y*/, ModelLoaderFactory/*T, Y*/> currentResourceToFactories =
									modelClassToResourceFactories.get(registeredModelClass);
							if (currentResourceToFactories != null) {
								result = currentResourceToFactories.get(resourceClass);
								if (result != null) {
									break;
								}
							}
						}
					}
				}


				return result;
			}

   以上就是生成streamModelLoader和fileDescriptorModelLoader。

    fromString()方法之后返回一个DrawableTypeRequest对象，然后就是调用这个对象的load(string)方法，其实是调用了父类DrawableRequestBuilder里load()

    into():此方法也是在父类DrawableRequestBuilder里

public Target<TranscodeType> into(ImageView view) {
				Util.assertMainThread();
				if (view == null) {
					throw new IllegalArgumentException("You must pass in a non null View");
				}

				if (!isTransformationSet && view.getScaleType() != null) {
					switch (view.getScaleType()) {
						case CENTER_CROP:
							applyCenterCrop();
							break;
						case FIT_CENTER:
						case FIT_START:
						case FIT_END:
							applyFitCenter();
							break;
						//$CASES-OMITTED$
						default:
							// Do nothing.
					}
				}

				return into(glide.buildImageViewTarget(view, transcodeClass));
			}

			<R> Target<R> buildImageViewTarget(ImageView imageView, Class<R> transcodedClass) {
				return imageViewTargetFactory.buildTarget(imageView, transcodedClass);
			}

			//返回一个Target
			public class ImageViewTargetFactory {

				@SuppressWarnings("unchecked")
				public <Z> Target<Z> buildTarget(ImageView view, Class<Z> clazz) {
					if (GlideDrawable.class.isAssignableFrom(clazz)) {
						return (Target<Z>) new GlideDrawableImageViewTarget(view);
					} else if (Bitmap.class.equals(clazz)) {
						return (Target<Z>) new BitmapImageViewTarget(view);
					} else if (Drawable.class.isAssignableFrom(clazz)) {
						return (Target<Z>) new DrawableImageViewTarget(view);
					} else {
						throw new IllegalArgumentException("Unhandled class: " + clazz
								+ ", try .as*(Class).transcode(ResourceTranscoder)");
					}
				}
			}

将返回的Target传入进来

public <Y extends Target<TranscodeType>> Y into(Y target) {
				Util.assertMainThread();
				if (target == null) {
					throw new IllegalArgumentException("You must pass in a non null Target");
				}
				if (!isModelSet) {
					throw new IllegalArgumentException("You must first set a model (try #load())");
				}

				Request previous = target.getRequest();

				if (previous != null) {
					previous.clear();
					requestTracker.removeRequest(previous);
					previous.recycle();
				}

				//调用buildRequest()方法构建出了一个Request对象
				Request request = buildRequest(target);
				target.setRequest(request);
				lifecycle.addListener(target);
				//执行这个Request。
				requestTracker.runRequest(request);

				return target;
			}

private Request buildRequest(Target<TranscodeType> target) {
				if (priority == null) {
					priority = Priority.NORMAL;
				}
				return buildRequestRecursive(target, null);
			}

			private Request buildRequestRecursive(Target<TranscodeType> target, ThumbnailRequestCoordinator parentCoordinator) {
				if (thumbnailRequestBuilder != null) {
					if (isThumbnailBuilt) {
						throw new IllegalStateException("You cannot use a request as both the main request and a thumbnail, "
								+ "consider using clone() on the request(s) passed to