Ehcache（二次封装，每个元素可自定义过期时间）

已于 2022-08-31 08:37:22 修改
阅读量3k 收藏 5
点赞数 8
CC 4.0 BY-SA版权
分类专栏： Java 文章标签： java Ehcache 缓存 代码 自定义过期时间
于 2022-08-29 00:36:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39651356/article/details/126576733

文章目录

Ehcache

官网： https://www.ehcache.org/
 
优势： 持续维护
 
作用： Java写的缓存工具

<!-- https://mvnrepository.com/artifact/org.ehcache/ehcache -->
<dependency>
    <groupId>org.ehcache</groupId>
    <artifactId>ehcache</artifactId>
    <version>3.10.1</version>
</dependency>

概念

官网文档： https://www.ehcache.org/documentation/3.10/expiry.html
内置过期策略==ExpiryPolicyBuilder
no expiry：永不过期
time-to-live：固定持有时间（不会由于你访问而重新计算过期时间）- 类似session过期时间策略
time-to-idle：访问元素之后重新开始计算元素过期时间 - 类似redis的过期时间策略

 
 

官网文档： https://www.ehcache.org/documentation/3.10/cache-event-listeners.html
事件监听==EventType
EVICTED：
EXPIRED：keyValue键值对过期
REMOVED：删除keyValue键值对
CREATED：首次设置keyValue键值对
UPDATED：keyValue键值对的value值变更

代码

简单使用
public class OtherTest {
    @Test
    public void test10() {


        CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
                .withCache("preConfigured",
                        CacheConfigurationBuilder.newCacheConfigurationBuilder(Long.class, String.class,
                                        ResourcePoolsBuilder.heap(100))
                                .build())
                .build(true);
        
        //必须key、value的类型一致，否则也找不到，非常的严格
        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);
        Console.log("=================");
        Console.log(value);
        Console.log("=================");

        cacheManager.close();

    }
}

在这里插入图片描述

工具封装
/**
 * Java缓存（封装ehcache）
 * 官网：https://www.ehcache.org/documentation/3.10/getting-started.html
 *
 * @author LinRuChang
 * @version 1.0
 * @date 2022/08/30
 * @since 1.8
 **/
public class EhcacheUtil {

    protected static final CacheManager CACHE_MANAGER = CacheManagerBuilder.newCacheManagerBuilder().build(true);

    /**
     * 默认缓存容器名
     */
    protected static final String DEFAULT_CACHE_NAME = "DEFAULT_CACHE";

    static {
        //默认缓存容器创建
        createCacheIfNot(DEFAULT_CACHE_NAME);
    }


    public static Cache<? super Serializable, ? super Serializable> getCache(String cacheName) {
        return CACHE_MANAGER.getCache(cacheName,Serializable.class,Serializable.class);
    }

    /**
     * 线程安全的创建缓存容器
     * @param cacheName 缓存容器名字
     * @return
     */
    public static Cache<? super Serializable, ? super Serializable> createCache(String cacheName) {
        Assert.notBlank(cacheName, "缓存名缺失");
        Cache<? super Serializable, ? super Serializable> cache = getCache(cacheName);
        if(cache == null) {
            synchronized (EhcacheUtil.class) {
                cache = getCache(cacheName);
                if(cache == null) {
                    //缓存过期策略
                    CustomExpiryPolicy<Object, Object> customExpiryPolicy = new CustomExpiryPolicy<>();
                    //事件监听
                    CacheEventListenerConfigurationBuilder cacheEventListenerConfiguration = CacheEventListenerConfigurationBuilder
                            .newEventListenerConfiguration(new CustomCacheEventListener(cacheName), EventType.CREATED, EventType.values())
                            .ordered().asynchronous();

                    return CACHE_MANAGER.createCache(cacheName, CacheConfigurationBuilder.newCacheConfigurationBuilder(
                                    Serializable.class,
                                    Serializable.class,
                                    ResourcePoolsBuilder.heap(Long.MAX_VALUE))
                            .withExpiry(customExpiryPolicy)
                            .withService(cacheEventListenerConfiguration));
                }else {
                    return cache;
                }
            }
        }else {
            return cache;
        }
    }

    /**
     * 如果不存在则创建缓存对象
     *
     * @param cacheName 缓存名
     * @return 缓存对象
     */
    public static Cache<? super Serializable, ? super Serializable> createCacheIfNot(String cacheName) {
        Cache<? super Serializable, ? super Serializable> cache = getCache(cacheName);
        return cache != null ? cache : createCache(cacheName);
    }

    /**
     * 获取键值
     *
     * @param cacheName 缓存容器名 不设置默认使用{@link EhcacheUtil#DEFAULT_CACHE_NAME}
     * @param key       键名
     */
    public static <K extends Serializable> Serializable get(String cacheName, K key) {
        if (key == null) {
            return null;
        }
        cacheName = StrUtil.blankToDefault(cacheName, DEFAULT_CACHE_NAME);
        return (Serializable) (createCacheIfNot(cacheName).get(key));
    }


    /**
     * 获取键值 【从默认缓存容器中取{@link EhcacheUtil#DEFAULT_CACHE_NAME}】
     *
     * @param key 键名
     */
    public static <K extends Serializable> Serializable get(K key) {
        return get(DEFAULT_CACHE_NAME, key);
    }


    public static List<? extends Cache.Entry<? super Serializable, ? super Serializable>> getAllEntry(String cacheName) {
        cacheName = StrUtil.blankToDefault(cacheName, DEFAULT_CACHE_NAME);
        Cache<? super Serializable, ? super Serializable> cache = getCache(cacheName);
        return CollUtil.newArrayList(cache);
    }
    public static List<? extends Cache.Entry<? super Serializable, ? super Serializable>> getAllEntry() {
        return getAllEntry(DEFAULT_CACHE_NAME);
    }


    /**
     * 获取容器{cacheName}所有键值
     * @param cacheName
     * @return
     */
    public static List<? super Serializable> getAllValues(String cacheName) {
        cacheName = StrUtil.blankToDefault(cacheName, DEFAULT_CACHE_NAME);
        return getAllEntry(cacheName).stream()
                .map(entry -> entry.getValue())
                .collect(Collectors.toList());
    }

    /**
     * 获取默认容器所有键值
     * @return
     */
    public static List<? super Serializable> getAllValues() {
        return getAllValues(DEFAULT_CACHE_NAME);
    }

    /**
     * 获取容器{cacheName}所有的键名
     * @return
     */
    public static List<? super Serializable> getAllKeys(String cacheName) {
        cacheName = StrUtil.blankToDefault(cacheName, DEFAULT_CACHE_NAME);
        return getAllEntry(cacheName).stream()
                .map(entry -> entry.getKey())
                .collect(Collectors.toList());
    }


    /**
     * 获取默认容器所有的键名
     * @return
     */
    public static List<? super Serializable> getAllKeys() {
        return getAllKeys(DEFAULT_CACHE_NAME);
    }


    /**
     * 获取键值 【从默认缓存容器中取{@link EhcacheUtil#DEFAULT_CACHE_NAME}】
     *
     * @param key 键名
     */
    public static <K extends Serializable, V> V getByType(K key, Class<V> resultType) {
        Serializable result = get(DEFAULT_CACHE_NAME, key);
        return Optional.ofNullable(result)
                .map(elem -> Convert.convert(resultType, elem))
                .orElse(null);

    }

    /**
     * 获取键值 【从默认缓存容器中取{@link EhcacheUtil#DEFAULT_CACHE_NAME}】
     *
     * @param key 键名
     */
    public static <K extends Serializable> String getStr(K key) {
        return getByType(key, String.class);
    }


    /**
     * 设置缓存
     *
     * @param cacheName 缓存容器名字，不设置默认使用{@link EhcacheUtil#DEFAULT_CACHE_NAME}
     * @param key       键名
     * @param value     键值
     * @param expireMs  键值对过期时间（单位毫秒）- 不设置、或负数默认为永不过期
     */
    public static <K extends Serializable, V extends Serializable> void set(String cacheName, K key, V value, Long expireMs) {
        cacheName = StrUtil.blankToDefault(cacheName, DEFAULT_CACHE_NAME);

        if (expireMs != null && expireMs >= 0) {
            CacheRuntimeConfiguration runtimeConfiguration = createCacheIfNot(cacheName).getRuntimeConfiguration();
            CustomExpiryPolicy expiryPolicy = (CustomExpiryPolicy) runtimeConfiguration.getExpiryPolicy();
            expiryPolicy.setExpire(key, Duration.ofMillis(expireMs));
        }

        createCacheIfNot(cacheName).put(key, value);
    }

    /**
     * 设置缓存（使用默认的缓存容器{@link EhcacheUtil#DEFAULT_CACHE_NAME）
     *
     * @param key      键名
     * @param value    键值
     * @param expireMs 键值对过期时间（单位毫秒）- 不设置、或负数默认为永不过期
     */
    public static <K extends Serializable, V extends Serializable> void set(String key, V value, Long expireMs) {
        set(DEFAULT_CACHE_NAME, key, value, expireMs);
    }

    /**
     * 设置缓存（使用默认的缓存容器{@link EhcacheUtil#DEFAULT_CACHE_NAME），键值对永不过期
     *
     * @param key   键名
     * @param value 键值
     */
    public static <V extends Serializable> void set(String key, V value) {
        set(key, value, null);
    }



    /**
     * 删除某个容器的某个键值对
     * @param cacheName 容器名
     * @param key 键名
     * @return
     */
    public static Serializable del(String cacheName, Serializable key) {
        cacheName  = StrUtil.blankToDefault(cacheName,DEFAULT_CACHE_NAME);
        Cache<? super Serializable, ? super Serializable> cache = getCache(cacheName);

        return Optional.ofNullable((Serializable)cache.get(key))
                .map(value -> {
                    cache.remove(key);
                    return value;
                })
                .orElse(null);
    }

    /**
     * 删除某人容器的某个键值对
     * @param key 键名
     * @return
     */
    public static Serializable del(Serializable key) {
        return del(DEFAULT_CACHE_NAME,key);
    }

    /**
     * 清空某个缓存容器的内容
     * @param cacheName 缓存容器名
     */
    public static void clear(String cacheName) {
        Cache<? super Serializable, ? super Serializable> cache = getCache(cacheName);
        if(cache != null) {
            cache.clear();
        }
    }

    /**
     * 销毁全部容器
     */
    public static void close() {
        CACHE_MANAGER.close();
    }


    /**
     * keyValue自定义过期时间
     * <p>
     * 参考的实现{@link ExpiryPolicyBuilder#noExpiration(),ExpiryPolicyBuilder#timeToLiveExpiration(Duration),ExpiryPolicyBuilder#timeToIdleExpiration(Duration)}
     * 文档<a href="https://www.ehcache.org/documentation/3.10/expiry.html"></a>
     *
     * @param <K>
     * @param <V>
     */
    private static class CustomExpiryPolicy<K, V> implements ExpiryPolicy<K, V> {

        private final ConcurrentHashMap<K, Duration> keyExpireMap = new ConcurrentHashMap();


        public Duration setExpire(K key, Duration duration) {
            return keyExpireMap.put(key, duration);
        }

        public Duration getExpireByKey(K key) {
            return Optional.ofNullable(keyExpireMap.get(key))
                    .orElse(null);
        }

        public Duration removeExpire(K key) {
            return keyExpireMap.remove(key);
        }


        @Override
        public Duration getExpiryForCreation(K key, V value) {
            return Optional.ofNullable(getExpireByKey(key))
                    .orElse(Duration.ofNanos(Long.MAX_VALUE));
        }


        @Override
        public Duration getExpiryForAccess(K key, Supplier<? extends V> value) {
            return getExpireByKey(key);
        }

        @Override
        public Duration getExpiryForUpdate(K key, Supplier<? extends V> oldValue, V newValue) {
            return getExpireByKey(key);
        }
    }

    /**
     * 自定义事件处理 == 当前主要是用于去除自定义键值对的Map过期时间东西，防止内存溢出
     * <p>
     * 文档<a href="https://www.ehcache.org/documentation/3.10/cache-event-listeners.html"></a>
     *
     * @param <K>
     * @param <V>
     */
    private static class CustomCacheEventListener<K, V> implements CacheEventListener<K, V> {

        String cacheName;

        Cache cache;

        CustomExpiryPolicy customExpiryPolicy;


        public CustomCacheEventListener(String cacheName) {
            this.cacheName = cacheName;
        }


        @Override
        public void onEvent(CacheEvent event) {
            Console.log("事件触发：{}======{}========{}", cacheName, event.getType(), event.getKey());
            this.cache = ObjectUtil.defaultIfNull(cache, CACHE_MANAGER.getCache(cacheName, Serializable.class, Serializable.class));
            this.customExpiryPolicy = ObjectUtil.defaultIfNull(customExpiryPolicy, (CustomExpiryPolicy) this.cache.getRuntimeConfiguration().getExpiryPolicy());
            if (StrUtil.equalsAnyIgnoreCase(event.getType().name(), EventType.EXPIRED.name(), EventType.EVICTED.name(), EventType.REMOVED.name())) {
                customExpiryPolicy.removeExpire(event.getKey());
            }
        }
    }


}

 
 

Demo测试

class EhcacheUtilTest {

    @Test
    void test1() {
        Cache<? super Serializable, ? super Serializable> test = EhcacheUtil.createCacheIfNot("test");
        test.put("name", "lrc");
        Object name = test.get("name");
        Console.log(name);
    }

    @Test
    @SneakyThrows
    void test2() {


        EhcacheUtil.set("name", "lrc");
        EhcacheUtil.set("year", 20, 1000L);
        EhcacheUtil.set("sport", "篮球",2000L);

        Console.log("\n========初始值========");
        Console.log("name：{}",EhcacheUtil.get("name"));
        Console.log("year：{}",EhcacheUtil.get("year"));
        Console.log("sport：{}",EhcacheUtil.get("sport"));

        Thread.sleep(1000);
        Console.log("\n========休眠1s后========");
        Console.log("name：{}",EhcacheUtil.get("name"));
        Console.log("year：{}",EhcacheUtil.get("year"));
        Console.log("sport：{}",EhcacheUtil.get("sport"));

        Thread.sleep(2000);
        Console.log("\n========休眠2s后========");
        Console.log("name：{}",EhcacheUtil.get("name"));
        Console.log("year：{}",EhcacheUtil.get("year"));
        Console.log("sport：{}",EhcacheUtil.get("sport"));

    }


    @Test
    @SneakyThrows
    void test3() {
        EhcacheUtil.set("testCacheContainer", "name", "lrc", 1000L);
        EhcacheUtil.set("testCacheContainer", "year", "20", null);

        Console.log("\n========初始值========");
        Console.log("name：{}",EhcacheUtil.get("testCacheContainer","name"));
        Console.log("year：{}",EhcacheUtil.get("testCacheContainer","year"));

        Thread.sleep(1000);
        Console.log("\n========休眠1s后========");
        Console.log("name：{}",EhcacheUtil.get("testCacheContainer","name"));
        Console.log("year：{}",EhcacheUtil.get("testCacheContainer","year"));

    }
    
    @Test
    @SneakyThrows
    void test4() {
        EhcacheUtil.set("year", 18);
        Console.log(EhcacheUtil.get("year"));

        EhcacheUtil.set("year", 25);
        Console.log(EhcacheUtil.get("year"));
    }    

}

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

[Java实战]Spring Boot 3 整合 Ehcache 3（十九）
曼岛_的博客
05-13 1294
[Java实战]Spring Boot 3 整合 Ehcache 3（十九）
【愚公系列】2024年01月 WPF+上位机+工业互联 093-Redis的基本使用
时光隧道
09-09 2万+
编程缓存工具主要有以下几种：内存缓存：内存缓存是将数据暂时存储在内存中，以提高应用程序的性能和响应时间。内存缓存通常涉及使用不同大小和类型的缓存区域，以缓存和重用数据。内存缓存的优点是快速、可靠、易于实现和管理。常用的内存缓存工具有Memcached、Redis等。硬盘缓存：硬盘缓存是将数据存储在磁盘上，以便在需要时更快地访问它们。硬盘缓存通常会在磁盘上创建一个缓存文件或目录，以保存已缓存的数据。硬盘缓存的优点是可以存储大量数据，而且可以长期保留数据。常用的硬盘缓存工具有文件系统缓存、数据库缓存等。数据库缓
Ehcache工具类
01-07
本工具类包括初始化cache 修改缓存容器配置 向指定容器中设置值 取值 删除指定的ehcache容器 删除所有容器 删除容器内所有元素 释放CacheManage 获取所有的cache名称
ehcache缓存过期时间和注解的使用。
热门推荐
shuixiou1的博客
03-27 2万+
一、过期时间： 详细配置说明请自行网上搜索。 timeToIdleSeconds表示最大空闲的时间，timeToLiveSeconds表示最大存活时间，(当为0时表示可以无限闲置或存活?此句好像存在疑问,特此来验证一下) 例子1：结果：5秒间隔内不过期，超过10秒一定过期，就不测试了，占用篇幅！备注：缓存的过期是访问后才过期! &lt;cache name="...
Ehcache缓存时间设置
weixin_33984032的博客
08-27 991
timeToLiveSeconds和timeToIdleSecondstimeToLiveSeconds=x：缓存自创建日期起至失效时的间隔时间x；timeToIdleSeconds=y：缓存创建以后，最后一次访问缓存的日期至失效之时的时间间隔y； 如果仅有timeToLiveSeconds那么自创建时间开始 间隔x后缓存失效；如果没有timeToLiveSeconds那么自最后一次访问缓存 间...
java 缓存周期_java编程之Ehcache3.x 缓存过期时间Java配置demo
weixin_32563411的博客
02-16 1177
import java.util.concurrent.TimeUnit;import org.ehcache.Cache;import org.ehcache.CacheManager;import org.ehcache.config.CacheConfiguration;import org.ehcache.config.builders.CacheConfigurationBuilder;...
随手记录第五话 -- SpringCache搭配Redis的实现以及设置每个key的过期时间
生生不息，则源源不断
08-18 2027
Spring 从3.1 开始定义了org.springframework.cache.Cache和org.springframework.cache.CacheManager 接口来统一不同的缓存技术；并支持使用JCache（JSR-107）注解简化我们开发；Cache 接口为缓存的组件规范定义，包含缓存的各种操作集合；Cache 接口下Spring 提供了各种xxxCache 的实现；如RedisCache ， EhCacheCache , ConcurrentMapCache 等；...
Hibernate二级缓存（Ehcache）
12-15
此外，Ehcache的配置可以通过ehcache.xml文件进行详细设置，包括缓存的最大元素数量、过期策略、更新策略等： ```xml maxEntriesLocalHeap="10000" eternal="false" timeToIdleSeconds="120" ...
Sage X3软件二次开发：SageX3数据库结构与优化
最新发布
kkchenjj的博客
08-19 1569
为了优化数据处理和确保数据一致性，Sage X3支持创建自定义存储过程。存储过程可以封装复杂的业务逻辑，提高数据操作的效率和安全性。-- 创建更新客户信用等级的存储过程ASBEGINEND;
SpringBoot——缓存(注解的使用，整合Redis，自定义CacheManager）
努力找工作呀
07-31 3577
1.JSR107 Java Caching定义了5个核心接口： CachingProvider：定义了创建，配置，获取，管理和控制多个CacheManager。一个应用可以在运行期间访问多个CachingProvider。 CacheManager：定义了创建，配置，获取和控制多个Cache，这些Cache存在于CacheManager的上下文中。一个CacheManager仅被一个CachingProvider所拥有 Cache：一个类似Map的数据结构并临时存储以Key为索引的值。一个Cache
009. Spring Boot(1.5.10版本)缓存技术(整合Ehcache+整合@Cacheable整合@CacheEvict+Redis(3.0.0))
凯凯的博客
12-17 1006
Spring Boot 整合 Ehcache EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider。 ehcache提供了多种缓存策略，主要分为内存和磁盘两级，所以无需担心容量问题。 spring-boot是一个快速的集成框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从...
使用ehcache的工具类
07-30
使用ehcahe时自己做的工具类，方便以后使用
Ehcache封装的工具类
11-28 6227
最近公司公司项目在框架上用到了Ehcache缓存，关于更多Ehcache详细的内容，请参考一下两个系列的博客，讲的都很好。 Ehcache详细解读 Ehcache系列博客 有了上面的两个系列的博客，更多有关于Ehcache细节的地方，就不在这篇博客中展示了，主要是跟大家分享一下，底层框架中封装关于Ehcache的工具类  CacheContainer类  缓存容器类，用来创建Cache对象，并
一个简单的内存缓存管理器，可设置过期时间
朱守成
02-09 5072
目前主流的大项目都使用ehcache，redis等第三方缓存做分布式缓存管理。然而中小项目一般并没有很多的数据需要使用缓存，如果引用第三方缓存不仅增加开发难度，也使项目更加复杂，维护起来更麻烦。例如，一个项目只需要做验证码错误次数的验证，这时使用内存缓存不仅简单而且高效，后期维护容易。import java.util.Calendar; import java.util.Map; import j...
SpringBoot整合EhCache3.6加过期机制
不积跬步无以至千里，不积小流无以成江河
07-11 3772
Ehcache3.6官方文档：http://www.ehcache.org/documentation/3.6/getting-started.html 本来不想加缓存的，但奈何我的接口还要调用另外一个公司的接口，那个公司的接口老是超时，导致页面加载很慢，本来想用redis的key过期机制的，但还要对redis的配置进行修改，而redis用的又是阿里云RDS，但奈何密码又不在我在，还要去问。。。...
Eacache缓存+缓存的过期时间
qq_36074043的博客
07-08 2411
Eacache的属性： 引用jar包     name：Cache的唯一标识       maxElementsInMemory：内存中最大缓存对象数       maxElementsOnDisk：磁盘中最大缓存对象数，若是0表示无穷大       eternal：Element是否永久有效，一但设置了，timeout将不起作用       overflowToDisk：配置
Ehcache 过期参数说明
zhushidan的博客
08-04 1591
Ehcache 缓存过期时间的说明:     timeToIdleSeconds="3" timeToLiveSeconds="5"     timeToIdleSeconds指缓存元素空闲的时间,如果从最后一次访问这个元素到当前时间差超出这个值则此元素会失效   timeToLiveSeconds指缓存元素的生存时间,从创建到死亡的时间长度   当然上面的参数是在没有设置...
在Spring Boot 3项目中为不同缓存设置不同的过期时间
jackiendsc的博客
03-04 1227
Slf4j@Primary@Bean// 用于获取yml配置文件中缓存自定义时间的配置@Resource@Override// 根据不同的缓存名称获取不同的缓存过期时间配置// 如果存在合法的配置，则使用配置设置缓存的过期时间// 根据传参设置缓存过期时间try {;return -1L;
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值