缓冲池实例剖析

package 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(); 
      }  
}

package cache;

import java.util.Date;

public class CacheItem {
    //创建缓存的时间
    private Date createTime = new Date();    
    //缓存期满时间
    private long expireTime = 1;
    //缓存实体
    private Object entity;
    
    public CacheItem(Object obj,long expire){
        this.entity = obj;
        this.expireTime = expire;
    }
    //判断缓存是否超时
    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;
    }
}

package cache;

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; 
     } 
}

package cache;

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); 
     } 
}