java加载网图并缓存下来_android下载网络图片并缓存

异步下载网络图片，并提供是否缓存至内存或外部文件的功能

异步加载类AsyncImageLoader

public void downloadImage(final String url, final ImageCallback callback);

public void downloadImage(final String url, final boolean cache2Memory, final ImageCallback callback);

public void setCache2File(boolean flag);

public void setCachedDir(String dir);

图片下载和缓存实现类LoaderImpl

1.AsyncImageLoader.java

package com.imagecache;

import java.lang.ref.SoftReference;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Map;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import android.content.Context;

import android.graphics.Bitmap;

import android.os.Handler;

import android.util.Log;

public class AsyncImageLoader {

//保存正在下载的图片URL集合，避免重复下载用

private static HashSet sDownloadingSet;

//软引用内存缓存

private static Map> sImageCache;

//图片三种获取方式管理者，网络URL获取、内存缓存获取、外部文件缓存获取

private static LoaderImpl impl;

//线程池相关

private static ExecutorService sExecutorService;

//通知UI线程图片获取ok时使用

private Handler handler;

/**

* 异步加载图片完毕的回调接口

*/

public interface ImageCallback{

/**

* 回调函数

* @param bitmap: may be null!

* @param imageUrl

*/

public void onImageLoaded(Bitmap bitmap, String imageUrl);

}

static{

sDownloadingSet = new HashSet();

sImageCache = new HashMap>();

impl = new LoaderImpl(sImageCache);

}

public AsyncImageLoader(Context context){

handler = new Handler();

startThreadPoolIfNecessary();

String defaultDir = context.getCacheDir().getAbsolutePath();

setCachedDir(defaultDir);

}

/**

* 是否缓存图片至/data/data/package/cache/目录

* 默认不缓存

*/

public void setCache2File(boolean flag){

impl.setCache2File(flag);

}

/**

* 设置缓存路径，setCache2File(true)时有效

*/

public void setCachedDir(String dir){

impl.setCachedDir(dir);

}

/**开启线程池*/

public static void startThreadPoolIfNecessary(){

if(sExecutorService == null || sExecutorService.isShutdown() || sExecutorService.isTerminated()){

sExecutorService = Executors.newFixedThreadPool(3);

//sExecutorService = Executors.newSingleThreadExecutor();

}

}

/**

* 异步下载图片，并缓存到memory中

* @param url

* @param callback  see ImageCallback interface

*/

public void downloadImage(final String url, final ImageCallback callback){

downloadImage(url, true, callback);

}

/**

*

* @param url

* @param cache2Memory 是否缓存至memory中

* @param callback

*/

public void downloadImage(final String url, final boolean cache2Memory, final ImageCallback callback){

if(sDownloadingSet.contains(url)){

Log.i("AsyncImageLoader", "###该图片正在下载，不能重复下载！");

return;

}

Bitmap bitmap = impl.getBitmapFromMemory(url);

if(bitmap != null){

if(callback != null){

callback.onImageLoaded(bitmap, url);

}

}else{

//从网络端下载图片

sDownloadingSet.add(url);

sExecutorService.submit(new Runnable(){

@Override

public void run() {

final Bitmap bitmap = impl.getBitmapFromUrl(url, cache2Memory);

handler.post(new Runnable(){

@Override

public void run(){

if(callback != null)

callback.onImageLoaded(bitmap, url);

sDownloadingSet.remove(url);

}

});

}

});

}

}

/**

* 预加载下一张图片，缓存至memory中

* @param url

*/

public void preLoadNextImage(final String url){

//将callback置为空，只将bitmap缓存到memory即可。

downloadImage(url, null);

}

}

2.LoaderImpl.java

package com.imagecache;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.UnsupportedEncodingException;

import java.lang.ref.SoftReference;

import java.net.HttpURLConnection;

import java.net.URL;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import java.util.Map;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

/**

*

* @author Administrator

* @desc 异步加载图片管理器

*

*/

public class LoaderImpl {

//内存中的软应用缓存

private Map> imageCache;

//是否缓存图片至本地文件

private boolean cache2FileFlag = false;

//缓存目录,默认是/data/data/package/cache/目录

private String cachedDir;

public LoaderImpl(Map> imageCache){

this.imageCache = imageCache;

}

/**

* 是否缓存图片至外部文件

* @param flag

*/

public void setCache2File(boolean flag){

cache2FileFlag = flag;

}

/**

* 设置缓存图片到外部文件的路径

* @param cacheDir

*/

public void setCachedDir(String cacheDir){

this.cachedDir = cacheDir;

}

/**

* 从网络端下载图片

* @param url 网络图片的URL地址

* @param cache2Memory 是否缓存(缓存在内存中)

* @return bitmap 图片bitmap结构

*

*/

public Bitmap getBitmapFromUrl(String url, boolean cache2Memory){

Bitmap bitmap = null;

try{

URL u = new URL(url);

HttpURLConnection conn = (HttpURLConnection)u.openConnection();

InputStream is = conn.getInputStream();

bitmap = BitmapFactory.decodeStream(is);

if(cache2Memory){

//1.缓存bitmap至内存软引用中

imageCache.put(url, new SoftReference(bitmap));

if(cache2FileFlag){

//2.缓存bitmap至/data/data/packageName/cache/文件夹中

String fileName = getMD5Str(url);

String filePath = this.cachedDir + "/" +fileName;

FileOutputStream fos = new FileOutputStream(filePath);

bitmap.compress(Bitmap.CompressFormat.PNG, 100, fos);

}

}

is.close();

conn.disconnect();

return bitmap;

}catch(IOException e){

e.printStackTrace();

return null;

}

}

/**

* 从内存缓存中获取bitmap

* @param url

* @return bitmap or null.

*/

public Bitmap getBitmapFromMemory(String url){

Bitmap bitmap = null;

if(imageCache.containsKey(url)){

synchronized(imageCache){

SoftReference bitmapRef = imageCache.get(url);

if(bitmapRef != null){

bitmap = bitmapRef.get();

return bitmap;

}

}

}

//从外部缓存文件读取

if(cache2FileFlag){

bitmap = getBitmapFromFile(url);

if(bitmap != null)

imageCache.put(url, new SoftReference(bitmap));

}

return bitmap;

}

/**

* 从外部文件缓存中获取bitmap

* @param url

* @return

*/

private Bitmap getBitmapFromFile(String url){

Bitmap bitmap = null;

String fileName = getMD5Str(url);

if(fileName == null)

return null;

String filePath = cachedDir + "/" + fileName;

try {

FileInputStream fis = new FileInputStream(filePath);

bitmap = BitmapFactory.decodeStream(fis);

} catch (FileNotFoundException e) {

e.printStackTrace();

bitmap = null;

}

return bitmap;

}

/**

* MD5 加密

*/

private static String getMD5Str(String str) {

MessageDigest messageDigest = null;

try {

messageDigest = MessageDigest.getInstance("MD5");

messageDigest.reset();

messageDigest.update(str.getBytes("UTF-8"));

} catch (NoSuchAlgorithmException e) {

System.out.println("NoSuchAlgorithmException caught!");

return null;

} catch (UnsupportedEncodingException e) {

e.printStackTrace();

return null;

}

byte[] byteArray = messageDigest.digest();

StringBuffer md5StrBuff = new StringBuffer();

for (int i = 0; i 

if (Integer.toHexString(0xFF & byteArray[i]).length() == 1)

md5StrBuff.append("0").append(Integer.toHexString(0xFF & byteArray[i]));

else

md5StrBuff.append(Integer.toHexString(0xFF & byteArray[i]));

}

return md5StrBuff.toString();

}

/**

* MD5 加密

private static String getMD5Str(Object...objects){

StringBuilder stringBuilder=new StringBuilder();

for (Object object : objects) {

stringBuilder.append(object.toString());

}

return getMD5Str(stringBuilder.toString());

}*/

}

3.测试Activity

package com.imagecache;

import android.app.Activity;

import android.graphics.Bitmap;

import android.os.Bundle;

import android.widget.ImageView;

public class MainActivity extends Activity {

/** Called when the activity is first created. */

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

final ImageView iv = (ImageView)findViewById(R.id.iv);

//网络图片地址

String imgUrl = "http://...";

//for test

AsyncImageLoader loader = new AsyncImageLoader(getApplicationContext());

//将图片缓存至外部文件中

loader.setCache2File(true); //false

//设置外部缓存文件夹

loader.setCachedDir(this.getCacheDir().getAbsolutePath());

//下载图片，第二个参数是否缓存至内存中

loader.downloadImage(imgUrl, true/*false*/, new AsyncImageLoader.ImageCallback() {

@Override

public void onImageLoaded(Bitmap bitmap, String imageUrl) {

if(bitmap != null){

iv.setImageBitmap(bitmap);

}else{

//下载失败，设置默认图片

}

}

});

}

}转自：http://blog.csdn.net/liliang497/article/details/7221110

原文：http://www.cnblogs.com/pricks/p/3921611.html