OSCache进行缓存对象

如何使用OSCache实现对象的缓存

今天参考网上的一些资料跑通了一个OSCache缓存对象的实例，就说下如何使用OSCache来进行对象的缓存，如有纰漏还请指教。

如果要使用OSCache进行对象缓存，最开始要做的还是要安装OSCache的环境，在这里我就不多说了，将包导入，拷入配置文件，配置一些基本的信息即可，如不清楚，可以参考我写的上篇随笔——OSCache基础知识与标签的使用。

对于对象的缓存我们首先要认识的一个类是OSCache最底层的GeneralCacheAdministrator类。打开下载到的官方的OSCache资料包下的docs目录下的api，找到com.opensymphony.oscache.general包中的GeneralCacheAdministrator类。我们首先来看下这个类中常用的一些方法。

 

Method Summary
void	flushAll()           立即清除全部的缓存.
void	flushAll(Date date)           在给定的时间清除全部的缓存.
void	flushEntry(String key)           根据给定的key值来清除对应的缓存.
void	flushGroup(String group)           清除指定group下的所有的缓存对象.
void	flushPattern(String pattern)           不赞成使用. 由于性能和灵活性的原因：最好来存储缓存group和使用flushGroup （字符串）方法而不是依赖模式清除。
Cache	getCache()           取得缓存
Object	getFromCache(String key)           从缓存中取得一个对象
Object	getFromCache(String key, int refreshPeriod)           从缓存中取得一个对象
Object	getFromCache(String key, int refreshPeriod, String cronExpression)           从缓存中取得一个对象
void	putInCache(String key, Object content)           将一个对象存入缓存
void	putInCache(String key, Object content, EntryRefreshPolicy policy)           将一个对象存入缓存
void	putInCache(String key, Object content, String[] groups)           将一个对象存入缓存
void	putInCache(String key, Object content, String[] groups, EntryRefreshPolicy policy)           将一个对象存入缓存
void	removeEntry(String key)          从缓存中删除一个对象
void	setCacheCapacity(int capacity)           设置缓存的容量(缓存的对象数目).

在这个api中我们看到了几个putInCache方法，到时我们可以根据需要来调用。

Ok，废话不多说，现在我用一个网上找到的实例来进行进一步的分析来看看OSCache是如何缓存对象的。

首先我们先写一个BaseCache类：

package com.sky.cache;
import java.util.Date;

import com.opensymphony.oscache.base.NeedsRefreshException;
import com.opensymphony.oscache.general.GeneralCacheAdministrator;

public class BaseCache extends GeneralCacheAdministrator {
	// 过期时间(单位为秒);
	private int refreshPeriod;
	// 关键字前缀字符;
	private String keyPrefix;

 
    /**
     * 构造器
     * @param 关键字前缀
     * @param 过期时间
     */
	public BaseCache(String keyPrefix, int refreshPeriod) {
		super();
		this.keyPrefix = keyPrefix;
		this.refreshPeriod = refreshPeriod;
	}

	// 添加被缓存的对象;
	public void put(String key, Object value) {
		//调用父类putInCache（String key, Object content）方法
		this.putInCache(this.keyPrefix + "_" + key, value);
	}

	// 删除被缓存的对象;
	public void remove(String key) {
		//调用父类flushEntry（String key）方法
		this.flushEntry(this.keyPrefix + "_" + key);
	}

	// 删除所有被缓存的对象;
	public void removeAll(Date date) {
		//调用父类flushAll（Date date）方法
		this.flushAll(date);
	}

	public void removeAll() {
		//调用父类flushAll（）方法
		this.flushAll();
	}

	// 获取被缓存的对象;
	public Object get(String key) throws Exception{   
         try{   
             return this.getFromCache(this.keyPrefix+"_"+key,this.refreshPeriod);             
             } catch (NeedsRefreshException e) {   
           this.cancelUpdate(this.keyPrefix+"_"+key);  
             throw e;   
        }   
  
     }
}

 

由于这个类继承了GeneralCacheAdministrator类，所以可以调用父类中方法。接下来再写一个Students类：

 

 

package com.sky;

import java.io.Serializable;

/**
 * 这个类是一个简单的学生类，用于测试OSCache缓存对象用
 * @author tincotian
 *
 */
public class Students implements Serializable{
	//学生ID
	public String ID;
	//学生姓名
	public String name;
    //学生成绩
	public String score;
	
	public Students(){
		
	}
	
	public Students(String studentsID) {
		this.ID=studentsID;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getScore() {
		return score;
	}
	public void setScore(String score) {
		this.score = score;
	}
	public String getID() {
		return ID;
	}
	public void setID(String id) {
		ID = id;
	}
	
}

 

这个类只是一个简单的测试类而已，接着我们写一个OSCache的管理类CacheManager：

package com.sky;     
      
 import com.sky.cache.BaseCache;
    
public class CacheManager {  
        
   private BaseCache studentsCache;     
       
   	private static CacheManager instance;   
    private static Object lock = new Object();   
      
   public CacheManager() {  
        //这个根据配置文件来，初始BaseCache;  
	   studentsCache = new BaseCache("students",1800);       
     }   
   
   /**
    * 单例化一个CacheManager
    * @return CacheManager对象
    */
    public static CacheManager getInstance(){  
         if (instance == null){  
             synchronized( lock ){   
              if (instance == null){  
                     instance = new CacheManager();  
                 }   
           }   
        }   
       return instance;   
     }   
   
    /**
     * 将学生对象存入缓存中
     * @param news：学生对象
     */
     public void putStudents(Students students) {   
    	 studentsCache.put(students.getID(),students);    
     }   
     
     /**
      * 根据学生ID将缓存中的学生对象移除
      * @param newsID：学生ID
      */
     public void removeStudents(String studentsID) {     
    	 studentsCache.remove(studentsID);    
    }  
      
     /**
      * 根据学生ID从缓存中提取对应的学生对象
      * @param newsID：学生ID
      * @return：学生对象
      */
      public Students getStudents(String studentsID) {       
       try {   
              return (Students) studentsCache.get(studentsID);   
         } catch (Exception e) {   
             //自动生成 catch 块    
             System.out.println("getStudents>>studentsID["+studentsID+"]>>"+e.getMessage());                
             Students students = new Students(studentsID);    
             this.putStudents(students);    
            return students;    
        }   
     }   
   
      /**
       * 删除缓存中所有的学生对象
       */
     public void removeAllStudents() {     
    	 studentsCache.removeAll();    
    }   
    
 }

 

好了，有了以上几个类之后，我们就可以写一个测试类了：

如下，TestObjectCache类：

 

package com.sky.cache;

import com.sky.*;

/**
 * 这个类是一个测试类，用来测试OSCache对对象的缓存
 * @author tincotian
 *
 */
public class TestObjectCache {
	public static void main(String args[]){
		//实例化一个学生对象
		Students student = new Students();
		//设置相关属性
		student.setID("a001");
		student.setName("张三");
		student.setScore("A");
		
		CacheManager.getInstance().putStudents(student);
		//从缓存中删除所有的学生对象
		CacheManager.getInstance().removeAllStudents();
        //从缓存中删除ID为a001的学生
//		CacheManager.getInstance().removeStudents("a001");
		//从缓存中取得ID为a001的学生
		Students s =(Students)CacheManager.getInstance().getStudents("a001");
		
		//取得该学生的名字与成绩
		System.out.println("Students'name is " +s.getName());
		System.out.println("Students'score is " +s.getScore());
		
	}

}

 

运行这个测试类后我们可以看到在控制台输出了以下两句话：

Students'name is 张三

Students'score is A

这就说明确实是先存入缓存然后又从缓存中拿出来。如果要更进一步证明，可以到oscache.properties中将缓存设置到缓存到硬盘，然后到设置的路径下去看是否有缓存文件。

    如果将CacheManager.getInstance().removeAllStudents();与CacheManager.getInstance().removeStudents("a001");这两句其中任何一句话的注释去除，运行后控制台会输出这两句话：

       Students'name is null

Students'score is null

这就说明缓存中的student对象已经被清楚了已经失效了。

 

至此，关于OSCache对对象的缓存应用的一些基础功能就已经实现了。