Android照片墙完整版，完美结合LruCache和DiskLruCache

最新推荐文章于 2023-09-22 21:12:15 发布
最新推荐文章于 2023-09-22 21:12:15 发布
阅读量280 收藏
点赞数
分类专栏： android 缓存 文章标签： android lrucache 图片 缓存

转载地址：http://blog.csdn.net/guolin_blog/article/details/34093441#comments


在上一篇文章当中，我们学习了DiskLruCache的概念和基本用法，但仅仅是掌握理论知识显然是不够的，那么本篇文章我们就来继续进阶一下，看一看在实战当中应该怎样合理使用DiskLruCache。还不熟悉DiskLruCache用法的朋友可以先去参考我的上一篇文章 Android DiskLruCache完全解析，硬盘缓存的最佳方案 。

其实，在真正的项目实战当中如果仅仅是使用硬盘缓存的话，程序是有明显短板的。而如果只使用内存缓存的话，程序当然也会有很大的缺陷。因此，一个优秀的程序必然会将内存缓存和硬盘缓存结合到一起使用，那么本篇文章我们就来看一看，如何才能将LruCache和DiskLruCache完美结合到一起。

在 Android照片墙应用实现，再多的图片也不怕崩溃 这篇文章当中，我编写了一个照片墙的应用程序，但当时只是单纯使用到了内存缓存而已，而今天我们就对这个例子进行扩展，制作一个完整版的照片墙。

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

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

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  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中的代码，如下所示：
[html]  view plain copy 在CODE上查看代码片 派生到我的代码片
  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布局，加入如下代码：
[html]  view plain copy 在CODE上查看代码片 派生到我的代码片
  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文件，并加入相应的权限，如下所示：

[html]  view plain copy 在CODE上查看代码片 派生到我的代码片
  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文件都在这里了，说明我们的硬盘缓存已经成功了。

好了，今天的讲解就到这里，有疑问的朋友可以在下面留言。

源码下载，请点击这里

yyc_dong
关注
专栏目录
LruCache与DiskLruCache结合，实现照片墙
小猪的博客
03-02 240
在上一篇的文章中，讲解了Bitmap的高效加载，以及LruCache和DiskLruCache的基本用法。但是在实际的项目中，只使用内存缓存或者只使用磁盘缓存是有短板的。内存缓存速度快，但空间有限；磁盘缓存相对内存缓存来说，速度相对慢，但空间较充足。因此，如果将二者相结合到开发中，会有如虎添翼的效果。 下面还是以网络获取图片，并添加内存缓存和磁盘缓存为例，实现照片墙的效果。 首先，定义网络图片...
DiskLruCache本地缓存图片技术精炼详解
Chin_Style的博客
04-09 397
一、前期基础知识储备上一篇文章《LruCache内存缓存图片技术精炼详解》中，笔者分析了利用LruCache类实现图片的内存缓存，在应用程序中，如果已经联网加载好了图片，那么把图片保存到内存中，下一次加载就会十分迅速。但是，内存缓存技术，也有缺点，如果图片从内存里被移除了的话，那么下一次加载仍然是要从网络中获取，那么有没有什么办法可以做到一个“中间状态”，既不用每次从网络加载，又不用担心内存不足的...
安卓开发笔记——关于图片的三级缓存策略（内存LruCache+磁盘DiskLruCache+网络Volley）...
weixin_34186931的博客
07-16 251
　　在开发安卓应用中避免不了要使用到网络图片，获取网络图片很简单，但是需要付出一定的代价——流量。对于少数的图片而言问题不大，但如果手机应用中包含大量的图片，这势必会耗费用户的一定流量，如果我们不加以处理，每次打开应用都去网络获取图片，那么用户可就不乐意了，这里的处理就是指今天要讲的缓存策略（缓存层分为三层：内存层，磁盘层，网络层）。 　　关于缓存层的工作，当我们第一次打开应用获取图片时，先到网...
Android缓存分为LruCache 和DiskLruCache两种
郑敏
08-16 2070
主要熟悉Android的缓存机制以及对缓存处理的一些建议，这样才能提高用户体验。才能帮助用户节省流量。
Android照片结合LruCache和DiskLruCache Demo源码程序
08-14
本项目"Android照片结合LruCache和DiskLruCache Demo源码程序"旨在展示如何将这两个缓存策略结合使用，以实现一个高效的图片墙应用。 首先，`LruCache`（Least Recently Used Cache）是Android SDK提供的一种基于...
LruCache/DiskLruCache实现照片墙
02-26
"LruCache/DiskLruCache实现照片墙"这个话题涉及到的是Android内存缓存和磁盘缓存的策略，主要通过LruCache和DiskLruCache两个库来实现。以下是关于这两个缓存机制的详细说明： **LruCache** LruCache（Least ...
Android的缓存技术：LruCache和DiskLruCache
09-05
在实际应用中，LruCache和DiskLruCache通常结合使用，先尝试从内存缓存中获取数据，如果没有则从磁盘缓存中读取，如果磁盘缓存也没有，则从网络或者其他来源加载数据，并同时存入内存和磁盘缓存，形成一套完整的缓存...
LruCache和DiskLruCache缓存
10-30
在实际项目中，可以结合Android的Volley、Picasso、Glide等网络库，它们都内置了缓存机制，支持自定义LruCache和DiskLruCache，方便开发者快速集成图片加载和缓存功能。 7. **优化建议**： - 适当调整缓存大小，...
LruCache和DiskLruCache改进版
09-07
在文章《LRuCache和DiskLruCache改进版》中，作者可能探讨了以下内容： 1. **LRUCache的使用**：如何创建自定义的LRU缓存，如为图片、数据对象等设置合适的缓存大小，并实现计算大小的函数。 2. **性能优化**：如何...
使用LruCache和DiskLruCache来下载图片
08-18
见博客:http://blog.csdn.net/baidu_nod/article/details/38660617
Android之本地缓存——LruCache（内存缓存）与DiskLruCache（硬盘缓存）统一框架
11-11
Android之本地缓存——LruCache（内存缓存）与DiskLruCache（硬盘缓存）统一框架 [注：本内容来自网络，在此分享仅为帮助有需要的网友，如果侵犯了您的权利，麻烦联系我，我会第一时间删除，谢谢您。]
Android使用磁盘缓存DiskLruCache
小马快跑的博客
07-17 1044
DiskLruCache 不同于LruCache，LruCache是将数据缓存到内存中去，而DiskLruCache是外部缓存，例如可以将网络下载的图片永久的缓存到手机外部存储中去，并可以将缓存数据取出来使用，DiskLruCache不是google官方所写，但是得到了官方推荐，DiskLruCache没有编写到SDK中去，如需使用可直接copy这个类到项目中去。DiskLruCache地址： h
Android中的缓存策略：LruCache和DiskLruCache
最新发布
Tai_Monster的博客
09-22 938
本篇文章主要是介绍Android中内置的两个缓存类的原理。所谓缓存，就是将获取的数据保存下来以便下次继续使用，这种技术尤其在网络请求和图片加载中有用，可以显著地提升App的性能表现。Android中也内置了两个缓存类，分别是和。
Android高效加载大图、多图解决方案，有效避免程序OOM
xuela-net
07-19 2229
转载请注明出处：http://blog.csdn.net/guolin_blog/article/details/9316683 本篇文章主要内容来自于Android Doc，我翻译之后又做了些加工，英文好的朋友也可以直接去读原文。 http://developer.android.com/training/displaying-bitmaps/index.html 高效加载大图片 我...
缓存要有道，一看就会的LruCache缓存机制
郭霖
11-22 513
/ 今日科技快讯 /昨日，拼多多公布了今年第3季度的财报。其中，营收为10.5亿美元，低于预期的10.8亿美元，净亏损23.35亿元，远高于去年同期的10.98亿元。受此影响，拼多多股票大跌23%，一晚蒸发了超过800亿的市值。现在，拼多多已被百度、京东、网易反超回来，暂居中国第七大互联网公司的位置。/ 作者简介 /开心的周五，更开心的周末，提前祝大家周末愉快！本篇文章来自刁儿郎当...
Android DiskLruCache完全解析，硬盘缓存的最佳方案
06-20 2051
LruCache只是管理了内存中图片的存储与释放，如果图片从内存中被移除的话，那么又需要从网络上重新加载一次图片，这显然非常耗时。对此，Google又提供了一套硬盘缓存的解决方案：DiskLruCache(非Google官方编写，但获得官方认证)。
Android 缓存LruCache和DiskLruCache
老花的博客
04-19 568
Lru缓存算法Lru（Least Recently Used）翻译过来就是最近最少使用意思，Lru其核心思想就是当缓存存满时，优先删除最近最少使用的缓存对象。Lru缓存方式：    1、LruCache  用于实现手机内存缓存    2、DiskLruCache 用于实现外置内存缓存（它不属于官方sdk的一部分，但得到官方的推荐）LruCacheLruCache是Android3.1提供的，使用s...
Android DiskLruCache磁盘缓存
qq_39431405的博客
11-22 572
一 概述 记得在很早之前，我有写过一篇文章Android高效加载大图、多图解决方案，有效避免程序OOM，这篇文章是翻译自Android Doc的，其中防止多图OOM的核心解决思路就是使用LruCache技术。但LruCache只是管理了内存中图片的存储与释放，如果图片从内存中被移除的话，那么又需要从网络上重新加载一次图片，这显然非常耗时。对此，Google又提供了一套硬盘缓存的解决方案：DiskLruCache(非Google官方编写，但获得官方认证)。只可惜，Android Doc中并没有对DiskLru
请描述下LruCache和DiskLruCache的几种使用场景，并且使用kotlin代码展示出来加上注释
05-17
LRU Cache (最近最少使用缓存) 和 DiskLruCache (基于磁盘的 LRU 缓存) 是两种常见的缓存技术，它们的使用场景和优点如下： 1. LRU Cache 的使用场景： - 当需要缓存一些数据时，但是又不能无限制地增加内存消耗时，可以使用 LRU Cache 进行缓存。 - 当需要快速访问某些数据时，而这些数据的访问频率比较高时，可以使用 LRU Cache 进行缓存。 - 当需要保证缓存数据的时效性，避免过期数据对程序造成影响时，可以使用 LRU Cache 进行缓存。 2. DiskLruCache 的使用场景： - 当需要缓存一些大量的数据时，但是这些数据又不能全部存放在内存中时，可以使用 DiskLruCache 进行缓存。 - 当需要保证数据能够持久化存储时，可以使用 DiskLruCache 进行缓存。 - 当需要对缓存数据进行一些额外的操作时，例如压缩、加密等操作时，可以使用 DiskLruCache 进行缓存。 以下是使用 Kotlin 代码展示 LRU Cache 和 DiskLruCache 的实现方法： ```kotlin // LRU Cache 的实现 import android.util.LruCache // 初始化一个 LRU Cache，设置最大缓存数量为 10 个 val lruCache = LruCache<String, String>(10) // 将数据加入缓存中 lruCache.put("key1", "value1") // 获取缓存中的数据 val value = lruCache.get("key1") // 移除缓存中的数据 lruCache.remove("key1") // 清除缓存中的所有数据 lruCache.evictAll() ``` ```kotlin // DiskLruCache 的实现 import com.jakewharton.disklrucache.DiskLruCache import java.io.File // 初始化一个 DiskLruCache，设置缓存目录和最大缓存数量为 10 个 val directory = File(context.cacheDir, "disk_cache") val diskCacheSize = 10 * 1024 * 1024 // 10MB val diskLruCache = DiskLruCache.open(directory, 1, 1, diskCacheSize.toLong()) // 将数据加入缓存中 val editor = diskLruCache.edit("key1") editor?.newOutputStream(0)?.use { outputStream -> outputStream.write("value1".toByteArray()) } editor?.commit() // 获取缓存中的数据 val snapshot = diskLruCache.get("key1") val value = snapshot?.getInputStream(0)?.bufferedReader().use { reader -> reader?.readText() } // 移除缓存中的数据 diskLruCache.remove("key1") // 清除缓存中的所有数据 diskLruCache.delete() ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值