EHcache模拟对象增删改查时缓存

    EHcache二级缓存，谁用过Hibernate二级缓存的同学，对于二级缓存这东东都知道一二，是干嘛用的，在这不多说。这里简答介绍EHcache的用法，以及写个小例子，模拟对象增删改查时，对象的缓存过程，对ehcache有过初步的了解。  ehcache元素属性：

name:缓存名称
maxElementsInMemory：内存中最大缓存对象数
maxElementsOnDisk：硬盘中最大缓存对象数，若是0表示无穷大
eternal：true表示对象永不过期，此时会忽略timeToIdleSeconds和timeToLiveSeconds属性，默认为false
overflowToDisk：true表示当内存缓存的对象数目达到了maxElementsInMemory界限后，会把溢出的对象写到硬盘缓存中。注意：如果缓存的对象要写入到硬盘中的话，则该对象必须实现了Serializable接口才行。
diskSpoolBufferSizeMB：磁盘缓存区大小，默认为30MB。每个Cache都应该有自己的一个缓存区
diskPersistent：是否缓存虚拟机重启期数据
diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认为120秒
timeToIdleSeconds： 设定允许对象处于空闲状态的最长时间，以秒为单位。当对象自从最近一次被访问后，如果处于空闲状态的时间超过了timeToIdleSeconds属性值，这个对象就会过期，EHCache将把它从缓存中清空。只有当eternal属性为false，该属性才有效。如果该属性值为0，则表示对象可以无限期地处于空闲状态
timeToLiveSeconds：设定对象允许存在于缓存中的最长时间，以秒为单位。当对象自从被存放到缓存中后，如果处于缓存中的时间超过了 timeToLiveSeconds属性值，这个对象就会过期，EHCache将把它从缓存中清除。只有当eternal属性为false，该属性才有效。如果该属性值为0，则表示对象可以无限期地存在于缓存中。timeToLiveSeconds必须大于timeToIdleSeconds属性，才有意义
memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。可选策略有：LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）

ehcache配置常用的一些元素介绍完了，下面来个完整的简单例子看看。
项目结构图：

bean下的Studnet.java,School.java模拟领域对象，允许二级缓存缓存它们；如果配置中允许缓存数超过最大缓存数时，将对象写入磁盘的话，则领域对象需要实现序列化。
dao模拟操作数据库，增删改查。
database模拟数据库中的数据
util工具对象，EHcacheUtil二级缓存工具，ehcache.xml配置文件.

下面贴源码：
ehcache.xml

<?xml version="1.0" encoding="UTF-8"?><ehcache><!-- 指定一个文件目录，当EHCache把数据写到硬盘上时，将把数据写到这个文件目录下 -->  <diskStore path="java.io.tmpdir" />  <!-- 必须要有defaultCache -->  <defaultCache      maxElementsInMemory="10000"      eternal="false"      timeToIdleSeconds="120"      timeToLiveSeconds="120"      diskSpoolBufferSizeMB="30"      maxElementsOnDisk="10000000"      overflowToDisk="false"      diskExpiryThreadIntervalSeconds="120">   </defaultCache>  <cache name="student"         maxElementsInMemory="100"         maxElementsOnDisk="1000"         eternal="false"         timeToIdleSeconds="5"         timeToLiveSeconds="5"         overflowToDisk="false"         memoryStoreEvictionPolicy="LFU">  </cache>  <cache name="school"         maxElementsInMemory="100"         maxElementsOnDisk="500"         eternal="false"         timeToIdleSeconds="240"         timeToLiveSeconds="240"         overflowToDisk="false"         memoryStoreEvictionPolicy="LFU">  </cache></ehcache>Student.javapackage com.fei.bean;public class Student {    private String code ;    private String name;    public Student() {    }    public Student(String code, String name) {        super();        this.code = code;        this.name = name;    }    public String getCode() {        return code;    }    public void setCode(String code) {        this.code = code;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public Student clone(){        return new Student(this.code,this.name);    }}School.javapackage com.fei.bean;//如果需要将对象缓存到磁盘，则对象需要序列化public class School {    private String code;    private String name;    public School() {    }    public School(String code, String name) {        super();        this.code = code;        this.name = name;    }    public String getCode() {        return code;    }    public void setCode(String code) {        this.code = code;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public School clone(){        return new School(this.code,this.name);    }}StudentDao.javapackage com.fei.dao;import com.fei.bean.Student;import com.fei.database.StudentDB;import com.fei.util.EHcacheUtil;public class StudentDao {    private static final String CACHE_NAME = "student";    /**     * 先从缓存获取，缓存没有，再从数据库中拿     */    public Student get(String code){        Student s = null;        s =(Student) EHcacheUtil.getInstance().get(CACHE_NAME,code);        if(s == null ) {            System.out.println("缓存中找不到"+code+"的学生");        }else{            System.out.println("缓存中找到了"+code+"的学生");            return s;        }        s = StudentDB.get(code);        //放入缓存        EHcacheUtil.getInstance().put(CACHE_NAME, code, s);        return s;    }    /**     * 更新时，删除缓存(或者也更新缓存)     */    public void update(Student s){        EHcacheUtil.getInstance().remove(CACHE_NAME, s.getCode());        StudentDB.update(s);    }    /**     * 删除，删除缓存，删除数据库     */    public void delete(Student s){        EHcacheUtil.getInstance().remove(CACHE_NAME, s.getCode());        StudentDB.delete(s);    }    /**     * 增加，添加到缓存，添加到数据库     */    public void add(Student s){        EHcacheUtil.getInstance().remove(CACHE_NAME, s.getCode());        StudentDB.insert(s);    }}SchoolDB.javapackage com.fei.database;import java.util.HashMap;import java.util.Map;import com.fei.bean.School;/** * 模拟数据库的增删改查 * */public class SchoolDB {    public static Map<String,School> schools = new HashMap<String , School>();    static{        schools.put("s001",new School("s001","魏国"));        schools.put("s002",new School("s002","吴国"));        schools.put("s003",new School("s003","蜀国"));    }    public static School get(String code){        School s = schools.get(code);        return s != null ? s.clone() : null;    }    public static void insert(School s){        schools.put(s.getCode(), s);    }    public static void update(School s){        School tempS = schools.get(s.getCode());        tempS.setName(s.getName());    }    public static void delete(School s){        schools.remove(s.getCode());    }}StudentDB.javapackage com.fei.database;import java.util.HashMap;import java.util.Map;import com.fei.bean.Student;/** * 模拟数据库的增删改查 * */public class StudentDB {    public static Map<String,Student> students = new HashMap<String,Student>();    static{        students.put("0001",new Student("0001","貂蝉"));        students.put("0002",new Student("0002","赵飞燕"));        students.put("0003",new Student("0003","小乔"));    }    public static Student get(String code){        Student s = students.get(code);        return s != null ? s.clone() : null;    }    public static void insert(Student s){        students.put(s.getCode(), s);    }    public static void update(Student s){        Student tempS = students.get(s.getCode());        tempS.setName(s.getName());    }    public static void delete(Student s){        students.remove(s.getCode());    }}EHcacheUtil.javapackage com.fei.util;import net.sf.ehcache.Cache;import net.sf.ehcache.CacheManager;import net.sf.ehcache.Element;/** *cacheManager：缓存管理器，以前是只允许单例的，不过现在也可以多实例了 *cache：缓存管理器内可以放置若干cache，存放数据的实质，所有cache都实现了Ehcache接口 *element：单条缓存数据的组成单位 * @author Administrator * */public class EHcacheUtil {    private static final String path = "ehcache.xml";    private static EHcacheUtil ehcacheUtil;    private CacheManager manager;     private EHcacheUtil(){        manager = CacheManager.create(EHcacheUtil.class.getResourceAsStream(path));    }    public synchronized static EHcacheUtil getInstance(){        if(ehcacheUtil == null){            return new EHcacheUtil();        }        return ehcacheUtil;    }    public void put(String cacheName, String key, Object value) {          Cache cache = getCache(cacheName);          Element element = new Element(key, value);          cache.put(element);      }      public Object get(String cacheName, String key) {          Cache cache = manager.getCache(cacheName);          Element element = cache.get(key);          return element == null ? null : element.getObjectValue();      }      public void remove(String cacheName, String key) {          Cache cache = manager.getCache(cacheName);          cache.remove(key);      }      public Cache getCache(String cacheName){        Cache cache = manager.getCache(cacheName);        if(cache == null){            throw new RuntimeException("根据cacheName="+cacheName+"无法获取到对于的cache!请检查配置文件"+path);        }        return cache;    }}EHcacheTest.javapackage com.fei;import net.sf.ehcache.Cache;import com.fei.bean.School;import com.fei.bean.Student;import com.fei.dao.SchoolDao;import com.fei.dao.StudentDao;import com.fei.database.StudentDB;import com.fei.util.EHcacheUtil;public class EHcacheTest {    private static StudentDao studentDao = new StudentDao();    private static SchoolDao schoolDao = new SchoolDao();    public static void main(String[] args) {//      test01();//      test02();//      test03();//      test04();    }    /**     * 测试1     * 2次查询同一个对象         *     期待：第一次缓存中不存在，第二次缓存中存在     */    private static void test01(){        studentDao.get("0001");        studentDao.get("0001");    }    /**     * 查询2次，更新对象，再查询2次，     *    期待：第一次缓存中不存在，第二次缓存中存在，第三次缓存中不存在，第四次缓存中存在     */    private static void test02(){        schoolDao.get("s001");        School s = schoolDao.get("s001");        s.setName(s.getName()+"aaa");        schoolDao.update(s);        schoolDao.get("s001");        s = schoolDao.get("s001");        System.out.println("学校名称："+s.getName());    }    /**     * 测试3     * 4次查询学生，第二次查询后线程休息10秒        * 期待：第一次缓存中不存在，第二次缓存中存在，第三次缓存中不存在，第四次缓存中存在     *      */    private static void test03(){        studentDao.get("0001");        studentDao.get("0001");        try {            Thread.currentThread().sleep(10000);        } catch (Exception e) {            e.printStackTrace();        }        studentDao.get("0001");        studentDao.get("0001");    }    /**     * 测试4     * 4次查询学生     * 期待：第一次缓存中不存在，第二次缓存中存在，第三次缓存中存在，第四次缓存中存在     */    private static void test04(){        studentDao.get("0001");        studentDao.get("0001");        studentDao.get("0001");        studentDao.get("0001");    }}

运行test01()的结果：
缓存中找不到0001的学生
缓存中找到了0001的学生

运行test02()的结果
缓存中找不到s001的学校
缓存中找到了s001的学校
缓存中找不到s001的学校
缓存中找到了s001的学校
学校名称：魏国aaa

运行test03()的结果：
缓存中找不到0001的学生
缓存中找到了0001的学生
缓存中找不到0001的学生
缓存中找到了0001的学生

运行test04()的结果：
缓存中找不到0001的学生
缓存中找到了0001的学生
缓存中找到了0001的学生
缓存中找到了0001的学生