android-----带你一步一步优化ListView(二)

    上一篇介绍了通常我们优化ListView的方式,但是这点对于要加载大量图片的ListView来说显然是不够的,因为我们知道要想获取一张图片不管是本地的还是网络的,其性能上均没有从内存中获取快,所以为了提升用户的体验度,对于加载图片的ListView,通常我们会通过缓存做以下优化:

         基本思想:

         (1)如果想要加载图片,首先先去内存缓存中查看是否有图片(内存缓存)

         (2)如果内存缓存中没有,就会去本地SD卡上查找是否存在(SD卡缓存)

         (3)如果本地SD卡上也没有的话,则会去网络下载了,下载完成之后将该图片存入本地缓存和内存缓存;

         这篇主要从本地缓存角度介绍优化ListView显示图片的方法,接下来的几篇再从内存缓存以及本地缓存和内存缓存相结合的角度来优化ListView显示图片;

         这里的本地缓存指的就是DiskLruCache,当缓存区已经满的时候他采用最近最少使用算法来替换其中的内容,当然对于本地缓存来说,这点并不是主要考虑的对象,因为毕竟SD卡的容量还是挺大的吧;

         要想使用DiskLruCache,我们需要在工程中引入DiskLruCache.java文件,虽然DiskLruCache是谷歌推荐的,但是并不是谷歌开发的,下载链接

         在正式使用之前,我们先来说说使用DiskLruCache的步骤:

        (1)首先当然是创建DiskLruCache对象了,因为DiskLruCache的构造函数是私有的,所以我们不能直接new出来他的实例,但是他提供了一个public static 类型的open方法,在这个方法里面是有通过new来创建DiskLruCache实例的,所以我们可以通过open方法的返回值来获得一个DiskLruCache对象;

        (2)接着我们来看看要想调用open方法需要哪些参数吧

[java] view plain copy
  1. /** 
  2.      * Opens the cache in {@code directory}, creating a cache if none exists 
  3.      * there. 
  4.      * 
  5.      * @param directory a writable directory 
  6.      * @param appVersion 
  7.      * @param valueCount the number of values per cache entry. Must be positive. 
  8.      * @param maxSize the maximum number of bytes this cache should use to store 
  9.      * @throws java.io.IOException if reading or writing the cache directory fails 
  10.      */  
  11.     public static DiskLruCache open(File directory, int appVersion, int valueCount, long maxSize)  
        官方注释已经写的很清楚了:

        第一个参数directory指的是一个可写的目录,如果有SD卡或者SD卡不可移除的话,通常通过context.getExternalCacheDir().getPath()获取,对应的SD卡路径是/sdcard/Android/data/包名/cache,如果没有SD卡的话,通常通过context.getCacheDir().getPath()获取,对应获取到的路径是/data/data/包名/cache;

        第二个参数是app的版本号,因为我们对于图片数据的缓存很大程度上是与app的版本号有关系的,当app的版本发生更新的时候DiskLruCache会默认先删除先前所缓存的内容,其实这点是很好理解的,因为新版本会有新功能加入,而新的功能会有不同的布局内容,之前缓存的图片及视频语音之类的可能已经不再能适应新版本的界面要求啦!

        第三个参数指的是同一个key值所对应的所对应的缓存文件的个数,这个值只能是正数;

        第四个参数指的是缓存区的最大字节数,当然你不能指定成大于SD卡的容量了;

        (3)很多人会发现你的app安装目录下会多好多名字奇怪的文件,然而你还打不开这些文件,别担心,那些就是缓存文件了,这些文件中有一个名字为journal,这类似于我们通常程序中的日志文件,这个文件是在open方法调用DiskLruCache构造函数的时候创建的,他记录了我们对缓存的种种操作,不信我打开一个你看看:

                                                

        第一行表示我们使用的是DiskLruCache

        第二行是DiskLruCache的版本,目前来说是恒为1的

        第三行是app的版本,这个值就是上面open方法传入的第二个参数了

        第四行是空行,用来分开头部和主体部分

        第五行DIRTY表示后面这个名字的文件是个脏数据文件,每当我们调用DiskLruCache的edit方法的时候都会写入一条DIRTY信息

        第六行CLEAN表示后面这个名字的文件已经成为了缓存文件,每当我们调用DiskLruCache的commit方法之后都会在journal文件中加入这么一条记录

        有时候你还会看到开头是REMOVE名字的一行,这是在调用DiskLruCache abort方法的时候写入日志的一条记录

        (4)好了,现在有了DiskLruCache对象了,通过他我们可以获取到Editor对象,他是DiskLruCache的内部类,注意这个才是真正写缓存的对象,我们可以通过他的commit、abort、close、flush等方法来进行写缓存操作

        (5)有了写缓存的介绍,那么读缓存呢?读缓存是通过Snapshot来完成的,同样,他也是DiskLruCache的内部类

        好了,DiskLruCache的大致操作过程介绍完毕了,接下来通过实例来完成带有本地缓存的ListView加载图片:

        首先定义Activity布局文件listView.xml,用来显示ListView

[java] view plain copy
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  3.     android:layout_width="match_parent"  
  4.     android:layout_height="match_parent"  
  5.     android:orientation="vertical" >  
  6.     <ListView   
  7.         android:id="@+id/listView"  
  8.         android:layout_width="match_parent"  
  9.         android:layout_height="match_parent">  
  10.     </ListView>  
  11. </LinearLayout>  
        接着定义ListView中每个item的布局文件item.xml

[java] view plain copy
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  3.     android:layout_width="match_parent"  
  4.     android:layout_height="match_parent"  
  5.     android:orientation="vertical" >  
  6.     <ImageView  
  7.         android:id="@+id/imageView"  
  8.         android:layout_width="50dp"  
  9.         android:layout_height="50dp"  
  10.         />  
  11.     <TextView  
  12.         android:id="@+id/textView"  
  13.         android:layout_width="100dp"  
  14.         android:layout_height="50dp"  
  15.         android:layout_toRightOf="@id/imageView"  
  16.         android:layout_marginTop="20dp"  
  17.         android:layout_marginRight="70dp"  
  18.         />  
  19. </RelativeLayout>  

        上面两个布局文件都很好理解,在此不做过多解释;

        因为创建DiskLruCache需要用到一个可写的目录以及app的版本号,因此我们实现了一个工具类Utils,其中两个方法如下:

[java] view plain copy
  1. /** 
  2.  * 获取磁盘缓存的存储路径 
  3.  * @param context 
  4.  * @param uniqueName 
  5.  * @return 
  6.  */  
  7. public static File getDiskCacheDir(Context context,String uniqueName)  
  8. {  
  9.     String filePath = "";  
  10.     if(Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState()) || !Environment.isExternalStorageRemovable())  
  11.     {  
  12.         //表示SD卡存在或者不可移除  
  13.         try {  
  14.             filePath = context.getExternalCacheDir().getPath();//获得缓存路径  
  15.         } catch (Exception e) {  
  16.             System.out.println(e.toString());  
  17.         }  
  18.     }else  
  19.     {  
  20.         filePath = context.getCacheDir().getPath();  
  21.     }  
  22.     System.out.println(filePath+File.separator+uniqueName);  
  23.     return new File(filePath+File.separator+uniqueName);  
  24. }  
  25.   
  26. /** 
  27.  * 获取app的版本号 
  28.  * @param context 
  29.  */  
  30. public static int getAppVersion(Context context)  
  31. {  
  32.     PackageInfo info;  
  33.     try {  
  34.         info = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);  
  35.         return info.versionCode;  
  36.     } catch (NameNotFoundException e) {  
  37.         e.printStackTrace();  
  38.     }  
  39.     return 1;  
  40. }  
        getDiskCacheDir用于生成需要将缓存文件存储的地方,getAppVersion用于获得app的版本号;

        接下来就是最关键的ListViewAdapter了,代码有点长,先贴出来再解释:

[java] view plain copy
  1. public class ListViewAdapter extends BaseAdapter{  
  2.       
  3.     public List<String> list;  
  4.     public DiskLruCache diskCache;  
  5.     public LayoutInflater inflater;  
  6.     public ListView listView;  
  7.     public Set<ImageAsyncTask> tasks;  
  8.     public int reqWidth;  
  9.     public int reqHeight;  
  10.       
  11.     public ListViewAdapter() {  
  12.     }  
  13.       
  14.     public ListViewAdapter(Context context,List<String> list,DiskLruCache diskCache,ListView listView,ImageView imageView) {  
  15.         this.list = list;  
  16.         this.diskCache = diskCache;  
  17.         this.inflater = LayoutInflater.from(context);  
  18.         this.listView = listView;  
  19.         tasks = new HashSet<ImageAsyncTask>();  
  20.         //获得ImageView的宽和高  
  21.         LayoutParams params = imageView.getLayoutParams();  
  22.         this.reqWidth = params.width;  
  23.         this.reqHeight = params.height;  
  24.     }  
  25.       
  26.     @Override  
  27.     public int getCount() {  
  28.         return list.size();  
  29.     }  
  30.   
  31.     @Override  
  32.     public String getItem(int position) {  
  33.         return list.get(position);  
  34.     }  
  35.   
  36.     @Override  
  37.     public long getItemId(int position) {  
  38.         return 0;  
  39.     }  
  40.   
  41.     @Override  
  42.     public View getView(int position, View convertView, ViewGroup parent) {  
  43.         View view = null;  
  44.         ViewHolder holder = null;  
  45.         if(convertView == null)  
  46.         {  
  47.             view = inflater.inflate(R.layout.item, null);  
  48.             holder = new ViewHolder();  
  49.             holder.imageView = (ImageView)view.findViewById(R.id.imageView);  
  50.             holder.textView = (TextView)view.findViewById(R.id.textView);  
  51.             view.setTag(holder);//为了复用holder  
  52.         }else  
  53.         {  
  54.             view = convertView;  
  55.             holder = (ViewHolder) view.getTag();  
  56.         }  
  57.         //为ImageView设置标志,防止乱序  
  58.         holder.imageView.setTag(position);  
  59.         holder.textView.setTag(position+"#");  
  60.         return view;  
  61.     }  
  62.       
  63.     /** 
  64.      * 加载图片 
  65.      * @param url 
  66.      * @param key 
  67.      * @param holder 
  68.      */  
  69.     public void loadImage(String url,String key,final int index)  
  70.     {  
  71.         //查看DiskLruCache缓存中是否存在对应key值得缓存文件,如果存在的话,则直接从缓存中取出图片即可,如果不存在的话,则需要从网络中加载,加载完成同时写到缓存中  
  72.         //读缓存是通过DiskLruCache的Snaphot来实现的  
  73.         final ImageView imageView;  
  74.         final TextView textView;  
  75.         DiskLruCache.Snapshot snapshot = null;  
  76.         FileInputStream  in = null;  
  77.         Bitmap bitmap = null;  
  78.         try {  
  79.             snapshot = diskCache.get(key);  
  80.             if(snapshot != null)  
  81.             {  
  82.                 imageView = (ImageView)listView.findViewWithTag(index);  
  83.                 textView = (TextView)listView.findViewWithTag(index+"#");  
  84.                 //非空表示缓存中存在该缓存文件  
  85.                 //通过Snapshot直接从缓存中取出写入到内存的输入流,随后调用BitmapFactory工厂方法来将其转变成为Bitmap对象显示在ImageView上面,同时将TextView设置为是从缓存中读取的数据  
  86.                 in = (FileInputStream) snapshot.getInputStream(0);//这里的0指的是key对应的第1个缓存文件,因为在创建DiskLruCache的时候,第三个参数我们会用来输入一个key对应几个缓存文件,之前我们创建的DiskLruCache的第三个参数输入的是1  
  87.                 //对流中的图片进行压缩处理操作  
  88.                 bitmap = decodeSampleBitmapFromStream(in, reqWidth, reqHeight);  
  89.                 if(imageView != null)  
  90.                     imageView.setImageBitmap(bitmap);  
  91.                 if(textView != null)  
  92.                     textView.setText("从缓存中获取的");  
  93.             }else  
  94.             {  
  95.                 //否则的话需要开启线程,从网络中获取图片,获取成功后返回该图片,并且将其设置为ImageView显示的图片,同时将TextView的值设置成是从网络中获取的  
  96.                 //这里我们使用的是AsyncTask,因为可以很方便的获取到我们要的图片,当然也可以通过Handler的方式来获取图片  
  97.                 ImageAsyncTask task = new ImageAsyncTask(listView,diskCache,index);  
  98.                 task.setOnImageLoadListener(new OnImageLoadListener() {  
  99.                       
  100.                     @Override  
  101.                     public void onSuccessLoad(Bitmap bitmap) {  
  102.                         System.out.println("已经使用的缓存大小:  "+((float)diskCache.size())/(1024*1024)+" M");  
  103.                         System.out.println("加载图片成功.......");  
  104.                     }  
  105.                       
  106.                     @Override  
  107.                     public void onFailureLoad() {  
  108.                         System.out.println("加载图片失败.......");  
  109.                     }  
  110.                 });  
  111.                 tasks.add(task);//将任务加入到线程池中  
  112.                 task.execute(url);//执行加载图片的线程  
  113.             }  
  114.         } catch (Exception e) {  
  115.             e.printStackTrace();  
  116.         }  
  117.     }  
  118.       
  119.     /** 
  120.      * 暂停所有任务(为了防止在滑动的时候仍然有线程处于请求状态) 
  121.      */  
  122.     public void cancelTask()  
  123.     {  
  124.         if(tasks != null)  
  125.         {  
  126.             for(ImageAsyncTask task: tasks)  
  127.                 task.cancel(false);//暂停任务  
  128.         }  
  129.     }  
  130.       
  131.     /** 
  132.      * 对图片进行压缩处理 
  133.      * @param in 
  134.      * @param reqWidth 
  135.      * @param reqHeight 
  136.      * @return 
  137.      */  
  138.     public static Bitmap decodeSampleBitmapFromStream(FileInputStream in,int reqWidth,int reqHeight)  
  139.     {  
  140.         //设置BitmapFactory.Options的inJustDecodeBounds属性为true表示禁止为bitmap分配内存  
  141.         BitmapFactory.Options options = new BitmapFactory.Options();  
  142.         options.inJustDecodeBounds = true;  
  143.         byte[] data = inputStreamToByteArray(in);  
  144.         //这次调用的目的是获取到原始图片的宽、高,但是这次操作是没有写内存操作的  
  145.         Bitmap beforeBitmap = BitmapFactory.decodeByteArray(data, 0, data.length, options);  
  146.         options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);  
  147.         //设置这次加载图片需要加载到内存中  
  148.         options.inJustDecodeBounds = false;  
  149.         Bitmap afterBitmap = BitmapFactory.decodeByteArray(data, 0, data.length, options);  
  150.         return afterBitmap;  
  151.     }  
  152.       
  153.     /** 
  154.      * 计算出压缩比 
  155.      * @param options 
  156.      * @param reqWith 
  157.      * @param reqHeight 
  158.      * @return 
  159.      */  
  160.     public static int calculateInSampleSize(BitmapFactory.Options options,int reqWidth,int reqHeight)  
  161.     {  
  162.         //通过参数options来获取真实图片的宽、高  
  163.         int width = options.outWidth;  
  164.         int height = options.outHeight;  
  165.         int inSampleSize = 1;//初始值是没有压缩的  
  166.         if(width > reqWidth || height > reqHeight)  
  167.         {  
  168.             //计算出原始宽与现有宽,原始高与现有高的比率  
  169.             int widthRatio = Math.round((float)width/(float)reqWidth);  
  170.             int heightRatio = Math.round((float)height/(float)reqHeight);  
  171.             //选出两个比率中的较小值,这样的话能够保证图片显示完全   
  172.             inSampleSize = widthRatio < heightRatio ? widthRatio:heightRatio;  
  173.         }  
  174.         return inSampleSize;  
  175.     }  
  176.       
  177.     /** 
  178.      * 将InputStream转换为Byte数组 
  179.      * @param in 
  180.      * @return 
  181.      */  
  182.     public static byte[] inputStreamToByteArray(InputStream in)  
  183.     {  
  184.         ByteArrayOutputStream outputStream = new ByteArrayOutputStream();  
  185.         byte[] buffer = new byte[1024];  
  186.         int len;  
  187.         try {  
  188.             while((len = in.read(buffer)) != -1)  
  189.             {  
  190.                 outputStream.write(buffer, 0, len);  
  191.             }  
  192.         } catch (IOException e) {  
  193.             e.printStackTrace();  
  194.         }finally{  
  195.             try {  
  196.                 in.close();  
  197.                 outputStream.close();  
  198.             } catch (IOException e) {  
  199.                 e.printStackTrace();  
  200.             }  
  201.         }  
  202.         return outputStream.toByteArray();  
  203.     }  
  204.     static class ViewHolder  
  205.     {  
  206.         ImageView imageView;  
  207.         TextView textView;  
  208.     }  
  209.     //这里为了能够获知ImageAsyncTask网络加载图片成功与否,我们定义了一个接口OnImageLoadListener,里面有两个方法onSuccessLoad  
  210.     //与onFailureLoad,并且通过setOnImageLoadListener来将其绑定到指定的ImageAsyncTask中  
  211.     class ImageAsyncTask extends AsyncTask<String, Void, Bitmap>  
  212.     {  
  213.         public OnImageLoadListener listener;  
  214.         public DiskLruCache diskCache;  
  215.         public int index;  
  216.         public ListView listView;  
  217.           
  218.         public void setOnImageLoadListener(OnImageLoadListener listener)  
  219.         {  
  220.             this.listener = listener;  
  221.         }  
  222.           
  223.         public ImageAsyncTask(ListView listView,DiskLruCache diskCache,int index)  
  224.         {  
  225.             this.listView = listView;  
  226.             this.diskCache = diskCache;  
  227.             this.index = index;  
  228.         }  
  229.         @Override  
  230.         protected Bitmap doInBackground(String... params) {  
  231.             String url = params[0];  
  232.             String key = Utils.md5(url);  
  233.             DiskLruCache.Editor editor;  
  234.             DiskLruCache.Snapshot snapshot;  
  235.             OutputStream out;  
  236.             FileInputStream in;  
  237.             Bitmap bitmap = null;  
  238.             try {  
  239.                 editor = diskCache.edit(key);  
  240.                 out = editor.newOutputStream(0);  
  241.                 if(Utils.downloadToStream(url, out))  
  242.                 {  
  243.                     //写入缓存  
  244.                     editor.commit();  
  245.                 }else  
  246.                 {  
  247.                     editor.abort();  
  248.                 }  
  249.                 diskCache.flush();//刷新到缓存中  
  250.                 //从缓存中将图片转换成Bitmap  
  251.                 snapshot = diskCache.get(key);  
  252.                 if(snapshot != null)  
  253.                 {  
  254.                     in = (FileInputStream) snapshot.getInputStream(0);  
  255.                     bitmap = ListViewAdapter.decodeSampleBitmapFromStream(in, reqWidth, reqHeight);  
  256.                 }  
  257.             } catch (IOException e) {  
  258.                 e.printStackTrace();  
  259.             }  
  260.             return bitmap;  
  261.         }  
  262.   
  263.         @Override  
  264.         protected void onPostExecute(Bitmap result) {  
  265.             if(result != null)  
  266.             {  
  267.                 listener.onSuccessLoad(result);  
  268.                 ImageView imageView = (ImageView) listView.findViewWithTag(index);  
  269.                 TextView textView = (TextView)listView.findViewWithTag(index+"#");  
  270.                 if(imageView != null)  
  271.                     imageView.setImageBitmap(result);  
  272.                 if(textView != null)  
  273.                     textView.setText("从网络获取的");  
  274.             }  
  275.             else  
  276.                 listener.onFailureLoad();  
  277.             tasks.remove(this);//加载结束移除任务(这点要特别注意,加载结束一定要记得移出任务)  
  278.         }  
  279.     }  
  280. }  

        第14行我们在创建ListViewAdapter的时候同时传入了DiskLruCache、ListView和ImageView对象,ImageView对象主要用来获得当前显示图片的ImageView宽和高分别是多少的,这样方便我们压缩图片;

        再看getView,第58,59行这里我们防止图片以及文本乱序,分别对其添加了Tag标志;其他部分就是复用convertView以及viewHolder了,这没什么可以讲的;

        第69行的loadImage用于加载第index位置上的图片,首先第79行,他会利用Snapshot对象去SD卡缓存里面查找是否存在指定key值的图片缓存是否存在,如果存在的话,则通过findViewWithTag获取到对应于index位置的ImageView和TextView对象,并且调用decodeSampleBitmapFromStream对图片进行适当的压缩处理,如果你对图片压缩不是很了解的话,可以看看我的另外一篇博客android-----解决Bitmap内存溢出的一种方法(图片压缩技术),89--92行则判断获得的ImageView和TextView是否为空并且对其进行相应赋值;如果缓存中不存在的话,则开启线程去网络加载图片,同时第111行将该线程加入到Set<ImageAsyncTask>类型的tasks中,便于我们对线程进行控制,这里我们实现了一个回调接口OnImageLoadListener,便于我们获知加载图片是否成功,这个接口很简单

[java] view plain copy
  1. public interface OnImageLoadListener {  
  2.     public void onSuccessLoad(Bitmap bitmap);  
  3.     public void onFailureLoad();  
  4. }  
就只是定义了onSuccessLoadonFailureLoad两个方法,并且我们通过ImageAsyncTask的setOnImageLoadListener方法将其设置到了当前线程中;

        第122行是用于暂停当前所有线程的,很简单,因为我们把当前所有开启的子线程都加到了Set<ImageAsyncTask>类型的tasks中了;

        那么接下来关键就是实现图片加载了,第230行开始就是比较关键的代码,首先通过params[0]获得当前传入需要加载的图片的url,随后调用md5算法计算出缓存文件的名字,md5实现代码:

[java] view plain copy
  1. /** 
  2.      * 对指定URL进行MD5编码,生成缓存文件的名字 
  3.      * @param str 
  4.      * @return 
  5.      */  
  6.     public static String md5(String str)  
  7.     {  
  8.         MessageDigest md5 = null;  
  9.         try {  
  10.             md5 = MessageDigest.getInstance("MD5");  
  11.         } catch (Exception e) {  
  12.             e.printStackTrace();  
  13.             return "";  
  14.         }  
  15.           
  16.         char[] charArray = str.toCharArray();  
  17.         byte[] byteArray = new byte[charArray.length];  
  18.           
  19.         for(int i = 0;i < charArray.length;i++)  
  20.         {  
  21.             byteArray[i] = (byte) charArray[i];  
  22.         }  
  23.           
  24.         byte[] md5Bytes = md5.digest(byteArray);  
  25.           
  26.          StringBuffer hexValue = new StringBuffer();  
  27.          for(int i = 0;i < md5Bytes.length;i++)  
  28.          {  
  29.              int val = ((int) md5Bytes[i]) & 0xff;  
  30.              if(val < 16)  
  31.              {  
  32.                  hexValue.append("0");  
  33.              }  
  34.              hexValue.append(Integer.toHexString(val));  
  35.          }  
  36.          return hexValue.toString();  
  37.     }  
  38.       
        第239行在SD卡上生成一个名字为key的文件对象,240行获得该文件对象的流对象,241行调用Utils的downloadToStream方法将对应url中的内容写入到out流对象中,downloadToStream的代码:

[java] view plain copy
  1. /** 
  2.      * 根据url路径将对应图片缓存到本地磁盘 
  3.      * @param urlString 
  4.      * @param outputStream 
  5.      * @return 
  6.      */  
  7.     public static boolean downloadToStream(String urlString,OutputStream outputStream)  
  8.     {  
  9.         HttpURLConnection connection = null;  
  10.         BufferedInputStream in = null;  
  11.         BufferedOutputStream out = null;  
  12.         Bitmap bitmap = null;  
  13.         try {  
  14.             URL url = new URL(urlString);  
  15.             connection = (HttpURLConnection) url.openConnection();  
  16.             InputStream instream = connection.getInputStream();  
  17.             in = new BufferedInputStream(instream);  
  18.             out = new BufferedOutputStream(outputStream);  
  19.             byte[] buf = new byte[1024];  
  20.             int len = 0;  
  21.             while((len = in.read(buf)) != -1)  
  22.             {  
  23.                 out.write(buf, 0, len);  
  24.             }  
  25.             return true;  
  26.         } catch (Exception e) {  
  27.             e.printStackTrace();  
  28.         }finally  
  29.         {  
  30.             if(connection != null)  
  31.                 connection.disconnect();  
  32.             try {  
  33.                 if(out != null)  
  34.                 {  
  35.                     out.close();  
  36.                     out = null;  
  37.                 }  
  38.                 if(in != null)  
  39.                 {  
  40.                     in.close();  
  41.                     in = null;  
  42.                 }  
  43.             } catch (Exception e2) {  
  44.                 e2.printStackTrace();  
  45.             }  
  46.         }  
  47.         return false;  
  48.     }  
        这段代码就是通过HttpURLConnection来获得对应url的流,随后将其写入到OutputStream对象中去,并且返回是否写入完成;

        如果写入流成功的话,第244行用于将流中的内容写入到缓存文件中,这时候你会发现SD卡上缓存文件的大小并没有发生变化,所以最后还得调用249行的flush方法刷新缓存内容到文件,如果写入流失败的话,第247行则调用abort方法关闭了缓存;之后和上面的方法一样,我们会使用Snapshot对象去缓存中对指定key的缓存文件,如果存在的话,则会对其进行压缩,并且将其返回,注意在doInBackground里面是不可以进行更新UI操作的,因为他属于子线程,更新UI操作的方法应该在第264行的onPostExecute中实现,这里的代码就应该很好理解了吧,之前有讲过啦,同时这里还进行了OnImageLoadListener回调处理,result不为空的话调用onSuccessLoad方法,为空的话调用onFailureLoad方法;

        最后就是我们的MainActivity了:

[java] view plain copy
  1. public class MainActivity extends Activity implements OnScrollListener {  
  2.   
  3.     public ListView listView = null;  
  4.     public ListViewAdapter adapter = null;  
  5.     public int start_index;  
  6.     public int end_index;  
  7.     public List<String> list;  
  8.     public boolean isInit = true;  
  9.     public ImageView imageView;  
  10.       
  11.     @Override  
  12.     protected void onCreate(Bundle savedInstanceState) {  
  13.         super.onCreate(savedInstanceState);  
  14.         setContentView(R.layout.listview);  
  15.         //首先创建存储缓存文件的地方  
  16.         File directory = Utils.getDiskCacheDir(this"bitmap");  
  17.         if(!directory.exists())  
  18.         {  
  19.             //目录不存在的话  
  20.             directory.mkdirs();  
  21.         }  
  22.         //获取app的版本信息  
  23.         int appVersion = Utils.getAppVersion(this);  
  24.         //此处的参数1表示每个key对应于一个缓存文件,1024*1024*100表示缓存大小为100M  
  25.         DiskLruCache diskCache = null;  
  26.         try {  
  27.             diskCache = DiskLruCache.open(directory, appVersion, 11024*1024*100);  
  28.         } catch (IOException e) {  
  29.             e.printStackTrace();  
  30.         }  
  31.         //创建用于传递给ListViewAdapter的数据  
  32.         list = new ArrayList<String>();  
  33.         int index = 0;  
  34.         for(int i = 0;i < 50;i++)  
  35.         {  
  36.             index = i % Utils.images.length;  
  37.             list.add(Utils.images[index]);  
  38.         }  
  39.         listView = (ListView) findViewById(R.id.listView);  
  40.         LayoutInflater inflater = LayoutInflater.from(this);  
  41.         View view = inflater.inflate(R.layout.item, null,false);  
  42.         imageView = (ImageView) view.findViewById(R.id.imageView);  
  43.         //创建Adapter对象  
  44.         adapter = new ListViewAdapter(this, list, diskCache,listView,imageView);  
  45.         listView.setOnScrollListener(this);  
  46.         listView.setAdapter(adapter);  
  47.     }  
  48.     @Override  
  49.     public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {  
  50.         start_index = firstVisibleItem;  
  51.         end_index = start_index + visibleItemCount;  
  52.         if(isInit == true && visibleItemCount > 0)  
  53.         {  
  54.             String url = "";  
  55.             String key = "";  
  56.             for(int i = start_index;i < end_index;i++)  
  57.             {  
  58.                 url = list.get(i);  
  59.                 key = Utils.md5(url);  
  60.                 adapter.loadImage(url,key,i);  
  61.             }  
  62.             isInit = false;  
  63.         }  
  64.     }  
  65.     @Override  
  66.     public void onScrollStateChanged(AbsListView view, int scrollState) {  
  67.         if(scrollState == AbsListView.OnScrollListener.SCROLL_STATE_IDLE)  
  68.         {  
  69.             //表示停止滑动,这时候就可以加载图片  
  70.             String url = "";  
  71.             String key = "";  
  72.             for(int i = start_index;i < end_index;i++)  
  73.             {  
  74.                 url = list.get(i);  
  75.                 key = Utils.md5(url);  
  76.                 adapter.loadImage(url,key,i);  
  77.             }  
  78.         }else  
  79.         {  
  80.             adapter.cancelTask();  
  81.         }  
  82.     }  
  83. }  

        首先第27行调用open方法创建了DiskLruCache,第44行创建了ListViewAdapter对象,同时将该对象设置到了ListView上面;

        为了防止在滑动的时候仍然有线程加载图片导致OOM异常,我们为ListView设置了滑动事件,第66行的onScrollStateChanged会在滑动停止的时候调用loadImage方法去加载图片的,否则的话会调用cancelTask停止所有正在执行加载图片的子线程,至于start_index以及end_index是通过第49行的onScroll获取的,还有一点需要注意的是,我们在首次加载的时候也是需要调用loadImage来加载图片的,这就是我们设置isInit标志的原因,因为首次加载你是没有滑动屏幕的,那么他就不会在onScrollStateChanged里面调用loadImage去加载图片,这时候你会发现首次加载ListView上面是没有图片的,当你滑动后再停止才会有图片出现,这显然是不合理的,所以首次加载的时候也应该让他能够调用loadImage方法;

        好了,采用DiskLruCache来实现ListView图片加载讲解结束啦,之后我们将会从内存缓存的角度对ListView进行进一步优化,谢谢大家!

点击下载源码!!!!!

阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页