Android异步下载图片并且缓存图片到本地

http://lishuaishuai.iteye.com/blog/1806667

在Android开发中我们经常有这样的需求，从服务器上下载xml或者JSON类型的数据，其中包括一些图片资源，本demo模拟了这个需求，从网络上加载XML资源，其中包括图片，我们要做的解析XML里面的数据，并且把图片缓存到本地一个cache目录里面，并且用一个自定义的Adapter去填充到LIstView，demo运行效果见下图：

通过这个demo，要学会有一下几点

1.怎么解析一个XML

2.demo中用到的缓存图片到本地一个临时目录的思想是怎样的？

3.AsyncTask类的使用，因为要去异步的加载数据，就必须开启线程，但是在开启线程的时有时候不能很好的控制线程的数量，线程数量太大的时候手机会很快被卡死 这里就采用AsynsTask类的去解决这个问题，这个类里面封装了线程池的技术，从而保证不会因开启过多的线程而消耗太多的资源

4.本demo中的Handler类的使用情况 5.自定义adapter的使用 

下面是demo中的Activity。

Java代码  

  1. public class MainActivity extends Activity {  
  2.     protected static final int SUCCESS_GET_CONTACT = 0;  
  3.     private ListView mListView;  
  4.     private MyContactAdapter mAdapter;  
  5.     private File cache;  
  6.       
  7.     private Handler mHandler = new Handler(){  
  8.         public void handleMessage(android.os.Message msg) {  
  9.             if(msg.what == SUCCESS_GET_CONTACT){  
  10.                 List<Contact> contacts = (List<Contact>) msg.obj;  
  11.                 mAdapter = new MyContactAdapter(getApplicationContext(),contacts,cache);  
  12.                 mListView.setAdapter(mAdapter);  
  13.             }  
  14.         };  
  15.     };  
  16.       
  17.     @Override  
  18.     public void onCreate(Bundle savedInstanceState) {  
  19.         super.onCreate(savedInstanceState);  
  20.         setContentView(R.layout.main);  
  21.           
  22.         mListView = (ListView) findViewById(R.id.listview);  
  23.           
  24.         //创建缓存目录，系统一运行就得创建缓存目录的，  
  25.         cache = new File(Environment.getExternalStorageDirectory(), "cache");  
  26.           
  27.         if(!cache.exists()){  
  28.             cache.mkdirs();  
  29.         }  
  30.           
  31.         //获取数据，主UI线程是不能做耗时操作的，所以启动子线程来做  
  32.         new Thread(){  
  33.             public void run() {  
  34.                 ContactService service = new ContactService();  
  35.                 List<Contact> contacts = null;  
  36.                 try {  
  37.                     contacts = service.getContactAll();  
  38.                 } catch (Exception e) {  
  39.                     e.printStackTrace();  
  40.                 }  
  41.                 //子线程通过Message对象封装信息，并且用初始化好的，  
  42.                 //Handler对象的sendMessage()方法把数据发送到主线程中，从而达到更新UI主线程的目的  
  43.                 Message msg = new Message();  
  44.                 msg.what = SUCCESS_GET_CONTACT;  
  45.                 msg.obj = contacts;  
  46.                 mHandler.sendMessage(msg);  
  47.             };  
  48.         }.start();  
  49.     }  
  50.       
  51.     @Override  
  52.     protected void onDestroy() {  
  53.         super.onDestroy();  
  54.         //清空缓存  
  55.         File[] files = cache.listFiles();  
  56.         for(File file :files){  
  57.             file.delete();  
  58.         }  
  59.         cache.delete();  
  60.     }  
  61. }  

 Activity中，注意以下几点，

1.初始化了一个缓存目录，这个目录最好是应用开启就去创建好，为手续缓存图片做准备，在这里把数据存放在SDCard上

2.要去服务器加载数据，这个耗时操作最好是去开启线程加载数据，加载完毕后去异步的更新UI线程，利用Handler机制能很好的解决这个问题，

3.最后退出应用的时候，要删掉缓存目录和目录里面的数据，避免给手机制造很多的垃圾文件

 

下面就是一个Service类了，

Java代码  

  1. public class ContactService {  
  2.   
  3.     /* 
  4.      * 从服务器上获取数据 
  5.      */  
  6.     public List<Contact> getContactAll() throws Exception {  
  7.         List<Contact> contacts = null;  
  8.         String Parth = "http://192.168.1.103:8080/myweb/list.xml";  
  9.         URL url = new URL(Parth);  
  10.         HttpURLConnection conn = (HttpURLConnection) url.openConnection();  
  11.         conn.setConnectTimeout(3000);  
  12.         conn.setRequestMethod("GET");  
  13.         if (conn.getResponseCode() == HttpURLConnection.HTTP_OK) {  
  14.             InputStream is = conn.getInputStream();  
  15.             // 这里获取数据直接放在XmlPullParser里面解析  
  16.             contacts = xmlParser(is);  
  17.             return contacts;  
  18.         } else {  
  19.             return null;  
  20.         }  
  21.     }  
  22.   
  23.     // 这里并没有下载图片下来，而是把图片的地址保存下来了  
  24.     private List<Contact> xmlParser(InputStream is) throws Exception {  
  25.         List<Contact> contacts = null;  
  26.         Contact contact = null;  
  27.         XmlPullParser parser = Xml.newPullParser();  
  28.         parser.setInput(is, "UTF-8");  
  29.         int eventType = parser.getEventType();  
  30.         while ((eventType = parser.next()) != XmlPullParser.END_DOCUMENT) {  
  31.             switch (eventType) {  
  32.             case XmlPullParser.START_TAG:  
  33.                 if (parser.getName().equals("contacts")) {  
  34.                     contacts = new ArrayList<Contact>();  
  35.                 } else if (parser.getName().equals("contact")) {  
  36.                     contact = new Contact();  
  37.                     contact.setId(Integer.valueOf(parser.getAttributeValue(0)));  
  38.                 } else if (parser.getName().equals("name")) {  
  39.                     contact.setName(parser.nextText());  
  40.                 } else if (parser.getName().equals("image")) {  
  41.                     contact.setImage(parser.getAttributeValue(0));  
  42.                 }  
  43.                 break;  
  44.   
  45.             case XmlPullParser.END_TAG:  
  46.                 if (parser.getName().equals("contact")) {  
  47.                     contacts.add(contact);  
  48.                 }  
  49.                 break;  
  50.             }  
  51.         }  
  52.         return contacts;  
  53.     }  
  54.   
  55.     /* 
  56.      * 从网络上获取图片，如果图片在本地存在的话就直接拿，如果不存在再去服务器上下载图片 
  57.      * 这里的path是图片的地址 
  58.      */  
  59.     public Uri getImageURI(String path, File cache) throws Exception {  
  60.         String name = MD5.getMD5(path) + path.substring(path.lastIndexOf("."));  
  61.         File file = new File(cache, name);  
  62.         // 如果图片存在本地缓存目录，则不去服务器下载   
  63.         if (file.exists()) {  
  64.             return Uri.fromFile(file);//Uri.fromFile(path)这个方法能得到文件的URI  
  65.         } else {  
  66.             // 从网络上获取图片  
  67.             URL url = new URL(path);  
  68.             HttpURLConnection conn = (HttpURLConnection) url.openConnection();  
  69.             conn.setConnectTimeout(5000);  
  70.             conn.setRequestMethod("GET");  
  71.             conn.setDoInput(true);  
  72.             if (conn.getResponseCode() == 200) {  
  73.   
  74.                 InputStream is = conn.getInputStream();  
  75.                 FileOutputStream fos = new FileOutputStream(file);  
  76.                 byte[] buffer = new byte[1024];  
  77.                 int len = 0;  
  78.                 while ((len = is.read(buffer)) != -1) {  
  79.                     fos.write(buffer, 0, len);  
  80.                 }  
  81.                 is.close();  
  82.                 fos.close();  
  83.                 // 返回一个URI对象  
  84.                 return Uri.fromFile(file);  
  85.             }  
  86.         }  
  87.         return null;  
  88.     }  
  89. }  

Serivce类中，注意以下几点

1.HttpURLConnection conn = (HttpURLConnection) url.openConnection();获取一个链接，从而进行通讯2.怎么利用XxmlPullPaser类去解析XML，从而把数据封装成对象

3.getImageURI(String path, File cache) 这个方法具体实现

4.Uri.fromFile(file);这个方法能够直接返回一个Uri来

 

下面是自定义的Adapter类，

Java代码  

  1. public class MyContactAdapter extends BaseAdapter {  
  2.   
  3.     protected static final int SUCCESS_GET_IMAGE = 0;  
  4.     private Context context;  
  5.     private List<Contact> contacts;  
  6.     private File cache;  
  7.     private LayoutInflater mInflater;  
  8.   
  9.     // 自己定义的构造函数  
  10.     public MyContactAdapter(Context context, List<Contact> contacts, File cache) {  
  11.         this.context = context;  
  12.         this.contacts = contacts;  
  13.         this.cache = cache;  
  14.   
  15.         mInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);  
  16.     }  
  17.   
  18.     @Override  
  19.     public int getCount() {  
  20.         return contacts.size();  
  21.     }  
  22.   
  23.     @Override  
  24.     public Object getItem(int position) {  
  25.         return contacts.get(position);  
  26.     }  
  27.   
  28.     @Override  
  29.     public long getItemId(int position) {  
  30.         return position;  
  31.     }  
  32.   
  33.     @Override  
  34.     public View getView(int position, View convertView, ViewGroup parent) {  
  35.         // 1获取item,再得到控件  
  36.         // 2 获取数据  
  37.         // 3绑定数据到item  
  38.         View view = null;  
  39.         if (convertView != null) {  
  40.             view = convertView;  
  41.         } else {  
  42.             view = mInflater.inflate(R.layout.item, null);  
  43.         }  
  44.   
  45.         ImageView iv_header = (ImageView) view.findViewById(R.id.iv_header);  
  46.         TextView tv_name = (TextView) view.findViewById(R.id.tv_name);  
  47.   
  48.         Contact contact = contacts.get(position);  
  49.   
  50.         // 异步的加载图片 (线程池 + Handler ) ---> AsyncTask  
  51.         asyncloadImage(iv_header, contact.image);  
  52.         tv_name.setText(contact.name);  
  53.   
  54.         return view;  
  55.     }  
  56.   
  57.     private void asyncloadImage(ImageView iv_header, String path) {  
  58.         ContactService service = new ContactService();  
  59.         AsyncImageTask task = new AsyncImageTask(service, iv_header);  
  60.         task.execute(path);  
  61.     }  
  62.   
  63.     private final class AsyncImageTask extends AsyncTask<String, Integer, Uri> {  
  64.   
  65.         private ContactService service;  
  66.         private ImageView iv_header;  
  67.   
  68.         public AsyncImageTask(ContactService service, ImageView iv_header) {  
  69.             this.service = service;  
  70.             this.iv_header = iv_header;  
  71.         }  
  72.   
  73.         // 后台运行的子线程子线程  
  74.         @Override  
  75.         protected Uri doInBackground(String... params) {  
  76.             try {  
  77.                 return service.getImageURI(params[0], cache);  
  78.             } catch (Exception e) {  
  79.                 e.printStackTrace();  
  80.             }  
  81.             return null;  
  82.         }  
  83.   
  84.         // 这个放在在ui线程中执行  
  85.         @Override  
  86.         protected void onPostExecute(Uri result) {  
  87.             super.onPostExecute(result);   
  88.             // 完成图片的绑定  
  89.             if (iv_header != null && result != null) {  
  90.                 iv_header.setImageURI(result);  
  91.             }  
  92.         }  
  93.     }  
  94.   
  95.     /** 
  96.      * 采用普通方式异步的加载图片 
  97.      */  
  98.     /*private void asyncloadImage(final ImageView iv_header, final String path) { 
  99.         final Handler mHandler = new Handler() { 
  100.             @Override 
  101.             public void handleMessage(Message msg) { 
  102.                 super.handleMessage(msg); 
  103.                 if (msg.what == SUCCESS_GET_IMAGE) { 
  104.                     Uri uri = (Uri) msg.obj; 
  105.                     if (iv_header != null && uri != null) { 
  106.                         iv_header.setImageURI(uri); 
  107.                     } 
  108.  
  109.                 } 
  110.             } 
  111.         }; 
  112.         // 子线程，开启子线程去下载或者去缓存目录找图片，并且返回图片在缓存目录的地址 
  113.         Runnable runnable = new Runnable() { 
  114.             @Override 
  115.             public void run() { 
  116.                 ContactService service = new ContactService(); 
  117.                 try { 
  118.                     //这个URI是图片下载到本地后的缓存目录中的URI 
  119.                     Uri uri = service.getImageURI(path, cache); 
  120.                     Message msg = new Message(); 
  121.                     msg.what = SUCCESS_GET_IMAGE; 
  122.                     msg.obj = uri; 
  123.                     mHandler.sendMessage(msg); 
  124.                 } catch (Exception e) { 
  125.                     e.printStackTrace(); 
  126.                 } 
  127.             } 
  128.         }; 
  129.         new Thread(runnable).start(); 
  130.     }*/  
  131. }  

自定义Adapter中，我们要注意 AsyncImageTask这个类继承了AsyncTask类，AsyncTask是Android中常用来做异步任务的类，对线程池进行了封装，详细分析稍后再贴出一篇Blog。

 

下面是我们从服务器上获取并且解析的Xml文件

Xml代码  

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <contacts>  
  3.     <contact id="1">  
  4.         <name>张飞</name>  
  5.         <image src="http://192.168.1.103:8080/mymyweb/images/1.gif"/>  
  6.     </contact>  
  7.     <contact id="2">  
  8.         <name>博文</name>  
  9.         <image src="http://192.168.1.103:8080/myweb/images/2.gif"/>  
  10.     </contact>      
  11.     <contact id="3">  
  12.         <name>张天佑</name>  
  13.         <image src="http://192.168.1.103:8080/myweb/images/3.gif"/>  
  14.     </contact>          
  15.     <contact id="4">  
  16.         <name>松德</name>  
  17.         <image src="http://192.168.1.103:8080/myweb/images/4.gif"/>  
  18.     </contact>          
  19.     <contact id="5">  
  20.         <name>赵薇</name>  
  21.         <image src="http://192.168.1.103:8080/myweb/images/5.gif"/>  
  22.     </contact>  
  23.     <contact id="6">  
  24.         <name>李静</name>  
  25.         <image src="http://192.168.1.103:8080/myweb/images/6.gif"/>  
  26.     </contact>      
  27.     <contact id="7">  
  28.         <name>李明</name>  
  29.         <image src="http://192.168.1.103:8080/myweb/images/7.gif"/>  
  30.     </contact>          
  31.     <contact id="8">  
  32.         <name>黎明</name>  
  33.         <image src="http://192.168.1.103:8080/myweb/images/8.gif"/>  
  34.     </contact>          
  35.       
  36.     <contact id="9">  
  37.         <name>秦桧</name>  
  38.         <image src="http://192.168.1.103:8080/myweb/images/9.gif"/>  
  39.     </contact>  
  40.     <contact id="10">  
  41.         <name>朱德</name>  
  42.         <image src="http://192.168.1.103:8080/myweb/images/10.gif"/>  
  43.     </contact>      
  44.     <contact id="11">  
  45.         <name>冯巩</name>  
  46.         <image src="http://192.168.1.103:8080/myweb/images/11.gif"/>  
  47.     </contact>          
  48.     <contact id="12">  
  49.         <name>dylan</name>  
  50.         <image src="http://192.168.1.103:8080/myweb/images/12.gif"/>  
  51.     </contact>          
  52.     <contact id="13">  
  53.         <name>黄单</name>  
  54.         <image src="http://192.168.1.103:8080/myweb/images/13.gif"/>  
  55.     </contact>  
  56.     <contact id="14">  
  57.         <name>含蕊</name>  
  58.         <image src="http://192.168.1.103:8080/myweb/images/14.gif"/>  
  59.     </contact>      
  60.     <contact id="15">  
  61.         <name>欣琪</name>  
  62.         <image src="http://192.168.1.103:8080/myweb/images/15.jpg"/>  
  63.     </contact>          
  64.     <contact id="16">  
  65.         <name>李忠华</name>  
  66.         <image src="http://192.168.1.103:8080/myweb/images/16.jpg"/>  
  67.     </contact>      
  68.     <contact id="17">  
  69.         <name>方产员</name>  
  70.         <image src="http://192.168.1.103:8080/myweb/images/17.jpg"/>  
  71.     </contact>          
  72.     <contact id="18">  
  73.         <name>张光</name>  
  74.         <image src="http://192.168.1.103:8080/myweb/images/18.jpg"/>  
  75.     </contact>      
  76. </contacts>  

 

本demo中为了安全起见，还对下载下来的图片的文件名进行了MD5加密，下面是MD5加密的代码，

Java代码  

  1. public class MD5 {  
  2.   
  3.     public static String getMD5(String content) {  
  4.         try {  
  5.             MessageDigest digest = MessageDigest.getInstance("MD5");  
  6.             digest.update(content.getBytes());  
  7.             return getHashString(digest);  
  8.               
  9.         } catch (NoSuchAlgorithmException e) {  
  10.             e.printStackTrace();  
  11.         }  
  12.         return null;  
  13.     }  
  14.       
  15.     private static String getHashString(MessageDigest digest) {  
  16.         StringBuilder builder = new StringBuilder();  
  17.         for (byte b : digest.digest()) {  
  18.             builder.append(Integer.toHexString((b >> 4) & 0xf));  
  19.             builder.append(Integer.toHexString(b & 0xf));  
  20.         }  
  21.         return builder.toString();  
  22.     }  
  23. }  

 以上省略了Contact.java这个domain类，通过这个demo，可以看出Android中会经常需要进行异步任务的处理，所以我们会常常用到自己手动开启线程，handler机制，或者AsyncTask类等手段来保证应用的性能。

时间： 2024-10-31 23:00:24

Android异步下载图片并且缓存图片到本地的相关文章

Android异步下载图片并且缓存图片到本地DEMO详解

在Android开发中我们经常有这样的需求,从服务器上下载xml或者JSON类型的数据,其中包括一些图片资源,本demo模拟了这个需求,从网络上加载XML资源,其中包括图片,我们要做的解析XML里面的数据,并且把图片缓存到本地一个cache目录里面,并且用一个自定义的Adapter去填充到LIstView,demo运行效果见下图: 通过这个demo,要学会有一下几点 1.怎么解析一个XML 2.demo中用到的缓存图片到本地一个临时目录的思想是怎样的? 3.AsyncTask类的使用,因为要去异

Android异步加载数据和图片的保存思路详解_Android

把从网络获取的图片数据保存在SD卡上, 先把权限都加上 网络权限 android.permission.INTERNET SD卡读写权限 android.permission.MOUNT_UNMOUNT_FILESYSTEMS android.permission.WRITE_EXTERNAL_STORAGE 总体布局 写界面,使用ListView,创建条目的布局文件,水平摆放的ImageView TextView 在activity中获取到ListView对象,调用setAdapter()方法

Android异步下载网络图片

项目中有时候需要获取网络上的图片,并下载下来到手机客户端显示.怎么做呢? 实现思路是:  1:在UI线程中启动一个线程,让这个线程去下载图片.  2:图片完成下载后发送一个消息去通知UI线程  2:UI线程获取到消息后,更新UI.  这里的UI线程就是主线程.  这两个步骤涉及到一些知识点,即是:ProgressDialog,Handler,Thread/Runnable,URL,HttpURLConnection等等一系列东东的使用.  现在让我们开始来实现这个功能吧!  第一步:新建项

Android 异步加载图片，使用LruCache和SD卡或手机缓存，效果非常的流畅

异步加载图片的例子,网上也比较多,大部分用了HashMap<String, SoftReference<Drawable>> imageCache ,但是现在已经不再推荐使用这种方式了,因为从 Android 2.3 (API Level 9)开始,垃圾回收器会更倾向于回收持有软引用或弱引用的对象,这让软引用和弱引用变得不再可靠.另外,Android 3.0 (API Level 11)中,图片的数据会存储在本地的内存当中,因而无法用一种可预见的方式将其释放,这就有潜在的风险造成应

Android实现图片异步加载并缓存到本地_Android

在android应用开发的时候,加载网络图片是一个非常重要的部分,很多图片不可能放在本地,所以就必须要从服务器或者网络读取图片. 软引用是一个现在非常流行的方法,用户体验比较好,不用每次都需要从网络下载图片,如果下载后就存到本地,下次读取时首先查看本地有没有,如果没有再从网络读取. 下面就分享一下异步加载网络图片的方法吧. FileCache.java import java.io.File; import android.content.Context; public class FileCa

Android程序开发ListView+Json+异步网络图片加载+滚动翻页的例子（图片能缓存，图片不错乱）_Android

例子中用于解析Json的Gson请自己Google下载 主Activity: package COM.Example.Main; import java.util.HashMap; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.Map; import COM.Example.Main.R; import COM.Example.Main.stringG

[Android]异步加载图片，内存缓存，文件缓存，imageview显示图片时增加淡入淡出动画

以下内容为原创,欢迎转载,转载请注明 来自天天博客:http://www.cnblogs.com/tiantianbyconan/p/3574131.html  这个可以实现ImageView异步加载图片,内存缓存,文件缓存,imageview显示图片时增加淡入淡出动画. github地址:https://github.com/wangjiegulu/ImageLoaderSample 解决了: 1. listview加载oom问题 2. listview加载时卡顿的现象 3. listview

android异步加载图片并缓存到本地实现方法

在android项目中访问网络图片是非常普遍性的事情,如果我们每次请求都要访问网络来获取图片,会非常耗费流量,而且图片占用内存空间也比较大,图片过多且不释放的话很容易造成内存溢出.针对上面遇到的两个问题,首先耗费流量我们可以将图片第一次加载上面缓存到本地,以后如果本地有就直接从本地加载.图片过多造成内存溢出,这个是最不容易解决的,要想一些好的缓存策略,比如大图片使用LRU缓存策略或懒加载缓存策略.今天首先介绍一下本地缓存图片. 首先看一下异步加载缓存本地代码: 复制代码 代码如下: public

Android实现图片异步加载并缓存到本地

在android应用开发的时候,加载网络图片是一个非常重要的部分,很多图片不可能放在本地,所以就必须要从服务器或者网络读取图片. 软引用是一个现在非常流行的方法,用户体验比较好,不用每次都需要从网络下载图片,如果下载后就存到本地,下次读取时首先查看本地有没有,如果没有再从网络读取. 下面就分享一下异步加载网络图片的方法吧. FileCache.java import java.io.File; import android.content.Context; public class FileCa