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

最新推荐文章于 2024-09-19 22:26:19 发布
最新推荐文章于 2024-09-19 22:26:19 发布
阅读量9w 收藏 324
点赞数 166
文章标签： Android 照片墙 LruCache DiskLruCache 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guolin_blog/article/details/34093441
版权

转载请注明出处：http://blog.csdn.net/guolin_blog/article/details/34093441


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


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


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


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


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

public class Images {

	public final static String[] imageThumbUrls = new String[] {
		"https://img-my.csdn.net/uploads/201407/26/1406383299_1976.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383291_6518.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383291_8239.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383290_9329.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383290_1042.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383275_3977.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383265_8550.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383264_3954.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383264_4787.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383264_8243.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383248_3693.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383243_5120.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383242_3127.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383242_9576.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383242_1721.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383219_5806.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383214_7794.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383213_4418.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383213_3557.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383210_8779.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383172_4577.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383166_3407.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383166_2224.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383166_7301.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383165_7197.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383150_8410.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383131_3736.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383130_5094.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383130_7393.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383129_8813.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383100_3554.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383093_7894.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383092_2432.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383092_3071.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383091_3119.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383059_6589.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383059_8814.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383059_2237.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383058_4330.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406383038_3602.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382942_3079.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382942_8125.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382942_4881.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382941_4559.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382941_3845.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382924_8955.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382923_2141.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382923_8437.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382922_6166.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382922_4843.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382905_5804.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382904_3362.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382904_2312.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382904_4960.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382900_2418.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382881_4490.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382881_5935.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382880_3865.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382880_4662.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382879_2553.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382862_5375.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382862_1748.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382861_7618.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382861_8606.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382861_8949.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382841_9821.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382840_6603.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382840_2405.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382840_6354.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382839_5779.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382810_7578.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382810_2436.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382809_3883.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382809_6269.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382808_4179.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382790_8326.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382789_7174.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382789_5170.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382789_4118.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382788_9532.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382767_3184.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382767_4772.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382766_4924.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382766_5762.jpg",
		"https://img-my.csdn.net/uploads/201407/26/1406382765_7341.jpg"
	};
}
设置好了图片源之后，我们需要一个GridView来展示照片墙上的每一张图片。打开或修改activity_main.xml中的代码，如下所示： 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <GridView
        android:id="@+id/photo_wall"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:columnWidth="@dimen/image_thumbnail_size"
        android:gravity="center"
        android:horizontalSpacing="@dimen/image_thumbnail_spacing"
        android:numColumns="auto_fit"
        android:stretchMode="columnWidth"
        android:verticalSpacing="@dimen/image_thumbnail_spacing" >
    </GridView>

</LinearLayout>
很简单，只是在LinearLayout中写了一个GridView而已。接着我们要定义GridView中每一个子View的布局，新建一个photo_layout.xml布局，加入如下代码： 
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content" >

    <ImageView 
        android:id="@+id/photo"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_centerInParent="true"
        android:scaleType="fitXY"
        />

</RelativeLayout>

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


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

public class PhotoWallAdapter extends ArrayAdapter<String> {

	/**
	 * 记录所有正在下载或等待下载的任务。
	 */
	private Set<BitmapWorkerTask> taskCollection;

	/**
	 * 图片缓存技术的核心类，用于缓存所有下载好的图片，在程序内存达到设定值时会将最少最近使用的图片移除掉。
	 */
	private LruCache<String, Bitmap> mMemoryCache;

	/**
	 * 图片硬盘缓存核心类。
	 */
	private DiskLruCache mDiskLruCache;

	/**
	 * GridView的实例
	 */
	private GridView mPhotoWall;

	/**
	 * 记录每个子项的高度。
	 */
	private int mItemHeight = 0;

	public PhotoWallAdapter(Context context, int textViewResourceId, String[] objects,
			GridView photoWall) {
		super(context, textViewResourceId, objects);
		mPhotoWall = photoWall;
		taskCollection = new HashSet<BitmapWorkerTask>();
		// 获取应用程序最大可用内存
		int maxMemory = (int) Runtime.getRuntime().maxMemory();
		int cacheSize = maxMemory / 8;
		// 设置图片缓存大小为程序最大可用内存的1/8
		mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {
			@Override
			protected int sizeOf(String key, Bitmap bitmap) {
				return bitmap.getByteCount();
			}
		};
		try {
			// 获取图片缓存路径
			File cacheDir = getDiskCacheDir(context, "thumb");
			if (!cacheDir.exists()) {
				cacheDir.mkdirs();
			}
			// 创建DiskLruCache实例，初始化缓存数据
			mDiskLruCache = DiskLruCache
					.open(cacheDir, getAppVersion(context), 1, 10 * 1024 * 1024);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	@Override
	public View getView(int position, View convertView, ViewGroup parent) {
		final String url = getItem(position);
		View view;
		if (convertView == null) {
			view = LayoutInflater.from(getContext()).inflate(R.layout.photo_layout, null);
		} else {
			view = convertView;
		}
		final ImageView imageView = (ImageView) view.findViewById(R.id.photo);
		if (imageView.getLayoutParams().height != mItemHeight) {
			imageView.getLayoutParams().height = mItemHeight;
		}
		// 给ImageView设置一个Tag，保证异步加载图片时不会乱序
		imageView.setTag(url);
		imageView.setImageResource(R.drawable.empty_photo);
		loadBitmaps(imageView, url);
		return view;
	}

	/**
	 * 将一张图片存储到LruCache中。
	 * 
	 * @param key
	 *            LruCache的键，这里传入图片的URL地址。
	 * @param bitmap
	 *            LruCache的键，这里传入从网络上下载的Bitmap对象。
	 */
	public void addBitmapToMemoryCache(String key, Bitmap bitmap) {
		if (getBitmapFromMemoryCache(key) == null) {
			mMemoryCache.put(key, bitmap);
		}
	}

	/**
	 * 从LruCache中获取一张图片，如果不存在就返回null。
	 * 
	 * @param key
	 *            LruCache的键，这里传入图片的URL地址。
	 * @return 对应传入键的Bitmap对象，或者null。
	 */
	public Bitmap getBitmapFromMemoryCache(String key) {
		return mMemoryCache.get(key);
	}

	/**
	 * 加载Bitmap对象。此方法会在LruCache中检查所有屏幕中可见的ImageView的Bitmap对象，
	 * 如果发现任何一个ImageView的Bitmap对象不在缓存中，就会开启异步线程去下载图片。
	 */
	public void loadBitmaps(ImageView imageView, String imageUrl) {
		try {
			Bitmap bitmap = getBitmapFromMemoryCache(imageUrl);
			if (bitmap == null) {
				BitmapWorkerTask task = new BitmapWorkerTask();
				taskCollection.add(task);
				task.execute(imageUrl);
			} else {
				if (imageView != null && bitmap != null) {
					imageView.setImageBitmap(bitmap);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 取消所有正在下载或等待下载的任务。
	 */
	public void cancelAllTasks() {
		if (taskCollection != null) {
			for (BitmapWorkerTask task : taskCollection) {
				task.cancel(false);
			}
		}
	}

	/**
	 * 根据传入的uniqueName获取硬盘缓存的路径地址。
	 */
	public File getDiskCacheDir(Context context, String uniqueName) {
		String cachePath;
		if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())
				|| !Environment.isExternalStorageRemovable()) {
			cachePath = context.getExternalCacheDir().getPath();
		} else {
			cachePath = context.getCacheDir().getPath();
		}
		return new File(cachePath + File.separator + uniqueName);
	}

	/**
	 * 获取当前应用程序的版本号。
	 */
	public int getAppVersion(Context context) {
		try {
			PackageInfo info = context.getPackageManager().getPackageInfo(context.getPackageName(),
					0);
			return info.versionCode;
		} catch (NameNotFoundException e) {
			e.printStackTrace();
		}
		return 1;
	}

	/**
	 * 设置item子项的高度。
	 */
	public void setItemHeight(int height) {
		if (height == mItemHeight) {
			return;
		}
		mItemHeight = height;
		notifyDataSetChanged();
	}

	/**
	 * 使用MD5算法对传入的key进行加密并返回。
	 */
	public String hashKeyForDisk(String key) {
		String cacheKey;
		try {
			final MessageDigest mDigest = MessageDigest.getInstance("MD5");
			mDigest.update(key.getBytes());
			cacheKey = bytesToHexString(mDigest.digest());
		} catch (NoSuchAlgorithmException e) {
			cacheKey = String.valueOf(key.hashCode());
		}
		return cacheKey;
	}
	
	/**
	 * 将缓存记录同步到journal文件中。
	 */
	public void fluchCache() {
		if (mDiskLruCache != null) {
			try {
				mDiskLruCache.flush();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	private String bytesToHexString(byte[] bytes) {
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < bytes.length; i++) {
			String hex = Integer.toHexString(0xFF & bytes[i]);
			if (hex.length() == 1) {
				sb.append('0');
			}
			sb.append(hex);
		}
		return sb.toString();
	}

	/**
	 * 异步下载图片的任务。
	 * 
	 * @author guolin
	 */
	class BitmapWorkerTask extends AsyncTask<String, Void, Bitmap> {

		/**
		 * 图片的URL地址
		 */
		private String imageUrl;

		@Override
		protected Bitmap doInBackground(String... params) {
			imageUrl = params[0];
			FileDescriptor fileDescriptor = null;
			FileInputStream fileInputStream = null;
			Snapshot snapShot = null;
			try {
				// 生成图片URL对应的key
				final String key = hashKeyForDisk(imageUrl);
				// 查找key对应的缓存
				snapShot = mDiskLruCache.get(key);
				if (snapShot == null) {
					// 如果没有找到对应的缓存，则准备从网络上请求数据，并写入缓存
					DiskLruCache.Editor editor = mDiskLruCache.edit(key);
					if (editor != null) {
						OutputStream outputStream = editor.newOutputStream(0);
						if (downloadUrlToStream(imageUrl, outputStream)) {
							editor.commit();
						} else {
							editor.abort();
						}
					}
					// 缓存被写入后，再次查找key对应的缓存
					snapShot = mDiskLruCache.get(key);
				}
				if (snapShot != null) {
					fileInputStream = (FileInputStream) snapShot.getInputStream(0);
					fileDescriptor = fileInputStream.getFD();
				}
				// 将缓存数据解析成Bitmap对象
				Bitmap bitmap = null;
				if (fileDescriptor != null) {
					bitmap = BitmapFactory.decodeFileDescriptor(fileDescriptor);
				}
				if (bitmap != null) {
					// 将Bitmap对象添加到内存缓存当中
					addBitmapToMemoryCache(params[0], bitmap);
				}
				return bitmap;
			} catch (IOException e) {
				e.printStackTrace();
			} finally {
				if (fileDescriptor == null && fileInputStream != null) {
					try {
						fileInputStream.close();
					} catch (IOException e) {
					}
				}
			}
			return null;
		}

		@Override
		protected void onPostExecute(Bitmap bitmap) {
			super.onPostExecute(bitmap);
			// 根据Tag找到相应的ImageView控件，将下载好的图片显示出来。
			ImageView imageView = (ImageView) mPhotoWall.findViewWithTag(imageUrl);
			if (imageView != null && bitmap != null) {
				imageView.setImageBitmap(bitmap);
			}
			taskCollection.remove(this);
		}

		/**
		 * 建立HTTP请求，并获取Bitmap对象。
		 * 
		 * @param imageUrl
		 *            图片的URL地址
		 * @return 解析后的Bitmap对象
		 */
		private boolean downloadUrlToStream(String urlString, OutputStream outputStream) {
			HttpURLConnection urlConnection = null;
			BufferedOutputStream out = null;
			BufferedInputStream in = null;
			try {
				final URL url = new URL(urlString);
				urlConnection = (HttpURLConnection) url.openConnection();
				in = new BufferedInputStream(urlConnection.getInputStream(), 8 * 1024);
				out = new BufferedOutputStream(outputStream, 8 * 1024);
				int b;
				while ((b = in.read()) != -1) {
					out.write(b);
				}
				return true;
			} catch (final IOException e) {
				e.printStackTrace();
			} finally {
				if (urlConnection != null) {
					urlConnection.disconnect();
				}
				try {
					if (out != null) {
						out.close();
					}
					if (in != null) {
						in.close();
					}
				} catch (final IOException e) {
					e.printStackTrace();
				}
			}
			return false;
		}

	}

}

代码有点长，我们一点点进行分析。首先在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的代码，非常简单，如下所示：

public class MainActivity extends Activity {

	/**
	 * 用于展示照片墙的GridView
	 */
	private GridView mPhotoWall;

	/**
	 * GridView的适配器
	 */
	private PhotoWallAdapter mAdapter;

	private int mImageThumbSize;
	private int mImageThumbSpacing;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		mImageThumbSize = getResources().getDimensionPixelSize(
				R.dimen.image_thumbnail_size);
		mImageThumbSpacing = getResources().getDimensionPixelSize(
				R.dimen.image_thumbnail_spacing);
		mPhotoWall = (GridView) findViewById(R.id.photo_wall);
		mAdapter = new PhotoWallAdapter(this, 0, Images.imageThumbUrls,
				mPhotoWall);
		mPhotoWall.setAdapter(mAdapter);
		mPhotoWall.getViewTreeObserver().addOnGlobalLayoutListener(
				new ViewTreeObserver.OnGlobalLayoutListener() {
					
					@Override
					public void onGlobalLayout() {
						final int numColumns = (int) Math.floor(mPhotoWall
								.getWidth()
								/ (mImageThumbSize + mImageThumbSpacing));
						if (numColumns > 0) {
							int columnWidth = (mPhotoWall.getWidth() / numColumns)
									- mImageThumbSpacing;
							mAdapter.setItemHeight(columnWidth);
							mPhotoWall.getViewTreeObserver()
									.removeGlobalOnLayoutListener(this);
						}
					}
				});
	}
	
	@Override
	protected void onPause() {
		super.onPause();
		mAdapter.fluchCache();
	}

	@Override
	protected void onDestroy() {
		super.onDestroy();
		// 退出程序时结束所有的下载任务
		mAdapter.cancelAllTasks();
	}

}

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


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

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.photoswalldemo"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="14"
        android:targetSdkVersion="17" />

    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name="com.example.photoswalldemo.MainActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

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




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


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




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

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


源码下载，请点击这里


关注我的技术公众号，每天都有优质技术文章推送。关注我的娱乐公众号，工作、学习累了的时候放松一下自己。

微信扫一扫下方二维码即可关注：

        

guolin
关注
LruCache与DiskLruCache结合，实现照片墙
小猪的博客
03-02 241
在上一篇的文章中，讲解了Bitmap的高效加载，以及LruCache和DiskLruCache的基本用法。但是在实际的项目中，只使用内存缓存或者只使用磁盘缓存是有短板的。内存缓存速度快，但空间有限；磁盘缓存相对内存缓存来说，速度相对慢，但空间较充足。因此，如果将二者相结合到开发中，会有如虎添翼的效果。 下面还是以网络获取图片，并添加内存缓存和磁盘缓存为例，实现照片墙的效果。 首先，定义网络图片...
DiskLruCache本地缓存图片技术精炼详解
Chin_Style的博客
04-09 400
一、前期基础知识储备上一篇文章《LruCache内存缓存图片技术精炼详解》中，笔者分析了利用LruCache类实现图片的内存缓存，在应用程序中，如果已经联网加载好了图片，那么把图片保存到内存中，下一次加载就会十分迅速。但是，内存缓存技术，也有缺点，如果图片从内存里被移除了的话，那么下一次加载仍然是要从网络中获取，那么有没有什么办法可以做到一个“中间状态”，既不用每次从网络加载，又不用担心内存不足的...
LRU Cache
最新发布
qq_67582098的博客
09-19 972
LRU Cache
安卓开发笔记——关于图片的三级缓存策略（内存LruCache+磁盘DiskLruCache+网络Volley）...
weixin_34186931的博客
07-16 252
　　在开发安卓应用中避免不了要使用到网络图片，获取网络图片很简单，但是需要付出一定的代价——流量。对于少数的图片而言问题不大，但如果手机应用中包含大量的图片，这势必会耗费用户的一定流量，如果我们不加以处理，每次打开应用都去网络获取图片，那么用户可就不乐意了，这里的处理就是指今天要讲的缓存策略（缓存层分为三层：内存层，磁盘层，网络层）。 　　关于缓存层的工作，当我们第一次打开应用获取图片时，先到网...
Android缓存分为LruCache 和DiskLruCache两种
郑敏
08-16 2070
主要熟悉Android的缓存机制以及对缓存处理的一些建议，这样才能提高用户体验。才能帮助用户节省流量。
使用LruCache和DiskLruCache来下载图片
08-18
见博客:http://blog.csdn.net/baidu_nod/article/details/38660617
Android照片结合LruCache和DiskLruCache Demo源码程序
08-14
本项目"Android照片结合LruCache和DiskLruCache Demo源码程序"旨在展示如何将这两个缓存策略结合使用，以实现一个高效的图片墙应用。 首先，`LruCache`（Least Recently Used Cache）是Android SDK提供的一种基于...
PhotosWallDemo 结合LruCache和DiskLruCache
12-13
《PhotosWallDemo结合LruCache和DiskLruCache在Android中的应用详解》 在Android开发中，优化内存管理和数据缓存是提升应用性能的关键环节。本文将深入探讨一个名为PhotosWallDemo的项目，该项目巧妙地结合了...
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. **优化建议**： - 适当调整缓存大小，...
DiskLruCache.java
02-06
Android DiskLruCache，硬盘缓存的最佳方案，研究源代码吧!
DiskLruCache源码
05-28
DiskLruCache的实现源码
Android照片墙加强版，使用ViewPager实现画廊效果Demo
11-13
此为示例代码，详细详解请参考： http://blog.csdn.net/guolin_blog/article/details/12646775 如对资源内容有疑问，请到博客主留言。
一个案例解析DiskLruCache的基本用法
03-18
一个案例解析DiskLruCache的基本用法 对应博客地址http://blog.csdn.net/leoleohan/article/details/50847209
Android高效加载大图、多图解决方案，有效避免程序OOM
xuela-net
07-19 2236
转载请注明出处：http://blog.csdn.net/guolin_blog/article/details/9316683 本篇文章主要内容来自于Android Doc，我翻译之后又做了些加工，英文好的朋友也可以直接去读原文。 http://developer.android.com/training/displaying-bitmaps/index.html 高效加载大图片 我...
DiskLruCache 硬盘级缓存存取JSON数据
qq_41898048的博客
09-21 610
DiskLruCache 不同于LruCache，LruCache是将数据缓存到内存中去，而DiskLruCache是外部缓存，例如可以将网络下载的图片永久的缓存到手机外部存储中去，并可以将缓存数据取出来使用，DiskLruCache不是google官方所写，但是得到了官方推荐，DiskLruCache没有编写到SDK中去，如需使用可直接copy这个类到项目中去。 DiskLruCache的创建...
Glide源码分析（一）——DiskLruCache磁盘缓存的实现
大雀儿飞飞的专栏
03-23 2331
Glide源码分析（一）——DiskLruCache磁盘缓存的实现Glide磁盘的实现主要是通过DiskLruCache来实现的。DiskLruCache并非针对Glide编写的，而是一个通用的磁盘缓存实现，虽然并非Google官方的代码，但是已经在很多应用中得到了引入使用。journal日志DiskLruCache通过日志来辅助保证磁盘缓存的有效性。在应用程序运行阶段，可以通过内存数据来保证缓存的
ListView优化之图片的三级缓存(LruCache)
wxx的记录窝
03-31 1686
最近写了一个图片的三级缓存，当然现在有很多的开源库都有这个功能，比如xUtils3等，那么我们为什么要自己去写呢，第一个是进一步熟悉它的原理，第二个是使用LruCache最近最少算法，LruCache的好处是可以指定你在手机缓存空间使用多大，在缓存的文件大小超出了你指定的大小，系统会自动回收最少使用的对象。LruCache声明的是一个强引用，它是不会被系统回收的。 图片的三级缓存，顾名思义有三级
请描述下LruCache和DiskLruCache的几种使用场景，并且使用kotlin代码展示出来加上注释
05-17
LRU Cache (最近最少使用缓存) 和 DiskLruCache (基于磁盘的 LRU 缓存) 是两种常见的缓存技术，它们的使用场景和优点如下： 1. LRU Cache 的使用场景： - 当需要缓存一些数据时，但是又不能无限制地增加内存消耗时...
评论 202
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值