java写的cacheutils_你想要的CacheUtils

最新推荐文章于 2022-11-14 16:18:57 发布
最新推荐文章于 2022-11-14 16:18:57 发布
阅读量811 收藏
点赞数
文章标签： java写的cacheutils
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39875754/article/details/115084749
版权

你想要的CacheUtils

Foreword

好久没发布新的工具类了，这次就来个劲爆点的，就是大家熟悉的缓存相关工具类，花了好几天时间方才撸出来的一个工具类，现已通过单元测试，相关单元测试代码的链接可以在下面的API介绍看到，该工具类参考ASimpleCache来实现，由于它的代码是三年多前的，存在bug还是有挺多的，不过我重构的代码已修复我所发现的bug了，而且如今的代码阅读性极佳，条理清楚，大家可以好好学一学。

Feature

支持配置缓存大小和缓存数量，不配置的话就是没有上限，如果配置了缓存大小的和上限的话，当缓存到达最大缓存尺寸或者超过缓存个数的时候便会自动删除最老的缓存；

支持配置缓存路径，不配置的话默认在/data/data/com.xxx.xxx/cache/cacheUtils目录下；

支持多个实例缓存，也就是可以把缓存放在不同的文件夹下，他们会根据你的缓存实例各司其职；

支持缓存众多数据类型，分有字节数组、String、JSONObject、JSONArray、Bitmap、Drawable、Parcelable、Serializable这八种；

支持缓存写入有效时长，在下次读取时失效的话默认返回null，也可返回自定义的默认值；

缓存读写速度快，采用了NIO的数据读写，读取更是使用了内存映射，相当于读写内存的速率；

支持获取缓存大小和个数；

支持移除某个缓存和清除所有缓存；

还有就是谁用谁知道有多爽。

API

getInstance : 获取缓存实例

put : 缓存中写入数据

getBytes : 缓存中读取字节数组

getString : 缓存中读取String

getJSONObject : 缓存中读取JSONObject

getJSONArray : 缓存中读取JSONArray

getBitmap : 缓存中读取Bitmap

getDrawable : 缓存中读取Drawable

getParcelable : 缓存中读取Parcelable

getSerializable: 缓存中读取Serializable

getCacheSize : 获取缓存大小

getCacheCount : 获取缓存个数

remove : 根据键值移除缓存

clear : 清除所有缓存

Usage

CacheUtils mCacheUtils = CacheUtils.getInstance();

mCacheUtils.put("test_key1", "test value");

mCacheUtils.put("test_key2", "test value", 10);// 保存10s，10s后获取返回null

mCacheUtils.put("test_key3", "test value", 12 * CacheUtils.HOUR);// 保存12小时，12小时后获取返回null

mCacheUtils.getString("test_key1");

mCacheUtils.getString("test_key2", "defaultValue")// 存在且没过期返回对应值，否则返回defaultValue

更多用法参见单元测试

Source Code

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.graphics.Canvas;

import android.graphics.drawable.BitmapDrawable;

import android.graphics.drawable.Drawable;

import android.os.Parcel;

import android.os.Parcelable;

import android.os.Process;

import android.support.annotation.NonNull;

import org.json.JSONArray;

import org.json.JSONObject;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.RandomAccessFile;

import java.io.Serializable;

import java.nio.ByteBuffer;

import java.nio.MappedByteBuffer;

import java.nio.channels.FileChannel;

import java.util.Collections;

import java.util.HashMap;

import java.util.Locale;

import java.util.Map;

import java.util.Set;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.concurrent.atomic.AtomicLong;

/**

* 

 
 
* author: Blankj
 
 
* blog : http://blankj.com
 
 
* time : 2017/05/24
 
 
* desc : 缓存相关工具类
 
 
* 
 
 
*/
 
 
public class CacheUtils {
 
 
private static final long DEFAULT_MAX_SIZE = Long.MAX_VALUE;
 
 
private static final int DEFAULT_MAX_COUNT = Integer.MAX_VALUE;
 
 
public static final int SEC = 1;
 
 
public static final int MIN = 60;
 
 
public static final int HOUR = 3600;
 
 
public static final int DAY = 86400;
 
 
private static Map sCacheMap = new HashMap<>();
 
 
private CacheManager mCacheManager;
 
 
/**
 
 
* 获取缓存实例
 
 
* 
 
 
在/data/data/com.xxx.xxx/cache/cacheUtils目录
 
 
* 
 
 
缓存尺寸不限
 
 
* 
 
 
缓存个数不限
 
 
*
 
 
* @return {@link CacheUtils}
 
 
*/
 
 
public static CacheUtils getInstance() {
 
 
return getInstance("", DEFAULT_MAX_SIZE, DEFAULT_MAX_COUNT);
 
 
}
 
 
/**
 
 
* 获取缓存实例
 
 
* 
 
 
在/data/data/com.xxx.xxx/cache/cacheName目录
 
 
* 
 
 
缓存尺寸不限
 
 
* 
 
 
缓存个数不限
 
 
*
 
 
* @param cacheName 缓存目录名
 
 
* @return {@link CacheUtils}
 
 
*/
 
 
public static CacheUtils getInstance(String cacheName) {
 
 
return getInstance(cacheName, DEFAULT_MAX_SIZE, DEFAULT_MAX_COUNT);
 
 
}
 
 
/**
 
 
* 获取缓存实例
 
 
* 
 
 
在/data/data/com.xxx.xxx/cache/cacheUtils目录
 
 
*
 
 
* @param maxSize 最大缓存尺寸，单位字节
 
 
* @param maxCount 最大缓存个数
 
 
* @return {@link CacheUtils}
 
 
*/
 
 
public static CacheUtils getInstance(long maxSize, int maxCount) {
 
 
return getInstance("", maxSize, maxCount);
 
 
}
 
 
/**
 
 
* 获取缓存实例
 
 
* 
 
 
在/data/data/com.xxx.xxx/cache/cacheName目录
 
 
*
 
 
* @param cacheName 缓存目录名
 
 
* @param maxSize 最大缓存尺寸，单位字节
 
 
* @param maxCount 最大缓存个数
 
 
* @return {@link CacheUtils}
 
 
*/
 
 
public static CacheUtils getInstance(String cacheName, long maxSize, int maxCount) {
 
 
if (isSpace(cacheName)) cacheName = "cacheUtils";
 
 
File file = new File(Utils.getContext().getCacheDir(), cacheName);
 
 
return getInstance(file, maxSize, maxCount);
 
 
}
 
 
/**
 
 
* 获取缓存实例
 
 
* 
 
 
在cacheDir目录
 
 
* 
 
 
缓存尺寸不限
 
 
* 
 
 
缓存个数不限
 
 
*
 
 
* @param cacheDir 缓存目录
 
 
* @return {@link CacheUtils}
 
 
*/
 
 
public static CacheUtils getInstance(@NonNull File cacheDir) {
 
 
return getInstance(cacheDir, DEFAULT_MAX_SIZE, DEFAULT_MAX_COUNT);
 
 
}
 
 
/**
 
 
* 获取缓存实例
 
 
* 
 
 
在cacheDir目录
 
 
*
 
 
* @param cacheDir 缓存目录
 
 
* @param maxSize 最大缓存尺寸，单位字节
 
 
* @param maxCount 最大缓存个数
 
 
* @return {@link CacheUtils}
 
 
*/
 
 
public static CacheUtils getInstance(@NonNull File cacheDir, long maxSize, int maxCount) {
 
 
final String cacheKey = cacheDir.getAbsoluteFile() + "_" + Process.myPid();
 
 
CacheUtils cache = sCacheMap.get(cacheKey);
 
 
if (cache == null) {
 
 
cache = new CacheUtils(cacheDir, maxSize, maxCount);
 
 
sCacheMap.put(cacheKey, cache);
 
 
}
 
 
return cache;
 
 
}
 
 
private CacheUtils(@NonNull File cacheDir, long maxSize, int maxCount) {
 
 
if (!cacheDir.exists() && !cacheDir.mkdirs()) {
 
 
throw new RuntimeException("can't make dirs in " + cacheDir.getAbsolutePath());
 
 
}
 
 
mCacheManager = new CacheManager(cacheDir, maxSize, maxCount);
 
 
}
 
 
///
 
 
// byte 读写
 
 
///
 
 
/**
 
 
* 缓存中写入字节数组
 
 
*
 
 
* @param key 键
 
 
* @param value 值
 
 
*/
 
 
public void put(@NonNull String key, @NonNull byte[] value) {
 
 
put(key, value, -1);
 
 
}
 
 
/**
 
 
* 缓存中写入字节数组
 
 
*
 
 
* @param key 键
 
 
* @param value 值
 
 
* @param saveTime 保存时长，单位：秒
 
 
*/
 
 
public void put(@NonNull String key, @NonNull byte[] value, int saveTime) {
 
 
if (value.length <= 0) return;
 
 
if (saveTime >= 0) value = CacheHelper.newByteArrayWithTime(saveTime, value);
 
 
File file = mCacheManager.getFileBeforePut(key);
 
 
CacheHelper.writeFileFromBytes(file, value);
 
 
mCacheManager.updateModify(file);
 
 
mCacheManager.put(file);
 
 
}
 
 
/**
 
 
* 缓存中读取字节数组
 
 
*
 
 
* @param key 键
 
 
* @return 存在且没过期返回对应值，否则返回{@code null}
 
 
*/
 
 
public byte[] getBytes(@NonNull String key) {
 
 
return getBytes(key, null);
 
 
}
 
 
/**
 
 
* 缓存中读取字节数组
 
 
*
 
 
* @param key 键
 
 
* @param defaultValue 默认值
 
 
* @return 存在且没过期返回对应值，否则返回默认值{@code defaultValue}
 
 
*/
 
 
public byte[] getBytes(@NonNull String key, byte[] defaultValue) {
 
 
final File file = mCacheManager.getFileIfExists(key);
 
 
if (file == null) return defaultValue;
 
 
byte[] data = CacheHelper.readFile2Bytes(file);
 
 
if (CacheHelper.isDue(data)) {
 
 
mCacheManager.removeByKey(key);
 
 
return defaultValue;
 
 
}
 
 
mCacheManager.updateModify(file);
 
 
return CacheHelper.getDataWithoutDueTime(data);
 
 
}
 
 
///
 
 
// String 读写
 
 
///
 
 
/**
 
 
* 缓存中写入String
 
 
*
 
 
* @param key 键
 
 
* @param value 值
 
 
*/
 
 
public void put(@NonNull String key, @NonNull String value) {
 
 
put(key, value, -1);
 
 
}
 
 
/**
 
 
* 缓存中写入String
 
 
*
 
 
* @param key 键
 
 
* @param value 值
 
 
* @param saveTime 保存时长，单位：秒
 
 
*/
 
 
public void put(@NonNull String key, @NonNull String value, int saveTime) {
 
 
put(key, CacheHelper.string2Bytes(value), saveTime);
 
 
}
 
 
/**
 
 
* 缓存中读取String
 
 
*
 
 
* @param key 键
 
 
* @return 存在且没过期返回对应值，否则返回{@code null}
 
 
*/
 
 
public String getString(@NonNull String key) {
 
 
return getString(key, null);
 
 
}
 
 
/**
 
 
* 缓存中读取String
 
 
*
 
 
* @param key 键
 
 
* @param defaultValue 默认值
 
 
* @return 存在且没过期返回对应值，否则返回默认值{@code defaultValue}
 
 
*/
 
 
public String getString(@NonNull String key, String defaultValue) {
 
 
byte[] bytes = getBytes(key);
 
 
if (bytes == null) return defaultValue;
 
 
return CacheHelper.bytes2String(bytes);
 
 
}
 
 
///
 
 
// JSONObject 读写
 
 
///
 
 
/**
 
 
* 缓存中写入JSONObject
 
 
*
 
 
* @param key 键
 
 
* @param value 值
 
 
*/
 
 
public void put(@NonNull String key, @NonNull JSONObject value) {
 
 
put(key, value, -1);
 
 
}
 
 
/**
 
 
* 缓存中写入JSONObject
 
 
*
 
 
* @param key 键
 
 
* @param value 值
 
 
* @param saveTime 保存时长，单位：秒
 
 
*/
 
 
public void put(@NonNull String key, @NonNull JSONObject value, int saveTime) {
 
 
put(key, CacheHelper.jsonObject2Bytes(value), saveTime);
 
 
}
 
 
/**
 
 
* 缓存中读取JSONObject
 
 
*
 
 
* @param key 键
 
 
* @return 存在且没过期返回对应值，否则返回{@code null}
 
 
*/
 
 
public JSONObject getJSONObject(@NonNull String key) {
 
 
return getJSONObject(key, null);
 
 
}
 
 
/**
 
 
* 缓存中读取JSONObject
 
 
*
 
 
* @param key 键
 
 
* @param defaultValue 默认值
 
 
* @return 存在且没过期返回对应值，否则返回默认值{@code defaultValue}
 
 
*/
 
 
public JSONObject getJSONObject(@NonNull String key, JSONObject defaultValue) {
 
 
byte[] bytes = getBytes(key);
 
 
if (bytes == null) return defaultValue;
 
 
return CacheHelper.bytes2JSONObject(bytes);
 
 
}
 
 
///
 
 
// JSONArray 读写
 
 
///
 
 
/**
 
 
* 缓存中写入JSONArray
 
 
*
 
 
* @param key 键
 
 
* @param value 值
 
 
*/
 
 
public void put(@NonNull String key, @NonNull JSONArray value) {
 
 
put(key, value, -1);
 
 
}
 
 
/**
 
 
* 缓存中写入JSONArray
 
 
*
 
 
* @param key 键
 
 
* @param value 值
 
 
* @param saveTime 保存时长，单位：秒
 
 
*/
 
 
public void put(@NonNull String key, @NonNull JSONArray value, int saveTime) {
 
 
put(key, CacheHelper.jsonArray2Bytes(value), saveTime);
 
 
}
 
 
/**
 
 
* 缓存中读取JSONArray
 
 
*
 
 
* @param key 键
 
 
* @return 存在且没过期返回对应值，否则返回{@code null}
 
 
*/
 
 
public JSONArray getJSONArray(@NonNull String key) {
 
 
return getJSONArray(key, null);
 
 
}
 
 
/**
 
 
* 缓存中读取JSONArray
 
 
*
 
 
* @param key 键
 
 
* @param defaultValue 默认值
 
 
* @return 存在且没过期返回对应值，否则返回默认值{@code defaultValue}
 
 
*/
 
 
public JSONArray getJSONArray(@NonNull String key, JSONArray defaultValue) {
 
 
byte[] bytes = getBytes(key);
 
 
if (bytes == null) return defaultValue;
 
 
return CacheHelper.bytes2JSONArray(bytes);
 
 
}
 
 
///
 
 
// Bitmap 读写
 
 
///
 
 
/**
 
 
* 缓存中写入Bitmap
 
 
*
 
 
* @param key 键
 
 
* @param value 值
 
 
*/
 
 
public void put(@NonNull String key, @NonNull Bitmap value) {
 
 
put(key, value, -1);
 
 
}
 
 
/**
 
 
* 缓存中写入Bitmap
 
 
*
 
 
* @param key 键
 
 
* @param value 值
 
 
* @param saveTime 保存时长，单位：秒
 
 
*/
 
 
public void put(@NonNull String key, @NonNull Bitmap value, int saveTime) {
 
 
put(key, CacheHelper.bitmap2Bytes(value), saveTime);
 
 
}
 
 
/**
 
 
* 缓存中读取Bitmap
 
 
*
 
 
* @param key 键
 
 
* @return 存在且没过期返回对应值，否则返回{@code null}
 
 
*/
 
 
public Bitmap getBitmap(@NonNull String key) {
 
 
return getBitmap(key, null);
 
 
}
 
 
/**
 
 
* 缓存中读取Bitmap
 
 
*
 
 
* @param key 键
 
 
* @param defaultValue 默认值
 
 
* @return 存在且没过期返回对应值，否则返回默认值{@code defaultValue}
 
 
*/
 
 
public Bitmap getBitmap(@NonNull String key, Bitmap defaultValue) {
 
 
byte[] bytes = getBytes(key);
 
 
if (bytes == null) return defaultValue;
 
 
return CacheHelper.bytes2Bitmap(bytes);
 
 
}
 
 
///
 
 
// Drawable 读写
 
 
///
 
 
/**
 
 
* 缓存中写入Drawable
 
 
*
 
 
* @param key 键
 
 
* @param value 值
 
 
*/
 
 
public void put(@NonNull String key, @NonNull Drawable value) {
 
 
put(key, CacheHelper.drawable2Bytes(value));
 
 
}
 
 
/**
 
 
* 缓存中写入Drawable
 
 
*
 
 
* @param key 键
 
 
* @param value 值
 
 
* @param saveTime 保存时长，单位：秒
 
 
*/
 
 
public void put(@NonNull String key, @NonNull Drawable value, int saveTime) {
 
 
put(key, CacheHelper.drawable2Bytes(value), saveTime);
 
 
}
 
 
/**
 
 
* 缓存中读取Drawable
 
 
*
 
 
* @param key 键
 
 
* @return 存在且没过期返回对应值，否则返回{@code null}
 
 
*/
 
 
public Drawable getDrawable(@NonNull String key) {
 
 
return getDrawable(key, null);
 
 
}
 
 
/**
 
 
* 缓存中读取Drawable
 
 
*
 
 
* @param key 键
 
 
* @param defaultValue 默认值
 
 
* @return 存在且没过期返回对应值，否则返回默认值{@code defaultValue}
 
 
*/
 
 
public Drawable getDrawable(@NonNull String key, Drawable defaultValue) {
 
 
byte[] bytes = getBytes(key);
 
 
if (bytes == null) return defaultValue;
 
 
return CacheHelper.bytes2Drawable(bytes);
 
 
}
 
 
///
 
 
// Parcelable 读写
 
 
///
 
 
/**
 
 
* 缓存中写入Parcelable
 
 
*
 
 
* @param key 键
 
 
* @param value 值
 
 
*/
 
 
public void put(@NonNull String key, @NonNull Parcelable value) {
 
 
put(key, value, -1);
 
 
}
 
 
/**
 
 
* 缓存中写入Parcelable
 
 
*
 
 
* @param key 键
 
 
* @param value 值
 
 
* @param saveTime 保存时长，单位：秒
 
 
*/
 
 
public void put(@NonNull String key, @NonNull Parcelable value, int saveTime) {
 
 
put(key, CacheHelper.parcelable2Bytes(value), saveTime);
 
 
}
 
 
/**
 
 
* 缓存中读取Parcelable
 
 
*
 
 
* @param key 键
 
 
* @param creator 建造器
 
 
* @return 存在且没过期返回对应值，否则返回{@code null}
 
 
*/
 
 
public T getParcelable(@NonNull String key, @NonNull Parcelable.Creator creator) {
 
 
return getParcelable(key, creator, null);
 
 
}
 
 
/**
 
 
* 缓存中读取Parcelable
 
 
*
 
 
* @param key 键
 
 
* @param creator 建造器
 
 
* @param defaultValue 默认值
 
 
* @return 存在且没过期返回对应值，否则返回默认值{@code defaultValue}
 
 
*/
 
 
public T getParcelable(@NonNull String key, @NonNull Parcelable.Creator creator, T defaultValue) {
 
 
byte[] bytes = getBytes(key);
 
 
if (bytes == null) return defaultValue;
 
 
return CacheHelper.bytes2Parcelable(bytes, creator);
 
 
}
 
 
///
 
 
// Serializable 读写
 
 
///
 
 
/**
 
 
* 缓存中写入Serializable
 
 
*
 
 
* @param key 键
 
 
* @param value 值
 
 
*/
 
 
public void put(@NonNull String key, @NonNull Serializable value) {
 
 
put(key, value, -1);
 
 
}
 
 
/**
 
 
* 缓存中写入Serializable
 
 
*
 
 
* @param key 键
 
 
* @param value 值
 
 
* @param saveTime 保存时长，单位：秒
 
 
*/
 
 
public void put(@NonNull String key, @NonNull Serializable value, int saveTime) {
 
 
put(key, CacheHelper.serializable2Bytes(value), saveTime);
 
 
}
 
 
/**
 
 
* 缓存中读取Serializable
 
 
*
 
 
* @param key 键
 
 
* @return 存在且没过期返回对应值，否则返回{@code null}
 
 
*/
 
 
public Object getSerializable(@NonNull String key) {
 
 
return getSerializable(key, null);
 
 
}
 
 
/**
 
 
* 缓存中读取Serializable
 
 
*
 
 
* @param key 键
 
 
* @param defaultValue 默认值
 
 
* @return 存在且没过期返回对应值，否则返回默认值{@code defaultValue}
 
 
*/
 
 
public Object getSerializable(@NonNull String key, Object defaultValue) {
 
 
byte[] bytes = getBytes(key);
 
 
if (bytes == null) return defaultValue;
 
 
return CacheHelper.bytes2Object(getBytes(key));
 
 
}
 
 
/**
 
 
* 获取缓存大小
 
 
* 
 
 
单位：字节
 
 
*
 
 
* @return 缓存大小
 
 
*/
 
 
public long getCacheSize() {
 
 
return mCacheManager.getCacheSize();
 
 
}
 
 
/**
 
 
* 获取缓存个数
 
 
*
 
 
* @return 缓存个数
 
 
*/
 
 
public int getCacheCount() {
 
 
return mCacheManager.getCacheCount();
 
 
}
 
 
/**
 
 
* 根据键值移除缓存
 
 
*
 
 
* @param key 键
 
 
* @return {@code true}: 移除成功
{@code false}: 移除失败
 
 
*/
 
 
public boolean remove(@NonNull String key) {
 
 
return mCacheManager.removeByKey(key);
 
 
}
 
 
/**
 
 
* 清除所有缓存
 
 
*
 
 
* @return {@code true}: 清除成功
{@code false}: 清除失败
 
 
*/
 
 
public boolean clear() {
 
 
return mCacheManager.clear();
 
 
}
 
 
private class CacheManager {
 
 
private final AtomicLong cacheSize;
 
 
private final AtomicInteger cacheCount;
 
 
private final long sizeLimit;
 
 
private final int countLimit;
 
 
private final Map lastUsageDates = Collections.synchronizedMap(new HashMap());
 
 
private final File cacheDir;
 
 
private CacheManager(File cacheDir, long sizeLimit, int countLimit) {
 
 
this.cacheDir = cacheDir;
 
 
this.sizeLimit = sizeLimit;
 
 
this.countLimit = countLimit;
 
 
cacheSize = new AtomicLong();
 
 
cacheCount = new AtomicInteger();
 
 
calculateCacheSizeAndCacheCount();
 
 
}
 
 
private void calculateCacheSizeAndCacheCount() {
 
 
new Thread(new Runnable() {
 
 
@Override
 
 
public void run() {
 
 
int size = 0;
 
 
int count = 0;
 
 
final File[] cachedFiles = cacheDir.listFiles();
 
 
if (cachedFiles != null) {
 
 
for (File cachedFile : cachedFiles) {
 
 
size += cachedFile.length();
 
 
count += 1;
 
 
lastUsageDates.put(cachedFile, cachedFile.lastModified());
 
 
}
 
 
cacheSize.getAndAdd(size);
 
 
cacheCount.getAndAdd(count);
 
 
}
 
 
}
 
 
}).start();
 
 
}
 
 
private long getCacheSize() {
 
 
return cacheSize.get();
 
 
}
 
 
private int getCacheCount() {
 
 
return cacheCount.get();
 
 
}
 
 
private File getFileBeforePut(String key) {
 
 
File file = new File(cacheDir, String.valueOf(key.hashCode()));
 
 
if (file.exists()) {
 
 
cacheCount.addAndGet(-1);
 
 
cacheSize.addAndGet(-file.length());
 
 
}
 
 
return file;
 
 
}
 
 
private File getFileIfExists(String key) {
 
 
File file = new File(cacheDir, String.valueOf(key.hashCode()));
 
 
if (!file.exists()) return null;
 
 
return file;
 
 
}
 
 
private void put(File file) {
 
 
cacheCount.addAndGet(1);
 
 
cacheSize.addAndGet(file.length());
 
 
while (cacheCount.get() > countLimit || cacheSize.get() > sizeLimit) {
 
 
cacheSize.addAndGet(-removeOldest());
 
 
cacheCount.addAndGet(-1);
 
 
}
 
 
}
 
 
private void updateModify(File file) {
 
 
Long millis = System.currentTimeMillis();
 
 
file.setLastModified(millis);
 
 
lastUsageDates.put(file, millis);
 
 
}
 
 
private boolean removeByKey(String key) {
 
 
File file = getFileIfExists(key);
 
 
if (file == null) return true;
 
 
if (!file.delete()) return false;
 
 
cacheSize.addAndGet(-file.length());
 
 
cacheCount.addAndGet(-1);
 
 
lastUsageDates.remove(file);
 
 
return true;
 
 
}
 
 
private boolean clear() {
 
 
File[] files = cacheDir.listFiles();
 
 
if (files == null || files.length <= 0) return true;
 
 
boolean flag = true;
 
 
for (File file : files) {
 
 
if (!file.delete()) {
 
 
flag = false;
 
 
continue;
 
 
}
 
 
cacheSize.addAndGet(-file.length());
 
 
cacheCount.addAndGet(-1);
 
 
lastUsageDates.remove(file);
 
 
}
 
 
if (flag) {
 
 
lastUsageDates.clear();
 
 
cacheSize.set(0);
 
 
cacheCount.set(0);
 
 
}
 
 
return flag;
 
 
}
 
 
/**
 
 
* 移除旧的文件
 
 
*
 
 
* @return 移除的字节数
 
 
*/
 
 
private long removeOldest() {
 
 
if (lastUsageDates.isEmpty()) return 0;
 
 
Long oldestUsage = Long.MAX_VALUE;
 
 
File oldestFile = null;
 
 
Set> entries = lastUsageDates.entrySet();
 
 
synchronized (lastUsageDates) {
 
 
for (Map.Entry entry : entries) {
 
 
Long lastValueUsage = entry.getValue();
 
 
if (lastValueUsage < oldestUsage) {
 
 
oldestUsage = lastValueUsage;
 
 
oldestFile = entry.getKey();
 
 
}
 
 
}
 
 
}
 
 
if (oldestFile == null) return 0;
 
 
long fileSize = oldestFile.length();
 
 
if (oldestFile.delete()) {
 
 
lastUsageDates.remove(oldestFile);
 
 
return fileSize;
 
 
}
 
 
return 0;
 
 
}
 
 
}
 
 
private static class CacheHelper {
 
 
static final int timeInfoLen = 14;
 
 
private static byte[] newByteArrayWithTime(int second, byte[] data) {
 
 
byte[] time = createDueTime(second).getBytes();
 
 
byte[] content = new byte[time.length + data.length];
 
 
System.arraycopy(time, 0, content, 0, time.length);
 
 
System.arraycopy(data, 0, content, time.length, data.length);
 
 
return content;
 
 
}
 
 
/**
 
 
* 创建过期时间
 
 
*
 
 
* @param second 秒
 
 
* @return _$millis$_
 
 
*/
 
 
private static String createDueTime(int second) {
 
 
return String.format(Locale.getDefault(), "_$%010d$_", System.currentTimeMillis() / 1000 + second);
 
 
}
 
 
private static boolean isDue(byte[] data) {
 
 
long millis = getDueTime(data);
 
 
return millis != -1 && System.currentTimeMillis() > millis;
 
 
}
 
 
private static long getDueTime(byte[] data) {
 
 
if (hasTimeInfo(data)) {
 
 
String millis = new String(copyOfRange(data, 2, 12));
 
 
try {
 
 
return Long.parseLong(millis) * 1000;
 
 
} catch (NumberFormatException e) {
 
 
return -1;
 
 
}
 
 
}
 
 
return -1;
 
 
}
 
 
private static byte[] getDataWithoutDueTime(byte[] data) {
 
 
if (hasTimeInfo(data)) {
 
 
return copyOfRange(data, timeInfoLen, data.length);
 
 
}
 
 
return data;
 
 
}
 
 
private static byte[] copyOfRange(byte[] original, int from, int to) {
 
 
int newLength = to - from;
 
 
if (newLength < 0) throw new IllegalArgumentException(from + " > " + to);
 
 
byte[] copy = new byte[newLength];
 
 
System.arraycopy(original, from, copy, 0, Math.min(original.length - from, newLength));
 
 
return copy;
 
 
}
 
 
private static boolean hasTimeInfo(byte[] data) {
 
 
return data != null
 
 
&& data.length >= timeInfoLen
 
 
&& data[0] == '_'
 
 
&& data[1] == '$'
 
 
&& data[12] == '$'
 
 
&& data[13] == '_';
 
 
}
 
 
private static void writeFileFromBytes(File file, byte[] bytes) {
 
 
FileChannel fc = null;
 
 
try {
 
 
fc = new FileOutputStream(file, false).getChannel();
 
 
fc.write(ByteBuffer.wrap(bytes));
 
 
fc.force(true);
 
 
} catch (IOException e) {
 
 
e.printStackTrace();
 
 
} finally {
 
 
CloseUtils.closeIO(fc);
 
 
}
 
 
}
 
 
private static byte[] readFile2Bytes(File file) {
 
 
FileChannel fc = null;
 
 
try {
 
 
fc = new RandomAccessFile(file, "r").getChannel();
 
 
int size = (int) fc.size();
 
 
MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_ONLY, 0, size).load();
 
 
byte[] data = new byte[size];
 
 
mbb.get(data, 0, size);
 
 
return data;
 
 
} catch (IOException e) {
 
 
e.printStackTrace();
 
 
return null;
 
 
} finally {
 
 
CloseUtils.closeIO(fc);
 
 
}
 
 
}
 
 
private static byte[] string2Bytes(String string) {
 
 
if (string == null) return null;
 
 
return string.getBytes();
 
 
}
 
 
private static String bytes2String(byte[] bytes) {
 
 
if (bytes == null) return null;
 
 
return new String(bytes);
 
 
}
 
 
private static byte[] jsonObject2Bytes(JSONObject jsonObject) {
 
 
if (jsonObject == null) return null;
 
 
return jsonObject.toString().getBytes();
 
 
}
 
 
private static JSONObject bytes2JSONObject(byte[] bytes) {
 
 
if (bytes == null) return null;
 
 
try {
 
 
return new JSONObject(new String(bytes));
 
 
} catch (Exception e) {
 
 
e.printStackTrace();
 
 
return null;
 
 
}
 
 
}
 
 
private static byte[] jsonArray2Bytes(JSONArray jsonArray) {
 
 
if (jsonArray == null) return null;
 
 
return jsonArray.toString().getBytes();
 
 
}
 
 
private static JSONArray bytes2JSONArray(byte[] bytes) {
 
 
if (bytes == null) return null;
 
 
try {
 
 
return new JSONArray(new String(bytes));
 
 
} catch (Exception e) {
 
 
e.printStackTrace();
 
 
return null;
 
 
}
 
 
}
 
 
private static byte[] parcelable2Bytes(Parcelable parcelable) {
 
 
if (parcelable == null) return null;
 
 
Parcel parcel = Parcel.obtain();
 
 
parcelable.writeToParcel(parcel, 0);
 
 
byte[] bytes = parcel.marshall();
 
 
parcel.recycle();
 
 
return bytes;
 
 
}
 
 
private static T bytes2Parcelable(byte[] bytes, Parcelable.Creator creator) {
 
 
if (bytes == null) return null;
 
 
Parcel parcel = Parcel.obtain();
 
 
parcel.unmarshall(bytes, 0, bytes.length);
 
 
parcel.setDataPosition(0);
 
 
T result = creator.createFromParcel(parcel);
 
 
parcel.recycle();
 
 
return result;
 
 
}
 
 
private static byte[] serializable2Bytes(Serializable serializable) {
 
 
if (serializable == null) return null;
 
 
ByteArrayOutputStream baos;
 
 
ObjectOutputStream oos = null;
 
 
try {
 
 
oos = new ObjectOutputStream(baos = new ByteArrayOutputStream());
 
 
oos.writeObject(serializable);
 
 
return baos.toByteArray();
 
 
} catch (Exception e) {
 
 
e.printStackTrace();
 
 
return null;
 
 
} finally {
 
 
CloseUtils.closeIO(oos);
 
 
}
 
 
}
 
 
private static Object bytes2Object(byte[] bytes) {
 
 
if (bytes == null) return null;
 
 
ObjectInputStream ois = null;
 
 
try {
 
 
ois = new ObjectInputStream(new ByteArrayInputStream(bytes));
 
 
return ois.readObject();
 
 
} catch (Exception e) {
 
 
e.printStackTrace();
 
 
return null;
 
 
} finally {
 
 
CloseUtils.closeIO(ois);
 
 
}
 
 
}
 
 
private static byte[] bitmap2Bytes(Bitmap bitmap) {
 
 
if (bitmap == null) return null;
 
 
ByteArrayOutputStream baos = new ByteArrayOutputStream();
 
 
bitmap.compress(Bitmap.CompressFormat.PNG, 100, baos);
 
 
return baos.toByteArray();
 
 
}
 
 
private static Bitmap bytes2Bitmap(byte[] bytes) {
 
 
return (bytes == null || bytes.length == 0) ? null : BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
 
 
}
 
 
private static byte[] drawable2Bytes(Drawable drawable) {
 
 
return drawable == null ? null : bitmap2Bytes(drawable2Bitmap(drawable));
 
 
}
 
 
private static Drawable bytes2Drawable(byte[] bytes) {
 
 
return bytes == null ? null : Bitmap2Drawable(bytes2Bitmap(bytes));
 
 
}
 
 
private static Bitmap drawable2Bitmap(Drawable drawable) {
 
 
if (drawable == null) return null;
 
 
if (drawable instanceof BitmapDrawable) {
 
 
BitmapDrawable BitmapDrawable = (BitmapDrawable) drawable;
 
 
if (BitmapDrawable.getBitmap() != null) {
 
 
return BitmapDrawable.getBitmap();
 
 
}
 
 
}
 
 
Bitmap bitmap;
 
 
if (drawable.getIntrinsicWidth() <= 0 || drawable.getIntrinsicHeight() <= 0) {
 
 
bitmap = Bitmap.createBitmap(1, 1, Bitmap.Config.ARGB_8888);
 
 
} else {
 
 
bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
 
 
}
 
 
Canvas canvas = new Canvas(bitmap);
 
 
drawable.setBounds(0, 0, canvas.getWidth(), canvas.getHeight());
 
 
drawable.draw(canvas);
 
 
return bitmap;
 
 
}
 
 
private static Drawable Bitmap2Drawable(Bitmap Bitmap) {
 
 
return Bitmap == null ? null : new BitmapDrawable(Utils.getContext().getResources(), Bitmap);
 
 
}
 
 
}
 
 
private static boolean isSpace(String s) {
 
 
if (s == null) return true;
 
 
for (int i = 0, len = s.length(); i < len; ++i) {
 
 
if (!Character.isWhitespace(s.charAt(i))) {
 
 
return false;
 
 
}
 
 
}
 
 
return true;
 
 
}
 
 
}
 
 
Conclusion
 
 
好了，终点站到了，如果对本次旅途满意的话，请给五星好评哦，毕竟老司机牺牲了很多时间才换来这么一份工具类，如果该工具类依赖其他工具类，都可以在我的
 


                

        

        




    




    

      

        

            

              
                
                  weixin_39875754
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
java写的cacheutils_本地缓存(Cache)系统简易设计

				
			

			

				

					weixin_39631344的博客
				

				

					02-25
					
					497
					
				

			

		

		

			
				
本地Cache系统简易设计为什么使用缓存？降低数据库的访问压力。提高查询效率。改善用户体验。你都了解哪些缓存？数据库内置缓存(DBA修改)。数据层缓存(由持久层框架决定,例如mybatis)业务层缓存(由业务层框架以及第三缓存产品决定:本地缓存+分布式缓存)浏览器缓存(Cache-Control)设计缓存都应该考虑什么问题？存储结构：使用什么结构存储数据？(数组，链表，散列存储-哈希存储)淘汰算法...

			
		

	



                

              
                



	

		

			

				
					
java工具类之cache缓存

				
			

			

				

					whwwycl的博客
				

				

					04-30
					
					642
					
				

			

		

		

			
				
创建一个java自己的缓存，包括kv存取
public class CacheUtil {
    private static Map<String, Object> cacheMap = new HashMap<String, Object>();

    private static ReadWriteLock lock = new ReentrantReadWriteLock();

    /*
    * 添加缓存
    * @Param obj 塞入的值
    *

			
		

	



                


  
              

                


	

		

			

				
					
CacheUtils

				
			

			

				

					weixin_41249041的博客
				

				

					10-19
					
					400
					
				

			

		

		

			
				
package com.thinkgem.jeesite.common.utils;

import java.util.Iterator;
import java.util.Set;

import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheManager;
import org.slf4j.Logger...

			
		

	





	

		

			

				
					
13.使用缓存

				
			

			

				

					chris_sen的博客
				

				

					05-18
					
					246
					
				

			

		

		

			
				
整套Play资料，从概念到具体事务，由浅入深的系统学习play。 经过本人整理和调整，希望能帮组到想要学习Play的小伙伴。持续更新中......

			
		

	



		

			
		



	

		

			

				
					
Java本地缓存工具，LoadingCache的使用（附代码） | Java工具类

				
			

			

				

					阿良的博客
				

				

					12-31
					
					4554
					
				

			

		

		

			
				
在工作总常常需要用到缓存，而redis往往是首选，但是短期的数据缓存一般我们还是会用到本地缓存。本文提供一个我在工作中用到的缓存工具，该工具代码为了演示做了一些调整。如果拿去使用的话，可以考虑做成注入Bean对象，看具体需求了。

			
		

	





	

		

			

				
					
Android 清除缓存功能

				
			

			

				

					m0_58663436的博客
				

				

					11-14
					
					1160
					
				

			

		

		

			
				
清除缓存工具类

			
		

	





	

		

			

				
					
EasyCommons JAVA 通用开发组件项目组

					
最新发布

				
			

			

				

					01-14
				

			

		

		

			
				
"EasyCommons JAVA 通用开发组件项目组"是一个专注于提供Java开发中常用工具类和模块化组件的项目。这个项目的目标是为Java开发者提供一套便捷、高效且易于集成的库，帮助他们快速构建应用程序，减少重复工作，提高...

			
		

	





	

		

			

				
					
JAVA整合JEDIS操作访问Redis的工具类

				
			

			

				

					10-27
				

			

		

		

			
				
本篇文章将深入探讨如何使用Java整合JEDIS来访问Redis，并介绍提供的工具类`CacheUtils`。  首先，Jedis是Java语言编写的Redis客户端，它提供了丰富的API，涵盖了Redis的所有命令，包括基本的数据类型如字符串...

			
		

	





	

		

			

				
					
JAVA开发27种常用工具类.zip

				
			

			

				

					01-21
				

			

		

		

			
				
在Java开发过程中，工具类（Utility Class）是程序员日常工作中不可或缺的部分。它们提供了一系列静态方法，帮助开发者简化代码，提高效率。"JAVA开发27种常用工具类.zip"这个压缩包很可能包含了各种实用的工具类...

			
		

	





	

		

			

				
					
28个java常用的工具类

				
			

			

				

					10-27
				

			

		

		

			
				
Java语言在开发过程中，工具类的使用不可或缺，它们提供了各种便捷的功能，简化了代码编写，提高了开发效率。这里我们探讨的“28个Java常用的工具类”集合，涵盖了字符串处理、日期时间操作、数学计算、集合操作等多...

			
		

	





	

		

			

				
					
meta_ws:球衣Springmybatis基本演示

				
			

			

				

					05-12
				

			

		

		

			
				
一、背景 针对目前各项目代码结构混乱，...基于Jersey Client封装的HttpUtils(调用http接口)，基于guava Cache封装的CacheUtils(缓存使用)，基于gson封装的JsonUtils(序列化json) jerseyClient剖析 Guava Cache使用教

			
		

	





	

		

			

				
					
Java中省时省力的工具类

				
			

			

				

					m0_45068483的博客
				

				

					08-09
					
					194
					
				

			

		

		

			
				
下面来看一看可以节省大部分时间的第三方开源库吧，第一个介绍的必须是Apache 下的 Commons 库，第二个是 google 开源的 Guava 库。

			
		

	





	

		

			

				
					
java cacheutil_缓存工具CacheUtil - 并发环境的缓存值存取

				
			

			

				

					weixin_30431137的博客
				

				

					02-16
					
					2104
					
				

			

		

		

			
				
缓存工具CacheUtil - 并发环境的缓存值存取目的适合并发环境的缓存值存取读取缓存值时，只需关注数据来源。不用再关注将源数据存入缓存等后续处理。应用程序N次读取数据时，数据源读取一次，缓存读取N-1次。设计当从缓存查找失败，则去数据源获取。获取成功，存入缓存并返回。实现Sourcable/*** 可溯源的。可从数据源获取数据*/public interface Sourcable {/***...

			
		

	





	

		

			

				
					
简单的cache缓存工具类

				
			

			

				

					chizi7811的博客
				

				

					06-17
					
					712
					
				

			

		

		

			
				
一、controller层 
package com.atzhongruan.excelutils.controller;

import com.atzhongruan.excelutils.service.CacheService;
import org.springframewor...

			
		

	





	

		

			

				
					
安卓开发中Cache模块(文件读写操作)

				
			

			

				

					陈如水的专栏
				

				

					08-02
					
					5245
					
				

			

		

		

			
				
activity中的代码
package com.example.tuhuadmin.fanxinglei.widget;

import android.content.Context;
import android.os.Bundle;
import android.os.Environment;
import android.view.View;
import android.widget

			
		

	





	

		

			

				
					
java cacheutil_CacheUtil-缓存工具类

				
			

			

				

					weixin_28790465的博客
				

				

					02-16
					
					800
					
				

			

		

		

			
				
package com.zxt.basic.util.cache;import java.util.List;import com.zxt.basic.util.cache.ehcache.EHCacheEngine;import com.zxt.basic.util.cache.memcached.MemcachedEngine;import com.zxt.basic.util.Propert...

			
		

	





	

		

			

				
					
Java 中常用缓存Cache机制的实现

					
热门推荐

				
			

			

				

					Fighting_xr的博客
				

				

					07-25
					
					2万+
					
				

			

		

		

			
				
Java 中常用缓存Cache机制的实现

所谓缓存，就是将程序或系统经常要调用的对象存在内存中，一遍其使用时可以快速调用，不必再去创建新的重复的实例。这样做可以减少系统开销，提高系统效率。



所谓缓存，就是将程序或系统经常要调用的对象存在内存中，一遍其使用时可以快速调用，不必再去创建新的重复的实例。这样做可以减少系统开销，提高系统效率。

缓存主要可分为二大类: 

一、通过文件缓存,顾名思...

			
		

	





	

		

			

				
					
Java Cache 入门

				
			

			

				

					github_39602765的博客
				

				

					04-06
					
					1万+
					
				

			

		

		

			
				
什么是缓存
术语缓存在计算机中无处不在。在应用程序设计的上下文中，它经常被用来描述应用程序开发人员利用单独的内存或低延迟的数据结构。缓存，用于临时存储或缓存信息的副本或引用，应用程序可能会在稍后的某个时间点重复使用，从而减轻重新访问或重新创建它的成本。
在 JCache 的上下文中，术语缓存描述了 Java 的技术开发人员使用缓存提供程序临时缓存 Java 对象。
JSR107(JCache)
J...

			
		

	





	

		

			

				
					
java nio 写事件_Java NIO

				
			

			

				

					05-31
				

			

		

		

			
				
写事件是 Java NIO 中的一种重要事件类型，它用于在通道中写入数据。在 Java NIO 中，写事件是由 SelectionKey.OP_WRITE 常量表示的。

当一个通道准备好写入数据时，将触发写事件。可以通过调用 SelectionKey.isWritable() 方法来检查通道是否准备好写入数据。如果通道准备好写入数据，则可以通过调用通道的 write() 方法将数据写入通道。

需要注意的是，写入数据时可能会发生写入缓冲区已满的情况。这时应该停止写入数据，并等待通道再次变为可写状态。

Java NIO 提供了一些帮助开发者处理写事件的工具类，如 ByteBuffer 和 Channel。使用这些工具类可以更加方便地处理写事件。

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值