打造完美的ImageLoader——LruCache+DiskLruCache

做android应用少不了要和网络打交道，在我刚开始学android的时候总是处理不好网络图片的加载，尤其是图片乱跳的问题，后来发现了各种缓存图片的方法：本地缓存、软引用、LruCache....

我知道的这三种方法中，第一中和其他两种并不冲突，我们完全可以缓存到本地一份，在缓存到内存中一份。软引用这样方式，第一次使用软引用的时候，感觉做一个完美的内存缓存太容易了，可惜在android2.3以后android加强了对软引用的回收，这种方式基本上算是废了。

LruCache登场

软引用废了，难道就没有替代品了吗？有，android sdk中google官方添加了LruCache类，该类使用Lru算法实现内存缓存，关于LruCache的使用，可以google一下，很简单。

本地缓存方案

以前我的本地缓存方案都是自己写流实现的，这种方式完全可以，而且也不是很费劲，现在也可以使用这种方式。但是，有一个更好用的方式：DiskLruCache，广域DiskLruCache，还是google一下就ok。这里说明一下，DiskLruCache并没有在SDK中需要我们自己下载，可以使用我在github上fork的：https://github.com/qibin0506/DiskLruCache
直接将源码copy到项目中即可。

ImageLoader的思路

给定一个url，我们通过这个url，先去内存中取图片，如果内存中不存在，在去本地获取，本地存在的话，再添加到内存中，不存在就去网络中下载，下载完毕后，缓存到本地和内存中。

实现

思路很清晰，那么现在开始跟着思路实现一下代码吧。

public class ImageLoader {

	private static final int SUCCESS = 1;

	private static final int FAILED = 0;

	private static int sImageWidth;

	private static Context sContext;

	private static ImageLoader sInstance;

	private static ExecutorService sThreadPool = Executors.newCachedThreadPool();

	private LruCache<String, Bitmap> mLruCache;

	private DiskLruCache mDiskCache;

	/**

	 * 初始化ImageLoader

	 * @param context

	 * @param width 预想的图片宽度

	 */

	public static void init(Context context, int width) {

		sContext = context;

		sImageWidth = width;

	}

	/**

	 * 单例 获取ImageLoader的实例

	 * @return

	 */

	public synchronized static ImageLoader getInstance() {

		if(null == sInstance) {

			sInstance = new ImageLoader();

		}

		return sInstance;

	}

	private ImageLoader() {

		// begin 初始化LruCache

		int maxMemory = (int) Runtime.getRuntime().maxMemory();

		int maxSize = maxMemory / 8;

		mLruCache = new LruCache<String, Bitmap>(maxSize) {

			@Override

			protected int sizeOf(String key, Bitmap value) {

				return value.getByteCount();

			}

		};

		// end

		// begin 初始化DiskLruCache

		try {

			mDiskCache = DiskLruCache.open(getCacheDir(), getAppVersion(), 1, 10*1024*1024);

		} catch (Exception e) {

			e.printStackTrace();

		}

		// end

	}

	public void load(final String url, final OnImageListener l) {

		final Handler handler = new Handler() {

			@Override

			public void handleMessage(Message msg) {

				switch (msg.what) {

				case SUCCESS:

					l.onResult((Bitmap) msg.obj);

					break;

				case FAILED:

					l.onResult(null);

					break;

				}

			}

		};

		// 从memory中获取

		Bitmap bmp = getFromLru(url);

		if(null != bmp) {

			System.out.println("--getFromLru");

			Message msg = handler.obtainMessage(SUCCESS, bmp);

			msg.sendToTarget();

			return;

		}

		// 如果memory中没有

		// 从disk中获取

		bmp = getFromDisk(url);

		if(null != bmp) {

			System.out.println("---getFromDisk");

			Message msg = handler.obtainMessage(SUCCESS, bmp);

			msg.sendToTarget();

			return;

		}

		// 如果disk中没有， 则从网络中下载

		sThreadPool.execute(new Runnable() {

			@Override

			public void run() {

				System.out.println("----getFromNet");

				DefaultHttpClient client = null;

				try {

					client = new DefaultHttpClient();

					HttpGet get = new HttpGet(url);

					HttpResponse response = client.execute(get);

					if(200 == response.getStatusLine().getStatusCode()) {

						InputStream in = response.getEntity().getContent();

						Bitmap bmp = BitmapFactory.decodeStream(in);

						bmp = scaleImage(bmp);

						// 缓存到本地

						addToDisk(url, bmp);

						// 缓存到memory

						addToLru(url, bmp);

						Message msg = handler.obtainMessage(SUCCESS, bmp);

						msg.sendToTarget();

					}

				} catch (Exception e) {

					e.printStackTrace();

					handler.sendEmptyMessage(FAILED);

				} finally {

					if(null != client) {

						client.getConnectionManager().shutdown();

					}

				}

			}

		});

	}

	// 缩放图片

	private Bitmap scaleImage(Bitmap bmp) {

		int sample = bmp.getWidth() / sImageWidth;

		int height = bmp.getHeight() / sample;

		return ThumbnailUtils.extractThumbnail(bmp, sImageWidth, height);

	}

	// 从memory中获取

	private Bitmap getFromLru(String url) {

		return mLruCache.get(Encrypt.md5(url));

	}

	// 添加到内存中

	private void addToLru(String url, Bitmap bmp) {

		if(getFromLru(url) == null) {

			System.out.println("++addToLru");

			mLruCache.put(Encrypt.md5(url), bmp);

		}

	}

	// 从本地缓存获取

	private Bitmap getFromDisk(String url) {

		Bitmap bmp = null;

		try {

			DiskLruCache.Snapshot snapshot = mDiskCache.get(Encrypt.md5(url));

			InputStream in = snapshot.getInputStream(0);

			bmp = BitmapFactory.decodeStream(in);

			addToLru(url, bmp); // 这里可以断言 内存中肯定没有

			in.close();

		} catch (Exception e) {

		}

		return bmp;

	}

	// 添加到本地缓存

	private void addToDisk(String url, Bitmap bmp) throws Exception {

		System.out.println("+++addtoDisk");

		ByteArrayOutputStream baos = new ByteArrayOutputStream();

		bmp.compress(CompressFormat.PNG, 100, baos);

		byte[] buf = baos.toByteArray();

		DiskLruCache.Editor editor = mDiskCache.edit(Encrypt.md5(url));

		OutputStream out = editor.newOutputStream(0);

		out.write(buf);

		out.flush();

		editor.commit();

	}

	// 获取缓存目录

	private File getCacheDir() {

		File dir = null;

		if(Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) {

			dir = new File(sContext.getExternalCacheDir().getPath() + File.separator + "images" + File.separator);

		}else {

			dir = new File(sContext.getCacheDir().getPath() + File.separator + "images" + File.separator);

		}

		return dir;

	}

	// 获取软件版本

	private int getAppVersion() {

		PackageInfo pi;

		try {

			pi = sContext.getPackageManager().getPackageInfo(sContext.getPackageName(), 0);

			return pi.versionCode;

		} catch (NameNotFoundException e) {

			e.printStackTrace();

		}

		return 0;

	}

	public interface OnImageListener {

		public void onResult(Bitmap bmp);

	}

}

可以看到ImageLoader中有一个init方法，该方法主要是初始化ImageLoader类中的context和我们预想的图片的宽度，为什么没有高度？高度要根据宽度比自动计算的。

27～32行，获取ImageLoader的实例，因为ImageLoader是单例的。

构造方法中，36～43行初始化LruCache，47～51行初始化DiskLruCache, DiskLruCache的静态方法open接收4个参数，分别是：缓存的路径，软件的版本号，一个key对应多少文件，最大缓存的大小。

load方法中，71～77行，从memory中尝试获取图片，如果获取到了，则发送消息，并停止执行。81～87行，如果从memory中获取不到，则尝试从本地缓存中获取，如果获取到了，则发送消息，并停止执行。94～110行，从网络下载图片，并添加到本地缓存和memory中。

scaleImage方法，是一个简单的缩放图片功能，使用了ThumbnailUtils.extractThumbnail，如果在低版本中，需要自己去实现。

131～141行，是从memory中获取和添加到memory中。

144～169行，是从本地缓存中获取和添加到本地缓存。

剩下的两个方法是获取缓存路径和软件版本号。

ImageLoader定义好了以后，怎么使用呢？很简单，调用load方法就行。

首先自定义一个Adapter继承自BaseAdapter，

public class ImageAdapter extends BaseAdapter {

	private Context mContext;

	private String[] mData;

	public ImageAdapter(Context context, String[] data) {

		mContext = context;

		mData = data;

		initImageLoader();

	}

	private void initImageLoader() {

		WindowManager wm = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);

		DisplayMetrics dm = new DisplayMetrics();

		wm.getDefaultDisplay().getMetrics(dm);

		ImageLoader.init(mContext, dm.widthPixels / 3);

	}

	@Override

	public int getCount() {

		return mData.length;

	}

	@Override

	public Object getItem(int position) {

		return mData[position];

	}

	@Override

	public long getItemId(int position) {

		return position;

	}

	@Override

	public View getView(int position, View convertView, ViewGroup parent) {

		final ViewHolder holder;

		if(null == convertView) {

			convertView = View.inflate(mContext, R.layout.image_item, null);

			holder = new ViewHolder();

			holder.imageView = (ImageView) convertView.findViewById(R.id.iv);

			convertView.setTag(R.id.iv, holder);

		}else {

			holder = (ViewHolder) convertView.getTag(R.id.iv);

		}

		holder.imageView.setImageResource(R.drawable.ic_launcher);

		ImageLoader imageLoader = ImageLoader.getInstance();

		imageLoader.load(mData[position], new ImageLoader.OnImageListener() {

			@Override

			public void onResult(Bitmap bmp) {

				holder.imageView.setImageBitmap(bmp);

			}

		});

		return convertView;

	}

	class ViewHolder {

		ImageView imageView;

	}

}

标准的BaseAdapter，需要注意到是第45行，主要是为了解决图片跳动的问题。

最后看一下效果吧：

图片借用了郭神的，实在是懒得自己去找了。效果还不错，挺顺畅的。

巴特西

打造完美的ImageLoader——LruCache+DiskLruCache

最新文章

热门文章