android 下的网络图片加载

Android图片的异步加载，主要原理：

加载图片时先查看缓存中时候存在该图片，如果存在则返回该图片，否则先加载载一个默认的占位图片，同时创建一个通过网络获取图片的任务并添加，任务完成后放松消息给主线程更新界面。

废话少说，先贴上代码：

 package com.wangge.uumao.http;  

 import java.lang.ref.SoftReference;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;  

 import android.graphics.Bitmap;
 import android.os.Handler;
 import android.os.Message;
 import android.util.Log;
 import android.widget.ImageView;  

 import com.wangge.uumao.util.PicUtil;  

 public class AsynImageLoader {
     private static final String TAG = "AsynImageLoader";
     // 缓存下载过的图片的Map
     private Map<String, SoftReference<Bitmap>> caches;
     // 任务队列
     private List<Task> taskQueue;
     private boolean isRunning = false;  

     public AsynImageLoader(){
         // 初始化变量
         caches = new HashMap<String, SoftReference<Bitmap>>();
         taskQueue = new ArrayList<AsynImageLoader.Task>();
         // 启动图片下载线程
         isRunning = true;
         new Thread(runnable).start();
     }  

     /**
      *
      * @param imageView 需要延迟加载图片的对象
      * @param url 图片的URL地址
      * @param resId 图片加载过程中显示的图片资源
      */
     public void showImageAsyn(ImageView imageView, String url, int resId){
         imageView.setTag(url);
         Bitmap bitmap = loadImageAsyn(url, getImageCallback(imageView, resId));  

         if(bitmap == null){
             imageView.setImageResource(resId);
         }else{
             imageView.setImageBitmap(bitmap);
         }
     }  

     public Bitmap loadImageAsyn(String path, ImageCallback callback){
         // 判断缓存中是否已经存在该图片
         if(caches.containsKey(path)){
             // 取出软引用
             SoftReference<Bitmap> rf = caches.get(path);
             // 通过软引用，获取图片
             Bitmap bitmap = rf.get();
             // 如果该图片已经被释放，则将该path对应的键从Map中移除掉
             if(bitmap == null){
                 caches.remove(path);
             }else{
                 // 如果图片未被释放，直接返回该图片
                 Log.i(TAG, "return image in cache" + path);
                 return bitmap;
             }
         }else{
             // 如果缓存中不常在该图片，则创建图片下载任务
             Task task = new Task();
             task.path = path;
             task.callback = callback;
             Log.i(TAG, "new Task ," + path);
             if(!taskQueue.contains(task)){
                 taskQueue.add(task);
                 // 唤醒任务下载队列
                 synchronized (runnable) {
                     runnable.notify();
                 }
             }
         }  

         // 缓存中没有图片则返回null
         return null;
     }  

     /**
      *
      * @param imageView
      * @param resId 图片加载完成前显示的图片资源ID
      * @return
      */
     private ImageCallback getImageCallback(final ImageView imageView, final int resId){
         return new ImageCallback() {  

             @Override
             public void loadImage(String path, Bitmap bitmap) {
                 if(path.equals(imageView.getTag().toString())){
                     imageView.setImageBitmap(bitmap);
                 }else{
                     imageView.setImageResource(resId);
                 }
             }
         };
     }  

     private Handler handler = new Handler(){  

         @Override
         public void handleMessage(Message msg) {
             // 子线程中返回的下载完成的任务
             Task task = (Task)msg.obj;
             // 调用callback对象的loadImage方法，并将图片路径和图片回传给adapter
             task.callback.loadImage(task.path, task.bitmap);
         }  

     };  

     private Runnable runnable = new Runnable() {  

         @Override
         public void run() {
             while(isRunning){
                 // 当队列中还有未处理的任务时，执行下载任务
                 while(taskQueue.size() > 0){
                     // 获取第一个任务，并将之从任务队列中删除
                     Task task = taskQueue.remove(0);
                     // 将下载的图片添加到缓存
                     task.bitmap = PicUtil.getbitmap(task.path);
                     caches.put(task.path, new SoftReference<Bitmap>(task.bitmap));
                     if(handler != null){
                         // 创建消息对象，并将完成的任务添加到消息对象中
                         Message msg = handler.obtainMessage();
                         msg.obj = task;
                         // 发送消息回主线程
                         handler.sendMessage(msg);
                     }
                 }  

                 //如果队列为空,则令线程等待
                 synchronized (this) {
                     try {
                         this.wait();
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
             }
         }
     };  

     //回调接口
     public interface ImageCallback{
         void loadImage(String path, Bitmap bitmap);
     }  

     class Task{
         // 下载任务的下载路径
         String path;
         // 下载的图片
         Bitmap bitmap;
         // 回调对象
         ImageCallback callback;  

         @Override
         public boolean equals(Object o) {
             Task task = (Task)o;
             return task.path.equals(path);
         }
     }
 }  

源代码的17-24行是一些变量，数组的声明。

    private static final String TAG = "AsynImageLoader";
     // 缓存下载过的图片的Map
     private Map<String, SoftReference<Bitmap>> caches;
     // 任务队列
     private List<Task> taskQueue;
     private boolean isRunning = false;
       

值得一提的是的这里的下载过的图片的mAp是软应用了，为什么了。我们查阅资料以后得知：
如果一个对象只具有软引用，那就类似于可有可物的生活用品。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。只 要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。 软引用可以和一个引用队列（ReferenceQueue）联 合使用，如果软引用所引用的对象被垃圾回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

由于图片是大对象了，确保没有足够的缓存以后，java虚拟机能够将其回收。

代码的25-33行做了一件事，来初始化变量。

  public AsynImageLoader(){
         // 初始化变量
         caches = new HashMap<String, SoftReference<Bitmap>>();
         taskQueue = new ArrayList<AsynImageLoader.Task>();
         // 启动图片下载线程
         isRunning = true;
         new Thread(runnable).start();
     }  

并且启动图片下载线程。
40行-50行主要是用来启动异步线程来展示图片。

 public void showImageAsyn(ImageView imageView, String url, int resId){
        imageView.setTag(url);
        Bitmap bitmap = loadImageAsyn(url, getImageCallback(imageView, resId));  

        if(bitmap == null){
            imageView.setImageResource(resId);
        }else{
            imageView.setImageBitmap(bitmap);
        }
    }  

这个方法，主要调用了本段源代码，最核心的方法loadImageAsyn方法。

    public Bitmap loadImageAsyn(String path, ImageCallback callback){
        // 判断缓存中是否已经存在该图片
        if(caches.containsKey(path)){
            // 取出软引用
            SoftReference<Bitmap> rf = caches.get(path);
            // 通过软引用，获取图片
            Bitmap bitmap = rf.get();
            // 如果该图片已经被释放，则将该path对应的键从Map中移除掉
            if(bitmap == null){
                caches.remove(path);
            }else{
                // 如果图片未被释放，直接返回该图片
                Log.i(TAG, "return image in cache" + path);
                return bitmap;
            }
        }else{
            // 如果缓存中不常在该图片，则创建图片下载任务
            Task task = new Task();
            task.path = path;
            task.callback = callback;
            Log.i(TAG, "new Task ," + path);
            if(!taskQueue.contains(task)){
                taskQueue.add(task);
                // 唤醒任务下载队列
                synchronized (runnable) {
                    runnable.notify();
                }
            }
        }  

        // 缓存中没有图片则返回null
        return null;
    }  

首先判断缓存池中是否包含了这个图片，如果有这个图片，就从缓存中取得这个图片，否则的话，就从网络段来请求。这就是本方法的作用。

而runnable是从网络直接下载图片的方法。

private Runnable runnable = new Runnable() {
118.
119.        @Override
120.        public void run() {
121.            while(isRunning){
122.                // 当队列中还有未处理的任务时，执行下载任务
123.                while(taskQueue.size() > 0){
124.                    // 获取第一个任务，并将之从任务队列中删除
125.                    Task task = taskQueue.remove(0);
126.                    // 将下载的图片添加到缓存
127.                    task.bitmap = PicUtil.getbitmap(task.path);
128.                    caches.put(task.path, new SoftReference<Bitmap>(task.bitmap));
129.                    if(handler != null){
130.                        // 创建消息对象，并将完成的任务添加到消息对象中
131.                        Message msg = handler.obtainMessage();
132.                        msg.obj = task;
133.                        // 发送消息回主线程
134.                        handler.sendMessage(msg);
135.                    }
136.                }
137.
138.                //如果队列为空,则令线程等待
139.                synchronized (this) {
140.                    try {
141.                        this.wait();
142.                    } catch (InterruptedException e) {
143.                        e.printStackTrace();
144.                    }
145.                }
146.            }
147.        }
148.    };  

上述的代码告诉我们这样一个意思，通过一个消息的队列来下载图片，如果没有此线程的话，就令线程等待。

这就实现了android异步加载图片的应用。