完美结合LruCache和DiskLruCache实现Android照片墙

转载自： http://blog.csdn.net/guolin_blog/article/details/34093441

Android照片墙完整版，完美结合LruCache和DiskLruCache ，看一看在实战当中应该怎样合理使用DiskLruCache。还不熟悉DiskLruCache用法的朋友可以先去参考郭霖大神的文章 Android DiskLruCache完全解析，硬盘缓存的最佳方案 。

 

第一部分，使用LruCache和DiskLruCache：

新建一个Android项目，起名叫PhotoWallDemo，这里我使用的是Android 4.0的API。然后新建一个libcore.io包，并将DiskLruCache.Java文件拷贝到这个包下，这样就把准备工作完成了。

接下来首先需要考虑的仍然是图片源的问题，简单起见，我仍然是吧所有图片都上传到了我的CSDN相册当中，然后新建一个Images类，将所有相册中图片的网址都配置进去，代码如下所示：

[java]  view plain  copy

1. public class Images {  
2.   
3.     public final static String[] imageThumbUrls = new String[] {  
4.         ”https://img-my.csdn.net/uploads/201407/26/1406383299_1976.jpg”,  
5.         ”https://img-my.csdn.net/uploads/201407/26/1406383291_6518.jpg”,  
6.         ”https://img-my.csdn.net/uploads/201407/26/1406383291_8239.jpg”,  
7.         ”https://img-my.csdn.net/uploads/201407/26/1406383290_9329.jpg”,  
8.         ”https://img-my.csdn.net/uploads/201407/26/1406383290_1042.jpg”,  
9.         ”https://img-my.csdn.net/uploads/201407/26/1406383275_3977.jpg”,  
10.         ”https://img-my.csdn.net/uploads/201407/26/1406383265_8550.jpg”,  
11.         ”https://img-my.csdn.net/uploads/201407/26/1406383264_3954.jpg”,  
12.         ”https://img-my.csdn.net/uploads/201407/26/1406383264_4787.jpg”,  
13.         ”https://img-my.csdn.net/uploads/201407/26/1406383264_8243.jpg”,  
14.         ”https://img-my.csdn.net/uploads/201407/26/1406383248_3693.jpg”,  
15.         ”https://img-my.csdn.net/uploads/201407/26/1406383243_5120.jpg”,  
16.         ”https://img-my.csdn.net/uploads/201407/26/1406383242_3127.jpg”,  
17.         ”https://img-my.csdn.net/uploads/201407/26/1406383242_9576.jpg”,  
18.         ”https://img-my.csdn.net/uploads/201407/26/1406383242_1721.jpg”,  
19.         ”https://img-my.csdn.net/uploads/201407/26/1406383219_5806.jpg”,  
20.         ”https://img-my.csdn.net/uploads/201407/26/1406383214_7794.jpg”,  
21.         ”https://img-my.csdn.net/uploads/201407/26/1406383213_4418.jpg”,  
22.         ”https://img-my.csdn.net/uploads/201407/26/1406383213_3557.jpg”,  
23.         ”https://img-my.csdn.net/uploads/201407/26/1406383210_8779.jpg”,  
24.         ”https://img-my.csdn.net/uploads/201407/26/1406383172_4577.jpg”,  
25.         ”https://img-my.csdn.net/uploads/201407/26/1406383166_3407.jpg”,  
26.         ”https://img-my.csdn.net/uploads/201407/26/1406383166_2224.jpg”,  
27.         ”https://img-my.csdn.net/uploads/201407/26/1406383166_7301.jpg”,  
28.         ”https://img-my.csdn.net/uploads/201407/26/1406383165_7197.jpg”,  
29.         ”https://img-my.csdn.net/uploads/201407/26/1406383150_8410.jpg”,  
30.         ”https://img-my.csdn.net/uploads/201407/26/1406383131_3736.jpg”,  
31.         ”https://img-my.csdn.net/uploads/201407/26/1406383130_5094.jpg”,  
32.         ”https://img-my.csdn.net/uploads/201407/26/1406383130_7393.jpg”,  
33.         ”https://img-my.csdn.net/uploads/201407/26/1406383129_8813.jpg”,  
34.         ”https://img-my.csdn.net/uploads/201407/26/1406383100_3554.jpg”,  
35.         ”https://img-my.csdn.net/uploads/201407/26/1406383093_7894.jpg”,  
36.         ”https://img-my.csdn.net/uploads/201407/26/1406383092_2432.jpg”,  
37.         ”https://img-my.csdn.net/uploads/201407/26/1406383092_3071.jpg”,  
38.         ”https://img-my.csdn.net/uploads/201407/26/1406383091_3119.jpg”,  
39.         ”https://img-my.csdn.net/uploads/201407/26/1406383059_6589.jpg”,  
40.         ”https://img-my.csdn.net/uploads/201407/26/1406383059_8814.jpg”,  
41.         ”https://img-my.csdn.net/uploads/201407/26/1406383059_2237.jpg”,  
42.         ”https://img-my.csdn.net/uploads/201407/26/1406383058_4330.jpg”,  
43.         ”https://img-my.csdn.net/uploads/201407/26/1406383038_3602.jpg”,  
44.         ”https://img-my.csdn.net/uploads/201407/26/1406382942_3079.jpg”,  
45.         ”https://img-my.csdn.net/uploads/201407/26/1406382942_8125.jpg”,  
46.         ”https://img-my.csdn.net/uploads/201407/26/1406382942_4881.jpg”,  
47.         ”https://img-my.csdn.net/uploads/201407/26/1406382941_4559.jpg”,  
48.         ”https://img-my.csdn.net/uploads/201407/26/1406382941_3845.jpg”,  
49.         ”https://img-my.csdn.net/uploads/201407/26/1406382924_8955.jpg”,  
50.         ”https://img-my.csdn.net/uploads/201407/26/1406382923_2141.jpg”,  
51.         ”https://img-my.csdn.net/uploads/201407/26/1406382923_8437.jpg”,  
52.         ”https://img-my.csdn.net/uploads/201407/26/1406382922_6166.jpg”,  
53.         ”https://img-my.csdn.net/uploads/201407/26/1406382922_4843.jpg”,  
54.         ”https://img-my.csdn.net/uploads/201407/26/1406382905_5804.jpg”,  
55.         ”https://img-my.csdn.net/uploads/201407/26/1406382904_3362.jpg”,  
56.         ”https://img-my.csdn.net/uploads/201407/26/1406382904_2312.jpg”,  
57.         ”https://img-my.csdn.net/uploads/201407/26/1406382904_4960.jpg”,  
58.         ”https://img-my.csdn.net/uploads/201407/26/1406382900_2418.jpg”,  
59.         ”https://img-my.csdn.net/uploads/201407/26/1406382881_4490.jpg”,  
60.         ”https://img-my.csdn.net/uploads/201407/26/1406382881_5935.jpg”,  
61.         ”https://img-my.csdn.net/uploads/201407/26/1406382880_3865.jpg”,  
62.         ”https://img-my.csdn.net/uploads/201407/26/1406382880_4662.jpg”,  
63.         ”https://img-my.csdn.net/uploads/201407/26/1406382879_2553.jpg”,  
64.         ”https://img-my.csdn.net/uploads/201407/26/1406382862_5375.jpg”,  
65.         ”https://img-my.csdn.net/uploads/201407/26/1406382862_1748.jpg”,  
66.         ”https://img-my.csdn.net/uploads/201407/26/1406382861_7618.jpg”,  
67.         ”https://img-my.csdn.net/uploads/201407/26/1406382861_8606.jpg”,  
68.         ”https://img-my.csdn.net/uploads/201407/26/1406382861_8949.jpg”,  
69.         ”https://img-my.csdn.net/uploads/201407/26/1406382841_9821.jpg”,  
70.         ”https://img-my.csdn.net/uploads/201407/26/1406382840_6603.jpg”,  
71.         ”https://img-my.csdn.net/uploads/201407/26/1406382840_2405.jpg”,  
72.         ”https://img-my.csdn.net/uploads/201407/26/1406382840_6354.jpg”,  
73.         ”https://img-my.csdn.net/uploads/201407/26/1406382839_5779.jpg”,  
74.         ”https://img-my.csdn.net/uploads/201407/26/1406382810_7578.jpg”,  
75.         ”https://img-my.csdn.net/uploads/201407/26/1406382810_2436.jpg”,  
76.         ”https://img-my.csdn.net/uploads/201407/26/1406382809_3883.jpg”,  
77.         ”https://img-my.csdn.net/uploads/201407/26/1406382809_6269.jpg”,  
78.         ”https://img-my.csdn.net/uploads/201407/26/1406382808_4179.jpg”,  
79.         ”https://img-my.csdn.net/uploads/201407/26/1406382790_8326.jpg”,  
80.         ”https://img-my.csdn.net/uploads/201407/26/1406382789_7174.jpg”,  
81.         ”https://img-my.csdn.net/uploads/201407/26/1406382789_5170.jpg”,  
82.         ”https://img-my.csdn.net/uploads/201407/26/1406382789_4118.jpg”,  
83.         ”https://img-my.csdn.net/uploads/201407/26/1406382788_9532.jpg”,  
84.         ”https://img-my.csdn.net/uploads/201407/26/1406382767_3184.jpg”,  
85.         ”https://img-my.csdn.net/uploads/201407/26/1406382767_4772.jpg”,  
86.         ”https://img-my.csdn.net/uploads/201407/26/1406382766_4924.jpg”,  
87.         ”https://img-my.csdn.net/uploads/201407/26/1406382766_5762.jpg”,  
88.         ”https://img-my.csdn.net/uploads/201407/26/1406382765_7341.jpg”  
89.     };  
90. }  

 

设置好了图片源之后，我们需要一个GridView来展示照片墙上的每一张图片。打开或修改activity_main.xml中的代码，如下所示：

[java]  view plain  copy

1. <LinearLayout xmlns:android=“http://schemas.android.com/apk/res/android”  
2.     xmlns:tools=”http://schemas.android.com/tools”  
3.     android:layout_width=”match_parent”  
4.     android:layout_height=”match_parent” >  
5.   
6.     <GridView  
7.         android:id=”@+id/photo_wall”  
8.         android:layout_width=”match_parent”  
9.         android:layout_height=”match_parent”  
10.         android:columnWidth=”@dimen/image_thumbnail_size”  
11.         android:gravity=”center”  
12.         android:horizontalSpacing=”@dimen/image_thumbnail_spacing”  
13.         android:numColumns=”auto_fit”  
14.         android:stretchMode=”columnWidth”  
15.         android:verticalSpacing=”@dimen/image_thumbnail_spacing” >  
16.     </GridView>  
17.   
18. </LinearLayout>  

很简单，只是在LinearLayout中写了一个GridView而已。接着我们要定义GridView中每一个子View的布局，新建一个photo_layout.xml布局，加入如下代码：

[java]  view plain  copy

1. <RelativeLayout xmlns:android=“http://schemas.android.com/apk/res/android”  
2.     xmlns:tools=”http://schemas.android.com/tools”  
3.     android:layout_width=”wrap_content”  
4.     android:layout_height=”wrap_content” >  
5.   
6.     <ImageView   
7.         android:id=”@+id/photo”  
8.         android:layout_width=”match_parent”  
9.         android:layout_height=”match_parent”  
10.         android:layout_centerInParent=”true”  
11.         android:scaleType=”fitXY”  
12.         />  
13.   
14. </RelativeLayout>  

 

仍然很简单，photo_layout.xml布局中只有一个ImageView控件，就是用它来显示图片的。这样我们就把所有的布局文件都写好了。

接下来新建PhotoWallAdapter做为GridView的适配器，代码如下所示：

[java]  view plain  copy

1. public class PhotoWallAdapter extends ArrayAdapter<String> {  
2.   
3.     /** 
4.      * 记录所有正在下载或等待下载的任务。 
5.      */  
6.     private Set<BitmapWorkerTask> taskCollection;  
7.   
8.     /** 
9.      * 图片缓存技术的核心类，用于缓存所有下载好的图片，在程序内存达到设定值时会将最少最近使用的图片移除掉。 
10.      */  
11.     private LruCache<String, Bitmap> mMemoryCache;  
12.   
13.     /** 
14.      * 图片硬盘缓存核心类。 
15.      */  
16.     private DiskLruCache mDiskLruCache;  
17.   
18.     /** 
19.      * GridView的实例 
20.      */  
21.     private GridView mPhotoWall;  
22.   
23.     /** 
24.      * 记录每个子项的高度。 
25.      */  
26.     private int mItemHeight = 0;  
27.   
28.     public PhotoWallAdapter(Context context, int textViewResourceId, String[] objects,  
29.             GridView photoWall) {  
30.         super(context, textViewResourceId, objects);  
31.         mPhotoWall = photoWall;  
32.         taskCollection = new HashSet<BitmapWorkerTask>();  
33.         // 获取应用程序最大可用内存  
34.         int maxMemory = (int) Runtime.getRuntime().maxMemory();  
35.         int cacheSize = maxMemory / 8;  
36.         // 设置图片缓存大小为程序最大可用内存的1/8  
37.         mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {  
38.             @Override  
39.             protected int sizeOf(String key, Bitmap bitmap) {  
40.                 return bitmap.getByteCount();  
41.             }  
42.         };  
43.         try {  
44.             // 获取图片缓存路径  
45.             File cacheDir = getDiskCacheDir(context, ”thumb”);  
46.             if (!cacheDir.exists()) {  
47.                 cacheDir.mkdirs();  
48.             }  
49.             // 创建DiskLruCache实例，初始化缓存数据  
50.             mDiskLruCache = DiskLruCache  
51.                     .open(cacheDir, getAppVersion(context), 1, 10 * 1024 * 1024);  
52.         } catch (IOException e) {  
53.             e.printStackTrace();  
54.         }  
55.     }  
56.   
57.     @Override  
58.     public View getView(int position, View convertView, ViewGroup parent) {  
59.         final String url = getItem(position);  
60.         View view;  
61.         if (convertView == null) {  
62.             view = LayoutInflater.from(getContext()).inflate(R.layout.photo_layout, null);  
63.         } else {  
64.             view = convertView;  
65.         }  
66.         final ImageView imageView = (ImageView) view.findViewById(R.id.photo);  
67.         if (imageView.getLayoutParams().height != mItemHeight) {  
68.             imageView.getLayoutParams().height = mItemHeight;  
69.         }  
70.         // 给ImageView设置一个Tag，保证异步加载图片时不会乱序  
71.         imageView.setTag(url);  
72.         imageView.setImageResource(R.drawable.empty_photo);  
73.         loadBitmaps(imageView, url);  
74.         return view;  
75.     }  
76.   
77.     /** 
78.      * 将一张图片存储到LruCache中。 
79.      *  
80.      * @param key 
81.      *            LruCache的键，这里传入图片的URL地址。 
82.      * @param bitmap 
83.      *            LruCache的键，这里传入从网络上下载的Bitmap对象。 
84.      */  
85.     public void addBitmapToMemoryCache(String key, Bitmap bitmap) {  
86.         if (getBitmapFromMemoryCache(key) == null) {  
87.             mMemoryCache.put(key, bitmap);  
88.         }  
89.     }  
90.   
91.     /** 
92.      * 从LruCache中获取一张图片，如果不存在就返回null。 
93.      *  
94.      * @param key 
95.      *            LruCache的键，这里传入图片的URL地址。 
96.      * @return 对应传入键的Bitmap对象，或者null。 
97.      */  
98.     public Bitmap getBitmapFromMemoryCache(String key) {  
99.         return mMemoryCache.get(key);  
100.     }  
101.   
102.     /** 
103.      * 加载Bitmap对象。此方法会在LruCache中检查所有屏幕中可见的ImageView的Bitmap对象， 
104.      * 如果发现任何一个ImageView的Bitmap对象不在缓存中，就会开启异步线程去下载图片。 
105.      */  
106.     public void loadBitmaps(ImageView imageView, String imageUrl) {  
107.         try {  
108.             Bitmap bitmap = getBitmapFromMemoryCache(imageUrl);  
109.             if (bitmap == null) {  
110.                 BitmapWorkerTask task = new BitmapWorkerTask();  
111.                 taskCollection.add(task);  
112.                 task.execute(imageUrl);  
113.             } else {  
114.                 if (imageView != null && bitmap != null) {  
115.                     imageView.setImageBitmap(bitmap);  
116.                 }  
117.             }  
118.         } catch (Exception e) {  
119.             e.printStackTrace();  
120.         }  
121.     }  
122.   
123.     /** 
124.      * 取消所有正在下载或等待下载的任务。 
125.      */  
126.     public void cancelAllTasks() {  
127.         if (taskCollection != null) {  
128.             for (BitmapWorkerTask task : taskCollection) {  
129.                 task.cancel(false);  
130.             }  
131.         }  
132.     }  
133.   
134.     /** 
135.      * 根据传入的uniqueName获取硬盘缓存的路径地址。 
136.      */  
137.     public File getDiskCacheDir(Context context, String uniqueName) {  
138.         String cachePath;  
139.         if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())  
140.                 || !Environment.isExternalStorageRemovable()) {  
141.             cachePath = context.getExternalCacheDir().getPath();  
142.         } else {  
143.             cachePath = context.getCacheDir().getPath();  
144.         }  
145.         return new File(cachePath + File.separator + uniqueName);  
146.     }  
147.   
148.     /** 
149.      * 获取当前应用程序的版本号。 
150.      */  
151.     public int getAppVersion(Context context) {  
152.         try {  
153.             PackageInfo info = context.getPackageManager().getPackageInfo(context.getPackageName(),  
154.                     0);  
155.             return info.versionCode;  
156.         } catch (NameNotFoundException e) {  
157.             e.printStackTrace();  
158.         }  
159.         return 1;  
160.     }  
161.   
162.     /** 
163.      * 设置item子项的高度。 
164.      */  
165.     public void setItemHeight(int height) {  
166.         if (height == mItemHeight) {  
167.             return;  
168.         }  
169.         mItemHeight = height;  
170.         notifyDataSetChanged();  
171.     }  
172.   
173.     /** 
174.      * 使用MD5算法对传入的key进行加密并返回。 
175.      */  
176.     public String hashKeyForDisk(String key) {  
177.         String cacheKey;  
178.         try {  
179.             final MessageDigest mDigest = MessageDigest.getInstance(“MD5”);  
180.             mDigest.update(key.getBytes());  
181.             cacheKey = bytesToHexString(mDigest.digest());  
182.         } catch (NoSuchAlgorithmException e) {  
183.             cacheKey = String.valueOf(key.hashCode());  
184.         }  
185.         return cacheKey;  
186.     }  
187.       
188.     /** 
189.      * 将缓存记录同步到journal文件中。 
190.      */  
191.     public void fluchCache() {  
192.         if (mDiskLruCache != null) {  
193.             try {  
194.                 mDiskLruCache.flush();  
195.             } catch (IOException e) {  
196.                 e.printStackTrace();  
197.             }  
198.         }  
199.     }  
200.   
201.     private String bytesToHexString(byte[] bytes) {  
202.         StringBuilder sb = new StringBuilder();  
203.         for (int i = 0; i < bytes.length; i++) {  
204.             String hex = Integer.toHexString(0xFF & bytes[i]);  
205.             if (hex.length() == 1) {  
206.                 sb.append(’0’);  
207.             }  
208.             sb.append(hex);  
209.         }  
210.         return sb.toString();  
211.     }  
212.   
213.     /** 
214.      * 异步下载图片的任务。 
215.      *  
216.      * @author guolin 
217.      */  
218.     class BitmapWorkerTask extends AsyncTask<String, Void, Bitmap> {  
219.   
220.         /** 
221.          * 图片的URL地址 
222.          */  
223.         private String imageUrl;  
224.   
225.         @Override  
226.         protected Bitmap doInBackground(String… params) {  
227.             imageUrl = params[0];  
228.             FileDescriptor fileDescriptor = null;  
229.             FileInputStream fileInputStream = null;  
230.             Snapshot snapShot = null;  
231.             try {  
232.                 // 生成图片URL对应的key  
233.                 final String key = hashKeyForDisk(imageUrl);  
234.                 // 查找key对应的缓存  
235.                 snapShot = mDiskLruCache.get(key);  
236.                 if (snapShot == null) {  
237.                     // 如果没有找到对应的缓存，则准备从网络上请求数据，并写入缓存  
238.                     DiskLruCache.Editor editor = mDiskLruCache.edit(key);  
239.                     if (editor != null) {  
240.                         OutputStream outputStream = editor.newOutputStream(0);  
241.                         if (downloadUrlToStream(imageUrl, outputStream)) {  
242.                             editor.commit();  
243.                         } else {  
244.                             editor.abort();  
245.                         }  
246.                     }  
247.                     // 缓存被写入后，再次查找key对应的缓存  
248.                     snapShot = mDiskLruCache.get(key);  
249.                 }  
250.                 if (snapShot != null) {  
251.                     fileInputStream = (FileInputStream) snapShot.getInputStream(0);  
252.                     fileDescriptor = fileInputStream.getFD();  
253.                 }  
254.                 // 将缓存数据解析成Bitmap对象  
255.                 Bitmap bitmap = null;  
256.                 if (fileDescriptor != null) {  
257.                     bitmap = BitmapFactory.decodeFileDescriptor(fileDescriptor);  
258.                 }  
259.                 if (bitmap != null) {  
260.                     // 将Bitmap对象添加到内存缓存当中  
261.                     addBitmapToMemoryCache(params[0], bitmap);  
262.                 }  
263.                 return bitmap;  
264.             } catch (IOException e) {  
265.                 e.printStackTrace();  
266.             } finally {  
267.                 if (fileDescriptor == null && fileInputStream != null) {  
268.                     try {  
269.                         fileInputStream.close();  
270.                     } catch (IOException e) {  
271.                     }  
272.                 }  
273.             }  
274.             return null;  
275.         }  
276.   
277.         @Override  
278.         protected void onPostExecute(Bitmap bitmap) {  
279.             super.onPostExecute(bitmap);  
280.             // 根据Tag找到相应的ImageView控件，将下载好的图片显示出来。  
281.             ImageView imageView = (ImageView) mPhotoWall.findViewWithTag(imageUrl);  
282.             if (imageView != null && bitmap != null) {  
283.                 imageView.setImageBitmap(bitmap);  
284.             }  
285.             taskCollection.remove(this);  
286.         }  
287.   
288.         /** 
289.          * 建立HTTP请求，并获取Bitmap对象。 
290.          *  
291.          * @param imageUrl 
292.          *            图片的URL地址 
293.          * @return 解析后的Bitmap对象 
294.          */  
295.         private boolean downloadUrlToStream(String urlString, OutputStream outputStream) {  
296.             HttpURLConnection urlConnection = null;  
297.             BufferedOutputStream out = null;  
298.             BufferedInputStream in = null;  
299.             try {  
300.                 final URL url = new URL(urlString);  
301.                 urlConnection = (HttpURLConnection) url.openConnection();  
302.                 in = new BufferedInputStream(urlConnection.getInputStream(), 8 * 1024);  
303.                 out = new BufferedOutputStream(outputStream, 8 * 1024);  
304.                 int b;  
305.                 while ((b = in.read()) != -1) {  
306.                     out.write(b);  
307.                 }  
308.                 return true;  
309.             } catch (final IOException e) {  
310.                 e.printStackTrace();  
311.             } finally {  
312.                 if (urlConnection != null) {  
313.                     urlConnection.disconnect();  
314.                 }  
315.                 try {  
316.                     if (out != null) {  
317.                         out.close();  
318.                     }  
319.                     if (in != null) {  
320.                         in.close();  
321.                     }  
322.                 } catch (final IOException e) {  
323.                     e.printStackTrace();  
324.                 }  
325.             }  
326.             return false;  
327.         }  
328.   
329.     }  
330.   
331. }  

 

代码有点长，我们一点点进行分析。首先在PhotoWallAdapter的构造函数中，我们初始化了LruCache类，并设置了内存缓存容量为程序最大可用内存的1/8，紧接着调用了DiskLruCache的open()方法来创建实例，并设置了硬盘缓存容量为10M，这样我们就把LruCache和DiskLruCache的初始化工作完成了。

接着在getView()方法中，我们为每个ImageView设置了一个唯一的Tag，这个Tag的作用是为了后面能够准确地找回这个ImageView，不然异步加载图片会出现乱序的情况。然后在getView()方法的最后调用了loadBitmaps()方法，加载图片的具体逻辑也就是在这里执行的了。

进入到loadBitmaps()方法中可以看到，实现是调用了getBitmapFromMemoryCache()方法来从内存中获取缓存，如果获取到了则直接调用ImageView的setImageBitmap()方法将图片显示到界面上。如果内存中没有获取到，则开启一个BitmapWorkerTask任务来去异步加载图片。

那么在BitmapWorkerTask的doInBackground()方法中，我们就灵活运用了上篇文章中学习的DiskLruCache的各种用法。首先根据图片的URL生成对应的MD5 key，然后调用DiskLruCache的get()方法来获取硬盘缓存，如果没有获取到的话则从网络上请求图片并写入硬盘缓存，接着将Bitmap对象解析出来并添加到内存缓存当中，最后将这个Bitmap对象显示到界面上，这样一个完整的流程就执行完了。

那么我们再来分析一下上述流程，每次加载图片的时候都优先去内存缓存当中读取，当读取不到的时候则回去硬盘缓存中读取，而如果硬盘缓存仍然读取不到的话，就从网络上请求原始数据。不管是从硬盘缓存还是从网络获取，读取到了数据之后都应该添加到内存缓存当中，这样的话我们下次再去读取图片的时候就能迅速从内存当中读取到，而如果该图片从内存中被移除了的话，那就重复再执行一遍上述流程就可以了。

这样我们就把LruCache和DiskLruCache完美结合到一起了。接下来还需要编写MainActivity的代码，非常简单，如下所示：

[java]  view plain  copy

1. public class MainActivity extends Activity {  
2.   
3.     /** 
4.      * 用于展示照片墙的GridView 
5.      */  
6.     private GridView mPhotoWall;  
7.   
8.     /** 
9.      * GridView的适配器 
10.      */  
11.     private PhotoWallAdapter mAdapter;  
12.   
13.     private int mImageThumbSize;  
14.     private int mImageThumbSpacing;  
15.   
16.     @Override  
17.     protected void onCreate(Bundle savedInstanceState) {  
18.         super.onCreate(savedInstanceState);  
19.         setContentView(R.layout.activity_main);  
20.         mImageThumbSize = getResources().getDimensionPixelSize(  
21.                 R.dimen.image_thumbnail_size);  
22.         mImageThumbSpacing = getResources().getDimensionPixelSize(  
23.                 R.dimen.image_thumbnail_spacing);  
24.         mPhotoWall = (GridView) findViewById(R.id.photo_wall);  
25.         mAdapter = new PhotoWallAdapter(this, 0, Images.imageThumbUrls,  
26.                 mPhotoWall);  
27.         mPhotoWall.setAdapter(mAdapter);  
28.         mPhotoWall.getViewTreeObserver().addOnGlobalLayoutListener(  
29.                 new ViewTreeObserver.OnGlobalLayoutListener() {  
30.                       
31.                     @Override  
32.                     public void onGlobalLayout() {  
33.                         final int numColumns = (int) Math.floor(mPhotoWall  
34.                                 .getWidth()  
35.                                 / (mImageThumbSize + mImageThumbSpacing));  
36.                         if (numColumns > 0) {  
37.                             int columnWidth = (mPhotoWall.getWidth() / numColumns)  
38.                                     - mImageThumbSpacing;  
39.                             mAdapter.setItemHeight(columnWidth);  
40.                             mPhotoWall.getViewTreeObserver()  
41.                                     .removeGlobalOnLayoutListener(this);  
42.                         }  
43.                     }  
44.                 });  
45.     }  
46.       
47.     @Override  
48.     protected void onPause() {  
49.         super.onPause();  
50.         mAdapter.fluchCache();  
51.     }  
52.   
53.     @Override  
54.     protected void onDestroy() {  
55.         super.onDestroy();  
56.         // 退出程序时结束所有的下载任务  
57.         mAdapter.cancelAllTasks();  
58.     }  
59.   
60. }  

 

上述代码中，我们通过getViewTreeObserver()的方式监听View的布局事件，当布局完成以后，我们重新修改一下GridView中子View的高度，以保证子View的宽度和高度可以保持一致。

到这里还没有结束，最后还需要配置一下AndroidManifest.xml文件，并加入相应的权限，如下所示：

[java]  view plain  copy

1. <manifest xmlns:android=“http://schemas.android.com/apk/res/android”  
2.     package=“com.example.photoswalldemo”  
3.     android:versionCode=”1”  
4.     android:versionName=”1.0” >  
5.   
6.     <uses-sdk  
7.         android:minSdkVersion=”14”  
8.         android:targetSdkVersion=”17” />  
9.   
10.     <uses-permission android:name=”android.permission.INTERNET” />  
11.     <uses-permission android:name=”android.permission.WRITE_EXTERNAL_STORAGE” />  
12.   
13.     <application  
14.         android:allowBackup=”true”  
15.         android:icon=”@drawable/ic_launcher”  
16.         android:label=”@string/app_name”  
17.         android:theme=”@style/AppTheme” >  
18.         <activity  
19.             android:name=”com.example.photoswalldemo.MainActivity”  
20.             android:label=”@string/app_name” >  
21.             <intent-filter>  
22.                 <action android:name=”android.intent.action.MAIN” />  
23.                 <category android:name=”android.intent.category.LAUNCHER” />  
24.             </intent-filter>  
25.         </activity>  
26.     </application>  
27.   
28. </manifest>  

好了，全部代码都在这儿了，让我们来运行一下吧，效果如下图所示：

第一次从网络上请求图片的时候有点慢，但之后加载图片就会非常快了，滑动起来也很流畅。

那么我们最后再检查一下这些图片是不是已经正确缓存在指定地址了，进入 /sdcard/Android/data/<application package>/cache/thumb 这个路径，如下图所示：

可以看到，每张图片的缓存以及journal文件都在这里了，说明我们的硬盘缓存已经成功了。

 

第二部分，LruCache和DiskLruCache的原理实际上是LinkedHashMap和File，

下面就来看看使用LinkedHashMap和File的实现：

 

网上关于这个方面的文章也不少，基本的思路是线程+缓存来解决。下面提出一些优化：

1、采用线程池

2、内存缓存+文件缓存

3、内存缓存中网上很多是采用SoftReference来防止堆溢出，这儿严格限制只能使用最大JVM内存的1/4

4、对下载的图片进行按比例缩放，以减少内存的消耗

具体的代码里面说明。先放上内存缓存类的代码MemoryCache.java：

[java]  view plain  copy

1. public class MemoryCache {  
2.   
3.     private static final String TAG = “MemoryCache”;  
4.     // 放入缓存时是个同步操作  
5.     // LinkedHashMap构造方法的最后一个参数true代表这个map里的元素将按照最近使用次数由少到多排列，即LRU  
6.     // 这样的好处是如果要将缓存中的元素替换，则先遍历出最近最少使用的元素来替换以提高效率  
7.     private Map<String, Bitmap> cache = Collections  
8.             .synchronizedMap(new LinkedHashMap<String, Bitmap>(10, 1.5f, true));  
9.     // 缓存中图片所占用的字节，初始0，将通过此变量严格控制缓存所占用的堆内存  
10.     private long size = 0;// current allocated size  
11.     // 缓存只能占用的最大堆内存  
12.     private long limit = 1000000;// max memory in bytes  
13.   
14.     public MemoryCache() {  
15.         // use 25% of available heap size  
16.         setLimit(Runtime.getRuntime().maxMemory() / 4);  
17.     }  
18.   
19.     public void setLimit(long new_limit) {   
20.         limit = new_limit;  
21.         Log.i(TAG, ”MemoryCache will use up to ” + limit / 1024. / 1024. + “MB”);  
22.     }  
23.   
24.     public Bitmap get(String id) {  
25.         try {  
26.             if (!cache.containsKey(id))  
27.                 return null;  
28.             return cache.get(id);  
29.         } catch (NullPointerException ex) {  
30.             return null;  
31.         }  
32.     }  
33.   
34.     public void put(String id, Bitmap bitmap) {  
35.         try {  
36.             if (cache.containsKey(id))  
37.                 size -= getSizeInBytes(cache.get(id));  
38.             cache.put(id, bitmap);  
39.             size += getSizeInBytes(bitmap);  
40.             checkSize();  
41.         } catch (Throwable th) {  
42.             th.printStackTrace();  
43.         }  
44.     }  
45.   
46.     /** 
47.      * 严格控制堆内存，如果超过将首先替换最近最少使用的那个图片缓存 
48.      *  
49.      */  
50.     private void checkSize() {  
51.         Log.i(TAG, ”cache size=” + size + “ length=” + cache.size());  
52.         if (size > limit) {  
53.             // 先遍历最近最少使用的元素  
54.             Iterator<Entry<String, Bitmap>> iter = cache.entrySet().iterator();  
55.             while (iter.hasNext()) {  
56.                 Entry<String, Bitmap> entry = iter.next();  
57.                 size -= getSizeInBytes(entry.getValue());  
58.                 iter.remove();  
59.                 if (size <= limit)  
60.                     break;  
61.             }  
62.             Log.i(TAG, ”Clean cache. New size ” + cache.size());  
63.         }  
64.     }  
65.   
66.     public void clear() {  
67.         cache.clear();  
68.     }  
69.   
70.     /** 
71.      * 图片占用的内存 
72.      *  
73.      * @param bitmap 
74.      * @return 
75.      */  
76.     long getSizeInBytes(Bitmap bitmap) {  
77.         if (bitmap == null)  
78.             return 0;  
79.         return bitmap.getRowBytes() * bitmap.getHeight();  
80.     }  
81. }  

也可以使用SoftReference，代码会简单很多，但是推荐上面的方法。因为上面的方法更有效率，而SoftReference要依靠系统回收，并且对文件大小没有节制。

[java]  view plain  copy

1. public class MemoryCache {  
2.       
3.     private Map<String, SoftReference<Bitmap>> cache = Collections  
4.             .synchronizedMap(new HashMap<String, SoftReference<Bitmap>>());  
5.   
6.     public Bitmap get(String id) {  
7.         if (!cache.containsKey(id))  
8.             return null;  
9.         SoftReference<Bitmap> ref = cache.get(id);  
10.         return ref.get();  
11.     }  
12.   
13.     public void put(String id, Bitmap bitmap) {  
14.         cache.put(id, new SoftReference<Bitmap>(bitmap));  
15.     }  
16.   
17.     public void clear() {  
18.         cache.clear();  
19.     }  
20.   
21. }  

下面是文件缓存类的代码FileCache.java:下面是文件缓存类的代码FileCache.java:

[java]  view plain  copy

1. public class FileCache {  
2.   
3.     private File cacheDir;  
4.   
5.     public FileCache(Context context) {  
6.         // 如果有SD卡则在SD卡中建一个LazyList的目录存放缓存的图片  
7.         // 没有SD卡就放在系统的缓存目录中  
8.         if (android.os.Environment.getExternalStorageState().equals(  
9.                 android.os.Environment.MEDIA_MOUNTED))  
10.             cacheDir = new File(  
11.                     android.os.Environment.getExternalStorageDirectory(),  
12.                     ”LazyList”);  
13.         else  
14.             cacheDir = context.getCacheDir();  
15.         if (!cacheDir.exists())  
16.             cacheDir.mkdirs();  
17.     }  
18.   
19.     public File getFile(String url) {  
20.         // 将url的hashCode作为缓存的文件名  
21.         String filename = String.valueOf(url.hashCode());  
22.         // Another possible solution  
23.         // String filename = URLEncoder.encode(url);  
24.         File f = new File(cacheDir, filename);  
25.         return f;  
26.   
27.     }  
28.   
29.     public void clear() {  
30.         File[] files = cacheDir.listFiles();  
31.         if (files == null)  
32.             return;  
33.         for (File f : files)  
34.             f.delete();  
35.     }  
36.   
37. }  

 

最后最重要的加载图片的类，ImageLoader.java:

[java]  view plain  copy

1. public class ImageLoader {  
2.   
3.     MemoryCache memoryCache = new MemoryCache();  
4.     FileCache fileCache;  
5.     private Map<ImageView, String> imageViews = Collections  
6.             .synchronizedMap(new WeakHashMap<ImageView, String>());  
7.     // 线程池  
8.     ExecutorService executorService;  
9.   
10.     public ImageLoader(Context context) {  
11.         fileCache = new FileCache(context);  
12.         executorService = Executors.newFixedThreadPool(5);  
13.     }  
14.   
15.     // 当进入listview时默认的图片，可换成你自己的默认图片  
16.     final int stub_id = R.drawable.stub;  
17.   
18.     // 最主要的方法  
19.     public void DisplayImage(String url, ImageView imageView) {  
20.         imageViews.put(imageView, url);  
21.         // 先从内存缓存中查找  
22.   
23.         Bitmap bitmap = memoryCache.get(url);  
24.         if (bitmap != null)  
25.             imageView.setImageBitmap(bitmap);  
26.         else {  
27.             // 若没有的话则开启新线程加载图片  
28.             queuePhoto(url, imageView);  
29.             imageView.setImageResource(stub_id);  
30.         }  
31.     }  
32.   
33.     private void queuePhoto(String url, ImageView imageView) {  
34.         PhotoToLoad p = new PhotoToLoad(url, imageView);  
35.         executorService.submit(new PhotosLoader(p));  
36.     }  
37.   
38.     private Bitmap getBitmap(String url) {  
39.         File f = fileCache.getFile(url);  
40.   
41.         // 先从文件缓存中查找是否有  
42.         Bitmap b = decodeFile(f);  
43.         if (b != null)  
44.             return b;  
45.   
46.         // 最后从指定的url中下载图片  
47.         try {  
48.             Bitmap bitmap = null;  
49.             URL imageUrl = new URL(url);  
50.             HttpURLConnection conn = (HttpURLConnection) imageUrl  
51.                     .openConnection();  
52.             conn.setConnectTimeout(30000);  
53.             conn.setReadTimeout(30000);  
54.             conn.setInstanceFollowRedirects(true);  
55.             InputStream is = conn.getInputStream();  
56.             OutputStream os = new FileOutputStream(f);  
57.             CopyStream(is, os);  
58.             os.close();  
59.             bitmap = decodeFile(f);  
60.             return bitmap;  
61.         } catch (Exception ex) {  
62.             ex.printStackTrace();  
63.             return null;  
64.         }  
65.     }  
66.   
67.     // decode这个图片并且按比例缩放以减少内存消耗，虚拟机对每张图片的缓存大小也是有限制的  
68.     private Bitmap decodeFile(File f) {  
69.         try {  
70.             // decode image size  
71.             BitmapFactory.Options o = new BitmapFactory.Options();  
72.             o.inJustDecodeBounds = true;  
73.             BitmapFactory.decodeStream(new FileInputStream(f), null, o);  
74.   
75.             // Find the correct scale value. It should be the power of 2.  
76.             final int REQUIRED_SIZE = 70;  
77.             int width_tmp = o.outWidth, height_tmp = o.outHeight;  
78.             int scale = 1;  
79.             while (true) {  
80.                 if (width_tmp / 2 < REQUIRED_SIZE  
81.                         || height_tmp / 2 < REQUIRED_SIZE)  
82.                     break;  
83.                 width_tmp /= 2;  
84.                 height_tmp /= 2;  
85.                 scale *= 2;  
86.             }  
87.   
88.             // decode with inSampleSize  
89.             BitmapFactory.Options o2 = new BitmapFactory.Options();  
90.             o2.inSampleSize = scale;  
91.             return BitmapFactory.decodeStream(new FileInputStream(f), null, o2);  
92.         } catch (FileNotFoundException e) {  
93.         }  
94.         return null;  
95.     }  
96.   
97.     // Task for the queue  
98.     private class PhotoToLoad {  
99.         public String url;  
100.         public ImageView imageView;  
101.   
102.         public PhotoToLoad(String u, ImageView i) {  
103.             url = u;  
104.             imageView = i;  
105.         }  
106.     }  
107.   
108.     class PhotosLoader implements Runnable {  
109.         PhotoToLoad photoToLoad;  
110.   
111.         PhotosLoader(PhotoToLoad photoToLoad) {  
112.             this.photoToLoad = photoToLoad;  
113.         }  
114.   
115.         @Override  
116.         public void run() {  
117.             if (imageViewReused(photoToLoad))  
118.                 return;  
119.             Bitmap bmp = getBitmap(photoToLoad.url);  
120.             memoryCache.put(photoToLoad.url, bmp);  
121.             if (imageViewReused(photoToLoad))  
122.                 return;  
123.             BitmapDisplayer bd = new BitmapDisplayer(bmp, photoToLoad);  
124.             // 更新的操作放在UI线程中  
125.             Activity a = (Activity) photoToLoad.imageView.getContext();  
126.             a.runOnUiThread(bd);  
127.         }  
128.     }  
129.   
130.     /** 
131.      * 防止图片错位 
132.      *  
133.      * @param photoToLoad 
134.      * @return 
135.      */  
136.     boolean imageViewReused(PhotoToLoad photoToLoad) {  
137.         String tag = imageViews.get(photoToLoad.imageView);  
138.         if (tag == null || !tag.equals(photoToLoad.url))  
139.             return true;  
140.         return false;  
141.     }  
142.   
143.     // 用于在UI线程中更新界面  
144.     class BitmapDisplayer implements Runnable {  
145.         Bitmap bitmap;  
146.         PhotoToLoad photoToLoad;  
147.   
148.         public BitmapDisplayer(Bitmap b, PhotoToLoad p) {  
149.             bitmap = b;  
150.             photoToLoad = p;  
151.         }  
152.   
153.         public void run() {  
154.             if (imageViewReused(photoToLoad))  
155.                 return;  
156.             if (bitmap != null)  
157.                 photoToLoad.imageView.setImageBitmap(bitmap);  
158.             else  
159.                 photoToLoad.imageView.setImageResource(stub_id);  
160.         }  
161.     }  
162.   
163.     public void clearCache() {  
164.         memoryCache.clear();  
165.         fileCache.clear();  
166.     }  
167.   
168.     public static void CopyStream(InputStream is, OutputStream os) {  
169.         final int buffer_size = 1024;  
170.         try {  
171.             byte[] bytes = new byte[buffer_size];  
172.             for (;;) {  
173.                 int count = is.read(bytes, 0, buffer_size);  
174.                 if (count == -1)  
175.                     break;  
176.                 os.write(bytes, 0, count);  
177.             }  
178.         } catch (Exception ex) {  
179.         }  
180.     }  
181. }  

 

主要流程是先从内存缓存中查找，若没有再开线程，从文件缓存中查找都没有则从指定的url中查找，并对bitmap进行处理，最后通过下面方法对UI进行更新操作：

[java]  view plain  copy

1. a.runOnUiThread(…);  

在你的程序中的基本用法：

[java]  view plain  copy

1. ImageLoader imageLoader=new ImageLoader(context);  
2. …  
3. imageLoader.DisplayImage(url, imageView);  

比如你的放在你的ListView的adapter的getView()方法中，当然也适用于GridView。