Android異步加載圖像小結

 研究了android從網絡上異步加載圖像，現總結如下：

（1）由於android UI更新支持單一線程原則，所以從網絡上取數據並更新到界面上，爲了不阻塞主線程首先可能會想到以下方法。

     在主線程中new 一個Handler對象，加載圖像方法如下所示

    private void loadImage(final String url, final int id) {
         handler.post(new Runnable() {
                public void run() {
                    Drawable drawable = null;
                    try {
                        drawable = Drawable.createFromStream(new URL(url).openStream(), "p_w_picpath.png");
                    } catch (IOException e) {
                    }
                    ((ImageView) LazyLoadImageActivity.this.findViewById(id)).setImageDrawable(drawable);
                }
            });
    }

上面這個方法缺點很顯然，經測試，如果要加載多個圖片，這並不能實現異步加載，而是等到所有的圖片都加載完才一起顯示，因爲它們都運行在一個線程中。

然後，我們可以簡單改進下，將Handler+Runnable模式改爲Handler+Thread+Message模式不就能實現同時開啓多個線程嗎？

（2）在主線程中new 一個Handler對象，代碼如下：

    final Handler handler2=new Handler(){
          @Override
          public void handleMessage(Message msg) {
             ((ImageView) LazyLoadImageActivity.this.findViewById(msg.arg1)).setImageDrawable((Drawable)msg.obj);
          }
      };

    對應加載圖像代碼如下：

  //採用handler+Thread模式實現多線程異步加載
     private void loadImage2(final String url, final int id) {
         Thread thread = new Thread(){
             @Override
             public void run() {
               Drawable drawable = null;
                    try {
                        drawable = Drawable.createFromStream(new URL(url).openStream(), "p_w_picpath.png");
                    } catch (IOException e) {
                    }

                Message message= handler2.obtainMessage() ;
                 message.arg1 = id;
                 message.obj = drawable;
                 handler2.sendMessage(message);
             }
         };
         thread.start();
         thread = null;
    }

這樣就簡單實現了異步加載了。細想一下，還可以優化的，比如引入線程池、引入緩存等，我們先介紹線程池。

（3）引入ExecutorService接口，於是代碼可以優化如下：

       在主線程中加入：private ExecutorService executorService = Executors.newFixedThreadPool(5);   

       對應加載圖像方法更改如下：

      // 引入線程池來管理多線程
    private void loadImage3(final String url, final int id) {
        executorService.submit(new Runnable() {
            public void run() {
                try {
                    final Drawable drawable = Drawable.createFromStream(new URL(url).openStream(), "p_w_picpath.png");
                    handler.post(new Runnable() {

                        public void run() {
                            ((ImageView) LazyLoadImageActivity.this.findViewById(id)).setImageDrawable(drawable);
                        }
                    });
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        });
    }

（4）爲了更方便使用我們可以將異步加載圖像方法封裝一個類，對外界只暴露一個方法即可，考慮到效率問題我們可以引入內存緩存機制，做法是

建立一個HashMap，其鍵（key）爲加載圖像url，其值（value）是圖像對象Drawable。先看一下我們封裝的類

public class AsyncImageLoader3 {
   //爲了加快速度，在內存中開啓緩存（主要應用於重複圖片較多時，或者同一個圖片要多次被訪問，比如在ListView時來回滾動）
    public Map<String, SoftReference<Drawable>> p_w_picpathCache = new HashMap<String, SoftReference<Drawable>>();
    private ExecutorService executorService = Executors.newFixedThreadPool(5);    //固定五個線程來執行任務
    private final Handler handler=new Handler();

     /**
     *
     * @param p_w_picpathUrl     圖像url地址
     * @param callback     回調接口
     * @return     返回內存中緩存的圖像，第一次加載返回null
     */
    public Drawable loadDrawable(final String p_w_picpathUrl, final ImageCallback callback) {
        //如果緩存過就從緩存中取出數據
        if (p_w_picpathCache.containsKey(p_w_picpathUrl)) {
            SoftReference<Drawable> softReference = p_w_picpathCache.get(p_w_picpathUrl);
            if (softReference.get() != null) {
                return softReference.get();
            }
        }
        //緩存中沒有圖像，則從網絡上取出數據，並將取出的數據緩存到內存中
         executorService.submit(new Runnable() {
            public void run() {
                try {
                    final Drawable drawable = Drawable.createFromStream(new URL(p_w_picpathUrl).openStream(), "p_w_picpath.png");

                    p_w_picpathCache.put(p_w_picpathUrl, new SoftReference<Drawable>(drawable));

                    handler.post(new Runnable() {
                        public void run() {
                           callback.p_w_picpathLoaded(drawable);
                        }
                    });
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        });
        return null;
    }
     //從網絡上取數據方法
    protected Drawable loadImageFromUrl(String p_w_picpathUrl) {
        try {
            return Drawable.createFromStream(new URL(p_w_picpathUrl).openStream(), "p_w_picpath.png");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    //對外界開放的回調接口
    public interface ImageCallback {
        //注意 此方法是用來設置目標對象的圖像資源
        public void p_w_picpathLoaded(Drawable p_w_picpathDrawable);
    }
}這樣封裝好後使用起來就方便多了。在主線程中首先要引入AsyncImageLoader3 對象，然後直接調用其loadDrawable方法即可，需要注意的是ImageCallback接口的p_w_picpathLoaded方法是唯一可以把加載的圖像設置到目標ImageView或其相關的組件上。

在主線程調用代碼：

  先實例化對象 private AsyncImageLoader3 asyncImageLoader3 = new AsyncImageLoader3();

  調用異步加載方法：

//引入線程池，並引入內存緩存功能,並對外部調用封裝了接口，簡化調用過程
    private void loadImage4(final String url, final int id) {
          //如果緩存過就會從緩存中取出圖像，ImageCallback接口中方法也不會被執行
         Drawable cacheImage = asyncImageLoader.loadDrawable(url,new AsyncImageLoader.ImageCallback() {
             //請參見實現：如果第一次加載url時下面方法會執行
             public void p_w_picpathLoaded(Drawable p_w_picpathDrawable) {
               ((ImageView) findViewById(id)).setImageDrawable(p_w_picpathDrawable);
             }
         });
        if(cacheImage!=null){
          ((ImageView) findViewById(id)).setImageDrawable(cacheImage);
        }
    }