【EhCache一】EhCache版Hello World

首先到ehcache官网下载：ehcache官网

下载完后解压。

打开Myeclipse 创建web项目，然后在项目classpath根目录下创建ehchache.xml

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
    updateCheck="true" monitoring="autodetect"
    dynamicConfig="true">

    <defaultCache
       maxElementsInMemory="20"
       eternal="false"
       overflowToDisk="false"
       timeToIdleSeconds="1800"
       timeToLiveSeconds="1800">
    </defaultCache>

    <cache name="data-cache"
      maxElementsInMemory="20"
      overflowToDisk="false"
      eternal="false"
      timeToIdleSeconds="1800"
      timeToLiveSeconds="1800"
      memoryStoreEvictionPolicy="LRU"
      transactionalMode="off"
       >
   <searchable keys="true"/> <!--可以根据Key进行查询，查询的Attribute就是keys-->
    </cache>
</ehcache>

参数含义：

name：Cache的唯一标识，程序中使用这个名字获得缓存实例

maxElementsInMemory：内存中最大缓存对象数 。

overflowToDisk：当overflowToDisk配置为true，当内存中Element数量达到maxElementsInMemory时，Ehcache将会Element写到磁盘中。

eternal：Element是否永久有效，一但设置了， timeToIdleSeconds和 timeToLiveSeconds 将不起作用

timeToIdleSeconds: Element在缓存中空闲的最大时间。也就是说，这个时间控制的是一个Element 在一直没有被访问的前提下，这个对象可以在cache中的存活时间。若是0，表示永远存活

timeToLiveSeconds： 设置对象在cache中的最大存活时间，就是 无论对象被访问或是闲置,这个对象在cache中总的存活时间。也就是说， timeToLiveSeconds的值得应该大于等于 timeToIdleSeconds， 若是0，表示永远存活。

memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内 存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）

maxElementsOnDisk：磁盘中最大缓存对象数，若是0表示无穷大。 该选项只有在overflowToDisk为true时有效

diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区

EhCache CRUD例子

package com.mayi.ehcache.demo;

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;
import net.sf.ehcache.config.CacheConfiguration;
import net.sf.ehcache.search.Attribute;
import net.sf.ehcache.search.Query;
import net.sf.ehcache.search.Result;
import net.sf.ehcache.search.Results;
import org.junit.Assert;
import org.junit.Test;

import java.io.InputStream;
import java.util.List;
import java.util.Set;

public class EhcacheTest {

    @Test
    public void testCacheManager() {
  //加载EhCache配置文件
  InputStream in = EhcacheTest.class.getClassLoader().getResourceAsStream("ehcache.xml");
  CacheManager cm = CacheManager.create(in);

  //列出所有的缓存名称，不包括配置文件中的<defaultCache>
  String[] names = cm.getCacheNames();

  //只有一个名称为data-cache的cache
  Assert.assertEquals(1, names.length);
  Assert.assertEquals(names[0], "data-cache");

  //根据指定名称查找缓存对象
  Cache cache = cm.getCache("data-cache"); //根据缓存名称获取缓存
  Assert.assertNotNull(cache);

  //获取，更新Cache配置的接口
//  CacheConfiguration configuration = cache.getCacheConfiguration();
//  configuration.setTimeToIdleSeconds(3600);

  //缓存在内存中的配置信息，缓存配置动态修改也会体现出来,
  System.out.println(cm.getActiveConfigurationText());

  //清除所有缓存的数据，但是缓存本身仍然存在
//  cm.clearAll();

  //从内存中删除一个缓存以及所有的数据，Cache被销毁
//  cm.removeCache("data-cache");

    }

    @Test
    public void testCache() {
  //只有被有初始化生效的Cache允许改名字
  //cache.setName("data-cache-changed");
    }

    @Test
    public void testAddElementToCache() {
  //加载EhCache配置文件
  InputStream in = EhcacheTest.class.getClassLoader().getResourceAsStream("ehcache.xml");
  CacheManager cm = CacheManager.create(in);

  Cache cache = cm.getCache("data-cache");

  Person p1 = new Person(1, "Jack", 21);
  Person p2 = new Person(2, "Mike", 73);

  cache.putIfAbsent(new Element(p1,p1, 1));
  cache.put(new Element(p2,p2, 1));
  cache.putIfAbsent(new Element(p2, p1,1));//只有Key为p2的数据不存在才插入

  //得到的是p2,而不是p1
  Element e = cache.get(p2);
  Assert.assertEquals(p2, e.getObjectValue());

  //把数据从内存刷到DiskStore，从DiskStore刷新到Disk中
  cache.flush();

    }

    @Test
    public void testRemoveElementFromCache() {
  //加载EhCache配置文件
  InputStream in = EhcacheTest.class.getClassLoader().getResourceAsStream("ehcache.xml");
  CacheManager cm = CacheManager.create(in);

  Cache cache = cm.getCache("data-cache");

  Person p1 = new Person(1, "Jack", 21);
  Person p2 = new Person(2, "Mike", 73);

  Element e1  = new Element(p1,p1, 1);
  cache.putIfAbsent(e1);
  Element e2 = new Element(p2,p2, 1);
  cache.put(e2);

  cache.remove(p1);
  boolean isSucc = cache.removeElement(e1);
  //e1已经被删除，因此操作返回false
  Assert.assertFalse(isSucc);

  cache.put(e1);

  cache.removeAll();

  Assert.assertEquals(0, cache.getSize());
    }

    @Test
    public void testUpdateElementInCache() {
  //加载EhCache配置文件
  InputStream in = EhcacheTest.class.getClassLoader().getResourceAsStream("ehcache.xml");
  CacheManager cm = CacheManager.create(in);

  Cache cache = cm.getCache("data-cache");

  Person p1 = new Person(1, "Jack", 21);
  Person p2 = new Person(2, "Mike", 73);

  Element e1  = new Element(p1,p1, 1);
  cache.putIfAbsent(e1);
  Element e2 = new Element(p2,p2, 1);
  cache.put(e2);

  e2 = new Element(p2, p1, 1);
  cache.replace(e2);

  Assert.assertEquals(p1, e2.getObjectValue());

    }

    @Test
    public void testQueryElementsFromCache() {
  InputStream in = EhcacheTest.class.getClassLoader().getResourceAsStream("ehcache.xml");
  CacheManager cm = CacheManager.create(in);
  Cache cache = cm.getCache("data-cache");

  //EhCache中的数据类型是Element，它包含Key,Value和一个版本信息
  Element e = new Element(1000, 10000, 1);
  cache.put(e);

  //添加第二个数据
  e = new Element(2000, 20000, 1);
  cache.put(e);

  //缓存中有两条数据
  Assert.assertEquals(2, cache.getSize());

  //通过get方法获得key对应的数据
  e = cache.get(1000);
  Assert.assertEquals(10000, e.getObjectValue());

  //创建查询
  Query q = cache.createQuery();

  //Cache没有配置任何查询属性，这里察看下默认的查询属性有哪些
  //set中包含两个可查询元素：key和value
  Set<Attribute> set = cache.getSearchAttributes();

  //属性是范型类，得到key都应的查询属性对象
  Attribute<Integer> keyAttribute = cache.getSearchAttribute("key"); //根据默认提供的可查询属性key进行查询

  //构造查询条件,这是一个链式写法，一个Query对象可以写多个查询条件
  //创建查找key的值为2000的查询
  q = q.addCriteria(keyAttribute.eq(2000));

  //如果不includeKeys和q.includeValues();,则测试结果集中不包括Keys和Values信息
  q.includeKeys();
  q.includeValues();

  //执行查询
  Results results = q.execute();//执行查询
  Assert.assertNotNull(results);
  Assert.assertEquals(results.size(), 1);

  //列出所有结果
  List<Result> resultList = results.all();
  Result result = resultList.get(0);
  Assert.assertEquals(2000, result.getKey());

  Assert.assertEquals(20000, result.getValue());
    }

}

Person 类

package com.mayi.ehcache.demo;

public class Person {
    private int id;
    private String name;
    private int age;

    public Person(int id, String name, int age) {
  this.id = id;
  this.name = name;
  this.age = age;
    }

    @Override
    public boolean equals(Object o) {
  if (this == o) return true;
  if (o == null || getClass() != o.getClass()) return false;

  Person person = (Person) o;

  if (age != person.age) return false;
  if (id != person.id) return false;
  if (name != null ? !name.equals(person.name) : person.name != null) return false;

  return true;
    }

    @Override
    public int hashCode() {
  int result = id;
  result = 31 * result + (name != null ? name.hashCode() : 0);
  result = 31 * result + age;
  return result;
    }
}

最后运行junit即可

案例下载：http://download.csdn.net/detail/caiwenfeng_for_23/8469925

时间： 2024-10-19 18:06:13

【EhCache一】EhCache版Hello World的相关文章

Ehcache——基于注解的缓存使用

ehcache是一个非常轻量级的缓存实现,而且从1.2之后就支持了集群,而且是hibernate默认的缓存provider.EhCache 是一个纯Java的进程内缓存框架,具有快速.精干等特点,是Hibernate中默认的CacheProvider. Ehcache的分布式缓存有传统的RMI,1.5版的JGroups,1.6版的JMS.分布式缓存主要解决集群环境中不同的服务器间的数据的同步问题. 使用Spring的AOP进行整合,可以灵活的对方法的返回结果对象进行缓存. CachingFilt

SpringMVC + ehcache（ ehcache-spring-annotations）基于注解的服务器端数据缓存

背景 声明,如果你不关心java缓存解决方案的全貌,只是急着解决问题,请略过背景部分. 在互联网应用中,由于并发量比传统的企业级应用会高出很多,所以处理大并发的问题就显得尤为重要.在硬件资源一定的情况下,在软件层面上解决高并发问题会比较经济实惠一些.解决并发的根本在于提高系统的响应时间与单位时间的吞吐量.解决问题的思路可分两个维度,一是提高系统的单位时间内的运算效率(比如集群),二是减少系统不必要的开支(比如缓存).缓存又会分为客户端缓存与服务器端缓存,本文就javaEE项目的服务器端缓存方案展

ehcache配置：使用Spring+SpringMVC+Mybatis或者有shiro【转】

SSM框架的搭建就不在叙述了 本文主要是讲解在SSM基础上再加上ehcache 1:首先:pom.xml需要的jar <dependency>   <groupId>org.mybatis</groupId>   <artifactId>mybatis-ehcache</artifactId>   <version>1.0.0</version>  </dependency>  <dependency&g

Ehcache整合spring

下面介绍一下简单使用的配置过程:ehcache.jar及spring相关jar就不说了,加到项目中就是了. 简单的使用真的很简单.但只能做为入门级了. 1.ehcache.xml,可放classpath根目录下, <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="ehcache.xsd" updateCheck="

ehcache memcache redis 三大缓存男高音

最近项目组有用到这三个缓存,去各自的官方看了下,觉得还真的各有千秋!今天特意归纳下各个缓存的优缺点,仅供参考!  Ehcache 在java项目广泛的使用.它是一个开源的.设计于提高在数据从RDBMS中取出来的高花费.高延迟采取的一种缓存方案.正因为Ehcache具有健壮性(基于java开发).被认证(具有apache 2.0  license).充满特色(稍后会详细介绍),所以被用于大型复杂分布式web application的各个节点中. 什么特色? 1.  够快 Ehcache的发行有一段

Spring使用Cache、整合Ehcache

从3.1开始,Spring引入了对Cache的支持.其使用方法和原理都类似于Spring对事务管理的支持.Spring Cache是作用在方法上的,其核心思想是这样的:当我们在调用一个缓存方法时会把该方法参数和返回结果作为一个键值对存放在缓存中,等到下次利用同样的参数来调用该方法时将不再执行该方法,而是直接从缓存中获取结果进行返回.所以在使用Spring Cache的时候我们要保证我们缓存的方法对于相同的方法参数要有相同的返回结果. 使用Spring Cache需要我们做两方面的事: n  声明

ehcache.xml

<?xml version="1.0" encoding="UTF-8"?> <!-- CacheManager Configuration ========================== An ehcache.xml corresponds to a single CacheManager. See instructions below or the ehcache schema (ehcache.xsd) on how to config

043 使用ehcache缓存权限数据 - bos

1.若不使用缓存,会频繁查询数据库,因此要为权限数据建立缓存 2.ehcache是一个缓存插件,可以缓存Java对象提高系统的性能 3.ehcache.xml配置文件样例 <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"> <diskStore pa

EhCache的配置

JPA和Hibernate的二级缓存都是这样做的 代码目录: 这是基础的jar包,如果少的话,再去maven下载 <!-- Spring --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${org.springframework-version}</vers