安卓图片的缓存与加载

    安卓中经常会用的图片的加载，但是每次都联网加载图片会降低程序的运行速度，同时也会消耗很多流量，因此需要用的缓存，下面的这个例子用到了软引用以及文件存储，这样就不必每次都联网加载图片。

  下面附上代码：

package com.itomato.downloadutil;


import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.ref.SoftReference;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;


import com.itomato.activity.R;
import com.itomato.constant.Constant;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.AsyncTask;
import android.util.Log;
import android.view.View;
import android.view.animation.Animation;
import android.view.animation.AnimationUtils;
import android.widget.ImageView;


public class ImageGetter {

public static ImageGetter imgGetter;
Bitmap bitmap;


//  drawable的软引用的map
private Map<String, SoftReference<Bitmap>> drawableMap = null;

   //  写文件时的阻塞队列
private BlockingQueue<SoftReference<Map<String, Object>>> writeQueue = null;
    private Context context;
    
private ImageGetter(Context context){
drawableMap=new HashMap<String, SoftReference<Bitmap>>();
writeQueue = new LinkedBlockingQueue<SoftReference<Map<String, Object>>>(200);
this.context=context;

}

public static synchronized  ImageGetter getImgGetter(Context context){
if(imgGetter==null){
imgGetter=new ImageGetter(context);
}
return imgGetter;
}



  /**
   * 获取图片并显示
   * @param url
   * @param view
   */
public void getImg(String url, View view) {

String imageName = getImageNameFromUrl(url);
if (imageName!=null) {
//从缓存中获取
if (drawableMap.containsKey(imageName)) {

           SoftReference<Bitmap> softReference = drawableMap.get(imageName);
           Bitmap bitmap = softReference.get();
           if (bitmap != null&&view != null) {           
    ((ImageView) view).setImageBitmap(bitmap); 


            Animation animation = AnimationUtils.loadAnimation(context,R.anim.alpha);
            view.startAnimation(animation);


            return ;
           }
       }
//若缓存中没有，从手机文件里面查找 图片
Bitmap bitmap = getImageDrawableByName(imageName);
if (bitmap != null && view != null) {

((ImageView) view).setImageBitmap(bitmap); 

Animation animation = AnimationUtils.loadAnimation(context, R.anim.alpha);
            view.startAnimation(animation);
           
            //存入缓存
drawableMap.put(imageName, new SoftReference<Bitmap>(bitmap));
return ;
}
//上面两个里面都没有取到图片，这个时候下载

forceDownload(url, view);
}


}

/**
* 仅获得图片
*
*/


public Bitmap getImage(String url) {

String imageName = getImageNameFromUrl(url);
if (imageName!=null) {
//从缓存中获取
if (drawableMap.containsKey(imageName)) {

           SoftReference<Bitmap> softReference = drawableMap.get(imageName);
           bitmap = softReference.get();
           if (bitmap != null) {               
            return bitmap;
           }
       }
//若缓存中没有，从手机文件里面查找 图片
bitmap = getImageDrawableByName(imageName);
if (bitmap != null ) {
           
            //存入缓存
drawableMap.put(imageName, new SoftReference<Bitmap>(bitmap));
return bitmap;
}
//上面两个里面都没有取到图片，这个时候下载
ImageView view=null;
forceDownload(url,view);
}

return bitmap;
}


/**
* 下载图片
* @param url
* @param view
*/
private void forceDownload(String url, View view) {

DrawableDownloaderTask task = new DrawableDownloaderTask(view);
task.execute(url);
}


/**
* 从手机文件夹中获取图片
* @param imgName
* @return
*/
public  Bitmap getImageDrawableByName(String imgName) {
String path = Constant.IMG_FILE_PATH+ imgName+".jpg";    //图片文件存储路径
File file = new File(path);
if (file.exists()) {
Bitmap da = BitmapFactory.decodeFile(path); 

if( da != null){
// 修改文件的最后访问时间
file.setLastModified(System.currentTimeMillis());

return da;
}
}

return null;
}

/**
* 下载图片并写入文件夹
* @param url
* @return
* @throws IOException
*/
public Bitmap downloadImageByUrl(String url) throws IOException {
Bitmap bitmap = null;
HttpURLConnection conn = null;
InputStream inputStream = null;
        String imgName=getImageNameFromUrl(url);
        
URL imageurl = new URL(url);
conn = (HttpURLConnection) imageurl.openConnection();
conn.setConnectTimeout(5 * 1000);
conn.setRequestMethod("GET");
conn.setDoInput(true);
conn.connect();
if (conn.getResponseCode() == 200) {
inputStream = new BufferedInputStream(conn.getInputStream());

if(inputStream!=null){

//写入文件夹
bitmap=saveToSdcard(inputStream, Constant.IMG_FILE_PATH+imgName+".jpg");
}
}

if (conn != null) {
conn.disconnect();
}
if (inputStream != null) {
inputStream.close();
}
return bitmap;
}



/**
 * 根据图片路径获取图片名
 * eg:  data/movie/labixiaoxin2.jpg
 * @param imageUrl
 * @return
 */
private String getImageNameFromUrl(String imageUrl){
String[] urls = null;
urls = imageUrl.split("/");
if (urls != null && urls.length > 0) {
String imgname = urls[urls.length - 1];
imgname = imgname.split("\\.")[0];
return imgname;
}else {
return null;
}
}




/**
* 写入文件夹
* @param map
*/
public static Bitmap saveToSdcard(InputStream in,String path){

File file=new File(path);
file.getParentFile().mkdirs();
Bitmap bitmap=null;
try {
OutputStream out =new FileOutputStream(file);
byte[] b=new byte[20];
int c=0;
while ((c=in.read(b,0,b.length))!=-1){
out.write(b, 0, c);
}
in.close();
out.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
bitmap=BitmapFactory.decodeFile(path);
return bitmap;

}


class DrawableDownloaderTask extends AsyncTask<String, Void, Bitmap> {
private String url;
private View view;
private String imgName = "";


public DrawableDownloaderTask(View view) {
this.view = view;
}


@Override
protected Bitmap doInBackground(String... params) {
url = params[0];
imgName = getImageNameFromUrl(url);

try {
return downloadImageByUrl(url);
} catch (IOException e) {
drawableMap.remove(imgName);
e.printStackTrace();
}
return null;
}


@Override
protected void onPostExecute(Bitmap result) {

if (view != null && result != null) {
((ImageView) view).setImageBitmap(result);

Animation animation = AnimationUtils.loadAnimation(context, R.anim.alpha);
            view.startAnimation(animation);
            drawableMap.put(imgName, new SoftReference<Bitmap>(result));
            bitmap=result;
           
}else if(result!=null){
drawableMap.put(imgName, new SoftReference<Bitmap>(result));
bitmap=result;
}



}
}


}