java缓存类的编码

这里我通过浏览一些其他博客写的缓存类编码，感觉不是很详细，要不然用不到程序上，要不然回事简单的说了下实现，这里我根据对其他缓存类的编码，总结了下，希望对你们有所帮助！

我总共写了1个接口，1个实现类，需要1个的缓存的实体类，1个测试类.

接口：public interface CacheManager<T>{ }；用于缓存数据的相关操作，如清空，添加，查询，是否过期等等；

实现类：public class CacheManagerImpl<T> implements CacheManager<T> {} 用于实现接口相关的方法；

缓存的数据类：public class Cache<T>；缓存存放数据的类；

测试类：public class CacheTest extends Thread{ }用于测试你写的缓存；

如果用到项目上，通常key都是你搜所的sql语句，然后T是你存放查询到的数据内容而用于测试都是存放的String

下面是依次类的相关编码，内容：

/**
 * 实现缓存接口
 * @author rainjm 
 *
 */
public interface CacheManager<T> {

/**
* 获取缓存
* @param key
* @return T
*/
public T getCache(String key);

/**
* 存入缓存
* @param key
* @return T
*/
public void setCache(String key,T t);

/**
* 删除缓存
* @param key
* @return T
*/
public void deCache(String key);

/** 
     * 设置缓存过期时间 
     *  
     * @param millsec 缓存过期时间，单位：毫秒 
     */  
    public void setExpired(Long millsec); 
    
    /** 
     * 是否存在缓存对象 
     *  
     * @param key 缓存key 
     * @return 存在返回true，不存在返回false 
     */  
    public Boolean exist(String key);  
    
    /** 
     * 清空缓存 
     *  
     * @param key 缓存key 
     */  
    public void clern();
    
    /** 
     * 缓存个数 
     */  
    public int Count();
    
    /** 
     * 缓存限制 
     */  
    public void limit();
    
    /** 
     * 判断缓存对象是否失效 
     */  
    public Boolean check(String key);

}

import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;




public class CacheManagerImpl<T> implements CacheManager<T> {


private Long timecheck;//用于判断过期时间
private Map<String,Cache<T>> cache=new ConcurrentHashMap<String,Cache<T>>();//为什么用ConcurrentHashMap，可以去网上搜搜，了解一下



//自动为限制时间定制失效隔离时间，通过构造器
public CacheManagerImpl(Long timecheck) {
this.timecheck=timecheck;


}


public CacheManagerImpl() {

this(30000l);

}




public Long getTimecheck() {
return timecheck;
}


public void setTimecheck(Long timecheck) {
this.timecheck = timecheck;
}


        //接口类的相关实现方法
@Override
public T getCache(String key) {

if(!exist(key)){
return null;
}
return cache.get(key).getData();
}


@Override
public void setCache(String key,T t) {


if(exist(key)){
cache.remove(key);
}
   cache.put(key, new Cache<T>(t));
}


@Override
public void deCache(String key) {
cache.remove(key);

}
//手动为限制时间定制失效隔离时间 ,如果不满意自带的限制时间
@Override
public void setExpired(Long millsec) {
this.setTimecheck(millsec);

}


@Override
public Boolean exist(String key) {
return cache.containsKey(key);
}


@Override
public void clern() {
cache.clear();
}


@Override
public int Count() {
    
return cache.entrySet().size();
}


@Override
public void limit() {
List<String> list=new ArrayList<String>();
Iterator<Entry<String, Cache<T>>> ite = cache.entrySet().iterator();
while(ite.hasNext()){
Entry<String, Cache<T>> en = ite.next();
String key = en.getKey();
list.add(key);
}

for (int i = 0; i < list.size(); i++) {

if(check(list.get(i))){
cache.remove(list.get(i));
}
}


}


@Override
public Boolean check(String key) {
if(((new Date()).getTime()-cache.get(key).getDatatime())>this.timecheck){
return true;
}
return false;

}


}

import java.util.Date;

//存放缓存数据的类
public class Cache<T> {
private T data;//存放数据对象
private Long datatime;//每次更新缓存数据或创建时的更新时间、用于判断数据是否过期的依据


public Cache() {
    super();
}

      public Cache(T t) {
      this.data=t;
      this.datatime=new Date().getTime();
}


public T getData() {
return data;
}


public void setData(T data) {
this.data = data;
}


public Long getDatatime() {
return datatime;
}


public void setDatatime(Long datatime) {
this.datatime = datatime;
}

}

import java.util.Scanner;

//测试类  
public class CacheTest extends Thread{
protected static CacheManager<String> ca=new CacheManagerImpl<String>();//这里定义存放缓存数据的类型，我这里定义的是字符串；方面测试！
protected static Boolean check=true;
static {
//打开即开始一个线程，且只运行一次
(new CacheTest()).start();
}



public void Te(){
Scanner can=new Scanner(System.in);
System.out.println("1: 添加数据！ 2：清空！ 3：退出！ 4:查询！"+"  当前连接数： "+ca.Count());

int key=can.nextInt();

if(key==1){
System.out.println("请你输入要添加的ID！");
String in=can.next();
System.out.println("请你输入要添加的数据！");
String ou=can.next();
ca.setCache(in, ou);
Te();
}
if(key==2){
ca.clern();
System.out.println("清除成功！");
Te();
}
if(key==3){
this.interrupt();
check=false;
System.out.println("稍后将自动退出线程！！");
}
if(key==4){
System.out.println("请你输入要查询的ID！");
String in=can.next();
String ab = ca.getCache(in);
if(ab==null){
System.out.println("暂无数据！！");
}else{
System.out.println("数据为： "+ab+ "   1:删除！  2返回" );
int de=can.nextInt();
if(de==1){
ca.deCache(in);
System.out.println("删除成功！");
}else {
Te();
}
}
Te();
}

}

@Override
public void run() {
while (check) {
try {
sleep(30000);
//自动检测过期的缓存数据。过期则自动清除,每30s检测一次
ca.limit();
} catch (InterruptedException e) {
e.printStackTrace();
}

}
}
public static void main(String[] args) {

CacheTest c=new CacheTest();
c.Te();

}


}

有什么问题，请留言！！