Glide（图片异步加载缓存库）的方法介绍

文章来源：http://blog.csdn.net/u011733020/article/details/52319283 

Glide 在开源中国上的介绍

• Glide 的详细介绍：请点这里
• Glide 的下载地址：请点这里

Glide :

An image loading and caching library for Android focused on smooth scrolling

安卓上专注于平滑滑动的图片加载和缓存库。

Glide有以下特点：

1.注重 list中的图片在scroll状态下的流畅性。

2.可以展示视频图像，普通格式图片和GIF格式。

3.默认网络请求使用的是httpurlconnection,同时支持自定义使用volley 或者 ok。

4.自定义多个请求的优先级，重要的图片，可以设置高的优先级，优先加载。

5.可以给url 设置一个签名，当url 指向不变，图片内容变化时，根据签名不同，去自动更换以缓存的图片，这一点是imagoader无法做到的。

6.更有一个非常优秀的特点，可以在非ImageView 类型上面加载图片。

7.Glide 对内存的使用非常优秀，并且Glide生命周期与Activity生命周期绑定，更好的分配回收内存。

。。。

更多优点，不一一总结，留待大家亲身使用感受。

获取Glide

首先获取Glide的jar包，可以去github下载，添加依赖，也可以使用gradle 下载。

You can download a jar from GitHub's releases page.

Or use Gradle:

repositories {
  mavenCentral() // jcenter() works as well because it pulls from Maven Central
}

dependencies {
  compile 'com.github.bumptech.glide:glide:3.7.0'
  compile 'com.android.support:support-v4:19.1.0'
}

How do I use Glide?

// For a simple view:
@Override public void onCreate(Bundle savedInstanceState) {
  ...
  ImageView imageView = (ImageView) findViewById(R.id.my_image_view);

  Glide.with(this).load("http://goo.gl/gEgYUd").into(imageView);
}

// For a simple image list:
@Override public View getView(int position, View recycled, ViewGroup container) {
  final ImageView myImageView;
  if (recycled == null) {
    myImageView = (ImageView) inflater.inflate(R.layout.my_image_view, container, false);
  } else {
    myImageView = (ImageView) recycled;
  }

  String url = myUrls.get(position);

  Glide
    .with(myFragment)
    .load(url)
    .centerCrop()
    .placeholder(R.drawable.loading_spinner)
    .crossFade()
    .into(myImageView);

  return myImageView;
}

可以看出Glide 的使用时相当简便的，添加依赖后，仅仅通过Glide.with().load().into();就可以展示远程图片。

以上便是Github上关于Glide的基本介绍，接下来我们看具体的使用。

Glide 使用起来非常简单，Glide 在Activity 、Fragment 中都可以使用，并且是通过绑定对应的对象去使用。

 Glide.with(this).load(url).into(imageView);

这就是最基本的使用方式 。

with() ：使Glide 的生命周期与当前对象绑定，可以是Activity Fragment Context等等。

load()：可以加载一个本地图片，或者网络图片地址，也可以是Android工程的 内部Resource 图片资源。

into()：将展示在ImageView 对象。

介绍一些常用的配置：

Glide基本方法：Glide.with(this).load(R.mipmap.bigger).into(imageView);

加载网络图片时显示的占位图： .placeholder(holderId).into(imageView);

加载失败时展示的失败图: .error(errorId).into(imageView);

淡入淡出的渐变展示过渡动画:.crossFade().into(imageView);淡入淡出的渐变展示过渡动画 crossFade(int millSeconds) 默认Glide是自动执行该方法的，淡入时间是300ms （可以自己传int 参数去调整时间），如果要禁止该效果，可以调用dontAnimate() 方法

按比例缩小或者放大到ImageView宽度，居中显示: .fitCenter().into(imageView);

按比例放大图片居中显示，图片的长/宽 可能大于ImageView的长/宽: .centerCrop().into(imageView); 。

priority( Priority.HIGH )：设置请求的优先级 由低到高分别为： Priority.LOW、  Priority.NORMAL、  Priority.HIGH   、 Priority.IMMEDIATE。

skipMemoryCache( true ) ：是否设置不允许内存缓存，如果是比较频繁的变化，那么可以不在内存中保存，默认是false，即允许内存缓存。

diskCacheStrategy()：设置磁盘缓存策略，因为默认情况下 Glide 不仅仅会缓存远程图片，并且会缓存适应当前View size的图片。

参数为枚举类型 有四种分辨是：

DiskCacheStrategy.NONE 什么都不缓存。
DiskCacheStrategy.SOURCE 仅仅只缓存原来的全分辨率的图像。
DiskCacheStrategy.RESULT 仅仅缓存最终的图像，即，降低分辨率后的（或者是转换后的）。
DiskCacheStrategy.ALL 缓存所有版本的图像（默认行为）。

override(int w,int h): 重新调整图片的大小。Glide 加载图片默认是适应ImageView的大小，调用该方法，可能导致图片显示小于ImageView的size。

缩略图：普通方式 .thumbnail(0.1f) 将原图缩小到10%。使用该方法需要保证ImageView的ScaleType。

高级方式通过请求一个额外的Request去请求缩略图

 private void loadImageThumbnailRequest() {
     // setup Glide request without the into() method
     DrawableRequestBuilder thumbnailRequest = Glide
         .with( context )
         .load( thumbnailUrl );

     // pass the request as a a parameter to the thumbnail request
     Glide
         .with( context )
         .load( UsageExampleGifAndVideos.gifUrl )
         .thumbnail( thumbnailRequest )
         .into( imageView);
 }

将图片显示在普通View上：

 public  void showImageOnCustomView(T t, String url, View view) {
     ViewTarget viewTarget = new ViewTarget(view) {
         @Override
         public void onResourceReady(GlideDrawable resource, GlideAnimationsuper GlideDrawable> glideAnimation) {
             //>=API 16 this.view.setBackground(resource.getCurrent());
             this.view.setBackgroundDrawable(resource.getCurrent());
         }
     };
     Glide.with(context).load(url).into(viewTarget);

 }

属性动画animate()： 给图片添加动画，比如属性动画 translate、scale、alpha、rotate,又或者 Activity切换样式 这种属性动画 android.R.anim.slide_in_left

 Glide
     .with( context )
     .load( url )
     .animate( android.R.anim.slide_in_left ) // or R.anim.zoom_in
     .into( imageView1 );

也可以自定义xml Animation。
或者：

 ViewPropertyAnimation.Animator animationObject = new ViewPropertyAnimation.Animator() {
     @Override
     public void animate(View view) {
         // if it's a custom view class, cast it here
         // then find subviews and do the animations
         // here, we just use the entire view for the fade animation
         view.setAlpha( 0f );

         ObjectAnimator fadeAnim = ObjectAnimator.ofFloat( view, "alpha", 0f, 1f );
         fadeAnim.setDuration( 2500 );
         fadeAnim.start();
     }
 };

 Glide
     .with( context )
     .load( url )
     .animate( animationObject )
     .into( imageView );

  

图片进行转换transform() /bitmapTransform(): 比如模糊，圆形图片 and so on。

 public class BlurTransformation extends BitmapTransformation {

     private RenderScript rs;

     public BlurTransformation(Context context) {
         super( context );

         rs = RenderScript.create( context );
     }

     @Override
     protected Bitmap transform(BitmapPool pool, Bitmap toTransform, int outWidth, int outHeight) {
         Bitmap blurredBitmap = toTransform.copy( Bitmap.Config.ARGB_8888, true );

         // Allocate memory for Renderscript to work with
         Allocation input = Allocation.createFromBitmap(
             rs,
             blurredBitmap,
             Allocation.MipmapControl.MIPMAP_FULL,
             Allocation.USAGE_SHARED
         );
         Allocation output = Allocation.createTyped(rs, input.getType());

         // Load up an instance of the specific script that we want to use.
         ScriptIntrinsicBlur script = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs));
         script.setInput(input);

         // Set the blur radius
         script.setRadius(10);

         // Start the ScriptIntrinisicBlur
         script.forEach(output);

         // Copy the output to the blurred bitmap
         output.copyTo(blurredBitmap);

         toTransform.recycle();

         return blurredBitmap;
     }

     @Override
     public String getId() {
         return "blur";
     }
 }




 Glide
     .with( context )
     .load( url )
     .transform( new BlurTransformation( context ) )
     //.bitmapTransform( new BlurTransformation( context ) ) // this would work too!
     .into( imageView);

自定义Glide组件GlideModule 配置

 /**
  * Instruction ：设置 MemoryCache BitmapPool  DiskCache size  or path&size
  * Created by zhangjun on 2016-8-19 17:24
  */
 public class CustomCachingGlideModule implements GlideModule {
     @Override
     public void applyOptions(Context context, GlideBuilder builder) {
         MemorySizeCalculator calculator = new MemorySizeCalculator(context);
         int defaultMemoryCacheSize = calculator.getMemoryCacheSize();
         int defaultBitmapPoolSize = calculator.getBitmapPoolSize();

         int customMemoryCacheSize = (int) (2 * defaultMemoryCacheSize);
         int customBitmapPoolSize = (int) (2 * defaultBitmapPoolSize);

         builder.setMemoryCache(new LruResourceCache(customMemoryCacheSize));
         builder.setBitmapPool(new LruBitmapPool( customBitmapPoolSize) );

         int cacheSize100MegaBytes = 104857600;
         Log.e("CustomCachingGlide","32");
 //      builder.setDiskCache(
                 // 内部
 //              new InternalCacheDiskCacheFactory(context, cacheSize100MegaBytes)
                 //外部
 //              new ExternalCacheDiskCacheFactory(context,cacheSize100MegaBytes)
 //      );

         //builder.setDiskCache(alCacheDiskCacheFactory(context, cacheSize100MegaBytes));
         //new Extern

         // or any other path
 //      String downloadDirectoryPath = Environment.getDownloadCacheDirectory().getPath();
 //      String downloadDirectoryPath= Environment.getExternalStorageDirectory().getPath();
         String downloadDirectoryPath=ApplicationData.getPicDir();
         Log.e("CustomCachingGlideModule",""+downloadDirectoryPath);
         Log.e("CustomCachingGlide","downloadDirectoryPat="+downloadDirectoryPath);
         builder.setDiskCache(
                 new DiskLruCacheFactory( downloadDirectoryPath, cacheSize100MegaBytes) );
     }




     @Override
     public void registerComponents(Context context, Glide glide) {

     }
 }

 在清单文件中：

             android:name="packageName.CustomCachingGlideModule"
             android:value="GlideModule" />

设置网络请求库：

Glide 默认用HttpUrlConnetction去请求网络，默认提供几张请求方式 分别是Volley 和OKHttp

使用方式：

Volley在build.gradle：

 dependencies {
     // your other dependencies
     // ...

     // Glide
     compile 'com.github.bumptech.glide:glide:3.7.0'

     // Glide's Volley Integration
     compile 'com.github.bumptech.glide:volley-integration:1.4.0@aar'
     compile 'com.mcxiaoke.volley:library:1.0.8'
 }

OK 在build.gradle:

 dependencies {
     // your other dependencies
     // ...

     // Glide
     compile 'com.github.bumptech.glide:glide:3.7.0'

     // Glide's OkHttp3 Integration
     compile 'com.github.bumptech.glide:okhttp3-integration:1.4.0@aar'
     compile 'com.squareup.okhttp3:okhttp:3.2.0'
 }

下面的作为了解

1.Glide请求Https ：

通过创建禁止ssl 验证的OKHttpClient来实现

 public class UnsafeOkHttpClient {
     public static OkHttpClient getUnsafeOkHttpClient() {
         try {
             // Create a trust manager that does not validate certificate chains
             final TrustManager[] trustAllCerts = new TrustManager[]{
                     new X509TrustManager() {
                         @Override
                         public void checkClientTrusted(java.security.cert.X509Certificate[] chain, String authType) throws CertificateException {
                         }

                         @Override
                         public void checkServerTrusted(java.security.cert.X509Certificate[] chain, String authType) throws CertificateException {
                         }

                         @Override
                         public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                             return null;
                         }
                     }
             };

             // Install the all-trusting trust manager
             final SSLContext sslContext = SSLContext.getInstance("SSL");
             sslContext.init(null, trustAllCerts, new java.security.SecureRandom());

             // Create an ssl socket factory with our all-trusting manager
             final SSLSocketFactory sslSocketFactory = sslContext.getSocketFactory();

             OkHttpClient okHttpClient = new OkHttpClient();
             okHttpClient.setSslSocketFactory(sslSocketFactory);
             okHttpClient.setProtocols(Arrays.asList(Protocol.HTTP_1_1));
             okHttpClient.setHostnameVerifier(new HostnameVerifier() {
                 @Override
                 public boolean verify(String hostname, SSLSession session) {
                     return true;
                 }
             });

             return okHttpClient;
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }
 }

 public class UnsafeOkHttpGlideModule implements GlideModule {
         @Override
         public void applyOptions(Context context, GlideBuilder builder) {

         }

         @Override
         public void registerComponents(Context context, Glide glide) {
             glide.register(GlideUrl.class, InputStream.class, new OkHttpUrlLoader.Factory());
         }
     }

 public class OkHttpUrlLoader implements ModelLoader {

     /**
      * The default factory for {@link OkHttpUrlLoader}s.
      */
     public static class Factory implements ModelLoaderFactory {
         private static volatile OkHttpClient internalClient;
         private OkHttpClient client;

         private static OkHttpClient getInternalClient() {
             if (internalClient == null) {
                 synchronized (Factory.class) {
                     if (internalClient == null) {
                         internalClient = UnsafeOkHttpClient.getUnsafeOkHttpClient();
                     }
                 }
             }
             return internalClient;
         }

         /**
          * Constructor for a new Factory that runs requests using a static singleton client.
          */
         public Factory() {
             this(getInternalClient());
         }

         /**
          * Constructor for a new Factory that runs requests using given client.
          */
         public Factory(OkHttpClient client) {
             this.client = client;
         }

         @Override
         public ModelLoader build(Context context, GenericLoaderFactory factories) {
             return new OkHttpUrlLoader(client);
         }

         @Override
         public void teardown() {
             // Do nothing, this instance doesn't own the client.
         }
     }

     private final OkHttpClient client;

     public OkHttpUrlLoader(OkHttpClient client) {
         this.client = client;
     }

     @Override
     public DataFetcher getResourceFetcher(GlideUrl model, int width, int height) {
         return new OkHttpStreamFetcher(client, model);
     }
 }

 public class OkHttpStreamFetcher implements DataFetcher {
     private final OkHttpClient client;
     private final GlideUrl url;
     private InputStream stream;
     private ResponseBody responseBody;

     public OkHttpStreamFetcher(OkHttpClient client, GlideUrl url) {
         this.client = client;
         this.url = url;
     }

     @Override
     public InputStream loadData(Priority priority) throws Exception {
         Request.Builder requestBuilder = new Request.Builder()
                 .url(url.toStringUrl());

         for (Map.Entry headerEntry : url.getHeaders().entrySet()) {
             String key = headerEntry.getKey();
             requestBuilder.addHeader(key, headerEntry.getValue());
         }

         Request request = requestBuilder.build();

         Response response = client.newCall(request).execute();
         responseBody = response.body();
         if (!response.isSuccessful()) {
             throw new IOException("Request failed with code: " + response.code());
         }

         long contentLength = responseBody.contentLength();
         stream = ContentLengthInputStream.obtain(responseBody.byteStream(), contentLength);
         return stream;
     }

     @Override
     public void cleanup() {
         if (stream != null) {
             try {
                 stream.close();
             } catch (IOException e) {
                 // Ignored
             }
         }
         if (responseBody != null) {
             try {
                 responseBody.close();
             } catch (IOException e) {
                 // Ignored.
             }
         }
     }

     @Override
     public String getId() {
         return url.getCacheKey();
     }

     @Override
     public void cancel() {
         // TODO: call cancel on the client when this method is called on a background thread. See #257
     }
 }

2.支持自定义请求当前ImageView的分辨率下的图片，比如 服务器提供了多种分辨率，如果你知道当前View的分辨率 w*h 那么可以去请求相同分辨率的服务器图片资源。