Android项目框架之图片加载框架的选择

本文来自http://blog.csdn.net/liuxian13183/ ，引用必须注明出处！

从Android爆发以后，自定义的控件如EditTextWithDelete、ActionBar、PullToRresh逐步进入开发者的视野，想起11年的时候，基本项目中使用的UI还全都是Android提供的基础控件，少一点的动画+布局，下载和网络请求都是用HttpClient，图片加载当然也是下载后再使用，当时的程序资源可没有现在这么丰富，看看Github上开源的项目，现在的程序员应该感到幸福。

项目开发从程序上来讲，万古不变两大事情，一是网络通信框架，二是图片加载框架，有关网络框架上一篇已经介绍了async-http和okhttp，而其他如volly同时拥有网络请求和图片加载两个框架，很多人图省事就一次性使用了，当然facebook自己的开源框架也是写的非常不错，接下来再一一介绍；先贴一张11年我们自己写的imageloader

public class ImageDownloader {

	private static ImageDownloader instance = null;
	private static File cacheDir;
	public static Map<String, SoftReference<Bitmap>> bitMapCache = new HashMap<String, SoftReference<Bitmap>>();

	public static ImageDownloader getInstance() {
		if (instance == null) {
			instance = new ImageDownloader();
		}
		return instance;
	}

	private ImageDownloader() {
		// Find the dir to save cached images
		if (android.os.Environment.getExternalStorageState().equals(
				android.os.Environment.MEDIA_MOUNTED))
			cacheDir = new File(
					android.os.Environment.getExternalStorageDirectory(),
					"WholeMag");
		else
			cacheDir = WholeMagApplication.getInstance().getCacheDir();
		if (!cacheDir.exists())
			cacheDir.mkdirs();
	}

	public void download(String actName, String url, ImageView imageView) {
		BitmapDownloaderTask task = new BitmapDownloaderTask(imageView, actName);
		task.execute(url);
		// return task.doInBackground(url);
	}

	class BitmapDownloaderTask extends AsyncTask<String, Void, Bitmap> {
		// private String url;
		// private boolean flag;
		private final WeakReference<ImageView> imageViewReference; // 使用WeakReference解决内存问题
		private String actName;

		public BitmapDownloaderTask(ImageView imageView, String actName) {
			imageViewReference = new WeakReference<ImageView>(imageView);
			this.actName = actName;
		}

		@Override
		protected Bitmap doInBackground(String... params) { // 实际的下载线程，内部其实是concurrent线程，所以不会阻塞
			Bitmap rebmp = getLocalBitmap(params[0], actName);
			if (rebmp == null)
				rebmp = downloadBitmap(params[0], actName);
			if (rebmp == null) {
				doInBackground(params[0]);
			}
			return rebmp;
		}

		@Override
		protected void onPostExecute(Bitmap bitmap) { // 下载完后执行的
			if (isCancelled()) {
				bitmap = null;
			}
			if (imageViewReference != null) {
				ImageView imageView = imageViewReference.get();
				if (imageView != null) {
					imageView.setDrawingCacheEnabled(true);
					Bitmap temp = imageView.getDrawingCache();
					imageView.setDrawingCacheEnabled(false);
					if (temp != null) {
						temp.recycle();
					}
					double widthX = (float) WholeMagDatas.getDeviceWidth()
							/ bitmap.getWidth(); // 图片宽度拉伸比例
					int bitmapHight = bitmap.getHeight();// 图片高度
					imageView.setImageBitmap(bitmap); // 下载完设置imageview为刚才下载的bitmap对象
					if(actName.equals(AppData.NEWS_DETAIL_ACT)){
						FrameLayout.LayoutParams ll = new FrameLayout.LayoutParams(
								android.view.ViewGroup.LayoutParams.FILL_PARENT,
								(int) (bitmapHight * widthX), Gravity.CENTER);
						imageView.setLayoutParams(ll);
					}
					AlphaAnimation alphaAnimation = new AlphaAnimation(0, 1);// 创建一个AlphaAnimation对象
					alphaAnimation.setDuration(500);// 设置动画执行的时间（单位：毫秒）
					imageView.startAnimation(alphaAnimation);
				}
			}
		}
	}

	static Bitmap getLocalBitmap(String url, String actName) {
		if (bitMapCache.containsKey(url)) {
			return bitMapCache.get(url).get();
		}
		// String tmp = url;
		// String first = url.substring(url.lastIndexOf("/") + 1);
		// tmp = tmp.substring(0, tmp.lastIndexOf("/"));
		// String second = tmp.substring(tmp.lastIndexOf("/") + 1);
		// tmp = tmp.substring(0, tmp.lastIndexOf("/"));
		// String third = tmp.substring(tmp.lastIndexOf("/") + 1);
		// String filename = third + second + first;
		// File f = new File(cacheDir, filename);
		File f = Tools.getFile(actName, url);
		InputStream inputStream = null;
		try {
			// decode image size
			BitmapFactory.Options o = new BitmapFactory.Options();
			o.inPreferredConfig = Bitmap.Config.RGB_565;
			o.inDither = false;
			o.inPurgeable = true;
			// o.inTempStorage = new byte[12 * 1024];
			inputStream = new FileInputStream(f);
			// Bitmap bitmap = BitmapFactory.decodeFile(f.getAbsolutePath());
			Bitmap bitmap = BitmapFactory.decodeStream(inputStream, null, o);
			bitMapCache.put(url, new SoftReference<Bitmap>(bitmap));
			return bitmap;
		} catch (Exception e) {
		} finally {
			if (null != inputStream) {
				try {
					inputStream.close();
				} catch (Exception ex) {
				}
			}
		}
		return null;
	}

	static Bitmap downloadBitmap(String url, String actName) {
		final AndroidHttpClient client = AndroidHttpClient.newInstance("linux");
		final HttpGet getRequest = new HttpGet(url);

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

			final HttpEntity entity = response.getEntity();
			if (entity != null) {
				// String tmp = url;
				// String first = url.substring(url.lastIndexOf("/") + 1);
				// tmp = tmp.substring(0, tmp.lastIndexOf("/"));
				// String second = tmp.substring(tmp.lastIndexOf("/") + 1);
				// tmp = tmp.substring(0, tmp.lastIndexOf("/"));
				// String third = tmp.substring(tmp.lastIndexOf("/") + 1);
				// String filename = third + second + first;
				// File f = new File(cacheDir, filename);
				File f = Tools.getFile(actName, url);
				OutputStream os = new FileOutputStream(f);
				InputStream inputStream = null;
				try {
					inputStream = entity.getContent();
					BitmapFactory.Options o = new BitmapFactory.Options();
					o.inPreferredConfig = Bitmap.Config.RGB_565;
					o.inDither = false;
					o.inPurgeable = true;
					final Bitmap bitmap = BitmapFactory.decodeStream(
							inputStream, null, o);
					bitmap.compress(Bitmap.CompressFormat.JPEG, 100, os);
					bitMapCache.put(url, new SoftReference<Bitmap>(bitmap));
					return bitmap;
				} finally {
					if (inputStream != null) {
						inputStream.close();
					}
					if (null != os) {
						os.close();
					}
					entity.consumeContent();
				}
			}
		} catch (Exception e) {
			getRequest.abort();
		} finally {
			if (client != null) {
				client.close();
			}
		}
		return null;
	}
}

当年为了防止图片爆掉出现OOM，使用了软引用，觉得还不错；图片加载的基本原理就是，把url+imageview抛过来，然后开启异步线程加载，根据获取的byte流decode成bitmap，最后在UI线程将图片加载到imageview上；也没有说做本地缓存，仅做了应用缓存；没有对图片进行压缩或者设置格式，使占用内存更小，展示也更合理；LruCache基本原理跟上面使用软引用的过程差不多，只不过多限制了图片占用内存的大小，计算图片使用的频率，对应用层、SD卡层均做了封装。

上面介绍完，相信你也对图片加载有个大概的轮廓，我们拿开源的imageloader为例，来讲讲图片加载框架的一些细节

public final class ImageLoaderConfiguration {

    final Resources resources;//主要给图片设计宽高时，获得屏幕宽高使用

    final int maxImageWidthForMemoryCache;//内存中最大的图片宽度
    final int maxImageHeightForMemoryCache;//内存中最大的图片高度

    final int maxImageWidthForDiskCache;//SD卡中最大的图片宽度
    final int maxImageHeightForDiskCache;//SD卡中最大的图片高度
    final BitmapProcessor processorForDiskCache;//从SD卡获得Bitmap的加载器

    final Executor taskExecutor;//加载图片时的执行器
    final Executor taskExecutorForCachedImages;//加载缓存时的执行器
    final boolean customExecutor;//是否使用默认执行器
    final boolean customExecutorForCachedImages;//是否使用默认缓存执行器

    final int threadPoolSize;//线程数，可以用来控制展示当前界面的item图片
    final int threadPriority;//线程的执行优先级
    final QueueProcessingType tasksProcessingType;//是LILO还是LIFO，默认是前者，但一般喜欢后者

    final MemoryCache memoryCache;//内存缓存对象，如不写可用默认
    final DiskCache diskCache;//SD卡缓存对象，如不写可用默认
    final ImageDownloader downloader;//图片加载器，根据网络(http/s)、file、content、drawable、asset来加载
    final ImageDecoder decoder;//图片解析器，根据获取的图片参数拿到Bitmap
    final DisplayImageOptions defaultDisplayImageOptions;//设置图片加载状态和结果，见下面源码

    final ImageDownloader networkDeniedDownloader;//不用网络下载图片的下载器，可理解为加载SD卡图片的加载器
    final ImageDownloader slowNetworkDownloader;//仅网络下载图片的下载器，支持断点续传

拿这些变量来讲，基本就可以说明事情 

public final class DisplayImageOptions {

    private final int imageResOnLoading;//图片是否加载中
    private final int imageResForEmptyUri;//图片是否来自于空url
    private final int imageResOnFail;//图片是否加载失败
    private final Drawable imageOnLoading;//加载中的图片
    private final Drawable imageForEmptyUri;//空数据的图片
    private final Drawable imageOnFail;//加载失败的图片
    private final boolean resetViewBeforeLoading;//加载完是否重置（意味着放弃之前的加载）
    private final boolean cacheInMemory;//是否缓存在内存中
    private final boolean cacheOnDisk;//是否缓存在SD卡中
    private final ImageScaleType imageScaleType;//要多大的图片，统一设置
    private final Options decodingOptions;//Bitmap的options对象
    private final int delayBeforeLoading;//是否延迟加载，可用于非当前页面图片
    private final boolean considerExifParams;//是否支持jpeg图片的rotate和flip等方法
    private final Object extraForDownloader;//额外数据
    private final BitmapProcessor preProcessor;//加载不在内存中的图片
    private final BitmapProcessor postProcessor;//加载在图片中的图片
    private final BitmapDisplayer displayer;//展示图片
    private final Handler handler;//这个就不用讲了吧，跟主线程交互必不可少的工具
    private final boolean isSyncLoading;//是否同步加载 

补充一下，上面框架还支持给图片设置像素点占位大小；看到这么多功能，对于现在的项目基本满足要求，因此就不打算换了，再看看其他几种图片加载框架的异同

fresco，facebook出品，最大的优势在于可展示加载过程，即加载进度、加载前图片、加载中图片、加载后图片、加载失败图片等，还可以设置图片的形状；并且提供加载Gif、Webp图片的方法。

picasso，加载更快，因为默认设置图片格式占内存小

Glide是升级版本的piccaso，支持跟fragment和activity生命周期绑定

volly，基于老的imageloader又做了次封装，差别不是太大，功能弱化一些

而后面这几种框架，都是在imageloader兴起之后出现的，所以也基本支持它，在我看来也仅有fresco和glide是真正写出了跟原框架不同的东西。