亲宝软件园·资讯

展开

android 三级缓存 Android图片三级缓存策略(网络、本地、内存缓存)

文明的小流氓 人气:0
想了解Android图片三级缓存策略(网络、本地、内存缓存)的相关内容吗,文明的小流氓在本文为您仔细讲解android 三级缓存的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:android三级缓存,android缓存,下面大家一起来学习吧。

一、简介

现在的Android应用程序中,不可避免的都会使用到图片,如果每次加载图片的时候都要从网络重新拉取,这样不但很耗费用户的流量,而且图片加载的也会很慢,用户体验很不好。所以一个应用的图片缓存策略是很重要的。通常情况下,Android应用程序中图片的缓存策略采用“内存-本地-网络”三级缓存策略,首先应用程序访问网络拉取图片,分别将加载的图片保存在本地SD卡中和内存中,当程序再一次需要加载图片的时候,先判断内存中是否有缓存,有则直接从内存中拉取,否则查看本地SD卡中是否有缓存,SD卡中如果存在缓存,则图片从SD卡中拉取,否则从网络加载图片。依据这三级缓存机制,可以让我们的应用程序在加载图片的时候做到游刃有余,有效的避免内存溢出。

PS:当然现在处理网络图片的时候,一般人都会选择XUtils中的BitmapUtil,它已经将网络缓存处理的相当好了,使用起来非常方便--本人就一直在用。仿照BitMapUtil的实现思路,定制一个自己的图片加载工具,来理解一下三级缓存的策略,希望对自己会有一个提升。

二、网络缓存

网络拉取图片严格来讲不能称之为缓存,实质上就是下载url对应的图片,我们这里姑且把它看作是缓存的一种。仿照BitmapUtil中的display方法,我自己定制的CustomBitmapUtils也定义这个方法,根据传入的url,将图片设置到ivPic控件上。

public void display(ImageView ivPic, String url) {
}

定义网络缓存的工具类,在访问网络的时候,我使用了AsyncTask来实现,在AsyncTask的doInBackGround方法里下载图片,然后将 图片设置给ivPic控件,AsyncTask有三个泛型,其中第一个泛型是执行异步任务的时候,通过execute传过来的参数,第二个泛型是更新的进度,第三个泛型是异步任务执行完成之后,返回来的结果,我们这里返回一个Bitmap。具体的下载实现代码如下:

/** * 网络缓存的工具类 * * @author ZHY * */ public class NetCacheUtils
{ private LocalCacheUtils localCacheUtils;
private MemoryCacheUtils memoryCacheUtils; 
public NetCacheUtils() 
{ 
localCacheUtils = new LocalCacheUtils();
memoryCacheUtils = new MemoryCacheUtils(); 
} 
/** * 从网络下载图片 * 
* @param ivPic *
@param url */ 
public void getBitmapFromNet(ImageView ivPic, String url) 
{
// 访问网络的操作一定要在子线程中进行,采用异步任务实现 MyAsyncTask task = new MyAsyncTask(); task.execute(ivPic, url); } 
/** * 第一个泛型--异步任务执行的时候,通过execute传过来的参数;
第二个泛型--更新进度; 第三个泛型--异步任务执行以后返回的结果 
* * @author ZHY * */ 
private class MyAsyncTask extends AsyncTask 
{ private ImageView ivPic; private String url; // 耗时任务执行之前
--主线程
@Override protected void onPreExecute() 
{ super.onPreExecute(); 
} 
// 后台执行的任务
@Override protected Bitmap doInBackground(Object... params) 
{ 
// 执行异步任务的时候,将URL传过来 ivPic = (ImageView) params[0]; url = (String) params[1]; Bitmap bitmap = downloadBitmap(url); 
// 为了保证ImageView控件和URL一一对应,给ImageView设定一个标记 ivPic.setTag(url);
// 关联ivPic和URL return bitmap; }
// 更新进度 --主线程 
@Override protected void onProgressUpdate(Void... values) 
{ super.onProgressUpdate(values); 
}
// 耗时任务执行之后--主线程 
@Override protected void onPostExecute(Bitmap result)
{ String mCurrentUrl = (String) ivPic.getTag(); 
if (url.equals(mCurrentUrl))
{ ivPic.setImageBitmap(result); 
System.out.println("从网络获取图片"); 
// 从网络加载完之后,将图片保存到本地SD卡一份,保存到内存中一份 
localCacheUtils.setBitmap2Local(url, result); 
// 从网络加载完之后,将图片保存到本地SD卡一份,保存到内存中一份 memoryCacheUtils.setBitmap2Memory(url, result);
} } }
/** * 下载网络图片 *
* @param url * @return */
private Bitmap downloadBitmap(String url)
{ 
HttpURLConnection conn = null;
try 
{ 
URL mURL = new URL(url); 
// 打开HttpURLConnection连接 
conn = (HttpURLConnection) mURL.openConnection(); 
// 设置参数 conn.setConnectTimeout(5000); conn.setReadTimeout(5000); conn.setRequestMethod("GET"); 
// 开启连接 conn.connect(); 
// 获得响应码 int code = conn.getResponseCode();
if (code == 200) { 
// 相应成功,获得网络返回来的输入流 
InputStream is = conn.getInputStream(); 
// 图片的输入流获取成功之后,设置图片的压缩参数,将图片进行压缩 BitmapFactory.Options options = new BitmapFactory.Options(); 
options.inSampleSize = 2;
// 将图片的宽高都压缩为原来的一半,在开发中此参数需要根据图片展示的大小来确定,否则可能展示的不正常 
options.inPreferredConfig = Bitmap.Config.RGB_565;
// 这个压缩的最小 
// Bitmap bitmap = BitmapFactory.decodeStream(is); Bitmap bitmap = BitmapFactory.decodeStream(is, null, options)
;// 经过压缩的图片 return bitmap; 
} } 
catch (Exception e)
{ e.printStackTrace(); 
} 
finally {
// 断开连接 conn.disconnect(); 
} 
return null; 
} }

三、本地缓存

从网络加载完图片之后,将图片保存到本地SD卡中。在加载图片的时候,判断一下SD卡中是否有图片缓存,如果有,就直接从SD卡加载图片。本地缓存的工具类中有两个公共的方法,分别是向本地SD卡设置网络图片,获取SD卡中的图片。设置图片的时候采用键值对的形式进行存储,将图片的url作为键,作为文件的名字,图片的Bitmap作位值来保存。由于url含有特殊字符,不能直接作为图片的名字来存储,故采用url的MD5值作为文件的名字。

/**
* 本地缓存
* 
* @author ZHY
* 
*/
public class LocalCacheUtils {
/**
* 文件保存的路径
*/
public static final String FILE_PATH = Environment
.getExternalStorageDirectory().getAbsolutePath() + "/cache/pics";
/**
* 从本地SD卡获取网络图片,key是url的MD5值
* 
* @param url
* @return
*/
public Bitmap getBitmapFromLocal(String url) {
try {
String fileName = MD5Encoder.encode(url);
File file = new File(FILE_PATH, fileName);
if (file.exists()) {
Bitmap bitmap = BitmapFactory.decodeStream(new FileInputStream(
file));
return bitmap;
}
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 向本地SD卡写网络图片
* 
* @param url
* @param bitmap
*/
public void setBitmap2Local(String url, Bitmap bitmap) {
try {
// 文件的名字
String fileName = MD5Encoder.encode(url);
// 创建文件流,指向该路径,文件名叫做fileName
File file = new File(FILE_PATH, fileName);
// file其实是图片,它的父级File是文件夹,判断一下文件夹是否存在,如果不存在,创建文件夹
File fileParent = file.getParentFile();
if (!fileParent.exists()) {
// 文件夹不存在
fileParent.mkdirs();// 创建文件夹
}
// 将图片保存到本地
bitmap.compress(CompressFormat.JPEG, 100,
new FileOutputStream(file));
} catch (Exception e) {
e.printStackTrace();
}
}
}

四、内存缓存

内存缓存说白了就是在内存中保存一份图片集合,首先会想到HashMap这种键值对的形式来进行保存,以url作为key,bitmap作为value。但是在Java中这种默认的new对象的方式是强引用,JVM在进行垃圾回收的时候是不会回收强引用的,所以如果加载的图片过多的话,map会越来越大,很容易出现OOM异常。在Android2.3之前,还可以通过软引用或者弱引用来解决,但是Android2.3之后,Google官方便不再推荐软引用了,Google推荐我们使用LruCache。

在过去,我们经常会使用一种非常流行的内存缓存技术的实现,即软引用或弱引用 (SoftReference or WeakReference)。但是现在已经不再推荐使用这种方式了,因为从 Android 2.3 (API Level 9)开始,垃圾回收器会更倾向于回收持有软引用或弱引用的对象,这让软引用和弱引用变得不再可靠。另外,Android 3.0 (API Level 11)中,图片的数据会存储在本地的内存当中,因而无法用一种可预见的方式将其释放,这就有潜在的风险造成应用程序的内存溢出并崩溃。

为了能够选择一个合适的缓存大小给LruCache, 有以下多个因素应该放入考虑范围内,例如:

你的设备可以为每个应用程序分配多大的内存?Android默认是16M。 设备屏幕上一次最多能显示多少张图片?有多少图片需要进行预加载,因为有可能很快也会显示在屏幕上? 你的设备的屏幕大小和分辨率分别是多少?一个超高分辨率的设备(例如 Galaxy Nexus) 比起一个较低分辨率的设备(例如 Nexus S),在持有相同数量图片的时候,需要更大的缓存空间。 图片的尺寸和大小,还有每张图片会占据多少内存空间。 图片被访问的频率有多高?会不会有一些图片的访问频率比其它图片要高?如果有的话,你也许应该让一些图片常驻在内存当中,或者使用多个LruCache 对象来区分不同组的图片。 你能维持好数量和质量之间的平衡吗?有些时候,存储多个低像素的图片,而在后台去开线程加载高像素的图片会更加的有效。 以上是Google对LruCache的描述,其实LruCache的使用非常简单,跟Map非常相近,只是在创建LruCache对象的时候需要指定它的最大允许内存,一般设置为当前应用程序的最大运行内存的八分之一即可。

/**
* 内存缓存
* 
* @author ZHY
* 
*/
public class MemoryCacheUtils {
/*
* 由于map默认是强引用,所有在JVM进行垃圾回收的时候不会回收map的引用
*/
// private HashMap<string, bitmap=""> map = new HashMap<string, bitmap="">();
// 软引用的实例,在内存不够时,垃圾回收器会优先考虑回收
// private HashMap<string, bitmap="">> mSoftReferenceMap = new
// HashMap<string, bitmap="">>();
// LruCache
private LruCache<string, bitmap=""> lruCache;
public MemoryCacheUtils() {
// lruCache最大允许内存一般为Android系统分给每个应用程序内存大小(默认Android系统给每个应用程序分配16兆内存)的八分之一(推荐)
// 获得当前应用程序运行的内存大小
long mCurrentMemory = Runtime.getRuntime().maxMemory();
int maxSize = (int) (mCurrentMemory / 8);
// 给LruCache设置最大的内存
lruCache = new LruCache<string, bitmap="">(maxSize) {
@Override
protected int sizeOf(String key, Bitmap value) {
// 获取每张图片所占内存的大小
// 计算方法是:图片显示的宽度的像素点乘以高度的像素点
int byteCount = value.getRowBytes() * value.getHeight();// 获取图片占用内存大小
return byteCount;
}
};
}
/**
* 从内存中读取Bitmap
* 
* @param url
* @return
*/
public Bitmap getBitmapFromMemory(String url) {
// Bitmap bitmap = map.get(url);
// SoftReference<bitmap> softReference = mSoftReferenceMap.get(url);
// Bitmap bitmap = softReference.get();
// 软引用在Android2.3以后就不推荐使用了,Google推荐使用lruCache
// LRU--least recently use
// 最近最少使用,将内存控制在一定的大小内,超过这个内存大小,就会优先释放最近最少使用的那些东东
Bitmap bitmap = lruCache.get(url);
return bitmap;
}
/**
* 将图片保存到内存中
* 
* @param url
* @param bitmap
*/
public void setBitmap2Memory(String url, Bitmap bitmap) {
// 向内存中设置,key,value的形式,首先想到HashMap
// map.put(url, bitmap);
// 保存软引用到map中
// SoftReference<bitmap> mSoftReference = new
// SoftReference<bitmap>(bitmap);
// mSoftReferenceMap.put(url, mSoftReference);
lruCache.put(url, bitmap);
}
}</bitmap></bitmap></bitmap></string,></string,></string,></string,></string,></string,>

好了。现在三级缓存策略封装完毕,接下来定制我们自己的BitmapUtils

/**
* 自定义的加载图片的工具类,类似于Xutils中的BitmapUtil,在实际使用中,一般使用BitmapUtil,为了理解三级缓存,
* 这里模拟BitmapUtil自定义了CustomBitmapUtil
* 
* @author ZHY
* 
*/
public class CustomBitmapUtils {
private Bitmap bitmap;
private NetCacheUtils netCacheUtils;
private LocalCacheUtils localCacheUtils;
private MemoryCacheUtils memoryCacheUtils;
public CustomBitmapUtils() {
netCacheUtils = new NetCacheUtils();
localCacheUtils = new LocalCacheUtils();
memoryCacheUtils = new MemoryCacheUtils();
}
/**
* 加载图片,将当前URL对应的图片显示到ivPic的控件上
* 
* @param ivPic
* ImageView控件
* @param url
* 图片的地址
*/
public void display(ImageView ivPic, String url) {
// 设置默认显示的图片
ivPic.setImageResource(R.drawable.ic_launcher);
// 1、内存缓存
bitmap = memoryCacheUtils.getBitmapFromMemory(url);
if (bitmap != null) {
ivPic.setImageBitmap(bitmap);
System.out.println("从内存缓存中加载图片");
return;
}
// 2、本地磁盘缓存
bitmap = localCacheUtils.getBitmapFromLocal(url);
if (bitmap != null) {
ivPic.setImageBitmap(bitmap);
System.out.println("从本地SD卡加载的图片");
memoryCacheUtils.setBitmap2Memory(url, bitmap);// 将图片保存到内存
return;
}
// 3、网络缓存
netCacheUtils.getBitmapFromNet(ivPic, url);
/*
* 从网络获取图片之后,将图片保存到手机SD卡中,在进行图片展示的时候,优先从SD卡中读取缓存,key是图片的URL的MD5值,
* value是保存的图片bitmap
*/
}
}

在mainActivity中使用ListView加载网络图片

/**
* Android中三级缓存--网络缓存-本地缓存-内存缓存
* 
* @author ZHY
* 
*/
public class MainActivity extends Activity {
private ListView list;
private Button btn;
private CustomBitmapUtils utils;
private static final String BASE_URL = "http://192.168.0.148:8080/pics";
// 初始化一些网络图片
String[] urls = { BASE_URL + "/1.jpg", BASE_URL + "/2.jpg",
BASE_URL + "/3.jpg", BASE_URL + "/4.jpg", BASE_URL + "/5.jpg",
BASE_URL + "/6.jpg", BASE_URL + "/7.jpg", BASE_URL + "/8.jpg",
BASE_URL + "/9.jpg", BASE_URL + "/10.jpg", BASE_URL + "/11.jpg",
BASE_URL + "/12.jpg", BASE_URL + "/13.jpg", BASE_URL + "/14.jpg",
BASE_URL + "/15.jpg", BASE_URL + "/16.jpg", BASE_URL + "/17.jpg",
BASE_URL + "/18.jpg", BASE_URL + "/19.jpg", BASE_URL + "/20.jpg",
BASE_URL + "/21.jpg", BASE_URL + "/22.jpg", BASE_URL + "/23.jpg",
BASE_URL + "/24.jpg", BASE_URL + "/25.jpg", BASE_URL + "/26.jpg",
BASE_URL + "/27.jpg", BASE_URL + "/28.jpg", BASE_URL + "/29.jpg",
BASE_URL + "/30.jpg" };
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
list = (ListView) findViewById(R.id.list);
btn = (Button) findViewById(R.id.btn_load);
utils = new CustomBitmapUtils();
// 加载网络图片
btn.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
MyAdapter adapter = new MyAdapter();
list.setAdapter(adapter);
}
});
}
class MyAdapter extends BaseAdapter {
@Override
public int getCount() {
return urls.length;
}
@Override
public String getItem(int position) {
return urls[position];
}
@Override
public long getItemId(int position) {
return position;
}
@Override
public View getView(int position, View convertView, ViewGroup parent) {
ViewHolder holder;
if (convertView == null) {
convertView = View.inflate(MainActivity.this,
R.layout.item_list, null);
holder = new ViewHolder();
holder.ivPic = (ImageView) convertView.findViewById(R.id.iv);
convertView.setTag(holder);
} else {
holder = (ViewHolder) convertView.getTag();
}
utils.display(holder.ivPic, urls[position]);
return convertView;
}
class ViewHolder {
ImageView ivPic;
}
}
}

运行的结果如下:

程序第一次运行,日志打印如下

之后将图片缓存在SD卡中,从本地加载图片


然后将图片缓存到内存,从内存加载图片


OK,到目前为止,Android中图片的三级缓存原理就都介绍完了,我自己本人受益匪浅,希望能够帮助到需要的朋友。需要源码的请点击如下链接进行下载。

加载全部内容

相关教程
猜你喜欢
用户评论