精华内容
下载资源
问答
  • ehcache缓存对象

    2019-07-26 08:52:58
    NULL 博文链接:https://sunny-java-163-com.iteye.com/blog/661304
  • 本篇文章主要介绍了Spring Boot 简单使用EhCache缓存框架的方法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • cache/ehcache缓存使用

    2015-10-23 21:25:09
    cache、ehcache缓存使用,实现存对象读对象等等
  • EHCache缓存

    2017-10-13 17:08:51
    ehcache是一个用Java实现的使用简单,高速,实现线程安全的缓存管理类库,ehcache提供了用内存,磁盘文件存储,以及分布式存储方式等多种灵活的cache管理方案,是hibernate中默认的CacheProvider。
  • Ehcache缓存技术

    2018-07-23 21:27:27
    Ehcache缓存技术 Ehcache缓存技术 Ehcache缓存技术 Ehcache缓存技术 Ehcache缓存技术
  • ehcache缓存demo

    2018-12-03 17:54:39
    简单的ehcache缓存demo实例,描述了 ehcache缓存的简单使用
  • ehcache缓存

    2017-07-14 18:30:44
    ehcache缓存
  • Ehcache缓存

    2013-06-28 15:03:11
    hibernate最核心的 就是缓存技术
  • EhCache缓存

    2018-05-10 10:23:45
    mybatis缓存, mybatis的缓存EhCache,mybatis工具,mybatis工具类
  • Ehcache 缓存查看

    千次阅读 2020-10-09 10:15:47
    参考:https://blog.csdn.net/EQuaker/article/details/90140137 ... package xxx.util.cache; import net.sf.ehcache.Cache; import net.sf.ehcache.CacheManager; import net.sf.ehcache.Element; impor

    参考:https://blog.csdn.net/EQuaker/article/details/90140137

    参考:https://blog.csdn.net/xintingandzhouyang/article/details/81433235

    环境

            <dependency>
                <groupId>net.sf.ehcache</groupId>
                <artifactId>ehcache</artifactId>
                <version>2.10.6</version>
            </dependency>

    实现

    查看上述参考后,本地自己写的一个Ehcache 缓存查询工具类

    package xx.cache;
    
    import net.sf.ehcache.*;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.stereotype.Component;
    
    import java.util.Collections;
    import java.util.List;
    
    /**
     * @author zcm
     * @since 2020/9/28 10:24
     * <p>
     * Ehcache 工具类
     */
    @Component
    public class EhcacheUtil {
    
        private static Logger log = LoggerFactory.getLogger(EhcacheUtil.class);
    
    
        private static CacheManager cacheManager;
    
    
        /**
         * 引入其他方式创建的 Ehcache 缓存管理器,同时为静态变量赋值
         *
         * @param cacheManager
         */
        @Qualifier("ehcacheCacheManager")
        @Autowired
        public void setCacheManager(CacheManager cacheManager) {
            EhcacheUtil.cacheManager = cacheManager;
        }
    
    
        /**
         * 得到当前存在的缓存的cache对象
         *
         * @param cacheName
         * @return 如果缓存类型不存在, 或已清理, 则可能返回空类型
         */
        public static Cache getCache(String cacheName) {
            Cache cache = cacheManager.getCache(cacheName);
            return cache;
        }
    
    
        public static Ehcache getEhcache(String cacheName){
            return cacheManager.getEhcache(cacheName);
        }
    
    
        /**
         * 得到该缓存的所有key
         *
         * @param cacheName
         * @return
         */
        public static List getKeys(String cacheName) {
            Cache cache = getCache(cacheName);
            if (cache == null) {
                return Collections.emptyList();
            }
            List keys = cache.getKeys();
            return keys;
        }
    
    
        /**
         * 得到缓存值的本来形式
         *
         * @param cacheName
         * @param key
         * @return
         */
        public static Object getObjVal(String cacheName, Object key) {
            Cache cache = getCache(cacheName);
            if (cache == null) {
                return null;
            }
            Element element = cache.get(key);
            return null == element ? null : element.getObjectValue();
        }
    
    
        /**
         * 得到字符串形式的缓存值
         *
         * @param cacheName
         * @param key
         * @return
         */
        public static String getStrVal(String cacheName, Object key) {
            Object objVal = getObjVal(cacheName, key);
            return null == objVal ? "" : String.valueOf(objVal);
        }
    
        /**
         * 判断该缓存是否存在
         *
         * @param cacheName
         * @return
         */
        public static boolean cacheExist(String cacheName) {
            return cacheManager.cacheExists(cacheName);
        }
    
        /**
         * 得到当前该缓存管理器下的所有存在的缓存的名称数组
         *
         * @return
         */
        public static String[] getCacheNames() {
            return cacheManager.getCacheNames();
        }
    
        /**
         * TODO 慎用,如果删除该缓存后,在往该缓存添加值,如果直接添加会报错,提示 该缓存已关闭或状态不存在
         * 报错: The allMenus Cache is not alive (STATUS_SHUTDOWN)
         *
         * 清空所有缓存下的键值,所有缓存也会被释放
         */
        public static void removeAll() {
            cacheManager.removeAllCaches();
        }
    
    
        /**
         * TODO 慎用,如果删除该缓存后,在往该缓存添加值,如果直接添加会报错,提示 该缓存已关闭或状态不存在
         * 移除该缓存的所有键值,该缓存也会被释放
         * 从CacheManager中删除缓存。缓存被释放。
         *
         * @param cacheName
         */
        public static void removeCache(String cacheName) {
            cacheManager.removeCache(cacheName);
        }
    
    
        /**
         * 移除该缓存的所有键值,但缓存不释放
         *
         * @param cacheName
         */
        public static void clearCache(String cacheName) {
            Cache cache = getCache(cacheName);
            if(cache != null) {
                cache.removeAll();
            }
        }
    
    
        /**
         * 删除缓存下的所有键值,但不释放该缓存
         */
        public static void clearAll() {
            cacheManager.clearAll();
        }
    
    
        /**
         * 清除CacheManager中名称以前缀开头的所有缓存的内容,但不删除它们。
         *
         * @param prefix
         */
        public static void clearStartWith(String prefix) {
            cacheManager.clearAllStartingWith(prefix);
        }
    
    
        /**
         * 检查 缓存管理器的 状态
         *
         * @return
         */
        public static String getStatus() {
            return cacheManager.getStatus().toString();
        }
    
        /**
         * 安全的添加 以某个名称为命名的缓存,如果存在,则直接返回,否则添加后在返回
         * @param cacheName
         * @return
         */
        public static Ehcache addCacheIfAbsent(String cacheName){
            Ehcache ehcache = cacheManager.addCacheIfAbsent(cacheName);
            return ehcache;
        }
    
        /**
         * 为某个缓存添加键值,默认空闲时间0s,过期时间 300s
         * @param cacheName     缓存名称
         * @param key           key
         * @param value         value
         * @return
         */
        public static void setValue(String cacheName,String key,String value) {
    //        // 设置空闲时间 0, 过期时间 300 ,单位都为秒
            setValue(cacheName,key,value,0,300);
        }
    
    
        /**
         * 为某个缓存添加键值,指定空闲时间和过期时间
         * @param cacheName
         * @param key
         * @param value
         * @param idleSeconds
         * @param liveSeconds
         */
        public static void setValue(String cacheName,String key,String value,int  idleSeconds,int liveSeconds) {
            Ehcache ehcache = addCacheIfAbsent(cacheName);
            // 设置空闲时间 0, 过期时间 300 ,单位都为秒
            ehcache.put(new Element(key,value,idleSeconds,liveSeconds));
        }
    
    }
    

    说明:

    至于在其他参考文章中,描述的如果,如果缓存要被检索,需要 在 ehcache.xml 中的具体元素中加入  searchable 子标签和相关查询的key 值和其他设定,由于我的项目使用的 springboot 项目,使用相关缓存的操作注解来设置 缓存和key ,所有没有设置 searchable 子标签也可以查询到对应的缓存的相关值

    展开全文
  • EhCache是一个比较成熟的Java缓存框架,最早从hibernate发展而来, 是进程中的缓存系统,它提供了用内存,磁盘文件存储,以及分布式存储方式等多种灵活的cache管理方案,快速简单。 网上很多教程都没说完整,本 1...

    EhCache是一个比较成熟的Java缓存框架,最早从hibernate发展而来, 是进程中的缓存系统,它提供了用内存,磁盘文件存储,以及分布式存储方式等多种灵活的cache管理方案,快速简单。

    网上很多教程都没说完整,本文写的代码都是经过实践测试出来的的结果。

    1、引入MAVEN

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
    <dependency>
        <groupId>net.sf.ehcache</groupId>
        <artifactId>ehcache</artifactId>
        <version>2.10.2</version>
    </dependency>

    2、编写ehcache.xml配置文件,放到resources文件夹下

    <?xml version="1.0" encoding="UTF-8"?>
    <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">
    
        <!-- 磁盘缓存位置 -->
        <diskStore path="D:\testEhcache"/>
    
        <!-- defaultCache:echcache的默认缓存策略  -->
        <defaultCache
                maxElementsInMemory="50000"
                maxElementsOnDisk="100000"
                overflowToDisk="true"
                diskPersistent="false"
                timeToIdleSeconds="0"
                timeToLiveSeconds="0"
                diskSpoolBufferSizeMB="50"
                diskExpiryThreadIntervalSeconds="120"
                memoryStoreEvictionPolicy="LFU"/>
    
        <!-- 自定义缓存策略  -->
        <cache name="test"
               maxElementsInMemory="1"
               maxElementsOnDisk="100000"
               overflowToDisk="true"
               diskPersistent="true"
               timeToIdleSeconds="0"
               timeToLiveSeconds="21600"
               diskSpoolBufferSizeMB="50"
               diskExpiryThreadIntervalSeconds="120"
               memoryStoreEvictionPolicy="FIFO"/>
    
    </ehcache>

     下面为属性全属性介绍:

    <diskStore path="java.io.tmpdir/Tmp_EhCache"/> : 默认临时文件路径
    name : 缓存名称。
    maxElementsInMemory : 缓存最大数目
    maxElementsOnDisk :硬盘最大缓存个数。
    eternal : 对象是否永久有效,一但设置了,timeout将不起作用。
    overflowToDisk : 是否保存到磁盘,当系统当机时
    timeToIdleSeconds : 设置对象在失效前的允许闲置时间(单位:秒)。
            仅当eternal=false对象不是永久有效时使用,可选属性,默认值是0,也就是可闲置时间无穷大。
    timeToLiveSeconds : 设置对象在失效前允许存活时间(单位:秒)。最大时间介于创建时间和失效时间之间。
            仅当eternal=false对象不是永久有效时使用,默认是0.,也就是对象存活时间无穷大。
    diskPersistent :是否缓存虚拟机重启期数据 
    diskSpoolBufferSizeMB :这个参数设置DiskStore(磁盘缓存)的缓存区大小。
            默认是30MB。每个Cache都应该有自己的一个缓冲区。
    diskExpiryThreadIntervalSeconds :磁盘失效线程运行时间间隔,默认是120秒。
    memoryStoreEvictionPolicy :当达到maxElementsInMemory限制时,Ehcache将会根据指定的策略去清理内存。
            默认策略是LRU(最近最少使用)。你可以设置为FIFO(先进先出)或是LFU(较少使用)。
    clearOnFlush :内存数量最大时是否清除。
    memoryStoreEvictionPolicy : 可选策略有:LRU(最近最少使用,默认策略)、FIFO(先进先出)、LFU(最少访问次数)。
            FIFO,先进先出。
            LFU,直白一点就是讲一直以来最少被使用的。如上面所讲,缓存的元素有一个hit属性,hit值最小的将会被清出缓存。
            LRU,缓存的元素有一个时间戳,当缓存容量满了,而又需要腾出地方来缓存新的元素的时候,那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。

    3、在application.properties中指定文件路径

    spring.cache.ehcache.config=classpath:ehcache.xml

    4、在Application.java中加入@EnableCaching注解,启动缓存启动器

    @EnableCaching
    public class Application {
        public static void main(String[] args) {
            SpringApplication.run(app.class, args);
        }
    }

    5、使用场景

    以在数据库中查询一个结果为例,我用一个字符串代表数据库结果,现需要将结果缓存起来,用Ehcache实现这个过程。

    service层:

    package com.service;
    
    import org.springframework.cache.annotation.CacheEvict;
    import org.springframework.cache.annotation.CachePut;
    import org.springframework.cache.annotation.Cacheable;
    import org.springframework.stereotype.Service;
    
    @Service
    public class TestCache {
        /**
         * 缓存数据和查询缓存
         */
        @Cacheable(value = "test", key = "#key")
        public String getConfigure(String key) {
            return "oldConfigure";
        }
    
        /**
         * 缓存数据
         */
        @CachePut(value = "test", key = "#key")
        public String updateConfigure(String key) {
            return "newConfigure";
        }
    
        /**
         * 清除缓存
         */
        @CacheEvict(value = "test", key = "#key")
        public void cleanConfigure(String key) {
            System.out.println("缓存清除成功");
        }
    
        /**
         * 清除缓存
         */
        @CacheEvict(value = "test", allEntries = true)
        public void cleanAll() {
            System.out.println("缓存清除成功");
        }
    }

    controller层:

    /**
     * 缓存数据和查询缓存
     */
    @RequestMapping("/getCache")
    public String getCache() {
        return testCache.getConfigure("configure");
    }
    
    /**
     * 缓存数据
     */
    @RequestMapping("/setCache")
    public String setCache() {
        return testCache.updateConfigure("configure");
    }
    
    /**
     * 清除缓存
     */
    @RequestMapping("/cleanCache")
    public void cleanCache() {
        testCache.cleanConfigure("configure");
    }
    
    /**
     * 清除缓存
     */
    @RequestMapping("/cleanAll")
    public void cleanAllCache() {
        testCache.cleanAll();
    }

    6、结果

    调用过程:1、获取缓存数据;2、修改缓存数据;3、获取缓存数据;4、清除缓存数据;5、获取缓存数据

    7、优化

    package com.service;
    
    import org.springframework.cache.annotation.CacheConfig;
    import org.springframework.cache.annotation.CacheEvict;
    import org.springframework.cache.annotation.CachePut;
    import org.springframework.cache.annotation.Cacheable;
    import org.springframework.stereotype.Service;
    
    @Service
    @CacheConfig(cacheNames = {"test"})
    public class TestCache {
        /**
         * 缓存数据和查询缓存
         */
        @Cacheable
        public String getConfigure(String key) {
            return "oldConfigure";
        }
    
        /**
         * 缓存数据
         */
        @CachePut
        public String updateConfigure(String key) {
            return "newConfigure";
        }
    
        /**
         * 清除缓存
         */
        @CacheEvict
        public void cleanConfigure(String key) {
            System.out.println("缓存清除成功");
        }
    
        /**
         * 清除缓存
         */
        @CacheEvict(allEntries = true)
        public void cleanAll() {
            System.out.println("缓存清除成功");
        }
    }

    8、补充

    (1)key支持SpEL上下文数据

    图片来源:https://www.jianshu.com/p/e9b40acb2993

    例如:@Cacheable(key = "targetClass + methodName +#p0")

               表示类名+方法名+第一个参数 拼接 key

    (2)实体存为缓存的时候,需要实例化,继承 Serializable 

    (3)@CacheEvict 的 beforeInvocation 属性表示在执行方法之前执行缓存操作,避免出现异常时缓存没执行

     

    相关文章:

    Springboot整合cache缓存到redis:https://blog.csdn.net/zhangjian8641/article/details/108246750

    展开全文
  • ehcache缓存的jar包和配置文件。
  • ehcache缓存技术讲解

    千次阅读 2017-11-10 21:22:27
    一,ehcache缓存 在这里,我们首先讨论一个问题,什么是缓存,我们为什么要使用缓存?缓存实际上是为了减轻数据库服务器的负载,使用缓存,我们可以将一些常用的数据放入缓存,因为这些数据经常性的使用,大大增加...

    一,ehcache缓存
    在这里,我们首先讨论一个问题,什么是缓存,我们为什么要使用缓存?缓存实际上是为了减轻数据库服务器的负载,使用缓存,我们可以将一些常用的数据放入缓存,因为这些数据经常性的使用,大大增加了服务器的负载,但是当放入缓存后,在使用这些数据的时候,首先会从缓存中查找,如果缓存中有就读取,不会再到数据库中查找,如果缓存中没有,才会到数据库中查询,在这里,需要注意的是,ehcache的是将数据放入jvm内存中,也就是说当次缓存在本次服务器启动期间有效,下次服务器启动将会失效。

    二,如何使用ehcache技术进行缓存?
    使用ehcache进行缓存其实非常简单,在这里简要介绍一下,然后我们通过一个实例来介绍具体怎么使用。

    Ehcache的类层次模型主要为三层,最上层的是CacheManager,他是操作Ehcache的入口。我们可以通过CacheManager.getInstance()获得一个单个的CacheManager,或者通过CacheManager的构造函数创建一个新的CacheManager。每个CacheManager都管理着多个Cache。而每个Cache都以一种类Hash的方式,关联着多个Elemenat。而Element则是我们用于存放要缓存内容的地方。

    ehcache的刷新策略
    ehcache的刷新策略是当缓存在放入的时候记录一个放入时间,它是用Lazy Evict的方式,在取的时候同设置的TTL比较

    ehcache缓存的3种清空策略:
    1 FIFO,先进先出
    2 LFU,最少被使用,缓存的元素有一个hit属性,hit值最小的将会被清出缓存。
    3 LRU,最近最少使用的,缓存的元素有一个时间戳,当缓存容量满了,而又需要腾出地方来缓存新的元素的时候,那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。

    事件处理
    可以为CacheManager添加事件监听,当对CacheManager增删Cache时,事件处理器将会得到通知。要配置事件处理,需要通过ehcache的配置文件来完成。
    可以为Cache添加事件监听,当对Cache增删Element时,事件处理器将会得到通知。要配置事件处理,需要通过ehcache的配置文件来完成。

    ehcache参数配置:
    maxInMemory - 设定内存中创建对象的最大值。
    eternal - 设置元素(译注:内存中对象)是否永久驻留。如果是,将忽略超时限制且元素永不消亡。
    timeToIdleSeconds - 设置某个元素消亡前的停顿时间。也就是在一个元素消亡之前,两次访问时间的最大时间间隔值。这只能在元素不是永久驻留时有效(译注:如果对象永恒不灭,则设置该属性也无用)。
    如果该值是 0 就意味着元素可以停顿无穷长的时间。
    timeToLiveSeconds - 为元素设置消亡前的生存时间。也就是一个元素从构建到消亡的最大时间间隔值。这只能在元素不是永久驻留时有效。
    overflowToDisk - 设置当内存中缓存达到maxInMemory 限制时元素是否可写到磁盘上。

    好了,经过上面的介绍,下面我们来看一个简单的实例。我们将会查询一条数据后然后删除这条数据再次查询任然能查询到该结果,因为它已经存入到缓存中了,即使数据库中不存在该数据。
    首先,要引入pom。

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>

    ehcache.xml文件

    <ehcache>
        <!-- 磁盘存储:将缓存中暂时不使用的对象,转移到硬盘,类似于Windows系统的虚拟内存 path:指定在硬盘上存储对象的路径 -->
        <diskStore path="java.io.tmpdir" />
        <!-- defaultCache:默认的缓存配置信息,如果不加特殊说明,则所有对象按照此配置项处理 maxElementsInMemory:设置了缓存的上限,最多存储多少个记录对象 
            eternal:代表对象是否永不过期 timeToIdleSeconds:最大的发呆时间 timeToLiveSeconds:最大的存活时间 overflowToDisk:是否允许对象被写入到磁盘 -->
        <defaultCache maxElementsInMemory="10000" eternal="false"
            timeToIdleSeconds="120" timeToLiveSeconds="120" overflowToDisk="true" />
        <!-- cache:为指定名称的对象进行缓存的特殊配置 name:指定对象的完整名 -->
        <cache name="ehcache" maxElementsInMemory="10000"
            eternal="false" timeToIdleSeconds="300" timeToLiveSeconds="600"
            overflowToDisk="true" />
    </ehcache>

    上面是配置文件,然后我们将会在DAO层进行缓存处理。代码如下。

    import org.apache.ibatis.annotations.Insert;
    import org.apache.ibatis.annotations.Param;
    import org.apache.ibatis.annotations.Select;
    import org.springframework.cache.annotation.CacheConfig;
    import org.springframework.cache.annotation.Cacheable;
    
    import cn.shinelon.entity.User;
    @CacheConfig(cacheNames="ehcache")
    public interface User1Dao {
        //使用ehcache缓存技术
        @Select("select * from user where id=#{id}")
        @Cacheable
        public User select(@Param("id")int id);
    }

    注意,上面的注释@CacheConfig(cacheNames=”ehcache”)的属性cacheNames的值与配置文件中cache中name的属性一致,@Cacheable注解表示我们这里将使用缓存。最后,我们来看一下controller层的代码。

    import org.apache.log4j.Logger;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.boot.context.properties.EnableConfigurationProperties;
    import org.springframework.cache.CacheManager;
    import org.springframework.cache.annotation.Cacheable;
    import org.springframework.cache.annotation.EnableCaching;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.bind.annotation.RestController;
    
    import cn.shinelon.config.DBConfig1;
    import cn.shinelon.config.DBConfig2;
    import cn.shinelon.entity.User;
    import cn.shinelon.test1.dao.User1Dao;
    import cn.shinelon.test1.services.User1Service;
    import cn.shinelon.test2.services.User2Service;
    
    @SpringBootApplication
    @EnableAutoConfiguration
    @ComponentScan(basePackages={"cn.shinelon.aop","cn.shinelon.config","cn.shinelon.datasource",
            "cn.shinelon.test1","cn.shinelon.test2"})
    @RestController
    @EnableConfigurationProperties(value= {DBConfig1.class,DBConfig2.class})
    @EnableCaching      //支持缓存
    public class UserController {
        //测试缓存
        @Autowired
        private User1Dao user1Dao;
        @ResponseBody
        @RequestMapping("/cache")
        public String cache(int id) {
            return user1Dao.select(id).toString();
        }

    然后,我们访问使用localost:8080/cache?id=4来访问服务器,可以访问到数据,然后删除数据库中的这条数据,继续访问,还是可以查询到数据,因为这条数据已经存入到缓存中了,这时,有一个问题,有时我们不需要缓存,这时该怎么清除缓存呢?这很简单,我们只需要在controller层通过cacheManager来管理清除缓存即可,需要插入的代码是:

        //清除缓存
        @Autowired
        private CacheManager cacheManager;
        @ResponseBody
        @RequestMapping("/clear")
        public String clear() {
            cacheManager.getCache("ehcache").clear();
            return "success";
        }

    接着,我们通过localhost:8080/clear访问来清除缓存后,再查询上面的那条数据,服务器将会报出不存在该记录的信息,至此,我们了解到了ehcahe缓存技术的使用,这也在项目的开发中经常使用。

    展开全文
  • springboot2+ehcache集成攻略与教程,,,先来看看ehcache缓存与redis缓存的区别 ---- - ehcache直接在`jvm虚拟机`/`java进程`中缓存,可以理解为缓存在内存中,速度快,效率高;但是缓存`共享麻烦`,集群分布式应用不...

    在这里插入图片描述
    官网对ehcache的描述是:

    Ehcache is an open source, standards-based cache that boosts performance, offloads your database, and simplifies scalability. It’s the most widely-used Java-based cache because it’s robust, proven, full-featured, and integrates with other popular libraries and frameworks. Ehcache scales from in-process caching, all the way to mixed in-process/out-of-process deployments with terabyte-sized caches.

    Ehcache是一个基于标准的开源缓存,可提高性能,减轻数据库负载并简化可伸缩性。 它是最广泛使用的基于Java的缓存,因为它健壮,可靠,功能齐全并与其他流行的库和框架集成。 Ehcache可以从进程内缓存扩展到具有TB级别缓存的混合进程内/进程外部署。

    ehcache特性

    • 快速、简单,纯Java的进程缓存框架
    • 快速集成,与springboot、hibernate等框架很友好
    • 多种缓存策略:LRU(最近最少使用算法,默认策略)、FIFO(先进先出)、LFU(最不经常使用策略)
    • 缓存数据有两级:内存和磁盘,因此无需担心内部不够或者内存爆掉问题
    • 缓存数据可以设置在虚拟机重启的过程中写入磁盘
    • 具有缓存和缓存管理器的侦听接口
    • 支持多缓存管理器实例,以及一个实例的多个缓存区域

    ehcache缓存与redis缓存的区别

    • ehcache直接在jvm虚拟机/java进程中缓存,可以理解为缓存在内存中,速度快,效率高;但是缓存共享麻烦,集群分布式应用不方便。可以直接单独使用,集成于项目内,一般在第三方库中被用到的比较多(如mybatis、shiro等),多用于内部缓存 ,或者一般没有微服务的单实例小项目。
    • redis是通过socket访问到缓存服务,效率比ecache低,比数据库要快很多,处理集群和分布式缓存方便,有成熟的方案。
    • 两者可以配合使用,ehcache做项目内部缓存 ,redis做分布式缓存。如果是单个应用或者对缓存访问要求很高的应用,用ehcache。如果是大型系统,存在缓存共享、分布式部署、缓存内容很大的,建议用redis。简单的讲,小项目/单例/不需节点同步的缓存 >直接ehcache大项目/微服务/分布式/性能/管理 >直接reids
    • 如果强行要搞分布式和缓存共享(不建议),ehcache也有缓存共享方案,不过是通过RMI或者Jgroup多播方式进行广播缓存通知更新,缓存共享复杂,维护不方便;简单的共享可以,但是涉及到缓存恢复,大数据缓存,则不合适。

    开源项目

    1024程序员节快乐!

    以下demo代码已经上传到 spring-cloud-study学习项目 https://github.com/moshowgame/spring-cloud-studyspring-cloud-study-ehcache 模块
    在这里插入图片描述

    大家可以自由下载、改进、讨论与学习!你的进步也是我的进步,你的意见和留言是我前进的动力!

    pom.xml:依赖引入

    	<dependencies>
    		
    		<!-- SpringBoot缓存支持启动器 -->
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-cache</artifactId>
    		</dependency>
    
    		<!-- Ehcache基础包 -->
    		<dependency>
    			<groupId>javax.cache</groupId>
    			<artifactId>cache-api</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>org.ehcache</groupId>
    			<artifactId>ehcache</artifactId>
    		</dependency>
    
    	</dependencies>
    

    Application.java:加@EnableCaching开启缓存

    @EnableCaching为Spring Cache的注解,使用后缓存功能生效,否则无效。

    package com.softdev.system.demo;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cache.annotation.EnableCaching;
    
    @SpringBootApplication
    @EnableCaching
    public class EmptyApplication {
    	public static void main(String[] args) {
    		SpringApplication.run(EmptyApplication.class,args);
    	}
    }
    
    

    ehcache.xml:缓存策略配置

    新建一个ehcache.xml与application.yml项目配置文件同级,也就是在src/main/resources/下。

    默认情况下ehcache会自动加载 classpath 根目录下名为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">
        <!--
          powered by zhengkai.blog.csdn.net
    
          diskStore:为缓存路径,ehcache分为内存和磁盘两级,此属性定义磁盘的缓存位置。参数解释如下:
          user.home – 用户主目录
          user.dir  – 用户当前工作目录
          java.io.tmpdir – 默认临时文件路径
    
          defaultCache:默认缓存策略,当ehcache找不到定义的缓存时,则使用这个缓存策略。只能定义一个。
          name:缓存名称。
          maxElementsInMemory:缓存最大数目
          maxElementsOnDisk:硬盘最大缓存个数。
          eternal:对象是否永久有效,一但设置了,timeout将不起作用。
          overflowToDisk:是否保存到磁盘,当内存中Element数量达到maxElementsInMemory时,Ehcache将会Element写到磁盘中
          timeToIdleSeconds:设置对象在失效前的允许闲置时间(单位:秒)。仅当eternal=false对象不是永久有效时使用,可选属性,默认值是0,也就是可闲置时间无穷大。
          timeToLiveSeconds:设置对象在失效前允许存活时间(单位:秒)。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用,默认是0.,也就是对象存活时间无穷大。
          diskPersistent:是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
          diskSpoolBufferSizeMB:这个参数设置DiskStore(磁盘缓存)的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
          diskExpiryThreadIntervalSeconds:磁盘失效线程运行时间间隔,默认是120秒。
          memoryStoreEvictionPolicy:当达到maxElementsInMemory限制时,Ehcache将会根据指定的策略去清理内存。默认策略是LRU(最近最少使用)。你可以设置为FIFO(先进先出)或是LFU(较少使用)。
          clearOnFlush:内存数量最大时是否清除。
          memoryStoreEvictionPolicy:可选策略有:LRU(最近最少使用算法,默认策略)、FIFO(先进先出)、LFU(最不经常使用策略)。
          FIFO,first in first out,先进先出策略。
          LFU, Less Frequently Used,最不经常使用策略。缓存的元素有一个hit计数属性,hit值最小的将会被清出缓存。
          LRU,Least Recently Used,最近最少使用策略(LRU)是大部分操作系统为最大化页面命中率而广泛采用的一种页面置换算法。该算法的思路是,选择未使用且时间最长的缓存移除掉。
       -->
        <diskStore path = "Java.io.tmpdir/tmp_ehcache"/>
        <defaultCache
                eternal="false"
                maxElementsInMemory="10000"
                overflowToDisk="false"
                diskPersistent="false"
                timeToIdleSeconds="1800"
                timeToLiveSeconds="259200"
                memoryStoreEvictionPolicy="LRU"/>
    
        <cache
                name="zhengkai.blog.csdn.net"
                eternal="false"
                maxElementsInMemory="10000"
                overflowToDisk="false"
                diskPersistent="false"
                timeToIdleSeconds="1800"
                timeToLiveSeconds="1800"
                memoryStoreEvictionPolicy="LRU"/>
    </ehcache>
    

    参数详解:

    • diskStore:为缓存路径,ehcache分为内存和磁盘两级,此属性定义磁盘的缓存位置。参数解释如下:
    • user.home – 用户主目录
    • user.dir – 用户当前工作目录
    • java.io.tmpdir – 默认临时文件路径-
    • defaultCache:默认缓存策略,当ehcache找不到定义的缓存时,则使用这个缓存策略。只能定义一个。
    • name:缓存名称。
    • maxElementsInMemory:缓存最大数目
    • maxElementsOnDisk:硬盘最大缓存个数。
    • eternal:对象是否永久有效,一但设置了,timeout将不起作用。
    • overflowToDisk:当内存中Element数量达到maxElementsInMemory时,Ehcache将会Element写到磁盘中
    • timeToIdleSeconds:设置对象在失效前的允许闲置时间(单位:秒)。仅当eternal=false对象不是永久有效时使用,可选属性,默认值是0,也就是可闲置时间无穷大。
    • timeToLiveSeconds:设置对象在失效前允许存活时间(单位:秒)。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用,默认是0.,也就是对象存活时间无穷大。
    • diskPersistent:是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
    • diskSpoolBufferSizeMB:这个参数设置DiskStore(磁盘缓存)的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
    • diskExpiryThreadIntervalSeconds:磁盘失效线程运行时间间隔,默认是120秒。
    • memoryStoreEvictionPolicy:当达到maxElementsInMemory限制时,Ehcache将会根据指定的策略去清理内存。默认策略是LRU(最近最少使用)。你可以设置为FIFO(先进先出)或是LFU(较少使用)。
    • clearOnFlush:内存数量最大时是否清除。
    • memoryStoreEvictionPolicy:可选策略有:LRU(最近最少使用算法,默认策略)、FIFO(先进先出)、LFU(最不经常使用策略)。
    • FIFO,first in first out,先进先出策略。
    • LFU, Less Frequently Used,最不经常使用策略。缓存的元素有一个hit计数属性,hit值最小的将会被清出缓存。
    • LRU,Least Recently Used,最近最少使用策略(LRU)是大部分操作系统为最大化页面命中率而广泛采用的一种页面置换算法。该算法的思路是,选择未使用且时间最长的缓存移除掉。

    application.yml:设置缓存区名称

    这里我设置了两个缓存区,例如我给证书查询系统设置缓存:

    • cache-certList , 证书列表 ,用于缓存单个证书的详情,变动比较多,一有编辑就更新指定id的记录。
    • cache-certType , 证书分类,用于缓存证书分类,一般很久才会变,一有编辑就清空所有缓存记录重新来过。
    server:
      port: 9999
      servlet:
          context-path: /ehcache
    spring:
        http:
          encoding:
            force: true
            charset: UTF-8
        application:
            name: spring-cloud-study-ehcache
        cache:
          cache-names:
            - cache-certList
            - cache-certType
    

    Entity:定义测试实体

    package com.softdev.system.demo.entity;
    import lombok.Data;
    import java.io.Serializable;
    @Data
    public class Cert implements Serializable {
        Integer certId;
        String certNumber;
    }
    
    @Data
    public class CertType implements Serializable {
        Integer typeId;
        String typeName;
        String certNumberPrefix;
    
        public CertType(Integer typeId, String typeName, String certNumberPrefix) {
            this.typeId = typeId;
            this.typeName = typeName;
            this.certNumberPrefix = certNumberPrefix;
        }
    }
    
    

    Controller:进行缓存

    这里用 Controlle 层做缓存,但是实际上建议在Service或者Repository / Mapper层做缓存,也可以设置一个CacheUtil来设置缓存的id等,然后再设置一个CacheService来设置一些全局缓存。
    无论你在哪一层,只要加上注释,马上成!

    • @Cacheable(value = "cache-certList", key = "#cert.certId") 保存指定的id到缓存。
    • @CacheEvict(value = "cache-certList", key = "#cert.certId") 使指定id的缓存失效。
    • @CacheEvict(value = "cache-certType" , allEntries=true) 使所有缓存都失效,清空该缓存区/组。
    package com.softdev.system.demo.controller;
    
    import com.alibaba.fastjson.JSON;
    import com.softdev.system.demo.entity.Cert;
    import com.softdev.system.demo.entity.CertType;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.cache.annotation.CacheEvict;
    import org.springframework.cache.annotation.Cacheable;
    import org.springframework.http.ResponseEntity;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.ArrayList;
    import java.util.List;
    /**
     * EhCache缓存控制器demo
     * @author zhengkai.blog.csdn.net
     * */
    @Slf4j
    @RestController
    public class DemoController {
    
        @GetMapping("")
        public ResponseEntity<String> index(){
            return ResponseEntity.ok("请求成功");
        }
    
        @RequestMapping("cert/save")
        @CacheEvict(value = "cache-certList", key = "#cert.certId")
        public Cert save(Cert cert){
            log.info("保存cert到数据库:"+ JSON.toJSONString(cert));
            return cert;
        }
        @Cacheable(value = "cache-certList", key = "#cert.certId")
        @RequestMapping("cert/find")
        public Cert find(Cert cert){
            log.info("从数据库中读取cert:"+ JSON.toJSONString(cert));
            return cert;
        }
        @RequestMapping("type/all")
        @CacheEvict(value = "cache-certType")
        public List<CertType> getType(){
            List<CertType> list = new ArrayList<>();
            list.add(new CertType(1,"个人证书","csdn-person"));
            list.add(new CertType(2,"企业证书","csdn-enterprise"));
            list.add(new CertType(3,"云证书","csdn-cloud"));
            log.info("从数据库中读取typeList:"+ JSON.toJSONString(list));
            return list;
        }
        @CacheEvict(value = "cache-certType" , allEntries=true)
        @RequestMapping("type/clean")
        public List<CertType> clean(){
            log.info("清理所有typeList缓存");
            return null;
        }
    }
    
    

    请求URL :开始缓存,校验缓存

    1. 先查询数据 http://localhost:9999/ehcache/cert/find?certId=1&certNumber=111111,首次调用控制台会输出 从数据库中读取cert:{"certId":1,"certNumber":"111111"} (因为我们没有数据库,这里模拟从数据库中读取数据出来的感觉)
      在这里插入图片描述
      在这里插入图片描述

    2. 继续查看证书,连续调用多次,看控制台输出,没有新的日志生成,代表成功 http://localhost:9999/ehcache/cert/find?id=1
      在这里插入图片描述

    3. 尝试能否修改缓存中的信息,不可能的,修改失败
      在这里插入图片描述

    4. save接口修改缓存 http://localhost:9999/ehcache/cert/save?certId=1&certNumber=3333 (save方法会让缓存失效,重新查询则会重新获取并缓存)
      在这里插入图片描述

    5. 再次进行缓存 http://localhost:9999/ehcache/cert/find?certId=1&certNumber=3333
      在这里插入图片描述

    6. 再次验证缓存 http://localhost:9999/ehcache/cert/find?certId=1
      在这里插入图片描述

    @Cacheable:使用缓存

    @Cacheable可以标记在一个方法上,也可以标记在一个类上。当标记在一个方法上时表示该方法是支持缓存的,当标记在一个类上时则表示该类所有的方法都是支持缓存的。对于一个支持缓存的方法,Spring会在其被调用后将其返回值缓存起来,以保证下次利用同样的参数来执行该方法时可以直接从缓存中获取结果,而不需要再次执行该方法。Spring在缓存方法的返回值时是以键值对进行缓存的,值就是方法的返回结果,至于键的话,Spring又支持两种策略,默认策略和自定义策略,这个稍后会进行说明。需要注意的是当一个支持缓存的方法在对象内部被调用时是不会触发缓存功能的。

    @Cacheable一般可以指定三个属性,valuekeycondition

    value属性指定Cache名称

    value属性是必须指定的,其表示当前方法的返回值是会被缓存在哪个Cache上的,对应Cache的名称。其可以是一个Cache也可以是多个Cache,当需要指定多个Cache时其是一个数组。

       @Cacheable("cache1")//Cache是发生在cache1上的
    
       public User find(Integer id) {
    
          returnnull;
    
       }
    
    
       @Cacheable({"cache1", "cache2"})//Cache是发生在cache1和cache2上的
    
       public User find(Integer id) {
    
          returnnull;
    
       }
    

    使用key属性自定义key

    key属性是用来指定Spring缓存方法的返回结果时对应的key的。该属性支持SpringEL表达式。当我们没有指定该属性时,Spring将使用默认策略生成key。我们这里先来看看自定义策略,至于默认策略会在后文单独介绍。

    自定义策略是指我们可以通过Spring的EL表达式来指定我们的key。这里的EL表达式可以使用方法参数及它们对应的属性。使用方法参数时我们可以直接使用“#参数名”或者“#p参数index”。下面是几个使用参数作为key的示例。

       @Cacheable(value="users", key="#id")
       public User find(Integer id) {
          return new User(1);
       }
    
       @Cacheable(value="users", key="#p0")
       public User find(Integer id) {
          return new User(1);
       }
    
       @Cacheable(value="users", key="#user.id")
       public User find(User user) {
        return user;
       }
    
    
       @Cacheable(value="users", key="#p0.id")
       public User find(User user) {
          return user;
       }
    

    Condition属性指定发生的条件

    有的时候我们可能并不希望缓存一个方法所有的返回结果。通过condition属性可以实现这一功能。condition属性默认为空,表示将缓存所有的调用情形。其值是通过SpringEL表达式来指定的,当为true时表示进行缓存处理;当为false时表示不进行缓存处理,即每次调用该方法时该方法都会执行一次。如下示例表示只有当user的id为偶数时才会进行缓存。

       @Cacheable(value={"users"}, key="#user.id", condition="#user.id%2==0")
       public User find(User user) {
          System.out.println("find user by user " + user);
          return user;
       }
    

    @CachePut:动态缓存

    在支持Spring Cache的环境下,对于使用@Cacheable标注的方法,Spring在每次执行前都会检查Cache中是否存在相同key的缓存元素,如果存在就不再执行该方法,而是直接从缓存中获取结果进行返回,否则才会执行并将返回结果存入指定的缓存中。@CachePut也可以声明一个方法支持缓存功能。与@Cacheable不同的是使用@CachePut标注的方法在执行前不会去检查缓存中是否存在之前执行过的结果,而是每次都会执行该方法,并将执行结果以键值对的形式存入指定的缓存中。

    @CachePut也可以标注在类上和方法上。使用@CachePut时我们可以指定的属性跟@Cacheable是一样的。

       @CachePut("users")//每次都会执行方法,并将结果存入指定的缓存中
       public User find(Integer id) {
          returnnull;
       }
    

    @CacheEvict:清除缓存

    @CacheEvict 是用来标注在需要清除缓存元素的方法或类上的。当标记在一个类上时表示其中所有的方法的执行都会触发缓存的清除操作。@CacheEvict可以指定的属性有value、key、condition、allEntries和beforeInvocation。其中value、key和condition的语义与@Cacheable对应的属性类似。即value表示清除操作是发生在哪些Cache上的(对应Cache的名称);key表示需要清除的是哪个key,如未指定则会使用默认策略生成的key;condition表示清除操作发生的条件。下面我们来介绍一下新出现的两个属性allEntries和beforeInvocation。

    allEntries属性

    allEntries是boolean类型,表示是否需要清除缓存中的所有元素。默认为false,表示不需要。当指定了allEntries为true时,Spring Cache将忽略指定的key。有的时候我们需要Cache一下清除所有的元素,这比一个一个清除元素更有效率。

       @CacheEvict(value="users", allEntries=true)
       public void delete(Integer id) {
          System.out.println("delete user by id: " + id);
       }
    

    beforeInvocation属性

    清除操作默认是在对应方法成功执行之后触发的,即方法如果因为抛出异常而未能成功返回时也不会触发清除操作。使用beforeInvocation可以改变触发清除操作的时间,当我们指定该属性值为true时,Spring会在调用该方法之前清除缓存中的指定元素。

       @CacheEvict(value="users", beforeInvocation=true)
       public void delete(Integer id) {
          System.out.println("delete user by id: " + id);
       }
    

    Ehcache的类层次模型

    Ehcache的类层次模型主要为三层,最上层的是CacheManager,它是操作Ehcache的入口。我们可以通过CacheManager.getInstance()获得一个单个的CacheManager,或者通过CacheManager的构造函数创建一个新的CacheManager.每个CacheManager都管理着多个Cache。而每个Cache都以一种类Hash的方式,关联着多个Element。而Element则是我们用于存放要缓存内容的地方。

    Ehcache的刷新策略

    ehcache的刷新策略是当缓存在放入的时候记录一个放入时间,它是用Lazy Evict的方式,在取的时候同设置的TTL比较 。

    MemoryStore回收策略

    MemoryStore支持三种策略:LRU、LFU、FIFO。

    -LRU:最近最少使用的,缓存的元素有一个时间戳,当缓存容量满了,而又需要腾出地方来缓存新的元素的时候,那么现有缓存元素中时间戳离当前时间最远的元素将被清除缓存。

    • LFU:最少被使用,缓存的元素有一个hit属性,hit值最小的将会被清除缓存。

    • FIFO:先进先出。

    EventHandler事件处理

    可以为CacheManager添加事件监听,当对CacheManager增删Cache时,事件处理器将会得到通知。要配置事件处理,需要通过ehcache的配置文件来完成。可以为Cache添加事件监听,当对Cache增删Element时,事件处理器将会得到通知。要配置事件处理,需要通过ehcache的配置文件来完成。

    开源项目spring-cloud-study

    其实应该叫spring-boot-study的,因为很多都是springboot+单个集成。

    我不想集成:直接用EHCACHE API

    如果两个缓存框架集成,或者因为业务需要只能直接用API,则可以参考以下用法。

    Coding with the Ehcache 3 API :

    CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
        .withCache("preConfigured",
             CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
                                            ResourcePoolsBuilder.heap(100))
             .build())
        .build(true);
    
    Cache<Long, String> preConfigured
        = cacheManager.getCache("preConfigured", Long.class, String.class);
    
    Cache<Long, String> myCache = cacheManager.createCache("myCache",
        CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
                                      ResourcePoolsBuilder.heap(100)).build());
    
    myCache.put(1L, "da one!");
    String value = myCache.get(1L);
    
    cacheManager.close();
    
    • 静态方法org.ehcache.config.builders.CacheManagerBuilder.newCacheManagerBuilder返回一个新的org.ehcache.config.builders.CacheManagerBuilder实例。
    • 使用构建器来定义别名为“ preConfigured”的缓存。在实际的CacheManager实例上调用cacheManager.build()时,将创建此缓存。第一个String参数是缓存别名,用于从CacheManager检索缓存。第二个参数org.ehcache.config.CacheConfiguration用于配置Cache。我们在org.ehcache.config.builders.CacheConfigurationBuilder上使用静态newCacheConfigurationBuilder()方法来创建默认配置。
    • 最后,调用build()返回我们可以使用的完全实例化但未初始化的CacheManager。
    • 在使用CacheManager之前,需要对其进行初始化,这可以通过2种方式之一进行初始化:在CacheManager实例上调用CacheManager.init(),或者在boolean参数设置为true的情况下调用CacheManagerBuilder.build(boolean init)方法。
    • 通过将其别名,键类型和值类型传递给CacheManager来检索缓存。例如,要获取在步骤2中声明的缓存,您需要使用其别名=“ preConfigured”keyType = Long.classvalueType = String.class。为了确保类型安全,我们要求传递键和值类型。如果这些键和值类型与我们期望的不同,则CacheManager在应用程序生命周期的早期会引发ClassCastException。这可以防止缓存受到随机类型的污染。
    • 可以根据需要使用CacheManager创建新的Cache实例。就像在步骤2中一样,它需要传入别名以及CacheConfiguration。添加的实例化和完全初始化的Cache将通过CacheManager.getCache API返回和/或访问。
    • 现在可以使用新添加的缓存来存储条目,这些条目由键值对组成,跟Map对象一样。 put方法的第一个参数是键,第二个参数是值。请记住,键和值类型必须与CacheConfiguration中定义的类型相同。此外,key必须唯一,并且仅与一个值相关联。
    • 通过调用cache.get(key)方法从缓存中检索值。它仅采用一个参数作为键,并返回与该键关联的值。如果没有与该键关联的值,则返回null。
    • 我们可以CacheManager.removeCache(String)给定的缓存。 CacheManager将不仅删除其对Cache的引用,还将关闭它。缓存释放所有本地保留的瞬时资源(例如内存)。对此缓存的引用将不可用。
    • 为了释放CacheManager提供给它管理的Cache实例的所有瞬时资源(内存,线程等),您必须调用CacheManager.close(),后者依次关闭当时已知的所有Cache实例。

    我还想要监控缓存:cache-event-listeners

    缓存侦听器允许实现者注册将在发生 缓存事件时执行回调方法 。侦听器是在高速缓存级别注册的,因此仅接收已向其注册的高速缓存的事件。

    官方文档也有详细介绍:http://www.ehcache.org/documentation/3.8/cache-event-listeners.html

    CacheEventListenerConfigurationBuilder cacheEventListenerConfiguration = CacheEventListenerConfigurationBuilder
        .newEventListenerConfiguration(new ListenerObject(), EventType.CREATED, EventType.UPDATED) 
        .unordered().asynchronous(); 
    
    final CacheManager manager = CacheManagerBuilder.newCacheManagerBuilder()
        .withCache("foo",
            CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class, String.class, ResourcePoolsBuilder.heap(10))
                .withService(cacheEventListenerConfiguration) 
        ).build(true);
    
    final Cache<String, String> cache = manager.getCache("foo", String.class, String.class);
    cache.put("Hello", "World"); 
    cache.put("Hello", "Everyone"); 
    cache.remove("Hello");
    

    Listener 参考,也就是new ListenerObject()的参考实现:

    public class NotNullCacheEventListener implements CacheEventListener {
     
        public static final CacheEventListener INSTANCE = new NotNullCacheEventListener();
     
        @Override
        public void notifyElementRemoved(final Ehcache cache, final Element element) throws CacheException {
        }
     
        @Override
        public void notifyElementPut(final Ehcache cache, final Element element) throws CacheException {
            removeIfNull(cache, element);
        }
     
        @Override
        public void notifyElementUpdated(final Ehcache cache, final Element element) throws CacheException {
            removeIfNull(cache, element);
        }
     
        private void removeIfNull(final Ehcache cache, final Element element) {
            if (element.getObjectValue() == null) {
                cache.remove(element.getKey());
            }
        }
     
        @Override
        public void notifyElementExpired(final Ehcache cache, final Element element) {
        }
     
        @Override
        public void notifyElementEvicted(final Ehcache cache, final Element element) {
        }
     
        @Override
        public void notifyRemoveAll(final Ehcache cache) {
        }
     
        @Override
        public void dispose() {
        }
     
        @Override
        public Object clone() throws CloneNotSupportedException {
            throw new CloneNotSupportedException("Singleton instance");
        }
    }
    
    
    展开全文
  • 一、Maven库pom.xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId>...net.sf.ehcache</groupId> &
  • ehcache 缓存

    2015-05-24 23:15:19
    有基于ehcache 自己的cache实现,也有是自己实现的,基于ehcache的写磁盘的缓存设置,已经测试过,可以放心使用。
  • Ehcache缓存的使用

    万次阅读 2017-03-03 10:44:24
    Ehcache缓存的使用
  • SpringBoot中使用Ehcache缓存简介Ehcache简介EhCache特性集成方式Ehcache和Redis对比整合示例 简介 Ehcache简介 Ehcache 是一个纯Java的进程内缓存框架,具有快速、精干等特点,是Hibernate中默认CacheProvider。...
  • Ehcache缓存配置及使用

    2020-12-15 10:29:44
    Ehcache缓存配置及使用 一、Pom.xml添加依赖 Pom.xml添加如下依赖: <!--开启cache缓存--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-...
  • EhCache缓存的使用

    2019-01-01 09:36:15
    我们使用EhCache缓存框架主要是为了判断重复Url,每次爬取一个网页,都把Url存储到缓存中,并且每次爬某个网页之前,都去缓存中搜索下,假如存在的话,我们就不要爬取这个网页了,不存在的话,我们就爬下网页,爬取...
  • Ehcache缓存和Redis缓存数据

    千次阅读 2020-07-19 11:46:11
    SpringBoot中使用JVM缓存 pom <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId> </dependency> ehcache.xml &...
  • springboot使用ehcache缓存

    千次阅读 2019-08-09 16:36:18
    EhCache是一个比较成熟的Java缓存框架,最早从hibernate发展而来, 是进程中的缓存系统,它提供了用内存,磁盘文件存储,以及分布式存储方式等多种灵活的cache管理方案,快速简单。 Springboot对ehcache的使用非常...
  • 本篇文章主要介绍了详解Spring MVC 集成EHCache缓存,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要为大家详细介绍了Spring+EHcache缓存实例,EhCache是一个纯Java的进程内缓存框架,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • java Ehcache缓存过期配置

    千次阅读 2018-08-15 11:44:55
    1.MyCacheEventListener类 package com.seryo.cache; import ... import net.sf.ehcache.CacheException;...import net.sf.ehcache.Ehcache; import net.sf.ehcache.Element;...
  • ehcache缓存框架

    2018-02-12 22:25:59
    Ehcache配置详解及CacheManager使用,设置时间和调用工具类实现
  • ehcache缓存刷新问题

    2019-10-02 04:36:55
    ehcache可以设置时间来定时刷新缓存,但是这个只是清空值,key依旧保存着. 只有你第一次利用key获取值,key才会释放. 转载于:https://www.cnblogs.com/yanjunwu/p/8435211.html...
  • Java流行ehcache缓存

    2014-10-11 15:06:43
    Java流行实用ehcache缓存,走过路过不要错过
  • shiro-demo使用ehcache缓存.zip

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 47,120
精华内容 18,848
关键字:

ehcache缓存