android下载网络图片并缓存

异步下载网络图片，并提供是否缓存至内存或外部文件的功能

异步加载类AsyncImageLoader

    public void downloadImage(final String url, final ImageCallback callback);

    public void downloadImage(final String url, final boolean cache2Memory, final ImageCallback callback);

    public void setCache2File(boolean flag);

    public void setCachedDir(String dir);

图片下载和缓存实现类LoaderImpl

1.AsyncImageLoader.java

package com.imagecache;

import java.lang.ref.SoftReference;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import android.content.Context;
import android.graphics.Bitmap;
import android.os.Handler;
import android.util.Log;

public class AsyncImageLoader {
	//保存正在下载的图片URL集合，避免重复下载用
	private static HashSet<String> sDownloadingSet;
	//软引用内存缓存
	private static Map<String,SoftReference<Bitmap>> sImageCache; 
	//图片三种获取方式管理者，网络URL获取、内存缓存获取、外部文件缓存获取
	private static LoaderImpl impl;
	//线程池相关
	private static ExecutorService sExecutorService;
	
	//通知UI线程图片获取ok时使用
	private Handler handler; 
	
	
	/**
	 * 异步加载图片完毕的回调接口
	 */
	public interface ImageCallback{
		/**
		 * 回调函数
		 * @param bitmap: may be null!
		 * @param imageUrl 
		 */
		public void onImageLoaded(Bitmap bitmap, String imageUrl);
	}
	
	static{
		sDownloadingSet = new HashSet<String>();
		sImageCache = new HashMap<String,SoftReference<Bitmap>>();
		impl = new LoaderImpl(sImageCache);
	}

	public AsyncImageLoader(Context context){
		handler = new Handler();
		startThreadPoolIfNecessary();
		
		String defaultDir = context.getCacheDir().getAbsolutePath();
		setCachedDir(defaultDir);
	}
	
	/**
	 * 是否缓存图片至/data/data/package/cache/目录
	 * 默认不缓存
	 */
	public void setCache2File(boolean flag){
		impl.setCache2File(flag);
	}
	
	/**
	 * 设置缓存路径，setCache2File(true)时有效
	 */
	public void setCachedDir(String dir){
		impl.setCachedDir(dir);
	}

	/**开启线程池*/
	public static void startThreadPoolIfNecessary(){
		if(sExecutorService == null || sExecutorService.isShutdown() || sExecutorService.isTerminated()){
			sExecutorService = Executors.newFixedThreadPool(3);
			//sExecutorService = Executors.newSingleThreadExecutor();
		}
	}
	
	/**
	 * 异步下载图片，并缓存到memory中
	 * @param url	
	 * @param callback	see ImageCallback interface
	 */
	public void downloadImage(final String url, final ImageCallback callback){
		downloadImage(url, true, callback);
	}
	
	/**
	 * 
	 * @param url
	 * @param cache2Memory 是否缓存至memory中
	 * @param callback
	 */
	public void downloadImage(final String url, final boolean cache2Memory, final ImageCallback callback){
		if(sDownloadingSet.contains(url)){
			Log.i("AsyncImageLoader", "###该图片正在下载，不能重复下载！");
			return;
		}
		
		Bitmap bitmap = impl.getBitmapFromMemory(url);
		if(bitmap != null){
			if(callback != null){
				callback.onImageLoaded(bitmap, url);
			}
		}else{
			//从网络端下载图片
			sDownloadingSet.add(url);
			sExecutorService.submit(new Runnable(){
				@Override
				public void run() {
					final Bitmap bitmap = impl.getBitmapFromUrl(url, cache2Memory);
					handler.post(new Runnable(){
						@Override
						public void run(){
							if(callback != null)
								callback.onImageLoaded(bitmap, url);
							sDownloadingSet.remove(url);
						}
					});
				}
			});
		}
	}
	
	/**
	 * 预加载下一张图片，缓存至memory中
	 * @param url 
	 */
	public void preLoadNextImage(final String url){
		//将callback置为空，只将bitmap缓存到memory即可。
		downloadImage(url, null);
	}
	
}

2.LoaderImpl.java

package com.imagecache;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.lang.ref.SoftReference;
import java.net.HttpURLConnection;
import java.net.URL;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Map;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;

/**
 * 
 * @author Administrator
 * @desc 异步加载图片管理器
 *
 */
public class LoaderImpl {
	//内存中的软应用缓存
	private Map<String, SoftReference<Bitmap>> imageCache;
	
	//是否缓存图片至本地文件
	private boolean cache2FileFlag = false;
	
	//缓存目录,默认是/data/data/package/cache/目录
	private String cachedDir;
	
	public LoaderImpl(Map<String, SoftReference<Bitmap>> imageCache){
		this.imageCache = imageCache;
	}
	
	/**
	 * 是否缓存图片至外部文件
	 * @param flag 
	 */
	public void setCache2File(boolean flag){
		cache2FileFlag = flag;
	}
	
	/**
	 * 设置缓存图片到外部文件的路径
	 * @param cacheDir
	 */
	public void setCachedDir(String cacheDir){
		this.cachedDir = cacheDir;
	}
	
	/**
	 * 从网络端下载图片
	 * @param url 网络图片的URL地址
	 * @param cache2Memory 是否缓存(缓存在内存中)
	 * @return bitmap 图片bitmap结构
	 * 
	 */
	public Bitmap getBitmapFromUrl(String url, boolean cache2Memory){
		Bitmap bitmap = null;
		try{
			URL u = new URL(url);
			HttpURLConnection conn = (HttpURLConnection)u.openConnection();  
			InputStream is = conn.getInputStream();
			bitmap = BitmapFactory.decodeStream(is);
			
			if(cache2Memory){
				//1.缓存bitmap至内存软引用中
				imageCache.put(url, new SoftReference<Bitmap>(bitmap));
				if(cache2FileFlag){
					//2.缓存bitmap至/data/data/packageName/cache/文件夹中
					String fileName = getMD5Str(url);
					String filePath = this.cachedDir + "/" +fileName;
					FileOutputStream fos = new FileOutputStream(filePath);
					bitmap.compress(Bitmap.CompressFormat.PNG, 100, fos);
				}
			}
			
			is.close();
			conn.disconnect();
			return bitmap;
		}catch(IOException e){
			e.printStackTrace();
			return null;
		}
	}
	
	/**
	 * 从内存缓存中获取bitmap
	 * @param url
	 * @return bitmap or null.
	 */
	public Bitmap getBitmapFromMemory(String url){
		Bitmap bitmap = null;
		if(imageCache.containsKey(url)){
			synchronized(imageCache){
				SoftReference<Bitmap> bitmapRef = imageCache.get(url);
				if(bitmapRef != null){
					bitmap = bitmapRef.get();
					return bitmap;
				}
			}
		}
		//从外部缓存文件读取
		if(cache2FileFlag){
			bitmap = getBitmapFromFile(url);
			if(bitmap != null)
				imageCache.put(url, new SoftReference<Bitmap>(bitmap));
		}
		
		return bitmap;
	}
	
	/**
	 * 从外部文件缓存中获取bitmap
	 * @param url
	 * @return
	 */
	private Bitmap getBitmapFromFile(String url){
		Bitmap bitmap = null;
		String fileName = getMD5Str(url);
		if(fileName == null)
			return null;
		
		String filePath = cachedDir + "/" + fileName;
		
		try {
			FileInputStream fis = new FileInputStream(filePath);
			bitmap = BitmapFactory.decodeStream(fis);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
			bitmap = null;
		}
		return bitmap;
	}
	
	
	/**  
     * MD5 加密  
     */   
    private static String getMD5Str(String str) {   
        MessageDigest messageDigest = null;   
        try {   
            messageDigest = MessageDigest.getInstance("MD5");   
            messageDigest.reset();   
            messageDigest.update(str.getBytes("UTF-8"));   
        } catch (NoSuchAlgorithmException e) {   
            System.out.println("NoSuchAlgorithmException caught!");   
            return null;
        } catch (UnsupportedEncodingException e) {   
            e.printStackTrace();
            return null;
        }   
   
        byte[] byteArray = messageDigest.digest();   
        StringBuffer md5StrBuff = new StringBuffer();   
        for (int i = 0; i < byteArray.length; i++) {               
            if (Integer.toHexString(0xFF & byteArray[i]).length() == 1)   
                md5StrBuff.append("0").append(Integer.toHexString(0xFF & byteArray[i]));   
            else   
                md5StrBuff.append(Integer.toHexString(0xFF & byteArray[i]));   
        }   
   
        return md5StrBuff.toString();   
    }  

	/**  
     * MD5 加密  
    private static String getMD5Str(Object...objects){
    	StringBuilder stringBuilder=new StringBuilder();
    	for (Object object : objects) {
			stringBuilder.append(object.toString());
		}
    	return getMD5Str(stringBuilder.toString());
    }*/ 
}

3.测试Activity

package com.imagecache;

import android.app.Activity;
import android.graphics.Bitmap;
import android.os.Bundle;
import android.widget.ImageView;

public class MainActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        final ImageView iv = (ImageView)findViewById(R.id.iv);
        //网络图片地址
        String imgUrl = "http://...";
        
        //for test
        AsyncImageLoader loader = new AsyncImageLoader(getApplicationContext());
        
        //将图片缓存至外部文件中
        loader.setCache2File(true);	//false
        //设置外部缓存文件夹
        loader.setCachedDir(this.getCacheDir().getAbsolutePath());
        
        //下载图片，第二个参数是否缓存至内存中
        loader.downloadImage(imgUrl, true/*false*/, new AsyncImageLoader.ImageCallback() {
			@Override
			public void onImageLoaded(Bitmap bitmap, String imageUrl) {
				if(bitmap != null){
					iv.setImageBitmap(bitmap);
				}else{
					//下载失败，设置默认图片
				}
			}
		});
    }
    
}