网络图片异步加载

 

Android之ListView异步加载网络图片(优化缓存机制)

网上关于这个方面的文章也不少，基本的思路是线程+缓存来解决。下面提出一些优化：

1、采用线程池

2、内存缓存+文件缓存

3、内存缓存中网上很多是采用SoftReference来防止堆溢出，这儿严格限制只能使用最大JVM内存的1/4

4、对下载的图片进行按比例缩放，以减少内存的消耗

具体的代码里面说明。先放上内存缓存类的代码MemoryCache.java：

public class MemoryCache {

 

         private static final String TAG = "MemoryCache";

         // 放入缓存时是个同步操作

         // LinkedHashMap构造方法的最后一个参数true代表这个map里的元素将按照最近使用次数由少到多排列，即LRU

         // 这样的好处是如果要将缓存中的元素替换，则先遍历出最近最少使用的元素来替换以提高效率

         private Map<String, Bitmap> cache = Collections

                            .synchronizedMap(new LinkedHashMap<String, Bitmap>(10, 1.5f, true));

         // 缓存中图片所占用的字节，初始0，将通过此变量严格控制缓存所占用的堆内存

         private long size = 0;// current allocated size

         // 缓存只能占用的最大堆内存

         private long limit = 1000000;// max memory in bytes

 

         public MemoryCache() {

                   // use 25% of available heap size

                   setLimit(Runtime.getRuntime().maxMemory() / 4);

         }

 

         public void setLimit(long new_limit) {

                   limit = new_limit;

                  Log.i(TAG, "MemoryCache will use up to " + limit / 1024. / 1024. + "MB");

         }

 

         public Bitmap get(String id) {

                   try {

                            if (!cache.containsKey(id))

                                     return null;

                            return cache.get(id);

                   } catch (NullPointerException ex) {

                            return null;

                   }

         }

 

         public void put(String id, Bitmap bitmap) {

                   try {

                            if (cache.containsKey(id))

                                     size -= getSizeInBytes(cache.get(id));

                            cache.put(id, bitmap);

                            size += getSizeInBytes(bitmap);

                            checkSize();

                   } catch (Throwable th) {

                            th.printStackTrace();

                   }

         }

 

         /**

          * 严格控制堆内存，如果超过将首先替换最近最少使用的那个图片缓存

          *

          */

         private void checkSize() {

                   Log.i(TAG, "cache size=" + size + " length=" + cache.size());

                   if (size > limit) {

                            // 先遍历最近最少使用的元素

                            Iterator<Entry<String, Bitmap>> iter = cache.entrySet().iterator();

                            while (iter.hasNext()) {

                                     Entry<String, Bitmap> entry = iter.next();

                                     size -= getSizeInBytes(entry.getValue());

                                     iter.remove();

                                     if (size <= limit)

                                               break;

                            }

                            Log.i(TAG, "Clean cache. New size " + cache.size());

                   }

         }

 

         public void clear() {

                   cache.clear();

         }

 

         /**

          * 图片占用的内存

          *

          * @param bitmap

          * @return

          */

         long getSizeInBytes(Bitmap bitmap) {

                   if (bitmap == null)

                            return 0;

                   return bitmap.getRowBytes() * bitmap.getHeight();

         }

}

 

也可以使用SoftReference，代码会简单很多，但是我推荐上面的方法。

public class MemoryCache {

        

         private Map<String, SoftReference<Bitmap>> cache = Collections

                            .synchronizedMap(new HashMap<String, SoftReference<Bitmap>>());

 

         public Bitmap get(String id) {

                   if (!cache.containsKey(id))

                            return null;

                   SoftReference<Bitmap> ref = cache.get(id);

                   return ref.get();

         }

 

         public void put(String id, Bitmap bitmap) {

                   cache.put(id, new SoftReference<Bitmap>(bitmap));

         }

 

         public void clear() {

                   cache.clear();

         }

 

}

 

下面是文件缓存类的代码FileCache.java

public class FileCache {

 

         private File cacheDir;

 

         public FileCache(Context context) {

                   // 如果有SD卡则在SD卡中建一个LazyList的目录存放缓存的图片

                   // 没有SD卡就放在系统的缓存目录中

                   if (android.os.Environment.getExternalStorageState().equals(

                                     android.os.Environment.MEDIA_MOUNTED))

                            cacheDir = new File(

                                               android.os.Environment.getExternalStorageDirectory(),

                                               "LazyList");

                   else

                            cacheDir = context.getCacheDir();

                   if (!cacheDir.exists())

                            cacheDir.mkdirs();

         }

 

         public File getFile(String url) {

                   // 将url的hashCode作为缓存的文件名

                   String filename = String.valueOf(url.hashCode());

                   // Another possible solution

                   // String filename = URLEncoder.encode(url);

                   File f = new File(cacheDir, filename);

                   return f;

 

         }

 

         public void clear() {

                   File[] files = cacheDir.listFiles();

                   if (files == null)

                            return;

                   for (File f : files)

                            f.delete();

         }

 

}

 

最后最重要的加载图片的类，ImageLoader.java:

public class ImageLoader {

 

         MemoryCache memoryCache = new MemoryCache();

         FileCache fileCache;

         private Map<ImageView, String> imageViews = Collections

                            .synchronizedMap(new WeakHashMap<ImageView, String>());

         // 线程池

         ExecutorService executorService;

 

         public ImageLoader(Context context) {

                   fileCache = new FileCache(context);

                   executorService = Executors.newFixedThreadPool(5);

         }

 

         // 当进入listview时默认的图片，可换成你自己的默认图片

         final int stub_id = R.drawable.stub;

 

         // 最主要的方法

         public void DisplayImage(String url, ImageView imageView) {

                   imageViews.put(imageView, url);

                   // 先从内存缓存中查找

 

                   Bitmap bitmap = memoryCache.get(url);

                   if (bitmap != null)

                            imageView.setImageBitmap(bitmap);

                   else {

                            // 若没有的话则开启新线程加载图片

                            queuePhoto(url, imageView);

                            imageView.setImageResource(stub_id);

                   }

         }

 

         private void queuePhoto(String url, ImageView imageView) {

                   PhotoToLoad p = new PhotoToLoad(url, imageView);

                   executorService.submit(new PhotosLoader(p));

         }

 

         private Bitmap getBitmap(String url) {

                   File f = fileCache.getFile(url);

 

                   // 先从文件缓存中查找是否有

                   Bitmap b = decodeFile(f);

                   if (b != null)

                            return b;

 

                   // 最后从指定的url中下载图片

                   try {

                            Bitmap bitmap = null;

                            URL imageUrl = new URL(url);

                            HttpURLConnection conn = (HttpURLConnection) imageUrl

                                               .openConnection();

                            conn.setConnectTimeout(30000);

                            conn.setReadTimeout(30000);

                            conn.setInstanceFollowRedirects(true);

                            InputStream is = conn.getInputStream();

                            OutputStream os = new FileOutputStream(f);

                            CopyStream(is, os);

                            os.close();

                            bitmap = decodeFile(f);

                            return bitmap;

                   } catch (Exception ex) {

                            ex.printStackTrace();

                            return null;

                   }

         }

 

         // decode这个图片并且按比例缩放以减少内存消耗，虚拟机对每张图片的缓存大小也是有限制的

         private Bitmap decodeFile(File f) {

                   try {

                            // decode image size

                            BitmapFactory.Options o = new BitmapFactory.Options();

                            o.inJustDecodeBounds = true;

                            BitmapFactory.decodeStream(new FileInputStream(f), null, o);

 

                            // Find the correct scale value. It should be the power of 2.

                            final int REQUIRED_SIZE = 70;

                            int width_tmp = o.outWidth, height_tmp = o.outHeight;

                            int scale = 1;

                            while (true) {

                                     if (width_tmp / 2 < REQUIRED_SIZE

                                                        || height_tmp / 2 < REQUIRED_SIZE)

                                               break;

                                     width_tmp /= 2;

                                     height_tmp /= 2;

                                     scale *= 2;

                            }

 

                            // decode with inSampleSize

                            BitmapFactory.Options o2 = new BitmapFactory.Options();

                            o2.inSampleSize = scale;

                            return BitmapFactory.decodeStream(new FileInputStream(f), null, o2);

                   } catch (FileNotFoundException e) {

                   }

                   return null;

         }

 

         // Task for the queue

         private class PhotoToLoad {

                   public String url;

                   public ImageView imageView;

 

                   public PhotoToLoad(String u, ImageView i) {

                            url = u;

                            imageView = i;

                   }

         }

 

         class PhotosLoader implements Runnable {

                   PhotoToLoad photoToLoad;

 

                   PhotosLoader(PhotoToLoad photoToLoad) {

                            this.photoToLoad = photoToLoad;

                   }

 

                   @Override

                   public void run() {

                            if (imageViewReused(photoToLoad))

                                     return;

                            Bitmap bmp = getBitmap(photoToLoad.url);

                            memoryCache.put(photoToLoad.url, bmp);

                            if (imageViewReused(photoToLoad))

                                     return;

                            BitmapDisplayer bd = new BitmapDisplayer(bmp, photoToLoad);

                            // 更新的操作放在UI线程中

                            Activity a = (Activity) photoToLoad.imageView.getContext();

                            a.runOnUiThread(bd);

                   }

         }

 

         /**

          * 防止图片错位

          *

          * @param photoToLoad

          * @return

          */

         boolean imageViewReused(PhotoToLoad photoToLoad) {

                   String tag = imageViews.get(photoToLoad.imageView);

                   if (tag == null || !tag.equals(photoToLoad.url))

                            return true;

                   return false;

         }

 

         // 用于在UI线程中更新界面

         class BitmapDisplayer implements Runnable {

                   Bitmap bitmap;

                   PhotoToLoad photoToLoad;

 

                   public BitmapDisplayer(Bitmap b, PhotoToLoad p) {

                            bitmap = b;

                            photoToLoad = p;

                   }

 

                   public void run() {

                            if (imageViewReused(photoToLoad))

                                     return;

                            if (bitmap != null)

                                     photoToLoad.imageView.setImageBitmap(bitmap);

                            else

                                     photoToLoad.imageView.setImageResource(stub_id);

                   }

         }

 

         public void clearCache() {

                   memoryCache.clear();

                   fileCache.clear();

         }

 

         public static void CopyStream(InputStream is, OutputStream os) {

                   final int buffer_size = 1024;

                   try {

                            byte[] bytes = new byte[buffer_size];

                            for (;;) {

                                     int count = is.read(bytes, 0, buffer_size);

                                     if (count == -1)

                                               break;

                                     os.write(bytes, 0, count);

                            }

                   } catch (Exception ex) {

                   }

         }

}

主要流程是先从内存缓存中查找，若没有再开线程，从文件缓存中查找都没有则从指定的url中查找，并对bitmap进行处理，最后通过下面方法对UI进行更新操作。

a.       runOnUiThread(...);

 

在你的程序中的基本用法：

ImageLoader imageLoader=new ImageLoader(context);

imageLoader.DisplayImage(url, imageView);

比如你的放在你的ListView的adapter的getView()方法中，当然也适用于GridView。