Android异步加载全解析之引入一级缓存

目录(?)[-]

1. Android异步加载全解析之引入缓存
   1. 为啥要缓存
   2. 内存缓存
   3. LruCache使用
   4. 为异步处理加入一级缓存
      1. 滚完再加载
      2. 加载显示的项目
      3. 下载与Asynctask
      4. 组装
         1. 我的Github 我的视频 慕课网

Android异步加载全解析之引入缓存

为啥要缓存

通过对图像的缩放，我们做到了对大图的异步加载优化，但是现在的App不仅是高清大图，更是高清多图，动不动就是图文混排，以图代文，如果这些图片都加载到内存中，必定会OOM。因此，在用户浏览完图像后，应当立即将这些废弃的图像回收，但是，这又带来了另一个问题，也就是当用户在浏览完一次图片后，如果还要返回去再进行重新浏览，那么这些回收掉的图像又要重新进行加载，保不准就要那些无聊到蛋疼的人在那一边看你回收GC，一边看你重新加载。这两件事情，肯定是互相矛盾的，也是影响性能的一个很重要的原因。

内存缓存

针对这样一个非常需要找到一个彼此平衡点的问题，Google提供了一套内存缓存技术。内存缓存技术对那些大量占用应用程序宝贵内存的图片提供了快速访问的方法。其中最核心的类是LruCache 。这个类非常适合用来缓存图片，它的主要算法原理是把最近使用的对象用强引用存储在 LinkedHashMap 中，并且把最近最少使用的对象在缓存值达到预设定值之前从内存中移除。LruCache 是在support-v4中才引入的，在引入LruCache 之前，Google建议的是使用软引用或弱引用 (SoftReference or WeakReference)来进行内存缓存。但是从Android 2.3开始，GC算法修改，软引用与弱引用同样会优先被GC回收，所以这种方法也就没有太高的使用价值了，现在网上很多还在继续使用SoftReference 和WeakReference的文章，大多都是过时的文章，建议大家跟上党的步伐，与时俱进。

LruCache使用

内存缓存LruCache所使用的内存缓存大小是由开发者决定的，开发者需要根据图像的使用率、分辨率、访问频率、设备性能等很多因素进行考虑。这个平衡点经常需要很多经验和测试来决定。使用LruCache非常简单：

[java]  view plain copy print ?

1. private LruCache<String, Bitmap> mMemoryCaches;  
2.   
3. // 获取应用内存  
4. int maxMemory = (int) Runtime.getRuntime().maxMemory();  
5. // 分配cache  
6. int cacheSize = maxMemory / 10;  
7. mMemoryCaches = new LruCache<String, Bitmap>(cacheSize) {  
8.             @Override  
9.             protected int sizeOf(String key, Bitmap value) {  
10.                 return value.getByteCount();  
11.             }  
12.         };  
13.   
14. // 从LruCache获取中获取缓存对象  
15. public Bitmap getBitmapFromMemoryCaches(String url) {  
16.     return mMemoryCaches.get(url);  
17. }  
18.   
19. // 增加缓存对象到LruCache  
20. public void addBitmapToMemoryCaches(String url,Bitmap bitmap) {  
21.     if (getBitmapFromMemoryCaches(url) == null) {  
22.         mMemoryCaches.put(url, bitmap);  
23.     }  
24. }  

首先，我们需要声明LruCache，接着，通过LruCache的构造方法创建缓存对象，并为其分配cacheSize，这个cacheSize通常我们需要通过Runtime来获取，获取当前系统分给App的可用内存，并将这些内存的一部分用做LruCache缓存。LruCache中必须重写sizeOf方法，通过这个方法，LruCache可以获取每个缓存对象的大小，子类必须重写，因为默认的LruCache获取的是缓存的个数。。。尼玛。

最后，我们提供两个方法getBitmapFromMemoryCaches和addBitmapToMemoryCaches分别用来获取和增加内存缓存到LruCache。

等等，我们好像还没写释放内存的方法，对，不用你写了，Lru算法可以保证cacheSize不会OOM，一旦超过这个大小，GC就会回收时间最长的对象，释放空间。

为异步处理加入一级缓存

OK，在了解了关于缓存的基础信息后，我们回到现在这个例子，想想怎么利用缓存来进行异步处理的优化。首先，ListView、GridView这些娇生惯养的玩意儿，碰不得摔不得，更不能在它滚的开心的时候，你还在后面拼命玩加载。所以，第一个重点，滚的时候就让它开心的滚，滚完了再开始加载。

滚完再加载

要实现这一点，我们可以通过给Adapter增加AbsListView.OnScrollListener接口来实现。

当然，还有一点需要注意，第一次初始化的时候，一定要手动来加载图片，不然系统判断你没滚，只能调用onScroll方法，不会调用onScrollStateChanged方法。而且我们也需要在onScroll方法中来不断获取可见的Item。特别要注意的是visibleItemCount，只要大于0的时候，才认为是开始显示图片了。

[java]  view plain copy print ?

1. @Override  
2. public void onScrollStateChanged(AbsListView view, int scrollState) {  
3.     if (scrollState == SCROLL_STATE_IDLE) {  
4.         mImageLoader.loadImages(mStart, mEnd);  
5.     } else {  
6.         mImageLoader.cancelAllTasks();  
7.     }  
8. }  
9.   
10. @Override  
11. public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {  
12.     mStart = firstVisibleItem;  
13.     mEnd = firstVisibleItem + visibleItemCount;  
14.     if (mFirstFlag  && visibleItemCount > 0) {  
15.         mImageLoader.loadImages(mStart, mEnd);  
16.         mFirstFlag = false;  
17.     }  
18. }  

加载显示的项目

加载数据的时候，获取第一个能显示的Item和最后一个可见的Item，只加载这一部分。所以我们创建一个方法——loadImages(int start, int end)。这个方法用来加载从start到end之间的Item数据。

加载的时候，先从内存缓存中去取，如果有，那说明最近已经加载过了，那直接加载就好了，如果没有取到，那就开启synctask去下载。

[java]  view plain copy print ?

1. public void loadImages(int start, int end) {  
2.     for (int i = start; i < end; i++) {  
3.         String url = Images.IMAGE_URLS[i];  
4.         Bitmap bitmap = getBitmapFromMemoryCaches(url);  
5.         if (bitmap == null) {  
6.             ASyncDownloadImage task = new ASyncDownloadImage(url);  
7.             mTasks.add(task);  
8.             task.execute(url);  
9.         } else {  
10.             ImageView imageView = (ImageView) mListView.findViewWithTag(url);  
11.             imageView.setImageBitmap(bitmap);  
12.         }  
13.     }  
14. }  

这里我们在设置图片的时候，直接通过findViewWithTag，通过url来找到相应的Imageview，这里与之前不同是因为我们这里是按照start到end来进行加载，直接从ListView对象中获取对应的Imageview比较简单。

下载与Asynctask

下载依然是使用老方法：

[java]  view plain copy print ?

1. private static Bitmap getBitmapFromUrl(String urlString) {  
2.     Bitmap bitmap;  
3.     InputStream is = null;  
4.     try {  
5.         URL url = new URL(urlString);  
6.         HttpURLConnection conn = (HttpURLConnection) url.openConnection();  
7.         is = new BufferedInputStream(conn.getInputStream());  
8.         bitmap = BitmapFactory.decodeStream(is);  
9.         conn.disconnect();  
10.         return bitmap;  
11.     } catch (Exception e) {  
12.         e.printStackTrace();  
13.     } finally {  
14.         try {  
15.             if (is != null)  
16.                 is.close();  
17.         } catch (IOException e) {  
18.         }  
19.     }  
20.     return null;  
21. }  

Asynctask也与之前基本类似：

[java]  view plain copy print ?

1. class ASyncDownloadImage extends AsyncTask<String, Void, Bitmap> {  
2.   
3.     private String url;  
4.   
5.     public ASyncDownloadImage(String url) {  
6.         this.url = url;  
7.     }  
8.   
9.     @Override  
10.     protected Bitmap doInBackground(String... params) {  
11.         url = params[0];  
12.         Bitmap bitmap = getBitmapFromUrl(url);  
13.         if (bitmap != null) {  
14.             addBitmapToMemoryCaches(url, bitmap);  
15.         }  
16.         return bitmap;  
17.     }  
18.   
19.     @Override  
20.     protected void onPostExecute(Bitmap bitmap) {  
21.         super.onPostExecute(bitmap);  
22.         ImageView imageView = (ImageView) mListView.findViewWithTag(url);  
23.         if (imageView != null && bitmap != null) {  
24.             imageView.setImageBitmap(bitmap);  
25.         }  
26.         mTasks.remove(this);  
27.     }  
28. }  

唯一不同的是，我们在下载好图像之后，会将图像加载到Lrucache。

组装

OK，万事具备，准备刷代码。在刷之前，我们先来重新整理下思路，首先，在Adapter中，一加载ListView，就开始下载显示范围内的Item的图像，这时候缓存中当然没有，所以都去下载了，下完了就显示在Item中，并缓存起来，如果还没下完，你就迫不及待的滚起来了，那么立即取消所有task，让ListView欢快的滚，滚完之后，继续加载。

OK，该讲的都讲了，下面我们开始刷代码了，一切尽在不言中，只有代码最懂你。

[java]  view plain copy print ?

1. package com.imooc.listviewacyncloader;  
2.   
3. import android.graphics.Bitmap;  
4. import android.graphics.BitmapFactory;  
5. import android.os.AsyncTask;  
6. import android.util.LruCache;  
7. import android.widget.ImageView;  
8. import android.widget.ListView;  
9.   
10. import java.io.BufferedInputStream;  
11. import java.io.IOException;  
12. import java.io.InputStream;  
13. import java.net.HttpURLConnection;  
14. import java.net.URL;  
15. import java.util.HashSet;  
16. import java.util.Set;  
17.   
18. public class ImageLoaderWithCaches {  
19.   
20.     private Set<ASyncDownloadImage> mTasks;  
21.     private LruCache<String, Bitmap> mMemoryCaches;  
22.     private ListView mListView;  
23.   
24.     public ImageLoaderWithCaches(ListView listview) {  
25.         this.mListView = listview;  
26.         mTasks = new HashSet<>();  
27.         int maxMemory = (int) Runtime.getRuntime().maxMemory();  
28.         int cacheSize = maxMemory / 10;  
29.         mMemoryCaches = new LruCache<String, Bitmap>(cacheSize) {  
30.             @Override  
31.             protected int sizeOf(String key, Bitmap value) {  
32.                 return value.getByteCount();  
33.             }  
34.         };  
35.     }  
36.   
37.     public void showImage(String url, ImageView imageView) {  
38.         Bitmap bitmap = getBitmapFromMemoryCaches(url);  
39.         if (bitmap == null) {  
40.             imageView.setImageResource(R.drawable.ic_launcher);  
41.         } else {  
42.             imageView.setImageBitmap(bitmap);  
43.         }  
44.     }  
45.   
46.     public Bitmap getBitmapFromMemoryCaches(String url) {  
47.         return mMemoryCaches.get(url);  
48.     }  
49.   
50.     public void addBitmapToMemoryCaches(String url,Bitmap bitmap) {  
51.         if (getBitmapFromMemoryCaches(url) == null) {  
52.             mMemoryCaches.put(url, bitmap);  
53.         }  
54.     }  
55.   
56.     public void loadImages(int start, int end) {  
57.         for (int i = start; i < end; i++) {  
58.             String url = Images.IMAGE_URLS[i];  
59.             Bitmap bitmap = getBitmapFromMemoryCaches(url);  
60.             if (bitmap == null) {  
61.                 ASyncDownloadImage task = new ASyncDownloadImage(url);  
62.                 mTasks.add(task);  
63.                 task.execute(url);  
64.             } else {  
65.                 ImageView imageView = (ImageView) mListView.findViewWithTag(url);  
66.                 imageView.setImageBitmap(bitmap);  
67.             }  
68.         }  
69.     }  
70.   
71.     private static Bitmap getBitmapFromUrl(String urlString) {  
72.         Bitmap bitmap;  
73.         InputStream is = null;  
74.         try {  
75.             URL url = new URL(urlString);  
76.             HttpURLConnection conn = (HttpURLConnection) url.openConnection();  
77.             is = new BufferedInputStream(conn.getInputStream());  
78.             bitmap = BitmapFactory.decodeStream(is);  
79.             conn.disconnect();  
80.             return bitmap;  
81.         } catch (Exception e) {  
82.             e.printStackTrace();  
83.         } finally {  
84.             try {  
85.                 if (is != null)  
86.                     is.close();  
87.             } catch (IOException e) {  
88.             }  
89.         }  
90.         return null;  
91.     }  
92.   
93.     public void cancelAllTasks() {  
94.         if (mTasks != null) {  
95.             for (ASyncDownloadImage task : mTasks) {  
96.                 task.cancel(false);  
97.             }  
98.         }  
99.     }  
100.   
101.     class ASyncDownloadImage extends AsyncTask<String, Void, Bitmap> {  
102.   
103.         private String url;  
104.   
105.         public ASyncDownloadImage(String url) {  
106.             this.url = url;  
107.         }  
108.   
109.         @Override  
110.         protected Bitmap doInBackground(String... params) {  
111.             url = params[0];  
112.             Bitmap bitmap = getBitmapFromUrl(url);  
113.             if (bitmap != null) {  
114.                 addBitmapToMemoryCaches(url, bitmap);  
115.             }  
116.             return bitmap;  
117.         }  
118.   
119.         @Override  
120.         protected void onPostExecute(Bitmap bitmap) {  
121.             super.onPostExecute(bitmap);  
122.             ImageView imageView = (ImageView) mListView.findViewWithTag(url);  
123.             if (imageView != null && bitmap != null) {  
124.                 imageView.setImageBitmap(bitmap);  
125.             }  
126.             mTasks.remove(this);  
127.         }  
128.     }  
129. }  

下面是Adapter的代码：

[java]  view plain copy print ?

1. package com.imooc.listviewacyncloader;  
2.   
3. import android.content.Context;  
4. import android.view.LayoutInflater;  
5. import android.view.View;  
6. import android.view.ViewGroup;  
7. import android.widget.AbsListView;  
8. import android.widget.BaseAdapter;  
9. import android.widget.ImageView;  
10. import android.widget.ListView;  
11.   
12. import java.util.List;  
13.   
14. public class MyAdapterUseCaches extends BaseAdapter implements  
15.         AbsListView.OnScrollListener {  
16.   
17.     private LayoutInflater mInflater;  
18.     private List<String> mData;  
19.     private ImageLoaderWithCaches mImageLoader;  
20.     private int mStart = 0, mEnd = 0;  
21.     private boolean mFirstFlag;  
22.   
23.     public MyAdapterUseCaches(Context context, List<String> data, ListView listView) {  
24.         this.mData = data;  
25.         mInflater = LayoutInflater.from(context);  
26.         mImageLoader = new ImageLoaderWithCaches(listView);  
27.         mImageLoader.loadImages(mStart, mEnd);  
28.         mFirstFlag = true;  
29.         listView.setOnScrollListener(this);  
30.     }  
31.   
32.     @Override  
33.     public int getCount() {  
34.         return mData.size();  
35.     }  
36.   
37.     @Override  
38.     public Object getItem(int position) {  
39.         return mData.get(position);  
40.     }  
41.   
42.     @Override  
43.     public long getItemId(int position) {  
44.         return position;  
45.     }  
46.   
47.     @Override  
48.     public View getView(int position, View convertView, ViewGroup parent) {  
49.         String url = mData.get(position);  
50.         ViewHolder viewHolder = null;  
51.         if (convertView == null) {  
52.             viewHolder = new ViewHolder();  
53.             convertView = mInflater.inflate(R.layout.listview_item, null);  
54.             viewHolder.imageView =  
55.                     (ImageView) convertView.findViewById(R.id.iv_lv_item);  
56.             convertView.setTag(viewHolder);  
57.         } else {  
58.             viewHolder = (ViewHolder) convertView.getTag();  
59.         }  
60.         viewHolder.imageView.setTag(url);  
61.         viewHolder.imageView.setImageResource(R.drawable.ic_launcher);  
62.         mImageLoader.showImage(url, viewHolder.imageView);  
63.         return convertView;  
64.     }  
65.   
66.     @Override  
67.     public void onScrollStateChanged(AbsListView view, int scrollState) {  
68.         if (scrollState == SCROLL_STATE_IDLE) {  
69.             mImageLoader.loadImages(mStart, mEnd);  
70.         } else {  
71.             mImageLoader.cancelAllTasks();  
72.         }  
73.     }  
74.   
75.     @Override  
76.     public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {  
77.         mStart = firstVisibleItem;  
78.         mEnd = firstVisibleItem + visibleItemCount;  
79.         if (mFirstFlag  && visibleItemCount > 0) {  
80.             mImageLoader.loadImages(mStart, mEnd);  
81.             mFirstFlag = false;  
82.         }  
83.     }  
84.   
85.     public class ViewHolder {  
86.         public ImageView imageView;  
87.     }  
88. }  

是不是非常简单，现在引入缓存了，下载过的图片会暂时保存在内存中，妈妈再也不用担心你OOM啦。

我们下拉试试，下载完的图片再次出现也可以马上加载了，除非滑动太多导致GC。

可以就看见，我们的这次利用缓存进行加载有这样几个特点：

1、初始化的时候加载

2、滑动的时候才加载

3、加载的内容暂存缓存中

4、只加载显示的区域