EaCache+spring+struts2对象缓存实例

Ehcache集成与应用

最新推荐文章于 2018-11-08 11:36:01 发布

magic_zz

最新推荐文章于 2018-11-08 11:36:01 发布

阅读量912

点赞数

CC 4.0 BY-SA版权

分类专栏：缓存

本文链接：https://blog.youkuaiyun.com/magic_zz/article/details/17751825

缓存专栏收录该内容

2 篇文章

订阅专栏

本文介绍了Ehcache的基本配置及在Spring环境下的集成方法，包括配置文件详解、测试类编写，并展示了如何通过Ehcache实现数据缓存，提高应用程序性能。

Ehcache在很多项目中都出现过，用法也比较简单。一般的加些配置就可以了，而且Ehcache可以对页面、对象、数据进行缓存，同时支持集群/分布式缓存。如果整合Spring、Hibernate也非常的简单，Spring对Ehcache的支持也非常好。EHCache支持内存和磁盘的缓存，支持LRU、LFU和FIFO多种淘汰算法，支持分布式的Cache，可以作为Hibernate的缓存插件。同时它也能提供基于Filter的Cache，该Filter可以缓存响应的内容并采用Gzip压缩提高响应速度。

一、准备工作

导入如下包：ehcache ；commons-logging ； cglib ； asm ； spring的jar包；struts2的jar包

二、添加spring配置文件applicationContext-cache.xml
<?xml version="1.0"encoding="UTF-8"?>
<beansxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:context="http://www.springframework.org/schema/context"
   xmlns:aop="http://www.springframework.org/schema/aop"xmlns:tx="http://www.springframework.org/schema/tx"
   xmlns="http://www.springframework.org/schema/beans"
   xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-3.0.xsd
   http://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">
   
   <bean id="cacheManager"
      class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
      <propertyname="configLocation">
         <value>classpath:ehcache.xml</value>
      </property>
   </bean>
   <bean id="userCache"class="org.springframework.cache.ehcache.EhCacheFactoryBean">
      <property name="cacheManager">
         <ref local="cacheManager" />
      </property>
      <property name="cacheName" value="userCache"/>
   </bean>
</beans>

三、添加EhCache配置文件ehcache.xml
<?xml version="1.0"encoding="UTF-8"?>
<ehcache>
   
   
   
   
   
   
   
   <!--MemoryStore支持三种策略：LRU、LFU、FIFO。
   1.LRU:最近最少使用的，缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清除缓存。
    2.LFU:最少被使用，缓存的元素有一个hit属性，hit值最小的将会被清除缓存。

3.FIFO:先进先出-->

   <diskStorepath="java.io.tmpdir"/>
   <defaultCache
      maxElementsInMemory="10000"
       eternal="false"
       overflowToDisk="true"
       timeToIdleSeconds="500"
       timeToLiveSeconds="1000"
       diskPersistent="false"
       diskExpiryThreadIntervalSeconds="120"/>
   <cachename="userCache" maxElementsInMemory="50000"
      maxElementsOnDisk="2000" eternal="false"overflowToDisk="true"
      diskSpoolBufferSizeMB="20" timeToIdleSeconds="300"timeToLiveSeconds="600"
      memoryStoreEvictionPolicy="LFU" />
</ehcache>

四、测试类
1、EhCacheProvider.java
public class EhCacheProvider {


    privatestatic final Log logger =LogFactory.getLog(EhCacheProvider.class);

    privatestatic ClassPathXmlApplicationContext ctxt;

    static{
       ctxt = newClassPathXmlApplicationContext(
            "/applicationContext-cache.xml");
      logger.info("初始化缓存");
    }


    publicstatic Cache getCache(String cacheName) {
       return(Cache) ctxt.getBean(cacheName);
    }


    publicstatic Object getObjectInCache(String cacheName, String key){
       Cache ch =getCache(cacheName);
       if (null !=ch) {
         logger.info("缓存["+cacheName + "]中的对象数量为= " + ch.getSize());
       }
       Element ele= ch.get(key);
       if (ele ==null) {
         logger.error("缓存["+cacheName + "]中key为["+key + "]的对象不存在");
          returnnull;
       } else{
          returnele.getValue();
       }
    }


    publicstatic void setObjectInCache(String cacheName, String key, Objectvalue) {
       Cache ch =getCache(cacheName);
       Element ele= new Element(key, value);
      ch.put(ele);
    }


    publicstatic void delCache(String cacheName) {
       Cache ch =getCache(cacheName);
      ch.removeAll();
      logger.info("清除缓存[" +cacheName + "]内的所有数据。");
    }


    publicstatic boolean checkKey(String cacheName, String key){
       Cache ch =getCache(cacheName);
       returnch.getKeys().contains(key);
    }
}

2、IehCacheService.java
public interface IehCacheService<T>{


    public TgetInCache(String key);


    public voidsetInCache(String key, T object);


    public voiddelCache();


    publicboolean checkKey(String key);
}

3、CacheService.java
public class CacheService implementsIehCacheService<User> {


    privatestatic Log log = LogFactory.getLog(UserCacheService.class);


    publicstatic final String USER_CACHENAME = "userCache";

    public UsergetInCache(String sid) {
       //直接调用辅助方法，返回结果
       return(User) EhCacheProvider.getObjectInCache(USER_CACHENAME, sid);
    }

    public voidsetInCache(String sid, User user) {
       //调用辅助方法，放入缓存
      EhCacheProvider.setObjectInCache(USER_CACHENAME, sid, user);
   }
    public voiddelCache() {
       //调用辅助方法，清空缓存数据
      EhCacheProvider.delCache(USER_CACHENAME);
      log.info("清空名称为[" + USER_CACHENAME + "]的缓存");
   }
    publicboolean checkKey(String sid) {
       returnEhCacheProvider.checkKey(USER_CACHENAME, sid);
    }
}

4、
public class Controllers extendsActionSupport{

    privatestatic final long serialVersionUID = 1L;
   @Autowired
    privateUserService userService;
    private Useruser;

    privateIehCacheService<User>userCacheService = new UserCacheService();


    privatestatic Log log = LogFactory.getLog(UserControllers.class);


    public UsergetUser() {
       returnuser;
    }


    public voidsetUser(User user) {
       this.user =user;
    }

    publicString selectUser(){

        //把对象加入缓存
       if(!userCacheService.checkKey(String.valueOf(user.getId()))){
          userCacheService.setInCache(String.valueOf(user.getId()),user);
          log.info(userr.getUsername()+"加入缓存成功。");
       }else{
             UsercacheUser =userCacheService.getInCache(String.valueOf(user.getId()));
             if(cacheUser!=null){
               log.info("缓存中已经存在此用户："+cacheUser.getUsername());
       }
            log.info(db_user.getUsername()+"加入缓存失败。");

       }
    }
}