java添加文件级缓存_java protostuff实现文件级数据缓存，使用文件缓存对象，java文件级数据缓存...

由于业务需要使用文件级别的缓存，特此采用protostuff加上基本的TXT文件操作，来实现基于文件的缓存。

实现以下功能：

文件级别缓存的对象工具类

1、传入一个对象和缓存时间还有缓存名称对这个对象进行缓存

2、传入一个缓存名称查询是否存在这个名称的缓存

3、传入一个缓存名称和该类的类型对象获取对应的缓存

4、传入一个缓存名称删除该名称的缓存

模块一：protostuff序列化使用类

package tool;

import io.protostuff.LinkedBuffer;

import io.protostuff.ProtostuffIOUtil;

import io.protostuff.runtime.RuntimeSchema;

/**

* Created by yy on 2017/9/28.

* 用与序列化以及反序列化对象的类

* 1、传入一个对象，返回该对象序列化后的字节数组

* 2、传入字节数组和类的类型对象，获取这个数据的反序列对象

*/

public class Serialization {

/**

* 传入一个对象，返回这个对象的序列化后的字节数组

* @param object 需要实例化的对象

* @param 传入对象的类型

* @return 返回对应的字节数组

* @throws Exception 序列化失败继续抛出异常

*/

public static byte[] sequence(T object) throws Exception{

//安全判断,要是传入的对象为空返回对应的也是空

if(object==null){

return null;

}

//获取对应的类

Class objectClass = (Class) object.getClass();

//使用LinkedBuffer分配一块默认大小的buffer空间；

LinkedBuffer linkedBuffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);

try {

//生成对应的图，返回对应的字节数组

//使用ProtoStuff-runtime生成模式，以便在运行时通过反射进行缓存和使用。

RuntimeSchema runtimeSchema = RuntimeSchema.createFrom(objectClass);

return ProtostuffIOUtil.toByteArray(object, runtimeSchema, linkedBuffer);

} catch (Exception e) {

//继续抛出异常

throw new RuntimeException("对象序列化失败！",e);

} finally {

//关闭Buffer空间

linkedBuffer.clear();

}

}

/**

* 根据穿进来的字节数组和具体的类的类型对象，获取对应反序列的结果对象

* @param info 序列化完成的字节数组对象

* @param classInfo 类的类型对象

* @param 具体要转换的类类型

* @return 序列化成功返回序列化前的对象，要是传入的数据为空返回空对象

* @throws Exception 抛出反序列化的异常

*/

public static T reverse(byte[] info,Class classInfo)throws Exception{

//安全判断

if(info.length==0||classInfo==null){

return null;

}

//根据传进来的数据反序列具体对象

try{

RuntimeSchema runtimeSchema = RuntimeSchema.createFrom(classInfo);

T object =runtimeSchema.newMessage();

ProtostuffIOUtil.mergeFrom(info,object,runtimeSchema);

return object;

}catch(Exception e){

throw new RuntimeException("反序列对象失败！",e);

}

}

}

模块二：MD5加密(用于文件名生成)

package tool;

import java.security.MessageDigest;

/**

* md5的生成类

* Created by yy on 2017/10/11.

*/

public class MD5maker {

public static String make(String value){

String md5str = "";

try {

MessageDigest md = MessageDigest.getInstance("MD5");

byte[] input = value.getBytes();

byte[] buff = md.digest(input);

md5str = bytesToHex(buff);

} catch (Exception e) {

e.printStackTrace();

}

return md5str;

}

/**

* 换成16进制

* @param bytes

* @return

*/

private static String bytesToHex(byte[] bytes) {

StringBuffer md5str = new StringBuffer();

int digital;

for (int i = 0; i < bytes.length; i++) {

digital = bytes[i];

if (digital < 0) {

digital += 256;

}

if (digital < 16) {

md5str.append("0");

}

md5str.append(Integer.toHexString(digital));

}

return md5str.toString().toUpperCase();

}

}

模块三：缓存工具类

package tool;

import org.apache.commons.lang3.StringEscapeUtils;

import java.io.*;

/**

* Created by yy on 2017/9/29.

* 文件级别缓存的对象工具类

* 1、传入一个对象和缓存时间还有缓存名称对这个对象进行缓存

* 2、传入一个名称查询是否存在这个名称的缓存

* 3、传入一个名称和该类的类型对象获取对应的缓存

* 4、传入一个缓存名称删除该名称的缓存

*/

public class CacheBF {

/**

* 根据穿进来的名称和实体缓存对象到文件中

* @param name 键名

* @param object 需要保存的实体

* @param time 过期时间秒

* @param 传入的实体类型

* @return 保存成功返回true，失败返回false

*/

public static boolean cache(String name,T object,int time) throws Exception{

File file=CacheBF.getCacheFile(name);//获取缓存文件

FileWriter fw=new FileWriter(file);

BufferedWriter bw = new BufferedWriter(fw);

//设置过期时间

bw.write((System.currentTimeMillis()+(time*1000))+"");

bw.newLine();

//设置缓存信息

bw.write(StringEscapeUtils.escapeJava(new String(Serialization.sequence(object))));//添加转义

bw.close();

fw.close();

return true;

}

/**

* 根据传进来的文件名，和类的类型获取缓存的实体类

* @param name 缓存名称

* @param objectClass 需要取得的实体类型

* @param 旋回对应实例

* @return

* @throws Exception

*/

public static T get(String name,Class objectClass)throws Exception{

T vo=null;

File file=new File(CacheBF.getCacheFileName(name));//获取缓存文件

if (file.exists()){//判断文件是否存在

FileReader fr=new FileReader(file);

BufferedReader br=new BufferedReader(fr);

Long now =System.currentTimeMillis();

Long time=Long.parseLong(br.readLine());//判断文件缓存是否过期

String object=StringEscapeUtils.unescapeJava(br.readLine());//返回程序，反转义字符

br.close();

fr.close();

if (time>now){

vo= Serialization.reverse(object.getBytes(),objectClass);

}else{

file.delete();//过期删除文件，删除前关闭输出流

}

}

return vo;

}

/**

* 传入一个缓存名称，查询是否存在此缓存

* @param name 缓存名称

* @return 存在并且不过期返回true，否则返回false

* @throws Exception

*/

public static boolean check(String name)throws Exception{

boolean back=false;

File file=new File(CacheBF.getCacheFileName(name));//获取缓存文件

if (file.exists()){

FileReader fr=new FileReader(file);

BufferedReader br=new BufferedReader(fr);

Long now=System.currentTimeMillis();

Long time=Long.parseLong(br.readLine());//判断文件缓存是否过期

br.close();

fr.close();

if (time>now){

back=true;

}else{

file.delete();//过期删除文件

}

}

return back;

}

/**

* 删除穿进来的缓存名称的文件

* @param name 需要删除的缓存的名称

* @throws Exception

*/

public static void delete(String name)throws Exception{

File file=new File(CacheBF.getCacheFileName(name));

if (file.exists()){

file.delete();

}

}

/**

* 根据缓存的名称获取需要操作的文件对象

* 1、判断父类目录cache是否存在，不存在则创建

* 2、判断当前文件是否存在，存在删除后创建，不存在直接创建

* 3、文件名MD5加密

* @param name 需要得到的缓存的名称

* @return

* @throws Exception

*/

private static File getCacheFile(String name)throws Exception{

File file=new File(CacheBF.getCacheFileName(name));//获取操作对象

//判断父目录是否存在

if (!file.getParentFile().exists()){

file.getParentFile().mkdir();

}

//判断当前文件是否存在

if (!file.exists()){

file.createNewFile();

}else {

file.delete();

file.createNewFile();

}

return file;

}

/**

* 传入缓存名获取缓存的文件名

* @param name 缓存名

* @return

*/

private static String getCacheFileName(String name){

name=MD5maker.make(name)+".txt";//获取文件名

StringBuffer fileName=new StringBuffer(System.getProperty("user.dir"))

.append(File.separator).append("src")

.append(File.separator).append("main")

.append(File.separator).append("webapp")

.append(File.separator).append("WEB-INF")

.append(File.separator).append("cache")

.append(File.separator).append(name);//获取文件路径

return fileName.toString();

}

}

模块四：测试

import tool.CacheBF;

import tool.Serialization;

import java.io.File;

/**

* Created by yy on 2017/10/11.

* 文件缓存测试

*/

public class test {

public static void main(String args[]) {

Data data= new Data();

data.setInfo("hello");

data.setName("world");

try {

CacheBF.cache("123",data,100);

System.out.println("缓存是否存在："+CacheBF.check("123"));

Data da=CacheBF.get("123",Data.class);

System.out.println(da);

CacheBF.delete("123");

System.out.println("缓存是否存在："+CacheBF.check("123"));

Data dd=CacheBF.get("123",Data.class);

System.out.println(dd);

}catch (Exception e){

e.printStackTrace();

}

}

}

//测试使用

class Data{

private String name;

private String info;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getInfo() {

return info;

}

public void setInfo(String info) {

this.info = info;

}

@Override

public String toString() {

return "Data{" +

"name='" + name + '\'' +

", info='" + info + '\'' +

'}';

}

}模块五：测试输出

缓存是否存在：true

Data{name='world', info='hello'}

缓存是否存在：false

null

模块六：文件内容(A8AE104615CB4E966DDB435F3E575A02.txt)

1508081000098

\n\u0005world\u0012\u0005hello