1.先将要保存的对象序列化
这里实现了Serializable接口，如果是实现Parcelable，写法就不同了。Serializable优点在于节省代码量，但是速度上要与Parcelable差不少。若果数据量并不是很多的话两者之间的差距是可以忽略的。
public class LoginModel implements Serializable {
@Expose
@SerializedName("phone")
public String phone;
@Expose
@SerializedName("accessToken")
public String accessToken;
@Expose
@SerializedName("bankNum")
public int bankNum;
@Expose
@SerializedName("realName")
public String realName;
}
public class SdegModel implements Parcelable {
private String phone;
public String getPhone(){
return phone;
}
public void setPhone(String phone){
this.phone = phone;
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(phone);
}
}
2.文件存储Utils类
public class CacheDataUtils {
/*
* @param dir 要保存的目录
* @param filename 要保存的文件名
* @param data 要保存的数据
* */
public static boolean writeCacheData(String dir, String filename, Object data){
File f = new File(dir);
if (!f.exists()){
f.mkdirs();
}
File target = new File(dir + File.separator + filename);
return writeCacheData(target, data);
}
public static boolean clearCacheData(String dir, String filename){
File target = new File(dir + File.separator + filename);
if (target.exists()){
target.delete();
}
return true;
}
/*
* @param file 要保存的文件
* @param data 要保存的数据
* */
public static boolean writeCacheData(File file, Object data){
if (!file.exists()){
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
return false;
}
}
ByteArrayOutputStream output = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream;
byte[] result = null;
try {
objectOutputStream = new ObjectOutputStream(output);
objectOutputStream.writeObject(data);
objectOutputStream.flush();
result = output.toByteArray();
objectOutputStream.close();
output.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (result == null){
return false;
}
try {
FileOutputStream outputStream = new FileOutputStream(file);
outputStream.write(result);
outputStream.close();
// AppCacheMgr.instance.appendCacheFileSize(file);
return true;
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return false;
}
/*
* 从指定文件读取数据，并反序列化对象
* @param dir 要读取的目录
* @param filename 要读取的文件名
* @return 反序列化后的对象
* */
public static Object readCacheData(String dir, String filename){
File target = new File(dir + File.separator + filename);
return readCacheData(target);
}
public static boolean isCacheDataExist(String dir, String filename){
File target = new File(dir + File.separator + filename);
return target.exists();
}
/*
* 从指定文件读取数据，并反序列化对象
* @param file 要读取的文件
* @return 反序列化后的对象
* */
public static Object readCacheData(File file){
if (!file.exists()){
return null;
}
Object obj = null;
try {
FileInputStream fileInput = new FileInputStream(file);
byte[] data = new byte[fileInput.available()];
fileInput.read(data);
fileInput.close();
ByteArrayInputStream input = new ByteArrayInputStream(data);
ObjectInputStream objectInputStream = new ObjectInputStream(input);
obj = objectInputStream.readObject();
objectInputStream.close();
input.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (Throwable e) {
e.printStackTrace();
}
return obj;
}
}
3.文件存储实现类
public class DataCache {
private String cacheDir;
private static final String CACHE_ROOT = "RESPONSE";
public static String APPCONFIG = "APPCONFIG";
public static final DataCache instance = new DataCache();
private DataCache() {
}
public void init(Context context) {
cacheDir = context.getCacheDir().getAbsolutePath()
+ File.separator + CACHE_ROOT;
}
private String getHashData(String key) {
return HashUtil.GetHashCode(key, HashUtil.HashType.MD5.toString());
}
/*
* 将对象序列化缓存到本地
*
* @param loginAccount 登录账号
* @param key 用于标识要保存的缓存数据
* @param data 要序列化保存的对象
* @return 成功返回true，否则false
*/
public boolean saveCacheData(String loginAccount, String key, Object data) {
key = getHashData(loginAccount + key);
return CacheDataUtils.writeCacheData(cacheDir, key, data);
}
/*
* 删除本地缓存数据
*
* @param loginAccount 登录账号
* @param key 用于标识要保存的缓存数据
* @return 成功返回true，否则false
*/
public boolean clearCacheData(String loginAccount, String key) {
key = getHashData(loginAccount + key);
return CacheDataUtils.clearCacheData(cacheDir, key);
}
/*
* 获取缓存数据并返反序列化
*
* @param loginAccount 登录账号
* @param key 用于标识要获取的缓存数据
* @return 成功返回对应对象实例，否则返回null
*/
public T getCacheData(String loginAccount, String key) {
key = getHashData(loginAccount + key);
Object obj = CacheDataUtils.readCacheData(cacheDir, key);
if (obj == null) {
return null;
}
return (T) obj;
}
public boolean isCacheExist(String loginAccount, String key) {
key = getHashData(loginAccount + key);
return CacheDataUtils.isCacheDataExist(cacheDir, key);
}
public String getImageFile(String loginAccount, String key) {
try {
key = getHashData(loginAccount + key);
File target = new File(cacheDir + File.separator + key);
return target.getCanonicalPath();
} catch (Throwable throwable) {
}
return null;
}
public Object getAppServiceConfigData() {
return getCacheData("", APPCONFIG);
}
}
4.具体使用
/**
* 保存数据
* @param loginAccount 登录账号
* @param key 保存文件的钥匙（开发人员自己拟定）
* @param obj 要保存的对象
*/
private void saveData(String loginAccount,String key,Object obj){
DataCache.instance.saveCacheData(loginAccount,key,obj);
}
/**
* 获取保存的数据
* @param loginAccount
* @param key
*/
private void getData(String loginAccount,String key){
DataCache.instance.getCacheData(loginAccount,key);
}
/**
* 清除保存的数据
* @param loginAccount
* @param key
*/
private void clearData(String loginAccount,String key){
DataCache.instance.clearCacheData(loginAccount,key);
}