ehcache2.8.3入门示例：hello world，以及在spring中使用 -

tommy_lu

浏览: 210437 次

最近访客更多访客>>

深情痞子

lonfiy

康敏栋

aininim

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

ehcache2.8.3入门示例：hello world，以及在spring中使用

博客分类：

java 基础

一、pom.xml 依赖项

<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.10</version>
		</dependency>
		<dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache</artifactId>
            <version>2.8.3</version>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.7</version>
        </dependency>
	</dependencies>

二、ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- 
参数的含义分别是：
a.maxElementInMemory表示该缓存中可以放置多少个对象，此处为1000个，根据内存的多少可以配置
b.eternal表示是否设置这些放入二级缓存的数据对象为永久的（即放入即保存，不再清除）一般都为false
c.timeToIdleSeconds=120表示如果120秒内，放入的对象没有被再次访问到，就清除出去
d.timeToLiveSeconds=120表示对象在缓存中存活的时间，一个对象进入到本缓存中120秒后，就会自动被清除（一般	设置的时间会比timeToIdleSeconds时间长），设置此属性是为了让更多活跃的对象进入到缓存中来。
e.overflowToDisk="true"表示如果活跃对象已经超出maxElementInMemory设置的最大值时，超出的对象要被写入到硬盘上保存下来，用于缓解活跃用户较多的情况。
f.Ehcache有一个后台线程专门做Ellment失效监测以及清除工作。设置线程运行间隔时间，可通过设置diskExpiryThreadIntervalSeconds属性来完成，此值不宜设置过低，否则会导致清理线程占用大量CPU资源。默认值是120秒。
-->
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:noNamespaceSchemaLocation="ehcache.xsd" updateCheck="true"
    monitoring="autodetect" dynamicConfig="true">


    <diskStore path="java.io.tmpdir" />

    <defaultCache maxEntriesLocalHeap="10000" eternal="false"
        timeToIdleSeconds="120" timeToLiveSeconds="120" diskSpoolBufferSizeMB="30"
        maxEntriesLocalDisk="10000000" diskExpiryThreadIntervalSeconds="120"
        memoryStoreEvictionPolicy="LRU">
        <persistence strategy="localTempSwap" />
    </defaultCache>

    <cache name="sampleCache1" maxEntriesLocalHeap="10000"
        maxEntriesLocalDisk="1000" eternal="false" diskSpoolBufferSizeMB="20"
        timeToIdleSeconds="300" timeToLiveSeconds="600"
        memoryStoreEvictionPolicy="LFU" transactionalMode="off">
        <persistence strategy="localTempSwap" />
    </cache>

    <cache name="sampleCache2" maxEntriesLocalHeap="1000" eternal="true"
        memoryStoreEvictionPolicy="FIFO" />

</ehcache>

三、示例代码

package com.cn.fangxin.ehcache.test;

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;

import org.junit.*;

public class TestEhcache {
	
	@Test
	public void testEhcachae() throws InterruptedException {
		CacheManager manager = CacheManager.create();

        // 取出所有的cacheName
        String names[] = manager.getCacheNames();
        System.out.println("----all cache names----");
        for (int i = 0; i < names.length; i++) {
            System.out.println(names[i]);
        }

        System.out.println("----------------------");
        // 得到一个cache对象
        Cache cache1 = manager.getCache(names[0]);

        // 向cache1对象里添加缓存
        cache1.put(new Element("key1", "values1"));
        Element element = cache1.get("key1");

        // 读取缓存
        System.out.println("key1 \t= " + element.getObjectValue());

        // 手动创建一个cache(ehcache里必须有defaultCache存在,"test"可以换成任何值)
        Cache cache2 = new Cache("test", 1, true, false, 2, 3);
        manager.addCache(cache2);

        cache2.put(new Element("jimmy", "菩提树下的杨过"));

        // 故意停1.5秒，以验证是否过期
        Thread.sleep(1500);

        Element eleJimmy = cache2.get("jimmy");

        //1.5s < 2s 不会过期
        if (eleJimmy != null) {
            System.out.println("jimmy \t= " + eleJimmy.getObjectValue());
        }

        //再等上0.5s, 总时长：1.5 + 0.5 >= min(2,3),过期
        Thread.sleep(500);

        eleJimmy = cache2.get("jimmy");

        if (eleJimmy != null) {
            System.out.println("jimmy \t= " + eleJimmy.getObjectValue());
        }

        // 取出一个不存在的缓存项
        System.out.println("fake \t= " + cache2.get("fake"));

        manager.shutdown();
	}

}

运行结果：

----all cache names----
sampleCache2
sampleCache1
----------------------
key1    = values1
jimmy    = 菩提树下的杨过
fake    = null

四、关于timeToLiveSeconds、timeToIdleSeconds

这二个参数直接影响缓存项的过期时间，看文档说明基本上没啥用，直接看net.sf.ehcache.Element源码的片段：

/**
     * The amount of time for the element to live, in seconds. 0 indicates unlimited.
     */
    private volatile int timeToLive = Integer.MIN_VALUE;

    /**
     * The amount of time for the element to idle, in seconds. 0 indicates unlimited.
     */
    private volatile int timeToIdle = Integer.MIN_VALUE;
    
    
    /**
     * Sets time to Live
     * <P/>
     * Value must be a positive integer, 0 means infinite time to live.
     * <P/>
     * If calling this method with 0 as the parameter, consider using {@link #setEternal(boolean)}
     * or make sure you also explicitly call {@link #setTimeToIdle(int)}.
     *
     * @param timeToLiveSeconds the number of seconds to live
     */
    public void setTimeToLive(final int timeToLiveSeconds) {
        if (timeToLiveSeconds < 0) {
            throw new IllegalArgumentException("timeToLive can't be negative");
        }
        this.cacheDefaultLifespan = false;
        this.timeToLive = timeToLiveSeconds;
    }

    /**
     * Sets time to idle
     * <P/>
     * Value must be a positive integer, 0 means infinite time to idle.
     * <P/>
     * If calling this method with 0 as the parameter, consider using {@link #setEternal(boolean)}
     * or make sure you also explicitly call {@link #setTimeToLive(int)}.
     *
     * @param timeToIdleSeconds the number of seconds to idle
     */
    public void setTimeToIdle(final int timeToIdleSeconds) {
        if (timeToIdleSeconds < 0) {
            throw new IllegalArgumentException("timeToIdle can't be negative");
        }
        this.cacheDefaultLifespan = false;
        this.timeToIdle = timeToIdleSeconds;
    }
    
    

    /**
     * An element is expired if the expiration time as given by {@link #getExpirationTime()} is in the past.
     *
     * @return true if the Element is expired, otherwise false. If no lifespan has been set for the Element it is
     *         considered not able to expire.
     * @see #getExpirationTime()
     */
    public boolean isExpired() {
        if (!isLifespanSet() || isEternal()) {
            return false;
        }

        long now = System.currentTimeMillis();
        long expirationTime = getExpirationTime();

        return now > expirationTime;
    }
    
    
    /**
     * An element is expired if the expiration time as given by {@link #getExpirationTime()} is in the past.
     * <p>
     * This method in addition propogates the default TTI/TTL values of the supplied cache into this element.
     *
     * @param config config to take default parameters from
     * @return true if the Element is expired, otherwise false. If no lifespan has been set for the Element it is
     *         considered not able to expire.
     * @see #getExpirationTime()
     */
    public boolean isExpired(CacheConfiguration config) {
        if (cacheDefaultLifespan) {
            if (config.isEternal()) {
                timeToIdle = 0;
                timeToLive = 0;
            } else {
                timeToIdle = TimeUtil.convertTimeToInt(config.getTimeToIdleSeconds());
                timeToLive = TimeUtil.convertTimeToInt(config.getTimeToLiveSeconds());
            }
        }
        return isExpired();
    }

    /**
     * Returns the expiration time based on time to live. If this element also has a time to idle setting, the expiry
     * time will vary depending on whether the element is accessed.
     *
     * @return the time to expiration
     */
    public long getExpirationTime() {
        if (!isLifespanSet() || isEternal()) {
            return Long.MAX_VALUE;
        }

        long expirationTime = 0;
        long ttlExpiry = creationTime + TimeUtil.toMillis(getTimeToLive());

        long mostRecentTime = Math.max(creationTime, lastAccessTime);
        long ttiExpiry = mostRecentTime + TimeUtil.toMillis(getTimeToIdle());

        if (getTimeToLive() != 0 && (getTimeToIdle() == 0 || lastAccessTime == 0)) {
            expirationTime = ttlExpiry;
        } else if (getTimeToLive() == 0) {
            expirationTime = ttiExpiry;
        } else {
            expirationTime = Math.min(ttlExpiry, ttiExpiry);
        }
        return expirationTime;
    }

    /**
     * @return true if the element is eternal
     */
    public boolean isEternal() {
        return (0 == timeToIdle) && (0 == timeToLive);
    }
    
    
    /**
     * Sets whether the element is eternal.
     *
     * @param eternal
     */
    public void setEternal(final boolean eternal) {
        if (eternal) {
            this.cacheDefaultLifespan = false;
            this.timeToIdle = 0;
            this.timeToLive = 0;
        } else if (isEternal()) {
            this.cacheDefaultLifespan = false;
            this.timeToIdle = Integer.MIN_VALUE;
            this.timeToLive = Integer.MIN_VALUE;
        }
    }

    /**
     * Whether any combination of eternal, TTL or TTI has been set.
     *
     * @return true if set.
     */
    public boolean isLifespanSet() {
        return this.timeToIdle != Integer.MIN_VALUE || this.timeToLive != Integer.MIN_VALUE;
    }

    /**
     * @return the time to live, in seconds
     */
    public int getTimeToLive() {
        if (Integer.MIN_VALUE == timeToLive) {
            return 0;
        } else {
            return timeToLive;
        }
    }

    /**
     * @return the time to idle, in seconds
     */
    public int getTimeToIdle() {
        if (Integer.MIN_VALUE == timeToIdle) {
            return 0;
        } else {
            return timeToIdle;
        }
    }
    
    
    /**
     * Set the default parameters of this element - those from its enclosing cache.
     * @param tti TTI in seconds
     * @param ttl TTL in seconds
     * @param eternal <code>true</code> if the element is eternal.
     */
    protected void setLifespanDefaults(int tti, int ttl, boolean eternal) {
        if (eternal) {
            this.timeToIdle = 0;
            this.timeToLive = 0;
        } else if (isEternal()) {
            this.timeToIdle = Integer.MIN_VALUE;
            this.timeToLive = Integer.MIN_VALUE;
        } else {
            timeToIdle = tti;
            timeToLive = ttl;
        }
    }

结论：

a) timeToIdleSeconds(空闲时间)、timeToLiveSeconds(生存时间)都设置为0时，表示不过期

b) 如果只有timeToLiveSeconds设置>0的值，则Element的过期时间为 timeToLiveSeconds

c) 如果只有timeToIdleSeconds设置>0的值，则Element的过期时间为 (上次访问时间+timeToIdleSeconds)，说得更通俗点，上次get过了，现在又想get，若二次get的时间间隔>timeToIdleSeconds，则过期(即：最后一次get出来为null)

d) 如果timeToLiveSeconds、timeToIdleSeconds都有>0的值，则最终过期时间为 b)，c)规则综合起来，取二者的最小值

测试1：

@Test
    public void testTimeToIdleSeconds() throws InterruptedException {
        CacheManager manager = CacheManager.create();

        Cache myCache = new Cache("MyCache", 1, true, false, 0, 0); // Cache上设置为永不过期
        manager.addCache(myCache);

        String key = "A";

        System.out.println("-------------------------");
        Element elementPut = new Element(key, "Some Value", 2, 0); // timeToIdleSeconds为2秒

        myCache.put(elementPut);// 放入缓存
        System.out.println(myCache.get(key));// 取出显示

        Thread.sleep(1500);// 停1.5秒
        System.out.println(myCache.get(key));// 再次取出

        Thread.sleep(1500);// 停1.5秒
        System.out.println(myCache.get(key));// 虽然总时间已达3秒，但刚刚被访问过了，所以又可以再"活"2秒，仍然有效

        Thread.sleep(2500);// 停2.5秒
        System.out.println(myCache.get(key));// 距离上次访问已过2.5s，已经>2s，过期

    }

输出结果

[ key = A, value=Some Value, version=1, hitCount=1, CreationTime = 1407898361782, LastAccessTime = 1407898361787 ]
[ key = A, value=Some Value, version=1, hitCount=2, CreationTime = 1407898361782, LastAccessTime = 1407898363287 ]
[ key = A, value=Some Value, version=1, hitCount=3, CreationTime = 1407898361782, LastAccessTime = 1407898364787 ]
null

测试2：

@Test
    public void testTimeToLiveSeconds() throws InterruptedException {
        CacheManager manager = CacheManager.create();

        Cache myCache = new Cache("MyCache", 1, true, false, 0, 0); // Cache上设置为永不过期
        manager.addCache(myCache);

        String key = "A";

        System.out.println("-------------------------");
        Element elementPut = new Element(key, "Some Value", 0, 2); // timeToLiveSeconds为2秒

        myCache.put(elementPut);// 放入缓存
        System.out.println(myCache.get(key));// 取出显示

        Thread.sleep(1500);// 停1.5秒
        System.out.println(myCache.get(key));// 再次取出(1.5s<2s，还"活"着)

        Thread.sleep(1500);// 停1.5秒
        System.out.println(myCache.get(key));// 总时间已达3s，>2s，已过期)

    }

输出结果

[ key = A, value=Some Value, version=1, hitCount=1, CreationTime = 1407898423291, LastAccessTime = 1407898423296 ]
[ key = A, value=Some Value, version=1, hitCount=2, CreationTime = 1407898423291, LastAccessTime = 1407898424797 ]
null

测试3：

@Test
    public void testTimeToIdleSecondsAndTimeToLiveSeconds()
            throws InterruptedException {
        CacheManager manager = CacheManager.create();

        Cache myCache = new Cache("MyCache", 1, true, false, 0, 0); // Cache上设置为永不过期
        manager.addCache(myCache);

        String key = "A";

        System.out.println("-------------------------");
        Element elementPut = new Element(key, "Some Value", 2, 5); // timeToIdleSeconds为2秒，timeToLiveSeconds为3秒

        myCache.put(elementPut);// 放入缓存
        System.out.println(myCache.get(key));// 取出显示

        Thread.sleep(1600);// 停1.6秒
        System.out.println(myCache.get(key));// 再次取出(1.6s < min(2 ,5)，还"活"着)

        Thread.sleep(1600);// 停1.6秒
        System.out.println(myCache.get(key));// 总时间已达3.2s，< min((1.6+2) ,5)，还"活"着)
        
        Thread.sleep(1600);// 停1.6秒
        System.out.println(myCache.get(key));// 总时间已达4.8s，< min((3.2+2) ,5)，还"活"着)
        
        Thread.sleep(500);// 停0.5秒
        System.out.println(myCache.get(key));// 总时间已达4.8+0.5=5.3s，> min((4.8+2) ,5)，过期)

    }

输出结果

[ key = A, value=Some Value, version=1, hitCount=1, CreationTime = 1407898480892, LastAccessTime = 1407898480897 ]
[ key = A, value=Some Value, version=1, hitCount=2, CreationTime = 1407898480892, LastAccessTime = 1407898482499 ]
[ key = A, value=Some Value, version=1, hitCount=3, CreationTime = 1407898480892, LastAccessTime = 1407898484099 ]
[ key = A, value=Some Value, version=1, hitCount=4, CreationTime = 1407898480892, LastAccessTime = 1407898485699 ]
null

关于这二个参数的设置，个人建议是：

a) 如果缓存的数据本身不存在更新(比如：一些几乎从来不动的基础数据)，只设置timeToIdleSeconds，这样的好处是，如果缓存项一直有人在访问，就永远不会过期，反之，如果没人用，空闲一段时间后，会自动过期，释放资源

b) 如果缓存的数据本身存在定期的更新问题(比如：天气预报之类每隔几小时，db中会更新的数据)，可同时设置二个参数，timeToLiveSeconds的值应该要小于db中的更新周期，这样db中的数据变化后，过一段时间就会更新到缓存中

四、在spring中集成ehcache

1、需要添加的依赖

<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context-support</artifactId>
			<version>3.0.5.RELEASE</version>
		</dependency>

2、在spring中的配置

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

出处：http://yjmyzz.cnblogs.com

分享到：

ehcache基本原理 | Ehcache详细解读

2015-08-21 15:56
浏览 1416
评论(0)
分类:编程语言
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

ehcache2.8.3入门示例：hello world，以及在spring中使用

评论

发表评论

相关推荐

最近访客 更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

ehcache2.8.3入门示例：hello world，以及在spring中使用

评论

发表评论

相关推荐

java静态和动态代理原理

log4j【1】（使用xml还是使用properties）

Java——协变数组和类型擦除(covariant array &amp; type erasure)

Java 可变参数

java为啥计算时间从1970年1月1日开始

使用Policy文件来设置Java的安全策略

问题详情 access denied(“java.net.SocketPermission””localhost:1527″”listen,resolve”)解

Java中的堆和栈的区别

Java 7 新的 try-with-resources 语句，自动资源释放

java的System.getProperty()方法可以获取的值

JSTL版本错误的解决-"This absolute uri (http://java.sun.co

解析J2EE、J2SE、J2ME、JDK的区别

HttpServletRequestWrapper 用法

深入理解 Java中的 流 (Stream)

深入理解 Java中的 流 (Stream)

转：java二维码工具类，中间带ＬＯＧＯ的，很强大

LinkedHashMap按存放顺序迭代

Java中的TreeMap、Comparable、Comparator

Java类分析器

java泛型，原始类型，桥接方法

最近访客更多访客>>

Java——协变数组和类型擦除(covariant array & type erasure)

深入理解 Java中的流 (Stream)

深入理解 Java中的流 (Stream)