《Android源码设计模式解析与实战》——面向对象的六大原则的图片加载器源码

缓存接口

ImageCache：

public interface ImageCache
{
	public Bitmap get(String url);
	public void put(String url,Bitmap bitmap);
}

内存缓存

MemoryCache：

public class MemoryCache implements ImageCache
{
	private LruCache<String, Bitmap> mMemoryCache;

	public MemoryCache()
	{
		initImageCache();
	}

	private void initImageCache()
	{
		//计算可使用的最大内存
		final int maxMemory = (int)(Runtime.getRuntime().maxMemory() / 1024);
		//取1/4作为缓存
		final int cacheSize = maxMemory / 4;
		mMemoryCache = new LruCache<String, Bitmap>(cacheSize)
		{
			@Override
			protected int sizeOf(String key, Bitmap value)
			{
				return value.getRowBytes() * value.getHeight() / 4;
			}
		};
	}

	@Override
	public Bitmap get(String url)
	{
		return mMemoryCache.get(url);
	}

	@Override
	public void put(String url, Bitmap bitmap)
	{
		mMemoryCache.put(url,bitmap);
	}
}

磁盘缓存

DiskCache ：

public class DiskCache implements ImageCache
{
	static String cacheDir = "sdcard/cache/";

	@Override
	public Bitmap get(String url)
	{
		return BitmapFactory.decodeFile(cacheDir+url);
	}

	@Override
	public void put(String url, Bitmap bmp)
	{
		FileOutputStream fileOutputStream = null;
		try
		{
			fileOutputStream = new FileOutputStream(cacheDir + url);
			bmp.compress(Bitmap.CompressFormat.PNG, 100, fileOutputStream);
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		finally
		{
			CloseUtils.closeQuitely(fileOutputStream);
			if(fileOutputStream != null)
			{
				try
				{
					fileOutputStream.close();
				}
				catch(IOException e)
				{
					e.printStackTrace();
				}
			}
		}
	}
}

流工具

CloseUtils：

public class CloseUtils
{
	private CloseUtils(){}

	/**
	 * 关闭closeable对象
	 * @param closeable
	 */
	public static void closeQuitely(Closeable closeable){
		if(closeable != null){
			try
			{
				closeable.close();
			}
			catch(IOException e)
			{
				e.printStackTrace();
			}
		}
	}
}

双缓存实现

DoubleCache ：

/**
 * 双缓存，获取图片先从内存，内存没有在从sdcard获取
 * 缓存时在内存和sdcard各缓存一份
 */
public class DoubleCache implements ImageCache
{
	private MemoryCache mMemoryCache = new MemoryCache();
	private DiskCache mDiskCache = new DiskCache();
	@Override
	public Bitmap get(String url)
	{
		Bitmap bitmap = mMemoryCache.get(url);
		if(bitmap == null){
			bitmap = mDiskCache.get(url);
		}
		return bitmap;
	}

	@Override
	public void put(String url, Bitmap bitmap)
	{
		mMemoryCache.put(url,bitmap);
		mDiskCache.put(url,bitmap);
	}
}

图片加载器的实现

ImageLoader：

public class ImageLoader
{
	//内存缓存
	private ImageCache mImageCache = new MemoryCache();
	//线程池，个数为cpu的数量
	private ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
	/**
	 * 注入缓存实现
	 * @param cache
	 */
	public void setImageCache(ImageCache cache){
		this.mImageCache = cache;
	}

	//加载图片
	public void displayImage(String url, ImageView imageView){
		Bitmap bitmap = mImageCache.get(url);
		if(bitmap != null){
			imageView.setImageBitmap(bitmap);
			return;
		}
		//没有缓存提交到线程池下载图片
		submitLoadRequest(url,imageView);
	}

	private void submitLoadRequest(final String url, final ImageView imageView)
	{
		imageView.setTag(url);
		mExecutorService.submit(new Runnable()
		{
			@Override
			public void run()
			{
				Bitmap bitmap = downloadImage(url);
				if(bitmap == null){
					return;
				}
				if(imageView.getTag().equals(url)){
					imageView.setImageBitmap(bitmap);
				}
				mImageCache.put(url,bitmap);
			}
		});
	}

	/**
	 * 下载图片
	 * @param imageUrl
	 * @return
	 */
	private Bitmap downloadImage(String imageUrl)
	{
		Bitmap mBitmap = null;
		try
		{
			URL url = new URL(imageUrl);
			final HttpURLConnection conn = (HttpURLConnection)url.openConnection();
			mBitmap = BitmapFactory.decodeStream(conn.getInputStream());
			conn.disconnect();
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}
		return mBitmap;
	}
}