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{
                    //下载失败，设置默认图片
                }
            }
        });
    }

}