首页 / 操作系统 / Linux / Android之图片异步加载并缓存到本地

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

1. public class AsyncBitmapLoader    
2. {    
3.     /**   
4.      * 内存图片软引用缓冲   
5.      */    
6.     private HashMap<String, SoftReference<Bitmap>> imageCache = null;    
7.         
8.     public AsyncBitmapLoader（）    
9.     {    
10.         imageCache = new HashMap<String, SoftReference<Bitmap>>（）;    
11.     }    
12.         
13.     public Bitmap loadBitmap（final ImageView imageView, final String imageURL, final ImageCallBack imageCallBack）    
14.     {    
15.         //在内存缓存中，则返回Bitmap对象    
16.         if（imageCache.containsKey（imageURL））    
17.         {    
18.             SoftReference<Bitmap> reference = imageCache.get（imageURL）;    
19.             Bitmap bitmap = reference.get（）;    
20.             if（bitmap ！= null）    
21.             {    
22.                 return bitmap;    
23.             }    
24.         }    
25.         else    
26.         {    
27.             /**   
28.              * 加上一个对本地缓存的查找   
29.              */    
30.             String bitmapName = imageURL.substring（imageURL.lastIndexOf（"/"） + 1）;    
31.             File cacheDir = new File（"/mnt/sdcard/test/"）;    
32.             File[] cacheFiles = cacheDir.listFiles（）;    
33.             int i = 0;    
34.             if（null！=cacheFiles）{  
35.             for（; i<cacheFiles.length; i++）    
36.             {    
37.                 if（bitmapName.equals（cacheFiles[i].getName（）））    
38.                 {    
39.                     break;    
40.                 }    
41.             }    
42.                 
43.             if（i < cacheFiles.length）    
44.             {    
45.                 return BitmapFactory.decodeFile（"/mnt/sdcard/test/" + bitmapName）;    
46.             }  
47.             }  
48.         }    
49.             
50.         final Handler handler = new Handler（）    
51.         {    
52.             /* （non-Javadoc）   
53.              * @see android.os.Handler#handleMessage（android.os.Message）   
54.              */    
55.             @Override    
56.             public void handleMessage（Message msg）    
57.             {    
58.                 // TODO Auto-generated method stub    
59.                 imageCallBack.imageLoad（imageView, （Bitmap）msg.obj）;    
60.             }    
61.         };    
62.             
63.         //如果不在内存缓存中，也不在本地（被jvm回收掉），则开启线程下载图片    
64.         new Thread（）    
65.         {    
66.             /* （non-Javadoc）   
67.              * @see java.lang.Thread#run（）   
68.              */    
69.             @Override    
70.             public void run（）    
71.             {    
72.                 // TODO Auto-generated method stub    
73.                 InputStream bitmapIs = HttpUtils.getStreamFromURL（imageURL）;    
74.                     
75.                 Bitmap bitmap = BitmapFactory.decodeStream（bitmapIs）;    
76.                 imageCache.put（imageURL, new SoftReference<Bitmap>（bitmap））;    
77.                 Message msg = handler.obtainMessage（0, bitmap）;    
78.                 handler.sendMessage（msg）;    
79.                     
80.                 File dir = new File（"/mnt/sdcard/test/"）;    
81.                 if（！dir.exists（））    
82.                 {    
83.                     dir.mkdirs（）;    
84.                 }    
85.                     
86.                 File bitmapFile = new File（"/mnt/sdcard/test/" +     
87.                         imageURL.substring（imageURL.lastIndexOf（"/"） + 1））;    
88.                 if（！bitmapFile.exists（））    
89.                 {    
90.                     try    
91.                     {    
92.                         bitmapFile.createNewFile（）;    
93.                     }    
94.                     catch （IOException e）    
95.                     {    
96.                         // TODO Auto-generated catch block    
97.                         e.printStackTrace（）;    
98.                     }    
99.                 }    
100.                 FileOutputStream fos;    
101.                 try    
102.                 {    
103.                     fos = new FileOutputStream（bitmapFile）;    
104.                     bitmap.compress（Bitmap.CompressFormat.PNG,     
105.                             100, fos）;    
106.                     fos.close（）;    
107.                 }    
108.                 catch （FileNotFoundException e）    
109.                 {    
110.                     // TODO Auto-generated catch block    
111.                     e.printStackTrace（）;    
112.                 }    
113.                 catch （IOException e）    
114.                 {    
115.                     // TODO Auto-generated catch block    
116.                     e.printStackTrace（）;    
117.                 }    
118.             }    
119.         }.start（）;    
120.             
121.         return null;    
122.     }    
123.   
124.     public interface ImageCallBack    
125.     {    
126.         public void imageLoad（ImageView imageView, Bitmap bitmap）;    
127.     }    
128. }