Android异步下载图片的类和缓存图片到SD卡的类。

最近因为以前写应用的网络图片读取都是另外启动一个线程去下载，现在感觉下载速度太慢了，而且也不方便管理。就打算写一个异步下载的，在网上找了一些大神们的博客看了。

开始自己动手写了。写了一个异步下载图片的类和一个缓存图片到SD卡的类。

首先是异步下载图片的类，用Android提供的LruCache来缓存图片非常方便，当使用的缓存接近最大时LruCache会自动释放掉使用次数最少的图片。需要了解LruCache更多的信息可以点这里。

/**
 * 
 * @ClassName ImageDownload
 * @Description 异步图片下载类，能异步多线程下载图片，最大为并发5线程。能将下载好的图片缓存在内存和SD卡中，
 *              等下次需要的时候就不用再下载，节省流量。
 * @author lan4627@gmail.com
 * @date 2014-3-27
 * @version V1.2
 */
public class ImageDownload {
    private static final String TAG = ImageDownload.class.getSimpleName();
    private Context mContext;
    private LruCache<String, Bitmap> mLruCache;
    private ImageLoader imageLoader;
    private ImageCache imageCache;

    public ImageDownload(Context context) {
        mContext = context.getApplicationContext();
        // 用最大内存的八分之一来存图片
        int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
        int cache = maxMemory / 8;
        mLruCache = new LruCache<String, Bitmap>(cache) {

            protected int sizeOf(String key, Bitmap value) {
                return (value.getRowBytes() * value.getHeight()) / 1024;
            }

        };
        // 初始化图片缓存类，用来把图片缓存到SD卡的文件夹里
        imageCache = new ImageCache(mContext);
    }
    
    private void addImageCache(String key, Bitmap bitmap) {
        if (getImage(key) == null) {
            mLruCache.put(key, bitmap);
        }
    }

    private Bitmap getImage(String key) {
        return mLruCache.get(key);
    }

    /**
     * 
     * @Method: loadBitmap
     * @Description: 读取图片的方法，先找缓存中看是否有，没有再找SD卡的缓存目录中是否有，没有再启动一个线程去下载图片。
     *               下载完成后返回图片，同时把下载好的图片储存在缓存和SD卡中，下次要用就不用再下载了。
     * @throws 无
     * @param key
     *            需要下载的图片的URL
     * @param imageLoader
     *            回调接口
     * @return 返回一个Bitmap类型的图片
     */
    @TargetApi(Build.VERSION_CODES.HONEYCOMB)
    public Bitmap loadBitmap(String key, ImageLoader imageLoader) {
        Bitmap bitmap = getImage(key);
        if (bitmap != null) {
            return bitmap;
        }
        // 读取内置SD卡的缓存文件夹看有没有这张图片
        bitmap = imageCache.getCacheImage(key);
        if (bitmap != null) {
            addImageCache(key, bitmap);
            return getImage(key);
        }
        // 如果都没有，则启动线程去联网读取。
        this.imageLoader = imageLoader;
        if (android.os.Build.VERSION.SDK_INT > 10) {
            new ImageDownloadTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, key); // 当SDK版本大于10时，建立一个线程池为5的AsyncTask
        } else {
            new ImageDownloadTask().execute(key);
        }
        // 返回一个默认的占位图。
        return BitmapFactory.decodeResource(mContext.getResources(), R.drawable.bit_null);
    }

    public interface ImageLoader {
        public void onImage(String key, Bitmap bitmap);
    }

    class ImageDownloadTask extends AsyncTask<String, Integer, Bitmap> {
        private String key;

        protected Bitmap doInBackground(String... params) {
            Bitmap bitmap = null;
            InputStream is = null;
            try {
                key = params[0];
                URL url = new URL(key);
                HttpURLConnection huc = (HttpURLConnection) url.openConnection();
                // 设置请求方式
                huc.setRequestMethod("GET");
                // 设置读取的超时时间
                huc.setReadTimeout(11000);
                // 设置网络连接超时时间
                huc.setConnectTimeout(4000);
                // 拿到服务器返回的响应码
                int hand = huc.getResponseCode();
                if (hand == 200) {
                    // 读取图片
                    is = huc.getInputStream();
                    bitmap = BitmapFactory.decodeStream(is);
                } else {
                    Log.e(TAG, "错误的服务器返回码" + hand);
                }
            } catch (ProtocolException e) {
                Log.e(TAG, "不支持的连接方式");
                e.printStackTrace();
            } catch (MalformedURLException e) {
                Log.e(TAG, "URL解析错误");
                e.printStackTrace();
            } catch (IOException e) {
                Log.e(TAG, "连接打开错误或创建输入流错误");
                e.printStackTrace();
            } finally {
                if (is != null) {
                    try {
                        is.close();
                    } catch (IOException e) {
                        Log.e(TAG, "InputStream关闭时发生错误");
                        e.printStackTrace();
                    }
                }
            }
            if (bitmap != null) {
                // 如果不等于空，则加入缓存中以及保存到SD卡。
                addImageCache(key, bitmap);
                imageCache.saveImage(key, bitmap);
            }
            return bitmap;
        }
        // 下载完成后通过实现好的接口设置图片
        protected void onPostExecute(Bitmap bitmap) {
            if (bitmap != null) {
                imageLoader.onImage(key, bitmap);
            }
        }

    }
}

一般都是在GridView和ListView的适配器里使用这个异步下载的工具。

public class Test extends BaseAdapter {
    private ArrayList<HashMap<String, Object>> list;
    private LayoutInflater lInflater;
    private ListView listView;
    private ImageDownload imageDownload;

    public final class ListItemView {
        public ImageView icon;
    }

    public Test(Context context, ArrayList<HashMap<String, Object>> list, ListView listView) {
        lInflater = LayoutInflater.from(context);
        this.list = list;
        this.listView = listView;
        // 初始化图片下载类
        imageDownload = new ImageDownload(context);
    }

    @Override
    public int getCount() {
        return list.size();
    }

    @Override
    public Object getItem(int position) {
        return list.get(position);
    }

    @Override
    public long getItemId(int position) {
        return position;
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        ListItemView listItem = null;
        if (convertView == null) {
            listItem = new ListItemView();
            // 获取listItem视图
            convertView = lInflater.inflate(R.layout.list_warinfo, null);
            listItem.icon = (ImageView) convertView.findViewById(R.id.get_icon);
            convertView.setTag(listItem);
        } else {
            listItem = (ListItemView) convertView.getTag();
        }
        // 获得要下载的图片网址
        String url = (String)list.get(position).get("url");
        // 设置标记
        listItem.icon.setTag(url);
        // 实现回调接口
        ImageLoader imageLoader = new ImageLoader() {
            
            public void onImage(String key, Bitmap bitmap) {
                ImageView image = (ImageView) listView.findViewWithTag(key);
                if (image != null) {
                    image.setImageBitmap(bitmap);
                }
            }
        };
        Bitmap bitmap = imageDownload.loadBitmap(url, imageLoader);
        listItem.icon.setImageBitmap(bitmap);
        return convertView;
    }

}

下面是图片缓存类，会如果缓存文件夹过大了会自动清除，而且对外也提供了两个清除缓存文件夹的方法。

/**
 * 
 * @ClassName ImageCache
 * @Description 图片缓存
 * @author lan4627@gmail.com
 * @date 2014-3-29
 * @version V1.0
 */
public class ImageCache {
    private static final String TAG = ImageCache.class.getSimpleName();
    private Context context;

    /**
     * 
     * @Description: ImageCache初始化的时候会启动一个线程检查两个缓存文件夹的大小。
     *               如果SD卡内的缓存文件大于5MB，则自动删除里面的文件。 如果内部的缓存文件大于1MB，则自动删除里面的文件。
     * @param context
     *            上下文
     */
    public ImageCache(final Context context) {
        this.context = context.getApplicationContext();
        new Thread() {
            public void run() {
                long externalSize = cacheDirSize(getExternalCacheDir());
                long cacheSize = cacheDirSize(context.getCacheDir());
                float size = Float.valueOf(externalSize) / (1024 * 1024);
                if (size > 5) {
                    Log.v(TAG, "开始删除文件");
                    delete(getExternalCacheDir());
                }
                size = cacheSize / (1024 * 1024);
                if (size > 1) {
                    Log.v(TAG, "开始删除文件");
                    delete(context.getCacheDir());
                }
            }

        }.start();
    }

    /**
     * 
     * @Method: getCacheFile
     * @Description: 此方法用来获取缓存文件夹的路径。
     *                   如果SD卡是可用的状态，返回SD卡里的缓存文件夹。如果不可以则返回程序安装目录下的缓存文件夹。
     * @throws 无
     * @return 返回缓存文件夹的路径。
     */
    private File getCacheFile() {
        File file = null;
        if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
            file = getExternalCacheDir();
        } else {
            file = context.getCacheDir();
        }
        return file;
    }
    /**
     * 
     * @Method: getExternalCacheDir 
     * @Description: 此方法根据不同的SDK版本来返回SD卡内的缓存文件夹路径。
     *                  Android2.1以上的版本返回/Android/data/包名/cache。
     *                  Android2.1及以下版本在SD卡根目录创建一个ImageCache文件夹。
     * @throws 无
     * @return 返回SD卡里的缓存文件夹路径。
     */
    @SuppressLint("NewApi")
    private File getExternalCacheDir() {
        File file = null;
        if (android.os.Build.VERSION.SDK_INT > 7) {
            file = context.getExternalCacheDir();
        } else {
            file = new File(Environment.getExternalStorageDirectory() + "/ImageCache");
            // 如果目录不存在就创建一个
            if (!file.exists()) {
                file.mkdir();
            }
        }
        return file;
    }

    /**
     * 
     * @Method: saveImage
     * @Description: 把下载的图片保存在内置SD卡的缓存文件夹中，下次要用的时候可以先检查缓存的文件夹里有没有，有的话就不用下载
     * @throws 无
     * @param key
     *            图片的URL
     * @param bitmap
     *            图片
     */
    public boolean saveImage(String path, Bitmap bitmap) {
        // 把图片的下载地址作为保存的名字，需要把/和：替换掉，不然程序会认为这是一个目录。
        String fileName = path.replace("/", "_").replace(":", "&");
        File saveFile = new File(getCacheFile(), fileName);
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(saveFile);
            return bitmap.compress(CompressFormat.JPEG, 70, fos);
        } catch (FileNotFoundException e) {
            Log.e(TAG, "缓存图片的文件夹路径不存在");
            return false;
        } finally {
            if (fos != null) {
                try {
                    fos.flush();
                    fos.close();
                } catch (IOException e) {
                    Log.e(TAG, "写入缓存图片的文件输出流关闭错误");
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 
     * @Method: getCacheImage
     * @Description: 从SD卡的缓存目录中读取图片
     * @throws 无
     * @param key
     *            图片的URL
     * @return 返回一个Bitmap类型的图片, 如果缓存文件夹里无此图片则返回null。
     */
    @SuppressLint("NewApi")
    public Bitmap getCacheImage(String path) {
        String fileName = path.replace("/", "_").replace(":", "&");
        Bitmap bitmap = null;
        File cacheFile = new File(getCacheFile(), fileName);
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(cacheFile);
            bitmap = BitmapFactory.decodeStream(fis);
        } catch (FileNotFoundException e) {
            Log.i(TAG, "缓存图片不存在");
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    Log.e(TAG, "读取缓存图片的文件输入流关闭错误");
                    e.printStackTrace();
                }
            }
        }
        return bitmap;
    }

    /**
     * 
     * @Method: cacheDirSize
     * @Description: 此方法用来计算文件夹的大小
     * @throws 无
     * @param file
     *            需要计算大小的文件夹
     * @return 返回文件夹大小。一个long类型的数，单位为字节。
     */
    private long cacheDirSize(File file) {
        long size = 0;
        String[] files = file.list();
        for (int i = 0; i < files.length; i++) {
            size += new File(file, files[i]).length();
        }
        return size;
    }

    /**
     * 
     * @Method: delete
     * @Description: 此方法用来删除文件夹内的所有文件。
     * @throws 无
     * @param file
     *            需要删除内部所有文件的文件夹
     */
    private static synchronized void delete(File file) {
        if (file != null && file.exists() && file.isDirectory()) {
            String[] files = file.list();
            for (int i = 0; i < files.length; i++) {
                new File(file, files[i]).delete();
            }
            Log.v(TAG, "删除完成");
        }
    }

    /**
     * 
     * @Method: deleteExternalCacheFile
     * @Description: 删除SD卡缓存文件夹里的所有文件。
     * @throws 无
     */
    public void deleteExternalCacheFile() {
        if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
            delete(getExternalCacheDir());
        }
    }

    /**
     * 
     * @Method: deleteCacheFile
     * @Description: 删除程序安装目录下的缓存文件夹里所有文件。
     * @throws 无
     */
    public void deleteCacheFile() {
        File cacheFile = context.getCacheDir();
        delete(cacheFile);
    }
}