android 缓存管理的方法

时间 2019-12-05

标签 android 缓存管理方法栏目 Android 繁體版

原文原文链接

缓存管理的适用环境：
java

1. 提供网络服务的应用android

2. 数据更新不须要实时更新，哪怕是3-5分钟的延迟也是能够采用缓存机制。数据库

3. 缓存的过时时间是能够接受的(相似网易的新闻阅读,支持离线离线阅读)缓存

这样所带来的好处：服务器

1. 减少服务器的压力网络

2. 提升客户端的响应速度(本地数据提取嘛)app

3. 必定程度上支持离线浏览(能够参考网易的那个新闻应用,我的感受离线阅读作得很是棒。)工具

1、缓存管理的方法性能

缓存管理的原理很简：经过时间的设置来判断是否读取缓存仍是从新下载；断网下就没什么好说的，直接去缓存便可。如图：网站

里面会有一些细节的处理，后面会详细阐述。基于这个原理，目前我的用过的两种比较常见的缓存管理方法是:数据库和文件(txt)。

2、数据库(SQLite)缓存方式

这种方法是在下载完数据文件后，把文件的相关信息如url，路经，下载时间，过时时间等存放到数据库，固然我我的建议把url做为惟一的标识。下次下载的时候根据url先从数据库中查询，若是查询到当前时间并未过时，就根据路径读取本地文件，从而实现缓存的效果。

从实现上咱们能够看到这种方法能够灵活存放文件的属性，进而提供了很大的扩展性，能够为其它的功能提供必定的支持。

从操做上须要建立数据库，每次查询数据库，若是过时还须要更新数据库，清理缓存的时候还须要删除数据库数据，稍显麻烦，而数据库操做不当又容易出现一系列的性能，ANR问题，指针错误问题，实现的时候要谨慎，具体做的话，但也只是增长一个工具类或方法的事情。

还有一个问题，缓存的数据库是存放在/data/data/<package>/databases/目录下，是占用内存空间的，若是缓存累计，容易浪费内存，须要及时清理缓存。

固然这种方法从目前一些应用的实用上看，我没有发现什么问题,估计使用的量还比较少吧。

本文本人不太喜欢数据库，缘由操做麻烦，尤为是要本身写建表那些语句，你懂的。我侧重文件缓存方式。

3、文件缓存方式

这种方法，使用File.lastModified()方法获得文件的最后修改时间，与当前时间判断是否过时，从而实现缓存效果。

实现上只能使用这一个属性，没有为其它的功能提供技术支持的可能。操做上却是简单，比较时间便可，并且取的数据也就是文件里的JSON数据而已。自己处理也不容易带来其它问题，代价低廉。

4、文件法缓存方式的两点说明

1. 不一样类型的文件的缓存时间不同。

笼统的说，不变文件的缓存时间是永久，变化文件的缓存时间是最大忍受不变时间。说白点，图片文件内容是不变的，通常存在SD卡上直到被清理，咱们是能够永远读取缓存的。配置文件内容是可能更新的，须要设置一个可接受的缓存时间。

2. 不一样环境下的缓存时间标准不同。

无网络环境下，咱们只能读取缓存文件，为了应用有东西显示，没有什么过时之说了。

WiFi网络环境下，缓存时间能够设置短一点，一是网速较快，而是流量不要钱。

3G流量环境下，缓存时间能够设置长一点，节省流量，就是节省金钱，并且用户体验也更好。

GPS就别说更新什么的，已经够慢的了。缓存时间能多长就多长把。

固然，做为一款好的应用，不会死定一种状况，针对于不一样网络变换不一样形式的缓存功能是必须有的。并且这个时间根据本身的实际状况来设置：数据的更新频率，数据的重要性等。

5、什么时候刷新

开发者一方面但愿尽可能读取缓存，用户一方面但愿实时刷新，可是响应速度越快越好，流量消耗越少越好(关于这块，的确开发中我没怎么想到，毕竟接口就是这么多，如今公司的产品几乎点一下就访问一下，并且还有些鸡肋多余的功能。慢慢修改哈哈)，是一个矛盾。

其实什么时候刷新我也不知道，这里我提供两点建议：

1. 数据的最长多长时间不变，对应用无大的影响。

好比，你的数据更新时间为4小时，则缓存时间设置为1~2小时比较合适。也就是更新时间/缓存时间=2,但用户我的修改、网站编辑人员等一些人为的更新就另说。一天用户总会看到更新，即使有延迟也好，视你产品的用途了；若是你以为你是资讯类应用，再减小，2~4小时，若是你以为数据比较重要或者比较受欢迎，用户会常常把玩，再减小，1~2小时，依次类推。

固然相似这个界面的数据我认为更新时间能多长就多长了，尽量长。若是你拿后边那个有多少数据会变更来搪塞。我会告诉你：这个只是一个引导性的界面，你有多少款游戏跟用户半毛钱关系都没有，10亿也跟他没关，他只要肯定这里能找到他要找的汤姆猫就行。不然你又失去了一个用户。

2. 提供刷新按钮。

必要时候或最保险的方法使在相关界面提供一个刷新按钮，或者当下流行的下拉列表刷新方式。为缓存，为加载失败提供一次从新来过的机会。毕竟喝骨头汤的时候，我也不介意碗旁多双筷子。

总而言之，一切用户至上，为了更好的用户体验，方法也会层出不穷。期待更好的办法

关键代码：

[java] view plain copy print ?

package com.hulutan.gamestore.cache;
import java.io.File;
import java.io.IOException;
import android.os.Environment;
import android.util.Log;
import com.hulutan.gamestore.Constants;
import com.hulutan.gamestore.GameStoreApplication;
import com.hulutan.gamestore.util.EncryptUtils;
import com.hulutan.gamestore.util.FileUtils;
import com.hulutan.gamestore.util.NetworkUtils;
import com.hulutan.gamestore.util.NetworkUtils.NetworkState;
import com.hulutan.gamestore.util.StringUtils;
/**
* 缓存工具类
* @author naibo-liao
* @时间： 2013-1-4下午02:30:52
*/
public class ConfigCacheUtil {
private static final String TAG=ConfigCacheUtil.class.getName();
/** 1秒超时时间 */
public static final int CONFIG_CACHE_SHORT_TIMEOUT=1000 * 60 * 5; // 5 分钟
/** 5分钟超时时间 */
public static final int CONFIG_CACHE_MEDIUM_TIMEOUT=1000 * 3600 * 2; // 2小时
/** 中长缓存时间 */
public static final int CONFIG_CACHE_ML_TIMEOUT=1000 * 60 * 60 * 24 * 1; // 1天
/** 最大缓存时间 */
public static final int CONFIG_CACHE_MAX_TIMEOUT=1000 * 60 * 60 * 24 * 7; // 7天
/**
* CONFIG_CACHE_MODEL_LONG : 长时间(7天)缓存模式 <br>
* CONFIG_CACHE_MODEL_ML : 中长时间(12小时)缓存模式<br>
* CONFIG_CACHE_MODEL_MEDIUM: 中等时间(2小时)缓存模式 <br>
* CONFIG_CACHE_MODEL_SHORT : 短期(5分钟)缓存模式
*/
public enum ConfigCacheModel {
CONFIG_CACHE_MODEL_SHORT, CONFIG_CACHE_MODEL_MEDIUM, CONFIG_CACHE_MODEL_ML, CONFIG_CACHE_MODEL_LONG;
}
/**
* 获取缓存
* @param url 访问网络的URL
* @return 缓存数据
*/
public static String getUrlCache(String url, ConfigCacheModel model) {
if(url == null) {
return null;
}
String result=null;
String path=Constants.ENVIROMENT_DIR_CACHE + StringUtils.replaceUrlWithPlus(EncryptUtils.encryptToMD5(url));
File file=new File(path);
if(file.exists() && file.isFile()) {
long expiredTime=System.currentTimeMillis() - file.lastModified();
Log.d(TAG, file.getAbsolutePath() + " expiredTime:" + expiredTime / 60000 + "min");
// 1。若是系统时间是不正确的
// 2。当网络是无效的,你只能读缓存
if(NetworkUtils.getNetworkState(GameStoreApplication.getInstance().getContext()) != NetworkState.NETWORN_NONE) {
if(expiredTime < 0) {
return null;
}
if(model == ConfigCacheModel.CONFIG_CACHE_MODEL_SHORT) {
if(expiredTime > CONFIG_CACHE_SHORT_TIMEOUT) {
return null;
}
} else if(model == ConfigCacheModel.CONFIG_CACHE_MODEL_MEDIUM) {
if(expiredTime > CONFIG_CACHE_MEDIUM_TIMEOUT) {
return null;
}
} else if(model == ConfigCacheModel.CONFIG_CACHE_MODEL_ML) {
if(expiredTime > CONFIG_CACHE_ML_TIMEOUT) {
return null;
}
} else if(model == ConfigCacheModel.CONFIG_CACHE_MODEL_LONG) {
if(expiredTime > CONFIG_CACHE_MEDIUM_TIMEOUT) {
return null;
}
} else {
if(expiredTime > CONFIG_CACHE_MAX_TIMEOUT) {
return null;
}
}
}
try {
result=FileUtils.readTextFile(file);
} catch(IOException e) {
e.printStackTrace();
}
}
return result;
}
/**
* 设置缓存
* @param data
* @param url
*/
public static void setUrlCache(String data, String url) {
if(Constants.ENVIROMENT_DIR_CACHE == null) {
return;
}
File dir=new File(Constants.ENVIROMENT_DIR_CACHE);
if(!dir.exists() && Environment.getExternalStorageState().equals(android.os.Environment.MEDIA_MOUNTED)) {
dir.mkdirs();
}
File file=new File(Constants.ENVIROMENT_DIR_CACHE + StringUtils.replaceUrlWithPlus(EncryptUtils.encryptToMD5(url)));
try {
// 建立缓存数据到磁盘，就是建立文件
FileUtils.writeTextFile(file, data);
} catch(IOException e) {
Log.d(TAG, "write " + file.getAbsolutePath() + " data failed!");
e.printStackTrace();
} catch(Exception e) {
e.printStackTrace();
}
}
/**
* 删除历史缓存文件
* @param cacheFile
*/
public static void clearCache(File cacheFile) {
if(cacheFile == null) {
if(Environment.getExternalStorageState().equals(android.os.Environment.MEDIA_MOUNTED)) {
try {
File cacheDir=new File(Environment.getExternalStorageDirectory().getPath() + "/hulutan/cache/");
if(cacheDir.exists()) {
clearCache(cacheDir);
}
} catch(Exception e) {
e.printStackTrace();
}
}
} else if(cacheFile.isFile()) {
cacheFile.delete();
} else if(cacheFile.isDirectory()) {
File[] childFiles=cacheFile.listFiles();
for(int i=0; i < childFiles.length; i++) {
clearCache(childFiles[i]);
}
}
}
}

获取缓存：

[java] view plain copy print ?

String cacheConfigString=ConfigCacheUtil.getUrlCache(Net.API_HELP, ConfigCacheModel.CONFIG_CACHE_MODEL_LONG);
if(cacheConfigString != null) {
//do something
}

设置缓存：

[java] view plain copy print ?

ConfigCacheUtil.setUrlCache(data, Net.API_HELP);

补充 FileUtils 文件

[java] view plain copy print ?

/**
* 文件处理工具类
*
* @author naibo-liao
* @时间： 2013-1-4下午03:13:08
*/
public class FileUtils {
public static final long B = 1;
public static final long KB = B * 1024;
public static final long MB = KB * 1024;
public static final long GB = MB * 1024;
private static final int BUFFER = 8192;
/**
* 格式化文件大小<b> 带有单位
*
* @param size
* @return
*/
public static String formatFileSize(long size) {
StringBuilder sb = new StringBuilder();
String u = null;
double tmpSize = 0;
if (size < KB) {
sb.append(size).append("B");
return sb.toString();
} else if (size < MB) {
tmpSize = getSize(size, KB);
u = "KB";
} else if (size < GB) {
tmpSize = getSize(size, MB);
u = "MB";
} else {
tmpSize = getSize(size, GB);
u = "GB";
}
return sb.append(twodot(tmpSize)).append(u).toString();
}
/**
* 保留两位小数
*
* @param d
* @return
*/
public static String twodot(double d) {
return String.format("%.2f", d);
}
public static double getSize(long size, long u) {
return (double) size / (double) u;
}
/**
* sd卡挂载且可用
*
* @return
*/
public static boolean isSdCardMounted() {
return android.os.Environment.getExternalStorageState().equals(
android.os.Environment.MEDIA_MOUNTED);
}
/**
* 递归建立文件目录
*
* @param path
* */
public static void CreateDir(String path) {
if (!isSdCardMounted())
return;
File file = new File(path);
if (!file.exists()) {
try {
file.mkdirs();
} catch (Exception e) {
Log.e("hulutan", "error on creat dirs:" + e.getStackTrace());
}
}
}
/**
* 读取文件
*
* @param file
* @return
* @throws IOException
*/
public static String readTextFile(File file) throws IOException {
String text = null;
InputStream is = null;
try {
is = new FileInputStream(file);
text = readTextInputStream(is);;
} finally {
if (is != null) {
is.close();
}
}
return text;
}
/**
* 从流中读取文件
*
* @param is
* @return
* @throws IOException
*/
public static String readTextInputStream(InputStream is) throws IOException {
StringBuffer strbuffer = new StringBuffer();
String line;
BufferedReader reader = null;
try {
reader = new BufferedReader(new InputStreamReader(is));
while ((line = reader.readLine()) != null) {
strbuffer.append(line).append("\r\n");
}
} finally {
if (reader != null) {
reader.close();
}
}
return strbuffer.toString();
}
/**
* 将文本内容写入文件
*
* @param file
* @param str
* @throws IOException
*/
public static void writeTextFile(File file, String str) throws IOException {
DataOutputStream out = null;
try {
out = new DataOutputStream(new FileOutputStream(file));
out.write(str.getBytes());
} finally {
if (out != null) {
out.close();
}
}
}
/**
* 将Bitmap保存本地JPG图片
* @param url
* @return
* @throws IOException
*/
public static String saveBitmap2File(String url) throws IOException {
BufferedInputStream inBuff = null;
BufferedOutputStream outBuff = null;
SimpleDateFormat sf = new SimpleDateFormat("yyyy_MM_dd_HH_mm_ss");
String timeStamp = sf.format(new Date());
File targetFile = new File(Constants.ENVIROMENT_DIR_SAVE, timeStamp
+ ".jpg");
File oldfile = ImageLoader.getInstance().getDiscCache().get(url);
try {
inBuff = new BufferedInputStream(new FileInputStream(oldfile));
outBuff = new BufferedOutputStream(new FileOutputStream(targetFile));
byte[] buffer = new byte[BUFFER];
int length;
while ((length = inBuff.read(buffer)) != -1) {
outBuff.write(buffer, 0, length);
}
outBuff.flush();
return targetFile.getPath();
} catch (Exception e) {
} finally {
if (inBuff != null) {
inBuff.close();
}
if (outBuff != null) {
outBuff.close();
}
}
return targetFile.getPath();
}
/**
* 读取表情配置文件
*
* @param context
* @return
*/
public static List<String> getEmojiFile(Context context) {
try {
List<String> list = new ArrayList<String>();
InputStream in = context.getResources().getAssets().open("emoji");// 文件名字为rose.txt
BufferedReader br = new BufferedReader(new InputStreamReader(in,
"UTF-8"));
String str = null;
while ((str = br.readLine()) != null) {
list.add(str);
}
return list;
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
/**
* 获取一个文件夹大小
*
* @param f
* @return
* @throws Exception
*/
public static long getFileSize(File f) {
long size = 0;
File flist[] = f.listFiles();
for (int i = 0; i < flist.length; i++) {
if (flist[i].isDirectory()) {
size = size + getFileSize(flist[i]);
} else {
size = size + flist[i].length();
}
}
return size;
}
/**
* 删除文件
*
* @param file
*/
public static void deleteFile(File file) {
if (file.exists()) { // 判断文件是否存在
if (file.isFile()) { // 判断是不是文件
file.delete(); // delete()方法你应该知道是删除的意思;
} else if (file.isDirectory()) { // 不然若是它是一个目录
File files[] = file.listFiles(); // 声明目录下全部的文件 files[];
for (int i = 0; i < files.length; i++) { // 遍历目录下全部的文件
deleteFile(files[i]); // 把每一个文件用这个方法进行迭代
}
}
file.delete();
}
}
}