范培华

Android Glide源码分析

前言

Glide，该功能非常强大 Android 图片加载开源框架相信大家并不陌生
正由于他的功能强大，所以它的源码非常复杂，这导致很多人望而却步
本人尝试将 Glide 的功能进行分解，并单独针对每个功能进行源码分析，从而降低Glide源码的复杂度。
接下来，我将推出一系列关于 Glide的功能源码分析，有兴趣可以继续关注
今天，我将主要源码分析Glide的基础功能：图片加载 ，希望你们会喜欢。
由于文章较长，希望读者先收藏 & 预留足够时间进行查看。

1. 简介

定义：Google开发者Sam sjudd出品的一个Android开源库
作用：图片加载
具体功能列表

注：从上面可看出，Glide不仅解决了图片异步加载的问题，还解决了Android加载图片时的一些常见问题，功能十分强大。

2. 与主流图片开源库对比

关于Glide与主流图片开源库（Universal-Image-Loader、Picasso、Fresco），请看文章：3分钟全面了解Android主流图片加载库

3. 具体使用

关于Glide的各种使用方法，请看文章：Android图片加载库：最全面解析Glide用法

4. 源码分析

在进行源码分析前，有几点需要特别说明：
1. 本次源码分析是基于 Glide 3.7.0，版本下载地址
2. 本次源码分析是主要分析Glide的基本功能：图片加载，所以关于其他功能的代码本文一律忽略

因为Glide的功能实在太多了，所以源码非常复杂，无法同时分析多个功能。但其他功能将下Glide的系列文章继续分析。

Glide源码较为难懂、难分析的其中一个原因是：许多对象都是很早之前就初始化好，而并非在使用前才初始化。所以当真正使用该对象时，开发者可能已经忘记是在哪里初始化、该对象是作什么用的了。所以本文会在每个阶段进行一次总结，而读者则需要经常往返看该总结，从而解决上述问题。

下面，我们将根据 Glide 的加载图片的使用步骤一步步源码分析。

Glide 的使用步骤如下：

Glide.with(this).load(url).into(imageView);
// 参数说明
// 参数1：Context context
// Context对于很多Android API的调用都是必须的，这里就不多说了

// 参数2：String imageUrl：被加载图像的Url地址
// 大多情况下，一个字符串代表一个网络图片的URL

// 参数3：ImageView targetImageView：图片最终要展示的地方。

所以Glide的源码分析分为三步：
1. .with（）
2. .load（）
3. .into（）

4.1 with（）

定义：Glide 类中的静态方法，根据传入不同参数进行方法重载
作用：
1. 得到一个RequestManager对象
2. 根据传入with()方法的参数 将Glide图片加载的生命周期与Activity/Fragment的生命周期进行绑定，从而实现自动执行请求，暂停操作
下面先说明一些重要对象名

具体源码

public class Glide {
    ...

    // with()重载种类非常多，根据传入的参数可分为：
    // 1. 非Application类型的参数（Activity & Fragment  ）
    // 2. Application类型的参数（Context）
    // 下面将详细分析

// 参数1：Application类型
 public static RequestManager with(Context context) {
        RequestManagerRetriever retriever = RequestManagerRetriever.get();
        // 步骤1：调用RequestManagerRetriever类的静态get()获得RequestManagerRetriever对象 - 单例实现
        return retriever.get(context);
        // 步骤2：调用RequestManagerRetriever实例的get()获取RequestManager对象 & 绑定图片加载的生命周期 ->>分析1
    }

// 参数2：非Application类型（Activity & Fragment ）
    public static RequestManager with(Activity activity) {
        RequestManagerRetriever retriever = RequestManagerRetriever.get();
        return retriever.get(activity);
    }

    public static RequestManager with(Fragment fragment) {
        RequestManagerRetriever retriever = RequestManagerRetriever.get();
        return retriever.get(fragment);

  @TargetApi(Build.VERSION_CODES.HONEYCOMB)
    public static RequestManager with(android.app.Fragment fragment) {
        RequestManagerRetriever retriever = RequestManagerRetriever.get();
        return retriever.get(fragment);
    }

    }
}

<-- 分析1：RequestManagerRetriever对象的实例 get（）-->
// 作用：
  // 1. 获取RequestManager对象
  // 2. 将图片加载的生命周期与Activity/Fragment的生命周期进行绑定

  public class RequestManagerRetriever implements Handler.Callback {
      ...

    // 实例的get（）重载种类很多，参数分为：（与with（）类似）
    // 1. Application类型（Context）
    // 2. 非Application类型（Activity & Fragment ）- >>分析3
    // 下面会详细分析

// 参数1：Application类型（Context） 
   public RequestManager get(Context context) {
        return getApplicationManager(context);
        // 调用getApplicationManager（）最终获取一个RequestManager对象 ->>分析2
        // 因为Application对象的生命周期即App的生命周期
        // 所以Glide加载图片的生命周期是自动与应用程序的生命周期绑定，不需要做特殊处理（若应用程序关闭，Glide的加载也会终止）
    }

// 参数2：非Application类型（Activity & Fragment  ）
// 将Glide加载图片的生命周期与Activity生命周期同步的具体做法：向当前的Activity添加一个隐藏的Fragment
// 原因：因Fragment的生命周期 与 Activity 的是同步的，通过添加隐藏的Fragment 从而监听Activity的生命周期，从而实现Glide加载图片的生命周期与Activity的生命周期 进行同步。
 @TargetApi(Build.VERSION_CODES.HONEYCOMB)
    public RequestManager get(Activity activity) {
        if (Util.isOnBackgroundThread() || Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB) {
            return get(activity.getApplicationContext());
        } else {

            assertNotDestroyed(activity);
             //判断activity是否已经销毁

            android.app.FragmentManager fm = activity.getFragmentManager();
            // 获取FragmentManager 对象

            return fragmentGet(activity, fm);
           // 通过fragmentGet返回RequestManager->>分析4


        }
    }

    public RequestManager get(FragmentActivity activity) {
      // 逻辑同上，此处不作过多描述
      ...

    }

    public RequestManager get(Fragment fragment) {
        // 逻辑同上，此处不作过多描述
      ...
    }

}

<-- 分析2：getApplicationManager（context）-->
private RequestManager getApplicationManager(Context context) {

      ...

        Glide glide = Glide.get(context);
        // 通过单例模式创建Glide实例 ->>分析3
        applicationManager =
            new RequestManager(
                glide, new ApplicationLifecycle(), new EmptyRequestManagerTreeNode());
      }
    }
  }
  return applicationManager;
}

<-- 分析3：Glide.get(context) -->
public static Glide get(Context context) {
  if (glide == null) {
  // 单例模式的体现
    synchronized (Glide.class) {
      if (glide == null) {
        Context applicationContext = context.getApplicationContext();

        List modules = new ManifestParser(applicationContext).parse();
        // 解析清单文件配置的自定义GlideModule的metadata标签，返回一个GlideModule集合

        GlideBuilder builder = new GlideBuilder(applicationContext);
        // 步骤1：创建GlideBuilder对象
        for (GlideModule module : modules) {
          module.applyOptions(applicationContext, builder);
        }
        glide = builder.createGlide();
        // 步骤2：根据GlideBuilder对象创建Glide实例
        // GlideBuilder会为Glide设置一默认配置，如：Engine，RequestOptions，GlideExecutor，MemorySizeCalculator

        for (GlideModule module : modules) {
          module.registerComponents(applicationContext, glide.registry);
           // 步骤3：利用GlideModule 进行延迟性的配置和ModelLoaders的注册
        }
      }
    }
  }
  return glide;
}
// 回到分析1 进入 分析2的地方


<--分析4：fragmentGet(） -->
// 作用：
           // 1. 创建Fragment
           // 2. 向当前的Activity中添加一个隐藏的Fragment
           // 3. 将RequestManager与该隐藏的Fragment进行绑定
 RequestManager fragmentGet(Context context, android.app.FragmentManager fm) {

        RequestManagerFragment current = getRequestManagerFragment(fm);
        // 获取RequestManagerFragment
        // 作用：利用Fragment进行请求的生命周期管理 

        RequestManager requestManager = current.getRequestManager();

        // 若requestManager 为空，即首次加载初始化requestManager 
        if (requestManager == null) {
            // 创建RequestManager传入Lifecycle实现类，如ActivityFragmentLifecycle
            requestManager = new RequestManager(context, current.getLifecycle(), current.getRequestManagerTreeNode());
            current.setRequestManager(requestManager);
            // 调用setRequestManager设置到RequestManagerFragment 
        }
        return requestManager;
    }

总结

with（）是为得到一个RequestManager对象从而将Glide加载图片周期与Activity 和Fragment进行绑定，从而管理Glide加载图片周期

最终返回RequestManager对象

由于本文主要讲解图片加载的功能，所以关于加载图片生命周期的内容暂时不讲解。

4.2 load（）

定义
由于 .with() 返回的是一个RequestManager对象，所以第2步中调用的是 RequestManager 类的 load()
作用
预先创建好对图片进行一系列操作（加载、编解码、转码）的对象，并全部封装到 DrawableTypeRequest `对象中。

Glide 支持加载图片的URL字符串、图片本地路径等，因此RequestManager 类存在load()的重载

此处主要讲解最常见的加载图片 URL 字符串的load()，即load(String url)

具体过程

public class RequestManager implements LifecycleListener {

    // 仅贴出关键代码
    ...

     public DrawableTypeRequest load(String string) {
        return (DrawableTypeRequest) fromString().load(string);
        // 先调用fromString（）再调用load（）
        // load（）作用：传入图片URL地址
       // fromString（）作用 ->>分析1

    }

<-- 分析1：fromString（）-->
    public DrawableTypeRequest fromString() {
        return loadGeneric(String.class);
         // loadGeneric（）的作用 ->>分析2
    }

<-- 分析2：loadGeneric（）-->
    private  DrawableTypeRequest loadGeneric(Class modelClass) {

        ModelLoader streamModelLoader = Glide.buildStreamModelLoader(modelClass, context);
        // 创建第1个ModelLoader对象；作用：加载图片
        // Glide会根据load()方法传入不同类型参数，得到不同的ModelLoader对象
        // 此处传入参数是String.class，因此得到的是StreamStringLoader对象（实现了ModelLoader接口）

        ModelLoader fileDescriptorModelLoader = Glide.buildFileDescriptorModelLoader(modelClass, context);
         // 创建第2个ModelLoader对象，作用同上：加载图片
        // 此处得到的是FileDescriptorModelLoader对象

        return optionsApplier.apply(
                new DrawableTypeRequest(modelClass, streamModelLoader, fileDescriptorModelLoader, context,
                        glide, requestTracker, lifecycle, optionsApplier));
            // 创建DrawableTypeRequest对象 & 传入刚才创建的ModelLoader对象 和 其他初始化配置的参数
            // DrawableTypeRequest类分析 ->>分析3
    }

    ...


<-- 分析3：DrawableTypeRequest类（）-->
public class DrawableTypeRequest extends DrawableRequestBuilder implements DownloadOptions {

// 关注1：构造方法
      DrawableTypeRequest(Class modelClass, ModelLoader streamModelLoader,
            ModelLoader fileDescriptorModelLoader, Context context, Glide glide,
            RequestTracker requestTracker, Lifecycle lifecycle, RequestManager.OptionsApplier optionsApplier) {
        super(context, modelClass,
                buildProvider(glide, streamModelLoader, fileDescriptorModelLoader, GifBitmapWrapper.class,
                        GlideDrawable.class, null),
                glide, requestTracker, lifecycle);
      // 调用buildProvider()方法 -->分析4
      // 并把上述创建的streamModelLoader和fileDescriptorModelLoader等参数传入到buildProvider()中

// 关注2：DrawableTypeRequest类主要提供2个方法： asBitmap() & asGif() 

    // asBitmap()作用：强制加载 静态图片
    public BitmapTypeRequest asBitmap() {
        return optionsApplier.apply(new BitmapTypeRequest(this, streamModelLoader,
                fileDescriptorModelLoader, optionsApplier));
        // 创建BitmapTypeRequest对象
    }

    // asGif() 作用：强制加载 动态图片
    public GifTypeRequest asGif() {
        return optionsApplier.apply(new GifTypeRequest(this, streamModelLoader, optionsApplier));
        // 创建GifTypeRequest对象

        // 注：若没指定，则默认使用DrawableTypeRequest
    }

}

<-- 分析4：buildProvider(）-->
private static  FixedLoadProvider buildProvider(Glide glide,
            ModelLoader streamModelLoader,
            ModelLoader fileDescriptorModelLoader, Class resourceClass,
            Class transcodedClass,
            ResourceTranscoder transcoder) {

        if (transcoder == null) {
            transcoder = glide.buildTranscoder(resourceClass, transcodedClass);
            // 创建GifBitmapWrapperDrawableTranscoder对象（实现了ResourceTranscoder接口）
            // 作用：对图片进行转码
        }

        DataLoadProvider dataLoadProvider = glide.buildDataProvider(ImageVideoWrapper.class,
                resourceClass);
        // 创建ImageVideoGifDrawableLoadProvider对象（实现了DataLoadProvider接口）
        // 作用：对图片进行编解码

        ImageVideoModelLoader modelLoader = new ImageVideoModelLoader(streamModelLoader,
                fileDescriptorModelLoader);
        // 创建ImageVideoModelLoader
        // 并把上面创建的两个ModelLoader：streamModelLoader和fileDescriptorModelLoader封装到了ImageVideoModelLoader中

        return new FixedLoadProvider(modelLoader, transcoder, dataLoadProvider);
       // 创建FixedLoadProvider对象
       // 把上面创建的GifBitmapWrapperDrawableTranscoder、ImageVideoModelLoader、ImageVideoGifDrawableLoadProvider都封装进去
      // 注：FixedLoadProvider对象就是第3步into（）中onSizeReady()的loadProvider对象
    }
      // 回到分析3的关注点2

在RequestManager的load()中，通过fromString()最终返回一个DrawableTypeRequest对象，并调用该对象的load()传入图片的URL地址

请回看分析1上面的代码
但从上面的分析3可看出，DrawableTypeRequest类中并没有load()和第3步需要分析的into（），所以load() 和 into（） 是在DrawableTypeRequest类的父类中：DrawableRequestBuilder类中。继承关系如下：

public class DrawableRequestBuilder
        extends GenericRequestBuilder
        implements BitmapOptions, DrawableOptions {

        ... 

// 最终load()方法返回的其实就是一个DrawableTypeRequest对象
@Override
    public Target into(ImageView view) {
        return super.into(view);
    }

// 特别注意：DrawableRequestBuilder类中有很多使用Glide的API方法，此处不做过多描述

}

至此，第2步的 load（）分析完成

总结

load（）中预先创建好对图片进行一系列操作（加载、编解码、转码）的对象，并全部封装到 DrawableTypeRequest对象中。

4.3 into（）

作用：构建网络请求对象并执行该网络请求

即获取图片资源 & 加载图片并显示
总体逻辑如下:
详细过程：

在第2步的RequestManager的load()中，最终返回一个DrawableTypeRequest对象

封装好了对图片进行一系列操作（加载、编解码、转码）的对象

但 DrawableTypeRequest类中并没有load()和第3步需要分析的into（），所以load() 和 into（） 是在DrawableTypeRequest类的父类中：DrawableRequestBuilder类

继承关系如下

所以，第三步是调用`DrawableRequestBuilder`类的 `into（）`完成图片的最终加载。

public class DrawableRequestBuilder
        extends GenericRequestBuilder
        implements BitmapOptions, DrawableOptions {

 @Override
    public Target into(ImageView view) {
        return super.into(view);
  // 调用DrawableRequestBuilder的父类GenericRequestBuilder的into() ->>分析1
    }
}

<-- 分析1：GenericRequestBuilder类的into（）-->
public class GenericRequestBuilder {

  ...

  public Target into(ImageView view) {

  // 判断是否在主线程(跟新UI只能在主线程)
  // 此处逻辑先不讲解，后面会详细说明，直接跳到方法的最后一行
    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));
    // 创建Target对象：用于最终展示图片 ->>分析2
    // 从分析3回来
  }
}

<-- 分析2：buildImageViewTarget（）-->
 Target buildImageViewTarget(ImageView imageView, Class transcodedClass) {
    return imageViewTargetFactory.buildTarget(imageView, transcodedClass);
    // ->>分析3

}

<-- 分析3：ImageViewTargetFactory的buildTarget()-->

public class ImageViewTargetFactory {

    public  Target buildTarget(ImageView view, Class clazz) {


        // 根据传入的class参数构建不同的Target对象，分为三种情况：
        // 情况1：若加载图片时调用了asBitmap()，那么构建的是BitmapImageViewTarget对象
       // 情况2：否则构建的是GlideDrawableImageViewTarget对象
       // 情况3：DrawableImageViewTarget对象基本用不到，此处忽略
       // 具体请看以下代码
        if (GlideDrawable.class.isAssignableFrom(clazz)) {
            return (Target) new GlideDrawableImageViewTarget(view);
        } else if (Bitmap.class.equals(clazz)) {
            return (Target) new BitmapImageViewTarget(view);    
        } else if (Drawable.class.isAssignableFrom(clazz)) {
            return (Target) new DrawableImageViewTarget(view);   
        } else {
            throw new IllegalArgumentException("Unhandled class: " + clazz
                    + ", try .as*(Class).transcode(ResourceTranscoder)");
        }
    }
}

此处得到了GlideDrawableImageViewTarget对象（大多数情况下）
回到上面分析1 - GenericRequestBuilder 类的 into（）最后一行：将GlideDrawableImageViewTarget对象传入到GenericRequestBuilder的into(Target target)中

我们继续看 GenericRequestBuilder的into(Target target) 的源码：

public > Y into(Y target) {

    Request request = buildRequest(target);
    // 关注1：构建Request对象：发出加载图片请求
    target.setRequest(request);
    // 将请求设置到target
    lifecycle.addListener(target);
    // 将target加入到lifecycle
    requestTracker.runRequest(request);
    // 关注2：执行网络请求Request
    return target;

}

此处是 发送加载图片网络请求
有2个关注点：构建 Request 对象 & 执行 Request

4.3.1 构建Request对象

作用
创建 GenericRequest 对象 & 初始化（即将 load（）中的API参数赋值到GenericRequest对象中）

<-- 分析4：buildRequest() -->
// 作用：构建Request对象
private Request buildRequest(Target target) {
    return buildRequestRecursive(target, null);
    // 往下调用
}

private Request buildRequestRecursive(Target target, ThumbnailRequestCoordinator parentCoordinator) {
        // 90%的代码用于处理缩略图，此处仅关注主流程，即如何构建Request对象
        // 仅贴出关键代码（如何构建Request对象）  
        ... 

        ThumbnailRequestCoordinator coordinator = new ThumbnailRequestCoordinator(parentCoordinator);
        Request fullRequest = obtainRequest(target, sizeMultiplier, priority, coordinator);
        // 往下调用

private Request obtainRequest(Target target, float sizeMultiplier, Priority priority,
        RequestCoordinator requestCoordinator) {

    return GenericRequest.obtain(
            loadProvider,
            model,
            signature,
            context,
            priority,
            target,
            sizeMultiplier,
            placeholderDrawable,
            placeholderId,
            errorPlaceholder,
            errorId,
            fallbackDrawable,
            fallbackResource,
            requestListener,
            requestCoordinator,
            glide.getEngine(),
            transformation,
            transcodeClass,
            isCacheable,
            animationFactory,
            overrideWidth,
            overrideHeight,
            diskCacheStrategy);
    // 调用了GenericRequest的obtain()
    // 作用：将在load()中调用的所有API参数都组装到Request对象当中 -->分析5
}

<-- 分析5：GenericRequest的obtain()  -->
public final class GenericRequest implements Request, SizeReadyCallback,
        ResourceCallback {
    // 仅贴出关键代码
    ...

    public static  GenericRequest obtain(
            LoadProvider loadProvider,
            A model,
            Key signature,
            Context context,
            Priority priority,
            Target target,
            float sizeMultiplier,
            Drawable placeholderDrawable,
            int placeholderResourceId,
            Drawable errorDrawable,
            int errorResourceId,
            Drawable fallbackDrawable,
            int fallbackResourceId,
            RequestListener requestListener,
            RequestCoordinator requestCoordinator,
            Engine engine,
            Transformation transformation,
            Class transcodeClass,
            boolean isMemoryCacheable,
            GlideAnimationFactory animationFactory,
            int overrideWidth,
            int overrideHeight,
            DiskCacheStrategy diskCacheStrategy) {
        @SuppressWarnings("unchecked")
        GenericRequest request = (GenericRequest) REQUEST_POOL.poll();
        if (request == null) {
            request = new GenericRequest();
            // 创建GenericRequest对象
        }
        // init（）作用：将传入的Load（）中的API参数赋值到GenericRequest的成员变量
        request.init(loadProvider,
                model,
                signature,
                context,
                priority,
                target,
                sizeMultiplier,
                placeholderDrawable,
                placeholderResourceId,
                errorDrawable,
                errorResourceId,
                fallbackDrawable,
                fallbackResourceId,
                requestListener,
                requestCoordinator,
                engine,
                transformation,
                transcodeClass,
                isMemoryCacheable,
                animationFactory,
                overrideWidth,
                overrideHeight,
                diskCacheStrategy);
        return request;
        // 返回GenericRequest对象
    }

    ...
}

至此，一个发送加载图片的网络请求 Request 对象GenericRequest 创建完毕。

本文主要针对图片加载功能，关于发送加载图片的网络请求细节将在下篇文章进行描述。

总结

4.3.2 执行网络请求对象Request

public > Y into(Y target) {

    Request request = buildRequest(target);
    // 关注1：构建Request对象：发出加载图片请求
    target.setRequest(request);
    lifecycle.addListener(target);
    requestTracker.runRequest(request);
    // 关注2：执行Request ->>分析6
    return target;
}

/**
  * 步骤1：加载前
**/
<-- 分析6：runRequest(request) -->
public void runRequest(Request request) {
    // 此时的Request是GenericRequest对象
    requests.add(request);
    // 将每个提交的请求加入到一个set中：管理请求

    // 判断Glide当前是否处于暂停状态    
    if (!isPaused) {
        // 若不处于暂停状态，则调用GenericRequest的begin()来执行Request ->>分析7
        request.begin();
    } else {
        // 若处于暂停，则先将Request添加到待执行队列里面，等暂停状态解除后再执行
        pendingRequests.add(request);
    }
}

/**
  * 步骤2：加载时
**/
<-- 分析7：GenericRequest的begin() -->
public void begin() {

// 有2个关注点

// 关注1
    // model = 第2步load()传入的图片URL地址
    // 若model（）等于null，会调用onException()
    // onException()内部调用setErrorPlaceholder()
    if (model == null) {
        onException(null);
        return;
    }
    status = Status.WAITING_FOR_SIZE;

// 关注2：
// 图片加载情况分两种：
// 1. 开发者使用了override() API为图片指定了一个固定的宽高
// 2. 无使用

// 情况1：使用了override() API为图片指定了一个固定的宽高
    if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
        onSizeReady(overrideWidth, overrideHeight);
        // 调用onSizeReady()加载

// 否则，则是情况2，调用target.getSize()
    } else {
        target.getSize(this);
        // target.getSize()的内部会根据ImageView的layout_width和layout_height值做一系列的计算，来算出图片显示的宽高
        // 计算后，也会调用onSizeReady()方法进行加载
    }
    if (!isComplete() && !isFailed() && canNotifyStatusChanged()) {
        target.onLoadStarted(getPlaceholderDrawable());
        // 从分析8看回来的：在图片请求开始前，会先使用Loading占位图代替最终的图片显示
    }

}

在begin（）方法中有两个关注点：

关注点1：若model（第2步load()传入的图片URL地址）等于null，会调用onException()
关注点2：图片加载情况
下面将详细说明

关注1

若model（第2步load()传入的图片URL地址）等于null，会调用onException()（内部调用setErrorPlaceholder()）

private void setErrorPlaceholder(Exception e) {

    Drawable error = model == null ? getFallbackDrawable() : null;

    // 若有error的占位图，则采用先获取error的占位图
    if (error == null) {
      error = getErrorDrawable();
    }
    // 若没有error的占位图，则再去获取一个loading占位图
    if (error == null) {
        error = getPlaceholderDrawable();
    }
    target.onLoadFailed(e, error);
    // 将占位图（error / loading）传入到onLoadFailed（）中 ->>分析8
}

<-- 分析8：onLoadFailed（） -->
public abstract class ImageViewTarget extends ViewTarget implements GlideAnimation.ViewAdapter {
    ...

    @Override
    public void onLoadFailed(Exception e, Drawable errorDrawable) {
        view.setImageDrawable(errorDrawable);
        // 将该error占位图显示到ImageView
    }

    @Override
    public void onLoadStarted(Drawable placeholder) {
        view.setImageDrawable(placeholder);
        // 在图片请求开始前，会先使用Loading占位图代替最终的图片显示
        // 在begin（）时调用（回看分析7）
    }



    ...
}

所以此处显示出Glide的用法：

若传入图片的url为 Null，会采用error / loading的占位图进行代替
图片请求开始前，会先使用 Loading 占位图代替最终的图片显示

关注2

图片加载情况（重点关注）

<-- 分析7：GenericRequest的begin() -->
public void begin() {

// 关注1（请跳过，直接看关注2）
    // 若model（第2步load()传入的图片URL地址）等于null，会调用onException()
    // onException()内部调用setErrorPlaceholder()
    if (model == null) {
        onException(null);
        return;
    }
    status = Status.WAITING_FOR_SIZE;

// 关注2：
  // 图片加载情况分两种：
    // 1. 为图片指定加载固定的宽高（使用override() 的API）
    // 2. 无指定加载的宽高

// 情况1：为图片指定加载固定的宽高（使用override() 的API）
    if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
        onSizeReady(overrideWidth, overrideHeight);
        // 调用onSizeReady()加载->>分析9

// 否则，则是情况2：无指定加载的宽高
    } else {
        target.getSize(this);
        // target.getSize()会根据ImageView的layout_width和layout_height值做一系列的计算，来算出图片显示的宽高
        // 计算后，最终也会调用onSizeReady()进行加载
    }


}

<-- 分析9：onSizeReady()-->
public void onSizeReady(int width, int height) {

    // loadProvider 对象 即 第2步load（）中的FixedLoadProvider对象 
    // 里面封装了GifBitmapWrapperDrawableTranscoder、ImageVideoModelLoader、ImageVideoGifDrawableLoadProvider对象）
    // ->>请回看第2步load（）中的 分析3：DrawableTypeRequest类

    ModelLoader modelLoader = loadProvider.getModelLoader();
    // 从loadProvider 对象中获取ImageVideoModelLoader对象
    ResourceTranscoder transcoder = loadProvider.getTranscoder();
    // 从loadProvider 对象中获取GifBitmapWrapperDrawableTranscoder对象

    final DataFetcher dataFetcher = modelLoader.getResourceFetcher(model, width, height);
    // ->>分析10
    // 创建ImageVideoFetcher对象（传入HttpUrlFetcher对象）

    loadStatus = engine.load(signature, width, height, dataFetcher, loadProvider, transformation, transcoder,
            priority, isMemoryCacheable, diskCacheStrategy, this);
    // 将上述获得的ImageVideoFetcher、GifBitmapWrapperDrawableTranscoder等一起传入到了Engine的load()方法中 ->>分析11

    }
    ...
}

<--分析10：ImageVideoModelLoader的getResourceFetcher() -->

public class ImageVideoModelLoader implements ModelLoader {

    @Override
    public DataFetcher getResourceFetcher(A model, int width, int height) {

         DataFetcher fileDescriptorFetcher = null;
         if (fileDescriptorLoader != null) {
            fileDescriptorFetcher = fileDescriptorLoader.getResourceFetcher(model, width, height);
            // fileDescriptorLoader是在第2步load（）中创建的FileDescriptorModelLoader：用于加载图片
           // 调用FileDescriptorModelLoader的getResourceFetcher()会得到一个HttpUrlFetcher对象
        }

        DataFetcher streamFetcher = null;
        if (streamLoader != null) {
            streamFetcher = streamLoader.getResourceFetcher(model, width, height);
            // streamLoader是在第2步load（）中创建的StreamStringLoader：用于加载图片
           // 调用streamLoader的getResourceFetcher()会得到一个HttpUrlFetcher对象
        }


        if (streamFetcher != null || fileDescriptorFetcher != null) {
            return new ImageVideoFetcher(streamFetcher, fileDescriptorFetcher);
        // 创建ImageVideoFetcher对象，并把上述获得的2个HttpUrlFetcher对象传进去
        // 即调用ImageVideoModelLoader的getResourceFetcher()得到的是ImageVideoFetcher
        } else {
            return null;
        }
    }
} 
// 回到分析9原处

<-- 分析11：Engine的load() -->
public class Engine implements EngineJobListener,
        MemoryCache.ResourceRemovedListener,
        EngineResource.ResourceListener {

      ...
      // 省略关键代码

        EngineJob engineJob = engineJobFactory.build(key, isMemoryCacheable);
        // 创建EngineJob对象
        // 作用：开启线程（作异步加载图片）

        DecodeJob decodeJob = new DecodeJob(key, width, height, fetcher, loadProvider, transformation,
                transcoder, diskCacheProvider, diskCacheStrategy, priority);
        // 创建DecodeJob对象
        // 作用：对图片解码（较复杂，下面会详细说明）

        EngineRunnable runnable = new EngineRunnable(engineJob, decodeJob, priority);
        // 创建EngineRunnable对象
        jobs.put(key, engineJob);
        engineJob.addCallback(cb);
        engineJob.start(runnable);
        // 执行EngineRunnable对象
        // 即在子线程中执行EngineRunnable的run()方法 ->>分析12

        return new LoadStatus(cb, engineJob);
    }

    ...
}

<--分析12：EngineRunnable的run() -->
    @Override
    public void run() {

    try {
        resource = decode();
        // 调用decode() 并 返回了一个Resource对象 ->>分析13

    } catch (Exception e) {
        if (Log.isLoggable(TAG, Log.VERBOSE)) {
            Log.v(TAG, "Exception decoding", e);
        }
       ...
}

<--分析13：decode() -->
private Resource decode() throws Exception {

// 分两种情况：从缓存当中读（解码）图片 & 不从缓存中读（解码）图片

    if (isDecodingFromCache()) {
    // 若从缓存中decode图片：执行decodeFromCache()
    // 本文先不讨论缓存情况
        return decodeFromCache();
    } else {
        // 不从缓存中读（解码）图片：执行decodeFromSource()  ->>分析14
        return decodeFromSource();
    }
}

<--分析14：decodeFromSource()  -->
private Resource decodeFromSource() throws Exception {
    return decodeJob.decodeFromSource();
    // 调用了DecodeJob的decodeFromSource()方法 ->>分析15
}


<--分析15：DecodeJob.decodeFromSource() -->
class DecodeJob {
    ...

   public Resource decodeFromSource() throws Exception {
        Resource decoded = decodeSource();
        // 获得Resource对象 ->>分析16
        return transformEncodeAndTranscode(decoded);
        // 调用transformEncodeAndTranscode()方法来处理该Resource对象。
    }

<--分析16： decodeSource()  -->
    private Resource decodeSource() throws Exception {
    ...

        try {
            final A data = fetcher.loadData(priority);
            // 该fetcher是在分析10：onSizeReady()中得到的ImageVideoFetcher对象
            // 即调用ImageVideoFetcher的loadData() - >>分析17

            // 从分析17回来时看这里：
            decoded = decodeFromSourceData(data);
            // 将分析17创建的ImageVideoWrapper对象传入到decodeFromSourceData()，解码该对象 -->分析19

      }

    ...
}

<--分析17： fetcher.loadData（）  -->
@Override
public ImageVideoWrapper loadData(Priority priority) throws Exception {
    InputStream is = null;

    if (streamFetcher != null) {
        try {
            is = streamFetcher.loadData(priority);
           // 该streamFetcher是创建ImageVideoFetcher对象时传入的HttpUrlFetcher
          // 因此这里调用的是HttpUrlFetcher的loadData() ->>分析18
        } catch (Exception e) {

    return new ImageVideoWrapper(is, fileDescriptor);
    // 从分析18回来时看这里
    // 创建ImageVideoWrapper对象 & 传入分析18创建的InputStream ->>回到分析16
}


<--分析18：HttpUrlFetcher的loadData（）  -->
// 此处是网络请求的代码
public class HttpUrlFetcher implements DataFetcher {

    @Override
    public InputStream loadData(Priority priority) throws Exception {
        return loadDataWithRedirects(glideUrl.toURL(), 0 /*redirects*/, null /*lastUrl*/, glideUrl.getHeaders());
        // 继续往下看
    }

    private InputStream loadDataWithRedirects(URL url, int redirects, URL lastUrl, Map headers)
           ...

        // 静态工厂模式创建HttpURLConnection对象
        urlConnection = connectionFactory.build(url);
        for (Map.Entry headerEntry : headers.entrySet()) {
          urlConnection.addRequestProperty(headerEntry.getKey(), headerEntry.getValue());
        }
        //设置请求参数
        //设置连接超时时间2500ms
        urlConnection.setConnectTimeout(2500);
        //设置读取超时时间2500ms
        urlConnection.setReadTimeout(2500);
        //不使用http缓存
        urlConnection.setUseCaches(false);
        urlConnection.setDoInput(true);

        // Connect explicitly to avoid errors in decoders if connection fails.
        urlConnection.connect();
        if (isCancelled) {
            return null;
        }
        final int statusCode = urlConnection.getResponseCode();
        if (statusCode / 100 == 2) {
              //请求成功
            return getStreamForSuccessfulRequest(urlConnection);
            // 继续往下看
        } 
    }

      private InputStream getStreamForSuccessfulRequest(HttpURLConnection urlConnection)
            throws IOException {
        if (TextUtils.isEmpty(urlConnection.getContentEncoding())) {
            int contentLength = urlConnection.getContentLength();
            stream = ContentLengthInputStream.obtain(urlConnection.getInputStream(), contentLength);
        } else {
            if (Log.isLoggable(TAG, Log.DEBUG)) {
                Log.d(TAG, "Got non empty content encoding: " + urlConnection.getContentEncoding());
            }
            stream = urlConnection.getInputStream();
        }
        return stream;
        // 最终返回InputStream对象（但还没开始读取数据）
        // 回到分析17中的最后一行
    }

    }
}

分析19：图片的解码


<--分析19：decodeFromSourceData()（）  -->
private Resource decodeFromSourceData(A data) throws IOException {

        decoded = loadProvider.getSourceDecoder().decode(data, width, height);
        // 调用loadProvider.getSourceDecoder()得到的是GifBitmapWrapperResourceDecoder对象
        // 即调用GifBitmapWrapperResourceDecoder对象的decode()来对图片进行解码 ->>分析20

    return decoded;
}

<--分析20：GifBitmapWrapperResourceDecoder对象的decode()  -->
    public class GifBitmapWrapperResourceDecoder implements ResourceDecoder {

    ...

    @Override
    public Resource decode(ImageVideoWrapper source, int width, int height) throws IOException {

            wrapper = decode(source, width, height, tempBytes);
            // 传入参数，并调用了另外一个decode（）进行重载 ->>分析21

    }

<--分析21：重载的decode（） -->
    private GifBitmapWrapper decode(ImageVideoWrapper source, int width, int height, byte[] bytes) throws IOException {
        final GifBitmapWrapper result;
        if (source.getStream() != null) {
            result = decodeStream(source, width, height, bytes);
            // 作用：从服务器返回的流当中读取数据- >>分析22

        } else {
            result = decodeBitmapWrapper(source, width, height);
        }
        return result;
    }

<--分析22：decodeStream（） -->
// 作用：从服务器返回的流当中读取数据
// 读取方式：
        // 1. 从流中读取2个字节的数据：判断该图是GIF图还是普通的静图
        // 2. 若是GIF图，就调用decodeGifWrapper() 解码
        // 3. 若普通静图，就调用decodeBitmapWrapper() 解码
        // 此处仅分析 对于静图解码
    private GifBitmapWrapper decodeStream(ImageVideoWrapper source, int width, int height, byte[] bytes)
            throws IOException {

        // 步骤1：从流中读取两个2字节数据进行图片类型的判断
        InputStream bis = streamFactory.build(source.getStream(), bytes);
        bis.mark(MARK_LIMIT_BYTES);
        ImageHeaderParser.ImageType type = parser.parse(bis);
        bis.reset();
        GifBitmapWrapper result = null;

        // 步骤2：若是GIF图，就调用decodeGifWrapper() 解码
        if (type == ImageHeaderParser.ImageType.GIF) {
            result = decodeGifWrapper(bis, width, height);
        }

        // 步骤3：若是普通静图，就调用decodeBitmapWrapper()解码
        if (result == null) {
            ImageVideoWrapper forBitmapDecoder = new ImageVideoWrapper(bis, source.getFileDescriptor());
            result = decodeBitmapWrapper(forBitmapDecoder, width, height);
            // ->>分析23
        }
        return result;
    }

<-- 分析23：decodeBitmapWrapper() -->
    private GifBitmapWrapper decodeBitmapWrapper(ImageVideoWrapper toDecode, int width, int height) throws IOException {
        GifBitmapWrapper result = null;
        Resource bitmapResource = bitmapDecoder.decode(toDecode, width, height);
       //  bitmapDecoder是一个ImageVideoBitmapDecoder对象
       // 即调用ImageVideoBitmapDecoder对象的decode（）->>分析24
        if (bitmapResource != null) {
            result = new GifBitmapWrapper(bitmapResource, null);
        }
        return result;
    }

    ...
}

<-- 分析24：ImageVideoBitmapDecoder.decode() -->
public class ImageVideoBitmapDecoder implements ResourceDecoder {

    ...

    @Override
    public Resource decode(ImageVideoWrapper source, int width, int height) throws IOException {
        Resource result = null;
        InputStream is = source.getStream();
        // 步骤1：获取到服务器返回的InputStream
        if (is != null) {
            try {
                result = streamDecoder.decode(is, width, height);
                // 步骤2：调用streamDecoder.decode()进行解码
                // streamDecode是一个StreamBitmapDecoder对象 ->>分析25

            } catch (IOException e) {
    ...
}

<-- 分析25：StreamBitmapDecoder.decode() -->
public class StreamBitmapDecoder implements ResourceDecoder {

    ...

    @Override
    public Resource decode(InputStream source, int width, int height) {
        Bitmap bitmap = downsampler.decode(source, bitmapPool, width, height, decodeFormat);
        // Downsampler的decode() ->>分析26

        // 从分析26回来看这里：
        return BitmapResource.obtain(bitmap, bitmapPool);
        // 作用：将分析26中返回的Bitmap对象包装成Resource对象
        // 因为decode()返回的是一个Resource对象；而从Downsampler中得到的是一个Bitmap对象，需要进行类型的转换
        // 经过这样一层包装后，如果还需要获取Bitmap，只需要调用Resource的get()即可
        // 接下来，我们需要一层层地向上返回（请向下看直到跳出该代码块）
    }

    ...
}

<-- 分析26：downsampler.decode（）  -->
// 主要作用：读取服务器返回的InputStream & 加载图片
// 其他作用：对图片的压缩、旋转、圆角等逻辑处理
public abstract class Downsampler implements BitmapDecoder {

    ...

    @Override
    public Bitmap decode(InputStream is, BitmapPool pool, int outWidth, int outHeight, DecodeFormat decodeFormat) {
        final ByteArrayPool byteArrayPool = ByteArrayPool.get();
        final byte[] bytesForOptions = byteArrayPool.getBytes();
        final byte[] bytesForStream = byteArrayPool.getBytes();
        final BitmapFactory.Options options = getDefaultOptions();
        // Use to fix the mark limit to avoid allocating buffers that fit entire images.
        RecyclableBufferedInputStream bufferedStream = new RecyclableBufferedInputStream(
                is, bytesForStream);
        // Use to retrieve exceptions thrown while reading.
        // TODO(#126): when the framework no longer returns partially decoded Bitmaps or provides a way to determine
        // if a Bitmap is partially decoded, consider removing.
        ExceptionCatchingInputStream exceptionStream =
                ExceptionCatchingInputStream.obtain(bufferedStream);
        // Use to read data.
        // Ensures that we can always reset after reading an image header so that we can still attempt to decode the
        // full image even when the header decode fails and/or overflows our read buffer. See #283.
        MarkEnforcingInputStream invalidatingStream = new MarkEnforcingInputStream(exceptionStream);
        try {
            exceptionStream.mark(MARK_POSITION);
            int orientation = 0;
            try {
                orientation = new ImageHeaderParser(exceptionStream).getOrientation();
            } catch (IOException e) {
                if (Log.isLoggable(TAG, Log.WARN)) {
                    Log.w(TAG, "Cannot determine the image orientation from header", e);
                }
            } finally {
                try {
                    exceptionStream.reset();
                } catch (IOException e) {
                    if (Log.isLoggable(TAG, Log.WARN)) {
                        Log.w(TAG, "Cannot reset the input stream", e);
                    }
                }
            }
            options.inTempStorage = bytesForOptions;
            final int[] inDimens = getDimensions(invalidatingStream, bufferedStream, options);
            final int inWidth = inDimens[0];
            final int inHeight = inDimens[1];
            final int degreesToRotate = TransformationUtils.getExifOrientationDegrees(orientation);
            final int sampleSize = getRoundedSampleSize(degreesToRotate, inWidth, inHeight, outWidth, outHeight);
            final Bitmap downsampled =
                    downsampleWithSize(invalidatingStream, bufferedStream, options, pool, inWidth, inHeight, sampleSize,
                            decodeFormat);
            // BitmapFactory swallows exceptions during decodes and in some cases when inBitmap is non null, may catch
            // and log a stack trace but still return a non null bitmap. To avoid displaying partially decoded bitmaps,
            // we catch exceptions reading from the stream in our ExceptionCatchingInputStream and throw them here.
            final Exception streamException = exceptionStream.getException();
            if (streamException != null) {
                throw new RuntimeException(streamException);
            }
            Bitmap rotated = null;
            if (downsampled != null) {
                rotated = TransformationUtils.rotateImageExif(downsampled, pool, orientation);
                if (!downsampled.equals(rotated) && !pool.put(downsampled)) {
                    downsampled.recycle();
                }
            }
            return rotated;
        } finally {
            byteArrayPool.releaseBytes(bytesForOptions);
            byteArrayPool.releaseBytes(bytesForStream);
            exceptionStream.release();
            releaseOptions(options);
        }
    }

    private Bitmap downsampleWithSize(MarkEnforcingInputStream is, RecyclableBufferedInputStream  bufferedStream,
            BitmapFactory.Options options, BitmapPool pool, int inWidth, int inHeight, int sampleSize,
            DecodeFormat decodeFormat) {
        // Prior to KitKat, the inBitmap size must exactly match the size of the bitmap we're decoding.
        Bitmap.Config config = getConfig(is, decodeFormat);
        options.inSampleSize = sampleSize;
        options.inPreferredConfig = config;
        if ((options.inSampleSize == 1 || Build.VERSION_CODES.KITKAT <= Build.VERSION.SDK_INT) && shouldUsePool(is)) {
            int targetWidth = (int) Math.ceil(inWidth / (double) sampleSize);
            int targetHeight = (int) Math.ceil(inHeight / (double) sampleSize);
            // BitmapFactory will clear out the Bitmap before writing to it, so getDirty is safe.
            setInBitmap(options, pool.getDirty(targetWidth, targetHeight, config));
        }
        return decodeStream(is, bufferedStream, options);
    }

    /**
     * A method for getting the dimensions of an image from the given InputStream.
     *
     * @param is The InputStream representing the image.
     * @param options The options to pass to
     *          {@link BitmapFactory#decodeStream(InputStream, android.graphics.Rect,
     *              BitmapFactory.Options)}.
     * @return an array containing the dimensions of the image in the form {width, height}.
     */
    public int[] getDimensions(MarkEnforcingInputStream is, RecyclableBufferedInputStream bufferedStream,
            BitmapFactory.Options options) {
        options.inJustDecodeBounds = true;
        decodeStream(is, bufferedStream, options);
        options.inJustDecodeBounds = false;
        return new int[] { options.outWidth, options.outHeight };
    }

    private static Bitmap decodeStream(MarkEnforcingInputStream is, RecyclableBufferedInputStream bufferedStream,
            BitmapFactory.Options options) {
         if (options.inJustDecodeBounds) {
             // This is large, but jpeg headers are not size bounded so we need something large enough to minimize
             // the possibility of not being able to fit enough of the header in the buffer to get the image size so
             // that we don't fail to load images. The BufferedInputStream will create a new buffer of 2x the
             // original size each time we use up the buffer space without passing the mark so this is a maximum
             // bound on the buffer size, not a default. Most of the time we won't go past our pre-allocated 16kb.
             is.mark(MARK_POSITION);
         } else {
             // Once we've read the image header, we no longer need to allow the buffer to expand in size. To avoid
             // unnecessary allocations reading image data, we fix the mark limit so that it is no larger than our
             // current buffer size here. See issue #225.
             bufferedStream.fixMarkLimit();
         }

        final Bitmap result = BitmapFactory.decodeStream(is, null, options);
        return result;
        // decode()方法执行后会返回一个Bitmap对象
        // 此时图片已经被加载出来
        // 接下来的工作是让加载了的Bitmap显示到界面上
        // 请回到分析25
    }

    ...
}

步骤3：返回图片资源

加载完图片后，需要一层层向上返回

返回路径
StreamBitmapDecoder（分析25）-> ImageVideoBitmapDecoder（分析24）-> GifBitmapWrapperResourceDecoder``decodeBitmapWrapper()（分析23）
由于隔得太远，我重新把（分析23）decodeBitmapWrapper()贴出

<-- 分析23：decodeBitmapWrapper -->
private GifBitmapWrapper decodeBitmapWrapper(ImageVideoWrapper toDecode, int width, int height) throws IOException {
    GifBitmapWrapper result = null;
    Resource bitmapResource = bitmapDecoder.decode(toDecode, width, height);
    if (bitmapResource != null) {
        result = new GifBitmapWrapper(bitmapResource, null);
        // 将Resource封装到了一个GifBitmapWrapper对象
    }
    return result;
   // 最终返回的是一个GifBitmapWrapper对象：既能封装GIF，又能封装Bitmap，从而保证了不管是什么类型的图片，Glide都能加载
   // 接下来我们分析下GifBitmapWrapper（） ->>分析27
}

<-- 分析27：GifBitmapWrapper（） -->
// 作用：分别对gifResource和bitmapResource做了一层封装
public class GifBitmapWrapper {
    private final Resource gifResource;
    private final Resource bitmapResource;

    public GifBitmapWrapper(Resource bitmapResource, Resource gifResource) {
        if (bitmapResource != null && gifResource != null) {
            throw new IllegalArgumentException("Can only contain either a bitmap resource or a gif resource, not both");
        }
        if (bitmapResource == null && gifResource == null) {
            throw new IllegalArgumentException("Must contain either a bitmap resource or a gif resource");
        }
        this.bitmapResource = bitmapResource;
        this.gifResource = gifResource;
    }

    /**
     * Returns the size of the wrapped resource.
     */
    public int getSize() {
        if (bitmapResource != null) {
            return bitmapResource.getSize();
        } else {
            return gifResource.getSize();
        }
    }

    /**
     * Returns the wrapped {@link Bitmap} resource if it exists, or null.
     */
    public Resource getBitmapResource() {
        return bitmapResource;
    }

    /**
     * Returns the wrapped {@link GifDrawable} resource if it exists, or null.
     */
    public Resource getGifResource() {
        return gifResource;
    }
}

然后该GifBitmapWrapper对象会一直向上返回
直到返回到GifBitmapWrapperResourceDecoder的decode()时（分析20），会对GifBitmapWrapper对象再做一次封装，如下所示：
此处将上面的分析20再次粘贴过来

<--分析20：GifBitmapWrapperResourceDecoder对象的decode()  -->
public class GifBitmapWrapperResourceDecoder implements ResourceDecoder {

    ...
    @Override
    public Resource decode(ImageVideoWrapper source, int width, int height) throws IOException {

        try {
            wrapper = decode(source, width, height, tempBytes);
        } finally {
            pool.releaseBytes(tempBytes);
        }

        // 直接看这里
        return wrapper != null ? new GifBitmapWrapperResource(wrapper) : null;
        // 将GifBitmapWrapper封装到一个GifBitmapWrapperResource对象中（Resource类型） 并返回
        // 该GifBitmapWrapperResource和上述的BitmapResource类似- 实现了Resource接口，可通过get()来获取封装的具体内容
        // GifBitmapWrapperResource（）源码分析 - >>分析28
    }

<-- 分析28： GifBitmapWrapperResource（）-->
// 作用：经过这层封装后，我们从网络上得到的图片就能够以Resource接口的形式返回，并且还能同时处理Bitmap图片和GIF图片这两种情况。
public class GifBitmapWrapperResource implements Resource {
    private final GifBitmapWrapper data;

    public GifBitmapWrapperResource(GifBitmapWrapper data) {
        if (data == null) {
            throw new NullPointerException("Data must not be null");
        }
        this.data = data;
    }

    @Override
    public GifBitmapWrapper get() {
        return data;
    }

    @Override
    public int getSize() {
        return data.getSize();
    }

    @Override
    public void recycle() {
        Resource bitmapResource = data.getBitmapResource();
        if (bitmapResource != null) {
            bitmapResource.recycle();
        }
        Resource gifDataResource = data.getGifResource();
        if (gifDataResource != null) {
            gifDataResource.recycle();
        }
    }
}

继续返回到DecodeJob的decodeFromSourceData()（分析19）中：

<-- 分析19：decodeFromSourceData()（）  -->
private Resource decodeFromSourceData(A data) throws IOException {

        decoded = loadProvider.getSourceDecoder().decode(data, width, height);

    return decoded;
    // 该方法返回的是一个`Resource`对象，其实就是Resource对象
}

继续向上返回，最终返回到DecodeJob的decodeFromSource()中（分析15）
如下所示：

<-- 分析15：DecodeJob的decodeFromSource()  -->
class DecodeJob {
    ...

 public Resource decodeFromSource() throws Exception {
        Resource decoded = decodeSource();
        // 返回到这里，最终得到了这个Resource对象，即Resource对象
        return transformEncodeAndTranscode(decoded);
        // 作用：将该Resource对象 转换成 Resource对象 -->分析29
    }


<--分析29：transformEncodeAndTranscode（） -->
private Resource transformEncodeAndTranscode(Resource decoded) {

    Resource result = transcode(transformed);
     // 把Resource对象转换成Resource对象 ->>分析30
    if (Log.isLoggable(TAG, Log.VERBOSE)) {
        logWithTimeAndKey("Transcoded transformed from source", startTime);
    }
    return result;
}

<-- 分析30：transcode(transformed)  -->

private Resource transcode(Resource transformed) {
    if (transformed == null) {
        return null;
    }
    return transcoder.transcode(transformed);
    // 调用了transcoder的transcode()
    // 这里的transcoder就是第二步load（）中的GifBitmapWrapperDrawableTranscoder对象（回看下第2步生成对象的表） 
    // 接下来请看 ->>分析31
}

<-- 分析31：GifBitmapWrapperDrawableTranscoder.transcode(transformed) -->
// 作用：转码，即从Resource中取出GifBitmapWrapper对象，然后再从GifBitmapWrapper中取出Resource对象。
// 因为GifBitmapWrapper是无法直接显示到ImageView上的，只有Bitmap或者Drawable才能显示到ImageView上。

public class GifBitmapWrapperDrawableTranscoder implements ResourceTranscoder {

...

    @Override
    public Resource transcode(Resource toTranscode) {
        GifBitmapWrapper gifBitmap = toTranscode.get();
        // 步骤1：从Resource中取出GifBitmapWrapper对象（上面提到的调用get（）进行提取）
        Resource bitmapResource = gifBitmap.getBitmapResource();
        // 步骤2：从GifBitmapWrapper中取出Resource对象

        final Resource result;


        // 接下来做了一个判断：

        // 1. 若Resource不为空
        if (bitmapResource != null) {
            result = bitmapDrawableResourceTranscoder.transcode(bitmapResource);
            // 则需要再做一次转码：将Bitmap转换成Drawable对象
            // 因为要保证静图和动图的类型一致性，否则难以处理->>分析32
        } else {

      // 2. 若Resource为空（说明此时加载的是GIF图）
      // 那么直接调用getGifResource()方法将图片取出
      // 因为Glide用于加载GIF图片是使用的GifDrawable这个类，它本身就是一个Drawable对象
            result = gifBitmap.getGifResource();
        }
        return (Resource) result;
    }

    ...
}

<-- 分析32：bitmapDrawableResourceTranscoder.transcode(bitmapResource)-->
// 作用：再做一次转码：将Bitmap转换成Drawable对象
public class GlideBitmapDrawableTranscoder implements ResourceTranscoder {

...

    @Override
    public Resource transcode(Resource toTranscode) {

        GlideBitmapDrawable drawable = new GlideBitmapDrawable(resources, toTranscode.get());
        // 创建GlideBitmapDrawable对象，并把Bitmap封装到里面

        return new GlideBitmapDrawableResource(drawable, bitmapPool);
        // 对GlideBitmapDrawable再进行一次封装，返回Resource对象
    }

}

此时，无论是静图的 Resource 对象，还是动图的Resource 对象，它们都属于父类Resource对象
因此transcode()返回的是Resource对象，即转换过后的Resource

所以，分析15DecodeJob的decodeFromSource()中，得到的Resource对象是 Resource对象

步骤4：在主线程显示图片

继续向上返回，最终返回到 EngineRunnable 的 run() 中（分析12）

重新贴出这部分代码

<--分析12：EngineRunnable的run() -->
@Override
public void run() {

    try {
        resource = decode();
        // 最终得到了Resource对象
        // 接下来的工作：将该图片显示出来

    } catch (Exception e) {
        if (Log.isLoggable(TAG, Log.VERBOSE)) {
            Log.v(TAG, "Exception decoding", e);
        }
        exception = e;
    }
    if (isCancelled) {
        if (resource != null) {
            resource.recycle();
        }
        return;
    }
    if (resource == null) {
        onLoadFailed(exception);
    } else {
        onLoadComplete(resource);
        // 表示图片加载已经完成 ->>分析33
    }
}

<-- 分析33：  onLoadComplete(resource) -->
private void onLoadComplete(Resource resource) {
    manager.onResourceReady(resource);
    // 该manager即EngineJob对象
    // 实际上调用的是EngineJob的onResourceReady() - >>分析34
}

<-- 分析34：EngineJob的onResourceReady() ： -->
class EngineJob implements EngineRunnable.EngineRunnableManager {
    ...

    private static final Handler MAIN_THREAD_HANDLER = new Handler(Looper.getMainLooper(), new MainThreadCallback());
    // 创建线程，并绑定主线程的Looper
    private final List cbs = new ArrayList();

    @Override
    public void onResourceReady(final Resource resource) {
        this.resource = resource;
        MAIN_THREAD_HANDLER.obtainMessage(MSG_COMPLETE, this).sendToTarget();
       // 使用Handler发出一条 MSG_COMPLETE 消息
      // 那么在MainThreadCallback的handleMessage()方法中就会收到这条消息 ->>分析35
      // 从此处开始，所有逻辑又回到主线程中进行了，即更新UI

    }

<-- 分析35：MainThreadCallback的handleMessage()-->
    private static class MainThreadCallback implements Handler.Callback {

        @Override
        public boolean handleMessage(Message message) {
            if (MSG_COMPLETE == message.what || MSG_EXCEPTION == message.what) {
                EngineJob job = (EngineJob) message.obj;
                if (MSG_COMPLETE == message.what) {
                    job.handleResultOnMainThread();
                    // 调用 EngineJob的handleResultOnMainThread() ->>分析36
                } else {
                    job.handleExceptionOnMainThread();
                }
                return true;
            }
            return false;
        }
    }

    ...
}

<-- 分析36：handleResultOnMainThread() -->
private void handleResultOnMainThread() {

        // 通过循环，调用了所有ResourceCallback的onResourceReady()
        for (ResourceCallback cb : cbs) {
            if (!isInIgnoredCallbacks(cb)) {
                engineResource.acquire();
                cb.onResourceReady(engineResource);
                // ResourceCallback 是在addCallback()方法当中添加的->>分析37
            }
        }
        engineResource.release();
    }

<-- 分析37：addCallback() -->
//
    public void addCallback(ResourceCallback cb) {
        Util.assertMainThread();
        if (hasResource) {
            cb.onResourceReady(engineResource);
            // 会向cbs集合中去添加ResourceCallback
        } else if (hasException) {
            cb.onException(exception);
        } else {
            cbs.add(cb);
        }
    }

// 而addCallback()是在分析11：Engine的load()中调用的：
<-- 上面的分析11：Engine的load() -->
public class Engine implements EngineJobListener,
        MemoryCache.ResourceRemovedListener,
        EngineResource.ResourceListener {

      ...

      public  LoadStatus load(Key signature, int width, int height, DataFetcher fetcher,
            DataLoadProvider loadProvider, Transformation transformation, ResourceTranscoder transcoder, Priority priority, 
            boolean isMemoryCacheable, DiskCacheStrategy diskCacheStrategy, ResourceCallback cb) {

              engineJob.addCallback(cb);
           // 调用addCallback()注册了一个ResourceCallback
           // 上述参数cb是load()传入的的最后一个参数
            // 而load（）是在GenericRequest的onSizeReady()调用的->>回到分析9（下面重新贴多了一次）
        return new LoadStatus(cb, engineJob);
    }

    ...
}

<-- 上面的分析9：onSizeReady() -->
public void onSizeReady(int width, int height) {

... 
    loadStatus = engine.load(signature, width, height, dataFetcher, loadProvider, transformation, transcoder,
            priority, isMemoryCacheable, diskCacheStrategy, this);
            // load（）最后一个参数是this
            // 所以，ResourceCallback类型参数cb是this
            // 而GenericRequest本身实现了ResourceCallback接口
            // 因此，EngineJob的回调 = cb.onResourceReady(engineResource) = 最终回调GenericRequest的onResourceReady() -->>分析6

    }
}

<-- 分析38：GenericRequest的onResourceReady() -->
// onResourceReady()存在两个方法重载

// 重载1
public void onResourceReady(Resource resource) {
    Object received = resource.get();
    // 获取封装的图片对象（GlideBitmapDrawable对象 或 GifDrawable对象

       onResourceReady(resource, (R) received);
      // 然后将该获得的图片对象传入到了onResourceReady()的重载方法中 ->>看重载2
}


// 重载2
private void onResourceReady(Resource resource, R result) {

        ...

        target.onResourceReady(result, animation);
        // Target是在第3步into()的最后1行调用glide.buildImageViewTarget()方法来构建出的Target：GlideDrawableImageViewTarget对象
        // ->>分析39

    }

<-- 分析39：GlideDrawableImageViewTarget.onResourceReady  -->
public class GlideDrawableImageViewTarget extends ImageViewTarget {

    @Override
    public void onResourceReady(GlideDrawable resource, GlideAnimation animation) {
        if (!resource.isAnimated()) {
            float viewRatio = view.getWidth() / (float) view.getHeight();
            float drawableRatio = resource.getIntrinsicWidth() / (float) resource.getIntrinsicHeight();
            if (Math.abs(viewRatio - 1f) <= SQUARE_RATIO_MARGIN
                    && Math.abs(drawableRatio - 1f) <= SQUARE_RATIO_MARGIN) {
                resource = new SquaringDrawable(resource, view.getWidth());
            }
        }
        super.onResourceReady(resource, animation);
        // 若是静态图片，就调用父类的.onResourceReady() 将GlideDrawable显示到ImageView上
        // GlideDrawableImageViewTarget的父类是ImageViewTarget ->>分析40
        this.resource = resource;
        resource.setLoopCount(maxLoopCount);
        resource.start();
        // 如果是GIF图片，就调用resource.start()方法开始播放图片
    }

    @Override
    protected void setResource(GlideDrawable resource) {
        view.setImageDrawable(resource);
    }

 ...
}

<-- 分析40：ImageViewTarget.onResourceReady（） -->
public abstract class ImageViewTarget extends ViewTarget implements GlideAnimation.ViewAdapter {

    ...

    @Override
    public void onResourceReady(Z resource, GlideAnimation glideAnimation) {
        if (glideAnimation == null || !glideAnimation.animate(resource, this)) {
            setResource(resource);
            // 继续往下看
        }
    }

    protected abstract void setResource(Z resource);
    // setResource()是一个抽象方法
   // 需要在子类具体实现：请回看上面分析39子类GlideDrawableImageViewTarget类重写的setResource()：调用view.setImageDrawable()，而这个view就是ImageView
  // 即setResource()的具体实现是调用ImageView的setImageDrawable() 并 传入图片，于是就实现了图片显示。

}

终于，静图 / Gif图成功显示出来

总结

至此，Glide的基本功能 图片加载的全功能解析完毕。

5. 总结

一图总结Glide的基本功能 图片加载的全过程

你可能感兴趣的:(Android高级开发之路)

如果面试官问你CAS，你还这么答，可能就要回去等通知了爱玛士程序员面试 Java java 面试开发语言程序员架构
前言大家好，我是JAVA高级开发之路，一个总在为粉丝解决面试题的程序员。最近有几个粉丝说在面试面试中遇到了CAS的问题，连着几次面试都没有让面试官满意，区区CAS底层源码，怎能难倒咱们这届程序员们呢？都支棱起来，跟我一起来搞定CAS底层源码。什么是CASCAS的全称是Compare-And-Swap，它是CPU并发原语。它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原
字节跳动资深面试官亲述：15个经典面试问题及回答思路，知乎上转疯了！左夜天程序员 android
前言这是“拔剑金九银十”的第二篇文章，本文主要针对3年以上的Android开发者进阶面试中高级开发工程师而整理。希望可以对你们有所帮助。不多废话，进入正题。目录：Java中高级计算机网络Android高级面试—性能优化Android优秀第三方库Androidframework相关其他Android高频面试题阿里P7薪资待遇**阿里薪资结构：**一般是12+1+3=16薪•年底的奖金为0-6个月薪资
BIOS开发之路(三)——UEFI的概念及启动阶段修行者xxl BIOS开发服务器 c++嵌入式硬件
一、UEFI概述1、UEFI的全称是UnifiedExtensibleFirmwareInterface，统一可扩展固件接口，定义了操作系统和平台固件之间的接口，可以让PC从预启动的操作环境，加载到操作系统上，是BIOS的替代者。UEFI提供给操作系统的接口包括启动时服务和运行时服务。2、UEFI相对于BIOS的改进：（1）UEFI对硬件的支持超过BIOS。UEFI可以使用2.2TB以上的硬盘作为
Android高级面试题汇总——Android篇（1） oO樱花祭LI Android 面试
（一）Android基础知识点1、四大组件是什么Activity，Service，ContentProvider，BroadcastReceiver2、四大组件的生命周期和简单用法Activity的生命周期：onCreate()->onStart()->onResume()->onPause()->onStop()->onRestart()->onDestroy()用法：创建一个Intent对象，
2024年Android高级面试题总结（附答案解析） 2401_84519907 程序员 android
9.简述jvm中默认的classLoader与功能10.switch语句后的控制表达式只能是short、char、int、long整数类型和枚举类型，不能是float，double和boolean类型。String类型是java7开始支持11.重写的特性12.!=和==，当用于基本类型时候，是比较值是否相同；当用于引用类型的时候，是比较对象是否相同，比较内存地址13.null可以被强制类型转换成任
Jetpack系列(十) — 测试，2021Android高级面试题总结 m0_61408726 Android android 面试 java 移动开发
```Room测试在androidTest文件夹下新建测试类```@RunWith(AndroidJUnit4::class)classWordDaoTest{privatelateinitvardatabase:AppDataBaseprivatelateinitvarwordDao:WordDaoprivatevalword1=Word("hello")privatevalword2=Word
Linux学习和阿里云服务器的配置(感谢秦老师) 南桑爱吃牛筋服务器 linux 学习
Linux学习我这里给大家准备的是继续Java全栈开发的Linux，而不是运维级别！我们为什么要在这个时间学习Linux？Java全栈开发的我们要掌握哪些知识？需要准备什么工作？Java开发之路：JavaSE、MySQL、前端（HTML、Css、JS）、JavaWeb、SSM框架（很多人就开始找工作了！）、SpringBoot、Vue、SpringCloud~、（MPGit）Linux（CentO
android高级ui01-自定义view- 亢正
学习笔记，整理中摘要面1、layoutparams:xml的属性转换为java用的格式2、面必问：measurespec------------------------------------主要讲自定义viewgroup,viewpager1、所有的xml解析都在layoutinflater里面2、自定义view至少3个构造函数，javanewview调用；xml反射调用；不同主题调用；自定义属
掌握Vue，开启你的前端开发之路！知识分享小能手学习心得体会编程语言如门 vue.js 前端 javascript
介绍：Vue.js是一个构建数据驱动的Web应用的渐进式框架，它以简洁和轻量级著称。首先，Vue.js的核心在于其视图层，它允许开发者通过简单的模板语法将数据渲染进DOM（文档对象模型）。以下是Vue.js的几个重要特点：响应式的数据绑定：Vue.js专注于创建可复用的组件，并通过数据绑定和组件化的思想，使得状态管理变得直观。组合式的视图组件：Vue鼓励以组件的形式组织代码，这些组件可以独立地开发
（一）ROS的简介及相关基础苦瓜汤补钙 ROS学习与实践 linux ubuntu
文章目录前言一、ROS是什么？二、ROS中的核心概念总结前言本文是根据“古月居“对ROS进行学习的笔记。还原最好的ROS入门体验，起航机器人开发之路！bilibili连接：6.ROS是什么_哔哩哔哩_bilibiliROS社区内的功能包数量、下载量、wiki访问量、相关文章均呈大幅度上涨。一、ROS是什么？ROS(RobotOperatingSystem,机器人操作系统)，包括了四个part：通信
深度剖析原理！Android高级工程师面试实战，文末领取面试资料左夜天程序员 android
Android开发前景怎么样？很多人说Android开发前景越来越差了我觉得这个回答是片面的首先Android应用开发前景差是在最近两年出现的，也就是从2018开始，从那时起移动端的程序员已经慢慢出现供大于求的局面，本人作为移动端开发，深知这一点。然而也必须说明一点，不论是Android开发还是iOS开发，虽然都出现了相关的程序员供大于求的情况，但市场仍然是有需求的，特别是对资深的开发人员及拥有相
Android高级工程师面试题-字节跳动，含BATJM大厂 Java范德萨程序员 android 移动开发面试
其实如果你技术深度足够，大必不用为就业而忧愁。每个行业何尝不是这样，最开始的风口，到慢慢的成熟。Android初级在2020年的日子里风光不再，靠会四大组件就能够获取到满意薪资的时代一去不复返。**经过一波一波的淘汰与洗牌，剩下的都是技术的金子。就像大浪褪去，裸泳的会慢慢上岸。**而真正坚持下来的一定会取得不错成绩。毕竟Android市场是如此之大。从Android高级的蓬勃的就业岗位需求来看，能
【从零开始的rust web开发之路四】rust语言tokio异步使用redis教程爱音乐的程序猿 redis rust语言云原生 rust redis 后端 cargo 异步 tokio
文章目录前言一、首先引入依赖二、创建redis客户端三、相关操作设置值mset设置多个key值设置含有过期时间的值如果key不存在才设置获取基本类型值删除一个键删除多个键判断键是否存在如何使用json序列化导入相关依赖代码相关实例总结前言使用rust写web，自然是离不开redis缓存的。rust也有现成redis连接库，并且支持阻塞和异步两种模式。下面教程我我以tokio异步操作redis方式为
【从零开始的rust web开发之路五】rust语言lazy_static加serde_yaml实现读取外部yaml配置爱音乐的程序猿 rust语言云原生 rust 后端 yaml 云原生
文章目录前言一、lazy_static介绍二、serde_yaml介绍二、正文实战前言web开发离不开外部配置。之前一直用的javaspringboot开发web。rust有读取yaml的库，可以实现类似的效果一、lazy_static介绍lazy_static是Rust语言中一个非常有用的第三方库，它的主要作用是允许开发者在程序中声明并初始化那些需要延迟求值（lateinitialization
[Android高级动画] 如何让箭头按圆形旋转？小米Metre
用Android动画，如何让一个箭头按圆形旋转？arrowlikethis：arrow.png最终效果图：效果图一、分析1、两个关键值箭头按圆形旋转，需要两个关键值，一个是圆形坐标，一个是对应圆形坐标位置的角度。圆形坐标：用来实现箭头移动坐标点的角度：用来改变箭头的方向2、两个关键APIa、实现箭头移动和旋转可以使用：Matrix类postTranslate和postRotate方法。b、获取圆坐
【Galois工具开发之路】SpringApplicationRunListener在SpringBoot项目启动过程中执行了两次... newcih Spring Java spring boot java spring Runlistener started
SpringApplicationRunListener是什么？SpringApplicationRunListener接口的作用主要就是在SpringBoot启动初始化的过程中可以通过SpringApplicationRunListener接口回调来让用户在启动的各个流程中可以加入自己的逻辑。比如以下的方法Galois通过注入各种Listener到SpringBoot的启动监听器列表中，实现了S
【从零开始的rust web开发之路三】orm框架sea-orm入门使用教程爱音乐的程序猿 rust语言云原生 mysql rust 后端异步 orm mysql
【从零开始的rustweb开发之路三】orm框架sea-orm入门使用教程文章目录前言一、引入依赖二、创建数据库连接简单链接连接选项开启日志调试三、生成实体安装sea-orm-cli创建数据库表使用sea-orm-cli命令生成实体文件代码四、增删改查实现新增数据主键查找条件查找查找用户名是admin的一条用户查找地址是郑州的所有用户查找地址是郑州并且用户名包含admin的所有用户分页查找修改数据
测试开发之路--Flask 之旅 (三):数据库孙高飞自动化测试 flask 数据库 python
背景通过前两次的努力，我们对环境有了增删查改以及部署和查看日志的能力。现在已经处于将就可用的状态。但其实还差了很重要的东西，就是权限的管理。因为不能说每个用户上来都能随便的重启和删除环境吧，太容易出事故了。所以我们想起码有最基本的隔离性。Flask扩展模块上一次我们使用了Flask-WTF这个针对于表单的扩展模块。这次为了加入权限管理，我们需要再安装以下这些扩展模块。Flask-SQLAlchem
Qt开发之路43---Qt屏蔽qDebug调试信息木木木. Qt debug qt
一：局部屏蔽如下，在当前文件加宏定义QT_NO_WARNING_OUTPUT和QT_NO_DEBUG_OUTPUT#defineQT_NO_DEBUG_OUTPUT//屏蔽debug输出#defineQT_NO_WARNING_OUTPUT//屏蔽warning输出二：全局屏蔽如下，在.pro文件中添加宏定义QT_NO_WARNING_OUTPUT和QT_NO_DEBUG_OUTPUTDEFINE
测试开发之路 (工具篇)--assertJ-db 科普孙高飞自动化测试自动化
前言今日我们看看java大名鼎鼎的assertj是怎么做断言的数据库断言在实际的测试中我们总是跟业务打交道的。跟业务打交道一般很难避免验证数据库中的东西。尤其在接口测试中，一个常见的例子是你测试一个下单的接口。接口返回可能就是成功过或者失败。你无法从返回值中判断订单的细节是否创建成功。这时候一般要查询数据库做断言。demo来看一下例子。Requestsql=newRequest(dataSourc
如今有了ChatGPT，我们该如何开始学习编程？也鱼实验室
如果你正在考虑或刚刚进入程序开发队伍，那么2023年绝对是个最好的时机。为什么？现在你不需要浪费时间在搜索引擎或论坛上搜索编程答案，也不需要是不是刷新页面等待在StackOverflow上有人解答你的问题。现在，你可以全天候24小时（当然不在限流的时候）向ChatGPT询问任何代码问题并快速获得答案。这个AI工具肯定会加快你的学习速度，除此之外，本文还将介绍一些其他的步骤，以便在你的新时代开发之路
探索编程世界的利器！选择哪个IDE，成就新手开发之路？ RobertTeacher ide
文章目录一、IDE的概念和作用IDE是什么？为什么说选择一款IDE对开发者来说可以起到事半功倍的作用？二、当下备受推崇的IDE有哪些？1.VisualStudioCode2.PyCharm3.IntelliJIDEA三、如何选择一个适合自己的IDE？四、IDE的使用建议和技巧总结一、IDE的概念和作用IDE是什么？IDE是IntegratedDevelopmentEnvironment（集成开发环
Qt开发之路52---给EXE或DLL添加版本信息木木木. Qt c++qt visual studio
一：VisualStudio在VisualStudio中，默认资源里有Version，想要添加版本信息（版本信息、描述、版权等），直接修改，如下图：若没有Version，则在添加资源的时候，选择Version，如下图：二：QtCreator1.方法一：新建xxx.rc文件，在rc文件填入以下的版本信息；把xxx.rc放在与pro同目录下，并将pro文件的RC_FILE=xxx.rc，然后构建，编译
Android Studio开发之路（七）CameraX&&Opencv的使用 bug远离Jemma Android Studio开发之路 android studio opencv android
一、前情提要以及工作目标工作目标：做一个显示单通道图像的相机，实现预览和拍照。原本是调用opencv-android里边的JavaCamera2View来实现，这个用起来比较方便，它提供了集成好的相机预览界面，并且提供了帧处理函数。但是问题是用opencv相机获取到的帧图片分辨率不高，达不到目标效果。而CameraX作为Google发行的相机处理库，可以方便的做分辨率设置、对焦等操作，于是决定使用
为什么APP备案如此重要？迅飒算法备案人工智能算法大数据安全
工信部app小程序快应用的ICP备案找我们！全国互联网安全管理服务平台APP小程序备案可以找我们！教育类应用程序APP备案也可以找我们！APP网站小程序算法备案都可以找我们！作为APP开发者，您是否了解APP备案的重要性？在竞争激烈的APP市场中，如何确保您的应用合规上线，并赢得用户的信任？本文将为您深入解析APP备案的必要性及流程，助您在开发之路上稳步前行。一、为什么APP备案如此重要？APP备
Likeshop单商户高级版商城的二次开发之路什么软件好个人开发
一、产品介绍likeshop单商户高级版是一款适用于B2C、单商户、自营商城场景的商城系统。它完美契合私域流量变现闭环交易使用，拥有丰富的营销玩法、强大的分销能力，支持DIY多模板，前后端分离。无论您是想要进行商城运营还是二次开发，likeshop都能满足您的需求。二、应用场景私域流量变现：借助likeshop单商户高级版，商家可以实现私域流量的快速变现，提高转化率。营销活动：系统内置多种营销工具
Flutter之配置环境创建第一个项目丿CoolTone Flutter开发实践 flutter
随着时代发展，使用Flutter开发的项目越来越多，于是踏上了Flutter开发之路。作为一个Android开发人员，也只能被卷到与时俱进，下面一起创建一个Flutter项目吧。一、Android开发，电脑上已经具备了的条件：1.JavaSE安装配置：下载https://www.oracle.com/java/technologies/downloads/#java8-window2.Androi
菜鸟的开发之路2--数据库设计太年轻z
数据库的设计与调优主键策略先说结果，项目最后采用了BIGINT类型的自增Id方式。思路：考虑到对事务的支持和主键索引效率（聚集索引），采用默认的InnoDB引擎。在InnoDB下，主键选用有以下几个原则：主键最好是单调（递增）的。因为主键默认是聚集索引，而聚集索引的叶子节点存放的就是数据本身（而非地址），索引的键值逻辑顺序决定了表数据行的物理存储顺序，也就是说，如果索引是递增的，则该索引在磁盘上的
迈向更高层次智能化开发之路：写给大模型的2023总结 pengxin_ce
2024新年快乐！由ChatGPT引爆的大模型浪潮从2023年年头热到了年尾，各种学术和行业技术大会的话题几乎都绕不开“大模型”。在软件工程领域，“大模型”话题也是热得发烫，各种代码大模型层出不穷，相关论文如雨后春笋般喷涌而出。街头巷尾、线上线下都在热议大模型是不是要颠覆软件工程了，CTO们和研发效能部都在思考如何回答老板诸如“开发人员能减少百分之几十”、“研发效能能有几倍提升”这样的灵魂拷问。大
Android高级目录及网络大神的笔记 wayne777
网络大神笔记:https://github.com/BlackZhangJX/Android-Notesjava、Android、高级开发技术、跨平台Hybrid开发一、java基础（一）java基础面试知识点java中==和equals和hashCode的区别int、char、long各占多少字节数int与integer的区别探探对java多态的理解String、StringBuffer、Str
枚举的构造函数中抛出异常会怎样 bylijinnan java enum 单例
首先从使用enum实现单例说起。为什么要用enum来实现单例？这篇文章（ http://javarevisited.blogspot.sg/2012/07/why-enum-singleton-are-better-in-java.html）阐述了三个理由： 1.enum单例简单、容易，只需几行代码： public enum Singleton { INSTANCE;
CMake 教程 aigo C++
转自：http://xiang.lf.blog.163.com/blog/static/127733322201481114456136/ CMake是一个跨平台的程序构建工具，比如起自己编写Makefile方便很多。介绍：http://baike.baidu.com/view/1126160.htm 本文件不介绍CMake的基本语法，下面是篇不错的入门教程： http:
cvc-complex-type.2.3: Element 'beans' cannot have character Cb123456 spring Webgis
cvc-complex-type.2.3: Element 'beans' cannot have character Line 33 in XML document from ServletContext resource [/WEB-INF/backend-servlet.xml] is i
jquery实例:随页面滚动条滚动而自动加载内容 120153216 jquery
<script language="javascript"> $(function (){ var i = 4;$(window).bind("scroll", function (event){ //滚动条到网页头部的高度，兼容ie,ff,chrome var top = document.documentElement.s
将数据库中的数据转换成dbs文件何必如此 sql dbs
旗正规则引擎通过数据库配置器（DataBuilder）来管理数据库，无论是Oracle，还是其他主流的数据都支持，操作方式是一样的。旗正规则引擎的数据库配置器是用于编辑数据库结构信息以及管理数据库表数据，并且可以执行SQL 语句，主要功能如下。 1)数据库生成表结构信息：主要生成数据库配置文件(.conf文
在IBATIS中配置SQL语句的IN方式 357029540 ibatis
在使用IBATIS进行SQL语句配置查询时，我们一定会遇到通过IN查询的地方，在使用IN查询时我们可以有两种方式进行配置参数：String和List。具体使用方式如下： 1.String:定义一个String的参数userIds，把这个参数传入IBATIS的sql配置文件，sql语句就可以这样写： <select id="getForms" param
Spring3 MVC 笔记（一） 7454103 spring mvc bean REST JSF
自从 MVC 这个概念提出来之后 struts1.X struts2.X jsf 。。。。。这个view 层的技术一个接一个！都用过！不敢说哪个绝对的强悍！要看业务，和整体的设计！最近公司要求开发个新系统！
Timer与Spring Quartz 定时执行程序 darkranger spring bean 工作 quartz
有时候需要定时触发某一项任务。其实在jdk1.3，java sdk就通过java.util.Timer提供相应的功能。一个简单的例子说明如何使用，很简单： 1、第一步，我们需要建立一项任务，我们的任务需要继承java.util.TimerTask package com.test; import java.text.SimpleDateFormat; import java.util.Date;
大端小端转换，le32_to_cpu 和cpu_to_le32 aijuans C语言相关
大端小端转换，le32_to_cpu 和cpu_to_le32 字节序 http://oss.org.cn/kernel-book/ldd3/ch11s04.html 小心不要假设字节序. PC 存储多字节值是低字节为先(小端为先, 因此是小端), 一些高级的平台以另一种方式(大端)
Nginx负载均衡配置实例详解 avords
[导读] 负载均衡是我们大流量网站要做的一个东西，下面我来给大家介绍在Nginx服务器上进行负载均衡配置方法，希望对有需要的同学有所帮助哦。负载均衡先来简单了解一下什么是负载均衡，单从字面上的意思来理解就可以解负载均衡是我们大流量网站要做的一个东西，下面我来给大家介绍在Nginx服务器上进行负载均衡配置方法，希望对有需要的同学有所帮助哦。负载均衡先来简单了解一下什么是负载均衡
乱说的 houxinyou 框架敏捷开发软件测试
从很久以前，大家就研究框架，开发方法，软件工程，好多！反正我是搞不明白！这两天看好多人研究敏捷模型，瀑布模型！也没太搞明白. 不过感觉和程序开发语言差不多，瀑布就是顺序，敏捷就是循环. 瀑布就是需求、分析、设计、编码、测试一步一步走下来。而敏捷就是按摸块或者说迭代做个循环，第个循环中也一样是需求、分析、设计、编码、测试一步一步走下来。也可以把软件开发理
欣赏的价值——一个小故事 bijian1013 有效辅导欣赏欣赏的价值
　　第一次参加家长会，幼儿园的老师说："您的儿子有多动症，在板凳上连三分钟都坐不了，你最好带他去医院看一看。"　　回家的路上，儿子问她老师都说了些什么，她鼻子一酸，差点流下泪来。因为全班30位小朋友，惟有他表现最差；惟有对他，老师表现出不屑，然而她还在告诉她的儿子："老师表扬你了，说宝宝原来在板凳上坐不了一分钟，现在能坐三分钟。其他妈妈都非常羡慕妈妈，因为全班只有宝宝
包冲突问题的解决方法 bingyingao eclipse maven exclusions 包冲突
包冲突是开发过程中很常见的问题：其表现有： 1.明明在eclipse中能够索引到某个类，运行时却报出找不到类。 2.明明在eclipse中能够索引到某个类的方法，运行时却报出找不到方法。 3.类及方法都有，以正确编译成了.class文件，在本机跑的好好的，发到测试或者正式环境就抛如下异常： java.lang.NoClassDefFoundError: Could not in
【Spark七十五】Spark Streaming整合Flume-NG三之接入log4j bit1129 Stream
先来一段废话：实际工作中，业务系统的日志基本上是使用Log4j写入到日志文件中的，问题的关键之处在于业务日志的格式混乱，这给对日志文件中的日志进行统计分析带来了极大的困难，或者说，基本上无法进行分析，每个人写日志的习惯不同，导致日志行的格式五花八门，最后只能通过grep来查找特定的关键词缩小范围，但是在集群环境下，每个机器去grep一遍，分析一遍，这个效率如何可想之二，大好光阴都浪费在这上面了
sudoku solver in Haskell bookjovi sudoku haskell
这几天没太多的事做，想着用函数式语言来写点实用的程序，像fib和prime之类的就不想提了（就一行代码的事），写什么程序呢？在网上闲逛时发现sudoku游戏，sudoku十几年前就知道了，学生生涯时也想过用C/Java来实现个智能求解，但到最后往往没写成，主要是用C/Java写的话会很麻烦。现在写程序，本人总是有一种思维惯性，总是想把程序写的更紧凑，更精致，代码行数最少，所以现
java apache ftpClient bro_feng java
最近使用apache的ftpclient插件实现ftp下载，遇见几个问题，做如下总结。 1. 上传阻塞，一连串的上传，其中一个就阻塞了，或是用storeFile上传时返回false。查了点资料，说是FTP有主动模式和被动模式。将传出模式修改为被动模式ftp.enterLocalPassiveMode();然后就好了。看了网上相关介绍，对主动模式和被动模式区别还是比较的模糊，不太了解被动模
读《研磨设计模式》-代码笔记-工厂方法模式 bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ package design.pattern; /* * 工厂方法模式：使一个类的实例化延迟到子类 * 某次，我在工作不知不觉中就用到了工厂方法模式（称为模板方法模式更恰当。2012-10-29）： * 有很多不同的产品，它
面试记录语 chenyu19891124 招聘
或许真的在一个平台上成长成什么样，都必须靠自己去努力。有了好的平台让自己展示，就该好好努力。今天是自己单独一次去面试别人，感觉有点小紧张，说话有点打结。在面试完后写面试情况表，下笔真的好难，尤其是要对面试人的情况说明真的好难。今天面试的是自己同事的同事，现在的这个同事要离职了，介绍了我现在这位同事以前的同事来面试。今天这位求职者面试的是配置管理，期初看了简历觉得应该很适合做配置管理，但是今天面
Fire Workflow 1.0正式版终于发布了 comsci 工作 workflow Google
Fire Workflow 是国内另外一款开源工作流，作者是著名的非也同志，哈哈.... 官方网站是 http://www.fireflow.org 经过大家努力,Fire Workflow 1.0正式版终于发布了正式版主要变化: 1、增加IWorkItem.jumpToEx(...)方法，取消了当前环节和目标环节必须在同一条执行线的限制，使得自由流更加自由 2、增加IT
Python向脚本传参 daizj python 脚本传参
如果想对python脚本传参数，python中对应的argc, argv(c语言的命令行参数)是什么呢？需要模块：sys 参数个数：len(sys.argv) 脚本名： sys.argv[0] 参数1： sys.argv[1] 参数2： sys.argv[
管理用户分组的命令gpasswd dongwei_6688 passwd
NAME： gpasswd - administer the /etc/group file SYNOPSIS： gpasswd group gpasswd -a user group gpasswd -d user group gpasswd -R group gpasswd -r group gpasswd [-A user,...] [-M user,...] g
郝斌老师数据结构课程笔记 dcj3sjt126com 数据结构与算法
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
yii2 cgridview加上选择框进行操作 dcj3sjt126com GridView
页面代码 <?=Html::beginForm(['controller/bulk'],'post');?> <?=Html::dropDownList('action','',[''=>'Mark selected as: ','c'=>'Confirmed','nc'=>'No Confirmed'],['class'=>'dropdown',])
linux mysql fypop linux
enquiry mysql version in centos linux yum list installed | grep mysql yum -y remove mysql-libs.x86_64 enquiry mysql version in yum repositoryyum list | grep mysql oryum -y list mysql* install mysq
Scramble String hcx2013 String
Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively. Below is one possible representation of s1 = "great":
跟我学Shiro目录贴 jinnianshilongnian 跟我学shiro
历经三个月左右时间，《跟我学Shiro》系列教程已经完结，暂时没有需要补充的内容，因此生成PDF版供大家下载。最近项目比较紧，没有时间解答一些疑问，暂时无法回复一些问题，很抱歉，不过可以加群（334194438/348194195）一起讨论问题。 ----广告-----------------------------------------------------
nginx日志切割并使用flume-ng收集日志 liyonghui160com
nginx的日志文件没有rotate功能。如果你不处理，日志文件将变得越来越大，还好我们可以写一个nginx日志切割脚本来自动切割日志文件。第一步就是重命名日志文件，不用担心重命名后nginx找不到日志文件而丢失日志。在你未重新打开原名字的日志文件前，nginx还是会向你重命名的文件写日志，linux是靠文件描述符而不是文件名定位文件。第二步向nginx主
Oracle死锁解决方法 pda158 oracle
　select p.spid,c.object_name,b.session_id,b.oracle_username,b.os_user_name from v$process p,v$session a, v$locked_object b,all_objects c where p.addr=a.paddr and a.process=b.process and c.object_id=b.
java之List排序 shiguanghui list排序
在Java Collection Framework中定义的List实现有Vector，ArrayList和LinkedList。这些集合提供了对对象组的索引访问。他们提供了元素的添加与删除支持。然而，它们并没有内置的元素排序支持。　　你能够使用java.util.Collections类中的sort()方法对List元素进行排序。你既可以给方法传递
servlet单例多线程 utopialxw 单例多线程 servlet
转自http://www.cnblogs.com/yjhrem/articles/3160864.html 和 http://blog.chinaunix.net/uid-7374279-id-3687149.html Servlet 单例多线程 Servlet如何处理多个请求访问？Servlet容器默认是采用单实例多线程的方式处理多个请求的：1.当web服务器启动的