Android 图片缓存设计

1.简介      

   大家都知道，在我们Android 开发的过程中，对于图片的处理，是非常重要的，而对于我们如果每次都重网络去拉去图片，那样会造成,现在android应用中不可避免的要使用图片，有些图片是可以变化的，需要每次启动时从网络拉取，这种场景在有广告位的应用以及纯图片应用（比如淘宝，qq的照片墙）中比较多。


现在有一个问题：假如每次启动的时候都从网络拉取图片的话，势必会消耗很多流量。在当前的状况下，对于非wifi用户来说，流量还是很贵的，一个很耗流量的应用，其用户数量级肯定要受到影响。当然，我想，向百度美拍这样的应用，必然也有其内部的图片缓存策略。总之，图片缓存是很重要而且是必须的。 



2.图片缓存的原理 

         实现图片缓存也不难，需要有相应的cache策略。这里我采用 内存-文件-网络 三层cache机制，其中内存缓存包括强引用缓存和软引用缓存（SoftReference），其实网络不算cache，这里姑且也把它划到缓存的层次结构中。当根据url向网络拉取图片的时候，先从内存中找，如果内存中没有，再从缓存文件中查找，如果缓存文件中也没有，再从网络上通过http请求拉取图片。在键值对（key-value）中，这个图片缓存的key是图片url的hash值，value就是bitmap。所以，按照这个逻辑，只要一个url被下载过，其图片就被缓存起来了。 


关于Java中对象的软引用（SoftReference），如果一个对象具有软引用，内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高 速缓存。使用软引用能防止内存泄露，增强程序的健壮性。 


3.实例源码

（1）内存缓存

package com.zengtao.tools;

import java.lang.ref.SoftReference;
import java.util.LinkedHashMap;

import android.annotation.SuppressLint;
import android.app.ActivityManager;
import android.content.Context;
import android.graphics.Bitmap;
import android.util.LruCache;

/**
 * 内存缓存：两层缓存
 * 
 * @author zengtao 2015年4月27日 上午10:39:23
 */
public class MemoryCache {

	private final static int SOFT_CACHE_SIZE = 15; // 软引用缓存容量
	private static LruCache<String, Bitmap> mLruCache; // 硬引用缓存
	private static LinkedHashMap<String, SoftReference<Bitmap>> mSoftCache; // 软引用缓存

	@SuppressLint("NewApi")
	public MemoryCache(Context context) {
		int memClass = ((ActivityManager) context
				.getSystemService(Context.ACTIVITY_SERVICE)).getMemoryClass();
		int cacheSize = 1024 * 1024 * memClass / 4; // 获取系统的1/4的空间 作为缓存大小
		mLruCache = new LruCache<String, Bitmap>(cacheSize) {

			@Override
			protected int sizeOf(String key, Bitmap value) {
				if (value != null) {
					return value.getRowBytes() * value.getHeight();
				}
				return 0;
			}

			@Override
			protected void entryRemoved(boolean evicted, String key,
					Bitmap oldValue, Bitmap newValue) {
				if (oldValue != null) {
					// 硬引用缓存满的时候，会根据lru算法把最近没有被使用的图片抓入软引用
					mSoftCache.put(key, new SoftReference<Bitmap>(oldValue));
				}
			}
		};
		mSoftCache = new LinkedHashMap<String, SoftReference<Bitmap>>(
				SOFT_CACHE_SIZE, 0.75f, true) {

			private static final long serialVersionUID = 1L;

			@Override
			protected boolean removeEldestEntry(
					java.util.Map.Entry<String, SoftReference<Bitmap>> eldest) {
				if (size() > SOFT_CACHE_SIZE) {
					return true;
				}
				return false;
			}
		};
	}

	/**
	 * 存储图片到缓存
	 * 
	 * @param url
	 *            ：key
	 * @param bitmap
	 *            ： 图片
	 */
	@SuppressLint("NewApi")
	public void saveBitmap(String url, Bitmap bitmap) {
		if (bitmap != null) {
			synchronized (bitmap) {
				mLruCache.put(url, bitmap);
			}
		}
	}

	/**
	 * 获取缓存图片
	 * 
	 * @param url
	 *            ：url
	 * @return
	 */
	@SuppressLint("NewApi")
	public Bitmap getBitmap(String url) {
		Bitmap bitmap = null;
		// 从硬引用找
		synchronized (mLruCache) {
			// 从硬引用中获取
			bitmap = mLruCache.get(url);
			if (bitmap != null) {
				// 如果找到了，将元素移动到linkendHashMap的最前面，从而保证lrd算法中的是最后删除
				mLruCache.remove(url);
				mLruCache.put(url, bitmap);
				return bitmap;
			}
		}
		// 硬引用没找到，从软引用找
		synchronized (mSoftCache) {
			SoftReference<Bitmap> softReference = mSoftCache.get(url);
			if (softReference != null) {
				bitmap = softReference.get();
				// 如果找到了，重新添加到硬缓存中
				mLruCache.put(url, bitmap);
				mSoftCache.remove(url);
				return bitmap;
			} else {
				mSoftCache.remove(url);
			}
		}
		return null;
	}

	public void clearCache() {
		mSoftCache.clear();
	}
}

package com.zengtao.tools;

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.util.Arrays;
import java.util.Comparator;

import android.annotation.SuppressLint;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Environment;
import android.os.StatFs;

/**
 * 文件缓存
 * 
 * @author zengtao 2015年4月27日 上午11:49:52
 */
public class FileCache {
	private final static String IMAGECACHE = "ImageCache";
	private final static String lASTPATHNAME = ".cache"; // 文件名

	private final static int MB = 1024 * 1024;
	private final static int CACHESIZE = 10;
	private final static int SDCARD_FREE_SPANCE_CACHE = 10;

	public FileCache() {
		removeCache(getDirectory());
	}

	/**
	 * 将图片存入缓存
	 * 
	 * @param url
	 *            ： 地址
	 * @param bitmap
	 *            ： 图片
	 */
	public void saveBitmap(String url, Bitmap bitmap) {
		if (bitmap == null) {
			return;
		}
		if (SDCARD_FREE_SPANCE_CACHE > caluateSDCardFreeSpance()) {
			return; // 空间不足
		}
		String fileName = convertUrlToFileName(url);
		String dirPath = getDirectory();
		File dirFile = new File(dirPath);
		if (dirFile.exists()) {
			dirFile.mkdirs();
		}
		File file = new File(dirPath + "/" + fileName);
		try {
			file.createNewFile();
			OutputStream outputStream = new FileOutputStream(file);
			bitmap.compress(Bitmap.CompressFormat.JPEG, 100, outputStream);
			outputStream.flush();
			outputStream.close();
		} catch (Exception e) {
			System.out.println("文件未找到或者io异常");
		}
	}

	/**
	 * 获取文件缓存图片
	 * 
	 * @param url
	 *            ： 地址
	 * @return ： bitmap
	 */
	public Bitmap getBitmap(final String url) {
		Bitmap bitmap = null;
		final String path = getDirectory() + convertUrlToFileName(url);
		File file = new File(path);
		if (file.exists()) {
			bitmap = BitmapFactory.decodeFile(path);
			if (bitmap == null) {
				file.delete();
			} else {
				updateFileTime(path);
			}
		}
		return bitmap;
	}

	/**
	 * 获取sdCard路径
	 * 
	 * @return ：路径地址
	 */
	private String getSDCardPath() {
		String path = "";
		File file = null;
		boolean isSDCardExist = Environment.getExternalStorageState()
				.toString().equals(android.os.Environment.MEDIA_MOUNTED); // 判断是否有sdCard
		if (isSDCardExist) {
			file = Environment.getExternalStorageDirectory();
		}
		if (file != null) {
			path = file.toString();
		}
		return path;
	}

	/**
	 * 计算存储目录下的文件大小，
	 * 当文件总大小大于规定的CACHE_SIZE或者sdcard剩余空间小于FREE_SD_SPACE_NEEDED_TO_CACHE的规定
	 * 那么删除40%最近没有被使用的文件
	 */
	private boolean removeCache(String dirPath) {
		File dir = new File(dirPath);
		File[] files = dir.listFiles();
		if (files == null) {
			return true;
		}

		if (!android.os.Environment.getExternalStorageState().equals(
				android.os.Environment.MEDIA_MOUNTED)) {
			return false;
		}

		int dirSize = 0;
		for (int i = 0; i < files.length; i++) {
			if (files[i].getName().contains(lASTPATHNAME)) {
				dirSize += files[i].length();
			}
		}

		if (dirSize > CACHESIZE * MB
				|| SDCARD_FREE_SPANCE_CACHE > caluateSDCardFreeSpance()) {
			int removeFactor = (int) ((0.4 * files.length) + 1);
			Arrays.sort(files, new FileLastModifSort());
			for (int i = 0; i < removeFactor; i++) {
				if (files[i].getName().contains(lASTPATHNAME)) {
					files[i].delete();
				}
			}
		}

		if (caluateSDCardFreeSpance() <= CACHESIZE) {
			return false;
		}

		return true;
	}

	/**
	 * 获取缓存目录
	 * 
	 * @return : 目录
	 */
	private String getDirectory() {
		return getSDCardPath() + "/" + IMAGECACHE;
	}

	/**
	 * 将url转换成文件名
	 * 
	 * @param url
	 *            ： 地址
	 * @return ： 文件名
	 */
	private String convertUrlToFileName(final String url) {
		String[] strs = url.split("/");
		return strs[strs.length - 1] + lASTPATHNAME;
	}

	/**
	 * 计算sdCard上的空闲空间
	 * 
	 * @return ： 大小
	 */
	@SuppressLint("NewApi")
	private int caluateSDCardFreeSpance() {
		int freespance = 0;
		StatFs start = new StatFs(Environment.getExternalStorageDirectory()
				.getPath());
		long blocksize = start.getBlockSizeLong();
		long availableBlocks = start.getAvailableBlocksLong();
		freespance = Integer.parseInt(blocksize * availableBlocks + "");
		return freespance;
	}

	/** 修改文件的最后修改时间 **/
	public void updateFileTime(String path) {
		File file = new File(path);
		long lastTime = System.currentTimeMillis();
		file.setLastModified(lastTime);
	}

	/** 根据文件的最后修改时间进行排序 **/
	private class FileLastModifSort implements Comparator<File> {
		public int compare(File arg0, File arg1) {
			if (arg0.lastModified() > arg1.lastModified()) {
				return 1;
			} else if (arg0.lastModified() == arg1.lastModified()) {
				return 0;
			} else {
				return -1;
			}
		}
	}
}

package com.zengtao.tools;

import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.util.Log;

/**
 * 网络缓存
 * 
 * @author zengtao 2015年4月27日 下午3:32:34
 */
public class HttpCache {
	private static final String LOG_TAG = "ImageGetFromHttp";

	public static Bitmap downloadBitmap(String url) {
		final HttpClient client = new DefaultHttpClient();
		final HttpGet getRequest = new HttpGet(url);

		try {
			HttpResponse response = client.execute(getRequest);
			final int statusCode = response.getStatusLine().getStatusCode();
			if (statusCode != HttpStatus.SC_OK) {
				Log.w(LOG_TAG, "Error " + statusCode
						+ " while retrieving bitmap from " + url);
				return null;
			}

			final HttpEntity entity = response.getEntity();
			if (entity != null) {
				InputStream inputStream = null;
				try {
					inputStream = entity.getContent();
					FilterInputStream fit = new FlushedInputStream(inputStream);
					return BitmapFactory.decodeStream(fit);
				} finally {
					if (inputStream != null) {
						inputStream.close();
						inputStream = null;
					}
					entity.consumeContent();
				}
			}
		} catch (IOException e) {
			getRequest.abort();
			Log.w(LOG_TAG, "I/O error while retrieving bitmap from " + url, e);
		} catch (IllegalStateException e) {
			getRequest.abort();
			Log.w(LOG_TAG, "Incorrect URL: " + url);
		} catch (Exception e) {
			getRequest.abort();
			Log.w(LOG_TAG, "Error while retrieving bitmap from " + url, e);
		} finally {
			client.getConnectionManager().shutdown();
		}
		return null;
	}

	/**
	 * InputStream流有个小bug在慢速网络的情况下可能产生中断，可以考虑重写FilterInputStream处理skip方法来解决这个bug
	 * BitmapFactory类的decodeStream方法在网络超时或较慢的时候无法获取完整的数据，这里我
	 * 们通过继承FilterInputStream类的skip方法来强制实现flush流中的数据
	 * ，主要原理就是检查是否到文件末端，告诉http类是否继续。
	 * 
	 * @author zengtao 2015年4月27日 下午6:33:17
	 */
	static class FlushedInputStream extends FilterInputStream {
		public FlushedInputStream(InputStream inputStream) {
			super(inputStream);
		}

		@Override
		public long skip(long n) throws IOException {
			long totalBytesSkipped = 0L;
			while (totalBytesSkipped < n) {
				long bytesSkipped = in.skip(n - totalBytesSkipped);
				if (bytesSkipped == 0L) {
					int b = read();
					if (b < 0) {
						break; // we reached EOF
					} else {
						bytesSkipped = 1; // we read one byte
					}
				}
				totalBytesSkipped += bytesSkipped;
			}
			return totalBytesSkipped;
		}
	}
}

@SuppressLint("HandlerLeak")
	private Handler handler = new Handler() {
		public void handleMessage(Message msg) {
			if (msg.arg1 == 0x1) {
				if (msg.obj != null) {
					image.setImageBitmap((Bitmap) msg.obj);
				}
			}
		};
	};

	class MyThread extends Thread {
		@Override
		public void run() {
			bitmap = getBitmap("http://a.hiphotos.baidu.com/image/pic/item/77c6a7efce1b9d16f5022b7ef1deb48f8d5464e3.jpg");
			Message message = new Message();
			message.arg1 = 0x1;
			message.obj = bitmap;
			handler.sendMessage(message);
		}
	}

	/*** 获得一张图片,从三个地方获取,首先是内存缓存,然后是文件缓存,最后从网络获取 ***/
	public Bitmap getBitmap(String url) {
		// 1.从内存缓存中获取图片
		Bitmap resultBitmap = memoryCache.getBitmap(url);
		if (resultBitmap == null) {
			// 2.文件缓存中获取
			resultBitmap = fileCache.getBitmap(url);
			if (resultBitmap == null) {
				// 3.从网络获取
				resultBitmap = HttpCache.downloadBitmap(url);
				if (resultBitmap != null) {
					fileCache.saveBitmap(url, resultBitmap);
					memoryCache.saveBitmap(url, resultBitmap);
					System.out.println("3.网络缓存中获取图片");
				}
			} else {
				// 添加到内存缓存
				memoryCache.saveBitmap(url, resultBitmap);
				System.out.println("2.文件缓存中获取图片");
			}
		} else {
			System.out.println("1.内存缓存中获取图片");
		}
		return resultBitmap;
	}

以上就完成了一套缓存的设计，值得注意的是，当去网络获取图片的时候，图片过于庞大，一定要做去异步线程中获取图片，或者做本地缓存，这样不会让用户感觉自己的app卡死，是的用户体验效果更加。