`
nick714
  • 浏览: 26118 次
  • 性别: Icon_minigender_1
  • 来自: 成都
社区版块
存档分类
最新评论

Android图片异步加载的实现

 
阅读更多

 

转帖自http://blog.csdn.net/sgl870927/article/details/6285535,谢谢该童鞋为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(), "image.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(), "image.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(), "image.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>> imageCache = new HashMap<String, SoftReference<Drawable>>();
    private ExecutorService executorService = Executors.newFixedThreadPool(5);    //固定五个线程来执行任务
    private final Handler handler=new Handler();

     /**
     *
     * @param imageUrl     图像url地址
     * @param callback     回调接口
     * @return     返回内存中缓存的图像,第一次加载返回null
     */
    public Drawable loadDrawable(final String imageUrl, final ImageCallback callback) {
        //如果缓存过就从缓存中取出数据
        if (imageCache.containsKey(imageUrl)) {
            SoftReference<Drawable> softReference = imageCache.get(imageUrl);
            if (softReference.get() != null) {
                return softReference.get();
            }
        }
        //缓存中没有图像,则从网络上取出数据,并将取出的数据缓存到内存中
         executorService.submit(new Runnable() {
            public void run() {
                try {
                    final Drawable drawable = Drawable.createFromStream(new URL(imageUrl).openStream(), "image.png");

                    imageCache.put(imageUrl, new SoftReference<Drawable>(drawable));

                    handler.post(new Runnable() {
                        public void run() {
                           callback.imageLoaded(drawable);
                        }
                    });
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        });
        return null;
    }
     //从网络上取数据方法
    protected Drawable loadImageFromUrl(String imageUrl) {
        try {
            return Drawable.createFromStream(new URL(imageUrl).openStream(), "image.png");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    //对外界开放的回调接口
    public interface ImageCallback {
        //注意 此方法是用来设置目标对象的图像资源
        public void imageLoaded(Drawable imageDrawable);
    }
}这样封装好后使用起来就方便多了。在主线程中首先要引入AsyncImageLoader3 对象,然后直接调用其loadDrawable方法即可,需要注意的是ImageCallback接口的imageLoaded方法是唯一可以把加载的图像设置到目标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 imageLoaded(Drawable imageDrawable) {
               ((ImageView) findViewById(id)).setImageDrawable(imageDrawable);
             }
         });
        if(cacheImage!=null){
          ((ImageView) findViewById(id)).setImageDrawable(cacheImage);
        }
    }

(5)同理,下面也给出采用Thread+Handler+MessageQueue+内存缓存代码,原则同(4),只是把线程池换成了Thread+Handler+MessageQueue模式而已。代码如下:

public class AsyncImageLoader {
   //为了加快速度,加入了缓存(主要应用于重复图片较多时,或者同一个图片要多次被访问,比如在ListView时来回滚动)
    private Map<String, SoftReference<Drawable>> imageCache = new HashMap<String, SoftReference<Drawable>>();

     /**
     *
     * @param imageUrl     图像url地址
     * @param callback     回调接口
     * @return     返回内存中缓存的图像,第一次加载返回null
     */
    public Drawable loadDrawable(final String imageUrl, final ImageCallback callback) {
        //如果缓存过就从缓存中取出数据
        if (imageCache.containsKey(imageUrl)) {
            SoftReference<Drawable> softReference = imageCache.get(imageUrl);
            if (softReference.get() != null) {
                return softReference.get();
            }
        }

        final Handler handler = new Handler() {
            @Override
            public void handleMessage(Message msg) {
                callback.imageLoaded((Drawable) msg.obj);
            }
        };
        new Thread() {
            public void run() {
                Drawable drawable = loadImageFromUrl(imageUrl);
                imageCache.put(imageUrl, new SoftReference<Drawable>(drawable));
                handler.sendMessage(handler.obtainMessage(0, drawable));

            }

        }.start();
        /*
        下面注释的这段代码是Handler的一种代替方法
         */
//        new AsyncTask() {
//            @Override
//            protected Drawable doInBackground(Object... objects) {
//                  Drawable drawable = loadImageFromUrl(imageUrl);
//                imageCache.put(imageUrl, new SoftReference<Drawable>(drawable));
//                return  drawable;
//            }
//
//            @Override
//            protected void onPostExecute(Object o) {
//                  callback.imageLoaded((Drawable) o);
//            }
//        }.execute();
        return null;
    }

    protected Drawable loadImageFromUrl(String imageUrl) {
        try {
            return Drawable.createFromStream(new URL(imageUrl).openStream(), "src");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    //对外界开放的回调接口
    public interface ImageCallback {
        public void imageLoaded(Drawable imageDrawable);
    }
}

至此,异步加载就介绍完了,下面给出的代码为测试用的完整代码:

package com.bshark.supertelphone.activity;

import android.app.Activity;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.widget.ImageView;
import com.bshark.supertelphone.R;
import com.bshark.supertelphone.ui.adapter.util.AsyncImageLoader;
import com.bshark.supertelphone.ui.adapter.util.AsyncImageLoader3;

import java.io.IOException;
import java.net.URL;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class LazyLoadImageActivity extends Activity {
       final Handler handler=new Handler();
      final Handler handler2=new Handler(){
          @Override
          public void handleMessage(Message msg) {
             ((ImageView) LazyLoadImageActivity.this.findViewById(msg.arg1)).setImageDrawable((Drawable)msg.obj);
          }
      };
 private ExecutorService executorService = Executors.newFixedThreadPool(5);    //固定五个线程来执行任务
    private AsyncImageLoader asyncImageLoader = new AsyncImageLoader();
    private AsyncImageLoader3 asyncImageLoader3 = new AsyncImageLoader3();

 

 @Override
 public void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  setContentView(R.layout.main);
  
//  loadImage("http://www.chinatelecom.com.cn/images/logo_new.gif", R.id.image1);
//  loadImage("http://www.baidu.com/img/baidu_logo.gif", R.id.image2);
//  loadImage("http://cache.soso.com/30d/img/web/logo.gif", R.id.image3);
//        loadImage("http://www.baidu.com/img/baidu_logo.gif", R.id.image4);
//  loadImage("http://cache.soso.com/30d/img/web/logo.gif", R.id.image5);

        loadImage2("http://www.chinatelecom.com.cn/images/logo_new.gif", R.id.image1);
  loadImage2("http://www.baidu.com/img/baidu_logo.gif", R.id.image2);
  loadImage2("http://cache.soso.com/30d/img/web/logo.gif", R.id.image3);
        loadImage2("http://www.baidu.com/img/baidu_logo.gif", R.id.image4);
  loadImage2("http://cache.soso.com/30d/img/web/logo.gif", R.id.image5);
//        loadImage3("http://www.chinatelecom.com.cn/images/logo_new.gif", R.id.image1);
//  loadImage3("http://www.baidu.com/img/baidu_logo.gif", R.id.image2);
//  loadImage3("http://cache.soso.com/30d/img/web/logo.gif", R.id.image3);
//        loadImage3("http://www.baidu.com/img/baidu_logo.gif", R.id.image4);
//  loadImage3("http://cache.soso.com/30d/img/web/logo.gif", R.id.image5);

//        loadImage4("http://www.chinatelecom.com.cn/images/logo_new.gif", R.id.image1);
//  loadImage4("http://www.baidu.com/img/baidu_logo.gif", R.id.image2);
//  loadImage4("http://cache.soso.com/30d/img/web/logo.gif", R.id.image3);
//        loadImage4("http://www.baidu.com/img/baidu_logo.gif", R.id.image4);
//  loadImage4("http://cache.soso.com/30d/img/web/logo.gif", R.id.image5);

//        loadImage5("http://www.chinatelecom.com.cn/images/logo_new.gif", R.id.image1);
//        //为了测试缓存而模拟的网络延时
//        SystemClock.sleep(2000);
//  loadImage5("http://www.baidu.com/img/baidu_logo.gif", R.id.image2);
//        SystemClock.sleep(2000);
//  loadImage5("http://cache.soso.com/30d/img/web/logo.gif", R.id.image3);
//        SystemClock.sleep(2000);
//        loadImage5("http://www.baidu.com/img/baidu_logo.gif", R.id.image4);
//        SystemClock.sleep(2000);
//  loadImage5("http://cache.soso.com/30d/img/web/logo.gif", R.id.image5);
//        SystemClock.sleep(2000);
//         loadImage5("http://www.baidu.com/img/baidu_logo.gif", R.id.image4);
 }

 @Override
 protected void onDestroy() {
  executorService.shutdown();
  super.onDestroy();
 }
    //线程加载图像基本原理
    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(), "image.png");
                    } catch (IOException e) {
                    }
                    ((ImageView) LazyLoadImageActivity.this.findViewById(id)).setImageDrawable(drawable);
                }
            });
    }
     //采用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(), "image.png");
                    } catch (IOException e) {
                    }

                Message message= handler2.obtainMessage() ;
                 message.arg1 = id;
                 message.obj = drawable;
                 handler2.sendMessage(message);
             }
         };
         thread.start();
         thread = null;
    }
    // 引入线程池来管理多线程
    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(), "image.png");
                    handler.post(new Runnable() {

                        public void run() {
                            ((ImageView) LazyLoadImageActivity.this.findViewById(id)).setImageDrawable(drawable);
                        }
                    });
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            }
        });
    }
    //引入线程池,并引入内存缓存功能,并对外部调用封装了接口,简化调用过程
    private void loadImage4(final String url, final int id) {
          //如果缓存过就会从缓存中取出图像,ImageCallback接口中方法也不会被执行
         Drawable cacheImage = asyncImageLoader.loadDrawable(url,new AsyncImageLoader.ImageCallback() {
             //请参见实现:如果第一次加载url时下面方法会执行
             public void imageLoaded(Drawable imageDrawable) {
               ((ImageView) findViewById(id)).setImageDrawable(imageDrawable);
             }
         });
        if(cacheImage!=null){
          ((ImageView) findViewById(id)).setImageDrawable(cacheImage);
        }
    }

    //采用Handler+Thread+封装外部接口
    private void loadImage5(final String url, final int id) {
          //如果缓存过就会从缓存中取出图像,ImageCallback接口中方法也不会被执行
         Drawable cacheImage = asyncImageLoader3.loadDrawable(url,new AsyncImageLoader3.ImageCallback() {
             //请参见实现:如果第一次加载url时下面方法会执行
             public void imageLoaded(Drawable imageDrawable) {
               ((ImageView) findViewById(id)).setImageDrawable(imageDrawable);
             }
         });
        if(cacheImage!=null){
                    ((ImageView) findViewById(id)).setImageDrawable(cacheImage);
        }
    }


}

 

xml文件大致如下:

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:layout_width="fill_parent"
              android:orientation="vertical"
              android:layout_height="fill_parent" >
  <ImageView android:id="@+id/image1" android:layout_height="wrap_content" android:layout_width="fill_parent"></ImageView>
   <ImageView android:id="@+id/image2" android:layout_height="wrap_content" android:layout_width="fill_parent"></ImageView>
    <ImageView android:id="@+id/image3" android:layout_height="wrap_content" android:layout_width="fill_parent"></ImageView>
    <ImageView android:id="@+id/image5" android:layout_height="wrap_content" android:layout_width="fill_parent"></ImageView>
    <ImageView android:id="@+id/image4" android:layout_height="wrap_content" android:layout_width="fill_parent"></ImageView>
</LinearLayout>

 

分享到:
评论

相关推荐

    Android 图片异步加载 加载网络图片

    在Android应用开发中,...总之,Android中的图片异步加载是提高用户体验的关键,开发者可以根据项目需求选择合适的库或自定义实现。无论哪种方式,都需要考虑内存管理、缓存策略和错误处理,以确保应用的稳定性和性能。

    Android异步加载图片例子

    在这个"Android异步加载图片例子"中,我们将探讨如何在Android应用中实现这一功能。 首先,我们需要理解Android的主线程(UI线程)与工作线程的区别。主线程负责处理用户界面交互,而工作线程则用于执行耗时操作,...

    Android 演示异步加载图片的实现 附源代码.rar

    Android 演示异步加载图片的实现 附源代码,这里主要是演示ListView的异步加载图片功能,异步加载一个view时,如果view里面有EditText,EditText在每次加载view都会触发焦点,这时候异步就会出错。可能我这样说不太...

    Android图片异步加载-ListView、GridView、ViewPager

    总的来说,Android-Universal-Image-Loader为Android开发者提供了一种高效、灵活的图片异步加载解决方案,无论是ListView、GridView还是ViewPager,都可以通过其强大的功能提升用户体验。在实际开发中,掌握这个库的...

    android Gridview 异步加载网络图片

    2. ** 异步加载图片的重要性** - 直接在主线程加载网络图片会导致应用卡顿,用户体验下降,因为主线程负责处理用户交互和UI更新。 - 异步加载是在后台线程执行耗时操作,如下载和解码图片,然后在主线程更新UI,...

    Android实现ListView异步加载图片

    "Android实现ListView异步加载图片" Android 实现 ListView 异步加载图片是一种常见的技术,旨在提高应用程序的性能和用户体验。本文将详细介绍 Android 中实现 ListView 异步加载图片的方法,并对相关的技术概念...

    Android 异步加载图片实现_图片缓存.zip

    综上所述,Android异步加载图片和缓存策略是提升应用性能的关键技术。通过合理使用工作线程和缓存机制,可以显著改善用户体验,降低系统负载。在实际开发中,选择合适的图片加载库,并结合最佳实践,能够帮助我们...

    Android AsyncTask用法和异步加载图片.rar

    本资料包主要讲解了如何使用`AsyncTask`进行异步加载图片,这对于在UI线程中保持流畅用户体验至关重要。 `AsyncTask`是Android SDK中的一个类,它为开发者提供了简单的多线程和回调功能。它的核心思想是将长时间...

    使用Android Studio 练习RecyclerView 异步加载图片,解决图片乱序问题。

    然而,在实际开发中,当我们需要在RecyclerView中异步加载图片时,可能会遇到图片显示乱序的问题。本文将深入探讨这个问题及其解决方案。 首先,我们来理解为什么会出现图片乱序的现象。这是因为RecyclerView在滚动...

    android listView图片异步加载(拖动时不加载,双缓存)

    因此,我们需要采用异步加载图片的方式,同时为了优化性能,通常会采用双缓存策略。本文将详细介绍如何在ListView中实现图片的异步加载,并且在用户拖动时不加载,以提高滚动流畅性。 一、异步加载原理 异步加载是...

    android listView 异步加载图片

    这里的“android listView 异步加载图片”指的是在不阻塞UI线程的情况下,从网络、本地存储或其他来源加载图片到ListView中的技术。 这篇名为“ImageLoader”的Java文件很可能就是一个实现图片异步加载的工具类。在...

    Android Listview异步加载图片

    本文将深入探讨Android ListView中异步加载图片的策略、常见问题以及解决方案。 首先,我们要理解异步加载的基本原理。异步加载是指在后台线程中执行耗时操作,如加载图片,而主线程则继续处理用户交互,保证界面...

    android TextView异步加载HTML(含图片)

    这个类通常会异步加载图片,防止阻塞UI线程。`URLImageParser`接收一个`TextView`对象作为参数,这样它就可以在加载图片完成后将`Drawable`设置到对应的`TextView`位置。 以下是一个简化的`URLImageParser`类的实现...

    Android App中实现图片异步加载的实例分享

    3. **CustomAdapter**:Adapter类需要实现异步加载图片的功能。每个ImageView对应的图片加载任务可以通过AsyncTask或者Loader API来异步处理。在任务完成时,使用主线程的Handler更新对应的ImageView。 ```java ...

    Android 图片异步加载

    本话题将深入探讨Android图片异步加载的原理、实现方式以及常见工具库。 首先,理解异步加载的基本概念。在Android中,主线程负责更新UI,而网络请求或文件读写等耗时操作应该在后台线程进行。图片异步加载就是将...

    android图片异步加载

    首先,我们要理解为什么需要异步加载图片。在Android中,如果在主线程执行耗时操作,如网络请求或大图解码,将会阻塞UI更新,导致用户界面无响应。为了解决这个问题,开发者通常会在后台线程执行这些操作,然后在...

    android 图片异步加载

    本篇文章将深入探讨图片异步加载的概念、原理以及在Android中的实现方法。 首先,我们要理解什么是异步加载。在计算机编程中,同步操作意味着一个任务执行完毕后才会进行下一个任务,而异步则允许同时执行多个任务...

    Android中实现异步加载图片的Demo

    这个"Android中实现异步加载图片的Demo"展示了如何在Android应用中高效地加载和显示图片,无论是从本地存储还是网络URL获取。 首先,我们需要理解Android主线程与工作线程的概念。主线程负责用户界面的交互,而工作...

    图片异步加载,照片墙,异步加载listview图片2

    因此,异步加载图片是必要的,它可以在后台线程中处理图片下载和解码工作,保持UI流畅。 2. ListView与异步加载: ListView是一个常用的组件,用于展示可滚动的列表数据。每个列表项可能包含图片。当用户滚动时,...

Global site tag (gtag.js) - Google Analytics