ehcache整合spring本地接口方式

一、简介

　　ehcache整合spring，可以通过使用echache的本地接口，从而达到定制的目的。在方法中根据业务逻辑进行判断，从缓存中获取数据或将数据保存到缓存。这样让程序变得更加灵活。

　　本例子使用maven构建，需要的依赖如下：

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>3.2.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache-core</artifactId>
            <version>2.4.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>3.2.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>3.2.6.RELEASE</version>
        </dependency>

二、示例代码

　　ehcache.xml代码如下：

 <?xml version="1.0" encoding="UTF-8"?>
 <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
     updateCheck="false">

     <!-- 默认缓存配置 ，缓存名称为 default -->
     <defaultCache maxElementsInMemory="50" eternal="false"
         overflowToDisk="false" memoryStoreEvictionPolicy="LFU" />
     <!-- 自定义缓存，名称为lt.ehcache -->
     <cache name="lt.ecache" maxElementsInMemory="50" eternal="false"
         overflowToDisk="false" memoryStoreEvictionPolicy="LFU" />
 </ehcache>  

　　spring-config-ehcache-custom.xml代码如下：

 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">

     <context:annotation-config />
     <context:component-scan base-package="com.ehcache.custom" /> <!-- 注解扫描路径 -->

     <bean id="cacheService" class="com.ehcache.custom.CacheService">
         <property name="cachename" value="lt.ecache"></property> <!-- ehcache.xml中配置的缓存名称 -->
         <property name="ehCacheCacheManager" ref="ehCacheCacheManager"></property>
     </bean>

     <bean id="ehCacheCacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager">
         <property name="cacheManager" ref="ehcache" />
     </bean>

     <bean id="ehcache"
         class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
         <property name="configLocation" value="classpath:ehcache.xml" />
     </bean>

 </beans>

　　ehcache.xml与spring-config-ehcache-custom.xml存放在系统类路径src目录下。

　　实体Employee.java如下

 package com.ehcache.custom;

 import java.io.Serializable;

 public class Employee implements Serializable {
     private static final long serialVersionUID = -4341595236940308296L;
     private int id;
     private String name;
     private String designation;

     public Employee(int id, String name, String designation) {
         super();
         this.id = id;
         this.name = name;
         this.designation = designation;
     }

     public int getId() {
         return id;
     }

     public void setId(int id) {
         this.id = id;
     }

     @Override
     public String toString() {
         return "Employee [id=" + id + ", name=" + name + ", designation="
                 + designation + "]";
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public String getDesignation() {
         return designation;
     }

     public void setDesignation(String designation) {
         this.designation = designation;
     }
 }

　　EmployeeDAO.java代码如下

package com.ehcache.custom;

import java.util.ArrayList;
import java.util.List;

import javax.annotation.Resource;

import org.springframework.cache.ehcache.EhCacheCacheManager;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

@Component("employeeDAO")
public class EmployeeDAO {

    @Resource
    private CacheService cacheService;

    private String listKey = "employeeList";

    /**
     * 获取对象列表
     *
     * @return
     */
    public List<Employee> getEmployees() {
        // 从缓存中获取
        List<Employee> list = (List<Employee>) cacheService.get(listKey);
        if (CollectionUtils.isEmpty(list)) { // 缓存中没有数据
            System.out.println("*** 缓存中没有数据 已经调用   ***");
            list = new ArrayList<Employee>(5);
            list.add(new Employee(1, "Ben", "Architect"));
            list.add(new Employee(2, "Harley", "Programmer"));
            list.add(new Employee(3, "Peter", "BusinessAnalyst"));
            list.add(new Employee(4, "Sasi", "Manager"));
            list.add(new Employee(5, "Abhi", "Designer"));
            this.cacheService.put(listKey, list);// 存放在缓存
        }else{
            System.out.println("*** 缓存中数据 已经存在   ***");
        }
        return list;
    }

    /**
     * 获取指定的对象
     *
     * @param id
     *            对象id
     * @param employees
     * @return
     */
    public Employee getEmployee(int id, List<Employee> employees) {
        // 从缓存中获取
        Employee emp = (com.ehcache.custom.Employee) cacheService.get(id);
        if (emp == null) {// 缓存中对象不存在
            System.out.println("***  缓存中对象不存在: " + id + " ***");
            for (Employee employee : employees) {
                if (employee.getId() == id) {
                    emp = employee;
                }
            }
            this.cacheService.put(id, emp);// 保存到缓存
        }else{
            System.out.println("***  缓存中对象存在: " + id + " ***");
        }
        return emp;
    }

    /**
     * 更新对象
     *
     * @param id
     *            对象id
     * @param designation
     * @param employees
     *
     */
    public void updateEmployee(int id, String designation,
            List<Employee> employees) {
        for (Employee employee : employees) {
            if (employee.getId() == id) {
                employee.setDesignation(designation);
                this.cacheService.put(id, employee);// 保存更新后的对象到缓存
            }
        }
    }

    /**
     * 添加对象
     *
     * @param employee
     *            要添加的对象
     * @param employees
     *
     */
    public void addEmployee(Employee employee, List<Employee> employees) {
        employees.add(employee);
        this.cacheService.put(employee.getId(), employee);// 保存更新后的对象到缓存
    }

    /**
     * 删除对象
     *
     * @param id
     *            Employee对象id
     * @param employees
     * @return
     */
    public void removeEmployee(int id, List<Employee> employees) {
        int i = 0;
        for (Employee employee : employees) {
            if (employee.getId() != id) {
                i++;
            } else {
                break;
            }
        }
        this.cacheService.evict(id);// 删除缓存中的数据
        employees.remove(i);
    }

    /**
     * 删除多个对象
     *
     * @param employees
     * @return
     */
    public List<Employee> removeAllEmployee(List<Employee> employees) {
        System.out.println("*** removeAllEmployee()  :  ***");
        employees.clear();
        System.out.println(employees.size());
        this.cacheService.evict(listKey);// 删除缓存中的数据
        return employees;
    }

}

　　CacheService.java代码如下：

 package com.ehcache.custom;

 import org.springframework.cache.Cache;
 import org.springframework.cache.Cache.ValueWrapper;
 import org.springframework.cache.ehcache.EhCacheCacheManager;

 /**
  * 封装springcache
  *
  */
 public class CacheService {

     /**
      * 缓存管理对象
      */
     private EhCacheCacheManager ehCacheCacheManager;

     /**
      * 缓存名称
      */
     private String cachename;

     public EhCacheCacheManager getEhCacheCacheManager() {
         return ehCacheCacheManager;
     }

     public void setEhCacheCacheManager(EhCacheCacheManager ehCacheCacheManager) {
         this.ehCacheCacheManager = ehCacheCacheManager;
     }

     public String getCachename() {
         return cachename;
     }

     public void setCachename(String cachename) {
         this.cachename = cachename;
     }

     /**
      * 获取进行操作的Cache对象
      *
      * @return
      */
     private Cache getCache() {
         return this.ehCacheCacheManager.getCache(this.cachename);
     }

     /**
      * 获取对象
      *
      * @param key
      *            对象对应的key值
      * @return
      */
     public Object get(Object key) {
         ValueWrapper valueWrapper = getCache().get(key);
         if (valueWrapper != null) {
             return getCache().get(key).get();
         }
         return valueWrapper;
     }

     /**
      * 缓存对象
      *
      * @param key
      * @param value
      */
     public void put(Object key, Object value) {
         getCache().put(key, value);
     }

     /**
      * 如果key对应的缓存数据存在则删除
      * @param key
      */
     public void evict(Object key){
         getCache().evict(key);
     }

     /**
      * 该方法获取的就是 net.sf.ehcache.Cache对象
      *
      * @return  net.sf.ehcache.Cache对象
      */
     public Object getNativeCache() {
         return getCache().getNativeCache();
     }

 }

　　该类主要是对spring中的ehcache进行封装。

　　Main.java代码如下：

 package com.ehcache.custom;

 import java.util.List;

 import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.ClassPathXmlApplicationContext;

 public class Main {

     public static void main(String[] args) {

         ApplicationContext context = new ClassPathXmlApplicationContext(
                 "spring-config-ehcache-custom.xml");

         EmployeeDAO dao = (EmployeeDAO) context.getBean("employeeDAO");

         System.out.println("-----------------------第1次调用----------------------------");
         List<Employee> employees = dao.getEmployees();
         System.out.println(employees.toString()); 

         System.out.println("------------------------第2次调用---------------------------");
         employees = dao.getEmployees();
         System.out.println(employees.toString()); 

         System.out.println("------------------------第3次调用---------------------------");
         employees = dao.getEmployees();
         System.out.println(employees.toString()); 

          System.out.println("------------------------- 获取对象--------------------------");
          System.out.println("-------------------------第1次调用--------------------------");
          Employee employee = dao.getEmployee(1, employees);
          System.out.println(employee.toString());
          System.out.println("-------------------------第2次调用--------------------------");
          employee = dao.getEmployee(1, employees);
          System.out.println(employee.toString());

          System.out.println("------------------------- 对象更新--------------------------");
          dao.updateEmployee(1, "已经更新的对象", employees);
          System.out.println("-------------------------第1次调用--------------------------");
          employee = dao.getEmployee(1, employees);
          System.out.println(employee.toString());
          System.out.println("-------------------------第2次调用--------------------------");
          employee = dao.getEmployee(1, employees);
          System.out.println(employee.toString());

          System.out.println("------------------------- 添加对象--------------------------");
          dao.addEmployee(new Employee(6, "555", "Designer5555"),employees);
          System.out.println("-------------------------第1次调用--------------------------");
          employee = dao.getEmployee(6, employees);
          System.out.println(employee);
          System.out.println("-------------------------第2次调用--------------------------");
          employee = dao.getEmployee(6, employees);
          System.out.println(employee.toString());

          System.out.println("------------------------- 清除一个对象--------------------------");
          dao.removeEmployee(2, employees);
          System.out.println("-------------------------第1次调用--------------------------");
          employees = dao.getEmployees();
          System.out.println(employees);
          System.out.println("-------------------------第2次调用--------------------------");
          employees = dao.getEmployees();
          System.out.println(employees);

          System.out.println("------------------------- 清除所有--------------------------");
          System.out.println(employees.size());
          employees = dao.removeAllEmployee(employees);
          System.out.println("-------------------------第1次调用--------------------------");
          employees = dao.getEmployees();
          System.out.println(employees);
          System.out.println("-------------------------第2次调用--------------------------");
          employees = dao.getEmployees();
          System.out.println(employees);
     }
 }

　　执行该文件即可。