Java缓存池代码实例详解

这篇实例中有四个类，分别为

CacheItem  缓存实体类

CachePool  缓存池

Student  学生实体类

MainTest  主测试类

其中，缓存实体类CacheItem  中存放管理学生实体对象Student  ，缓存实体类CacheItem  存放在缓存池CachePool  中，MainTest  主要负责整体的测试工作。

缓存实体类

package com.paic.zhangqi.cache;
import java.util.Date; 

/**
 * 缓存实体
 * @author ZHANGQI947
 */
public class CacheItem {
 // 创建缓存时间
 private Date createTime = new Date();
 // 缓存期满时间
 private long expireTime = 1;
 // 缓存实体
 private Object entity;
 public CacheItem(Object obj, long expires) {
  this.entity = obj;
  this.expireTime = expires;
 }
 // 判断缓存是否超时
 public boolean isExpired() {
  return (expireTime != -1 && new Date().getTime() - createTime.getTime() > expireTime);
 }
 public Date getCreateTime() {
  return createTime;
 }
 public void setCreateTime(Date createTime) {
  this.createTime = createTime;
 }
 public Object getEntity() {
  return entity;
 }
 public void setEntity(Object entity) {
  this.entity = entity;
 }
 public long getExpireTime() {
  return expireTime;
 }
 public void setExpireTime(long expireTime) {
  this.expireTime = expireTime;
 }
} 

缓存池CachePool

package com.paic.zhangqi.cache;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
/**
 * 缓存池
 * @author Administrator
 */
public class CachePool {
 // 缓存池唯一实例
 private static CachePool instance;
 // 缓存Map
 private static Map<String, Object> cacheItems;
 private CachePool() {
  cacheItems = new HashMap<String, Object>();
 }
 /**
  * 获取唯一的实例
  * @return instance
  */
 public synchronized static CachePool getInstance() {
  if (instance == null) {
   instance = new CachePool();
  }
  return instance;
 }
 /**
  * 清除所有的Item缓存
  */
 public synchronized void clearAllItems() {
  cacheItems.clear();
 }
 /**
  * 获取缓存实例
  * @param name 缓存名称
  * @return 缓存实例
  */
 public synchronized Object getCacheItem(String name) {
  if (!cacheItems.containsKey(name)) {
   return null;
  }
  CacheItem cacheItem = (CacheItem) cacheItems.get(name);
  if (cacheItem.isExpired()) {
   return null;
  }
  return cacheItem.getEntity();
 }
 /**
  * 存放缓存信息
  * @param name 名称
  * @param obj 实例对象
  * @param expires 超时时长
  */
 public synchronized void putCacheItem(String name, Object obj, long expires) {
  // 判断该对象是否在在缓存池，不在直接put
  if (!cacheItems.containsKey(name)) {
   cacheItems.put(name, new CacheItem(obj, expires));
  }
  // 获取缓存池中对象，更新对象信息
  CacheItem cacheItem = (CacheItem) cacheItems.get(name);
  cacheItem.setCreateTime(new Date());
  cacheItem.setEntity(obj);
  cacheItem.setExpireTime(expires);
 }
 /**
  * 移除缓存数据
  * @param name
  */
 public synchronized void removeCacheItem(String name) {
  if (!cacheItems.containsKey(name)) {
   return ;
  }
  cacheItems.remove(name);
 }
 /**
  * 获取缓存数据的数量
  * @return
  */
 public int getSize() {
  return cacheItems.size();
 }
} 

学生类Student

package com.paic.zhangqi.cache;
/**
 * 学生类
 * @author Administrator
 */
public class Student {
 private String name;
 private String id;
 private int age;
 private int sal;
 public Student() { 

 }
 public Student(String name, String id, int age, int sal) {
  this.name = name;
  this.id = id;
  this.age = age;
  this.sal = sal;
 }
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public String getId() {
  return id;
 }
 public void setId(String id) {
  this.id = id;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public int getSal() {
  return sal;
 }
 public void setSal(int sal) {
  this.sal = sal;
 }
}

主测试类MainTest

package com.paic.zhangqi.cache;
/**
 * 主测试类
 * @author ZHANGQI947
 */
public class MainTest { 

 /**
  * @param args
  * @throws InterruptedException
  */
 public static void main(String[] args) throws InterruptedException {
  // 获取缓存池
  CachePool cachePool = CachePool.getInstance();
  Student stu1 = new Student("l1", "stu001", 25, 40);
  Student stu2 = new Student("l2", "stu002", 25, 40);
  Student stu3 = new Student("l3", "stu003", 25, 40);
  Student stu4 = new Student("l4", "stu004", 25, 40);
  cachePool.putCacheItem("001", stu1, 122222);
  cachePool.putCacheItem("002", stu2, 10);
  cachePool.putCacheItem("003", stu3, 360002);
  cachePool.putCacheItem("004", stu4, 1222222);
  // 设置线程休眠，其中002对象会超时
  Thread.sleep(200);
  Student stu001 = (Student) cachePool.getCacheItem("001");
  if (null != stu001) {
   System.out.println(stu001.getName());
  }
  // 由于超时，这里取出的002对象为null
  Student stu002 = (Student) cachePool.getCacheItem("002");
  if (null != stu002) {
   System.out.println(stu002.getName());
  }
  // 获取打印缓存池中对象数量
  int cacheSize = cachePool.getSize();
  System.out.println(cacheSize);
  // 删除对象002
  cachePool.removeCacheItem("002");
  // 打印缓存池数量
  cacheSize = cachePool.getSize();
  System.out.println(cacheSize);
 }
} 

测试结果

l1 
4 
3

希望本篇文章内容对您有所帮助