堆缓存 — Guava Cache/Ehcache/MapDB

最新推荐文章于 2024-03-14 17:35:06 发布
最新推荐文章于 2024-03-14 17:35:06 发布
阅读量1k 收藏 3
点赞数 2
分类专栏： 系统框架 java 文章标签： java tomcat servlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37543627/article/details/121380797
版权

目录

一、Java缓存类型

二、Guava Cache/Ehcache/MapDB堆内缓存对比

三、代码实例

1. 依赖jar包

2. Cache定义

3. 调用实例

三、参考资料

一、Java缓存类型

类型优点缺点组件适用场景注意
堆内缓存

速度最快

1.受JVM堆大小限制

2.JVM重启时数据消失

Guava Cache、

Ehcache、

MapDB

热点数据、

数据量少

1.存储软弱引用对象

2.无需序列化/反序列化

堆外缓存速度较慢

1.受机器内存大小限制

2.机器重启时数据消失

Ehcache、

MapDB

相对热的数据需序列化/反序列化
磁盘缓存数据不会丢失

速度很慢

Ehcache、

MapDB

不热的数据需序列化/反序列化
分布式缓存大量数据缓存速度最慢

Redis、

Ehcache + Terracotta

全量数据

1.可单机、可集群

2.需序列化/反序列化

二、Guava Cache/Ehcache/MapDB堆内缓存对比

类型描述Guava CacheEhcacheMapDB
并发量并发线程数.concurrencyLevel.withDispatcherConcurrency.concurrencyScale
条目回收缓存最大条目.maximumSize.heap(100, EntryUnit.ENTRIES).expireMaxSize
TTL回收存活期失效.expireAfterWrite(10, TimeUnit.SECONDS).withExpiry(
ExpiryPolicyBuilder.timeToLiveExpiration(
Duration.ofSeconds(10)))

.expireAfterCreate

/.expireAfterUpdate

TTI回收空闲期失效.expireAfterAccess(10, TimeUnit.SECONDS).withExpiry(
ExpiryPolicyBuilder.timeToIdleExpiration(
Duration.ofSeconds(10)))		.expireAfterGet
主动失效主动删除

.invalidate

/.invalidateAll

.remove

/.removeAll

.remove

/.clear

触发失效被动删除PUT时缓存清理

PUT时缓存清理

/定义线程池处理

PUT时缓存清理

/定义线程池处理

命中统计缓存命中率.recordStats------------
其他

1.Guava Cache只有堆内缓存；定义软弱引用对象：软引用.softValues/弱引用.weakValues；

2.Ehcache提供堆内、堆外、磁盘、分布式缓存，集群功能不完善；若是集群建议Redis；

3.MapDB提供堆内、堆外、磁盘缓存，且提供事务支持；

三、代码实例

1. 依赖jar包

<dependency>
   <groupId>com.google.guava</groupId>
   <artifactId>guava</artifactId>
   <version>30.1-jre</version>
</dependency>

<dependency>
   <groupId>org.ehcache</groupId>
   <artifactId>ehcache</artifactId>
   <version>3.5.2</version>
</dependency>

<dependency>
   <groupId>org.mapdb</groupId>
   <artifactId>mapdb</artifactId>
   <version>3.0.8</version>
</dependency>

2. Cache定义

package com.common.instance.test.config.heapcache;

import com.common.instance.test.dao.WcPendantTabDao;
import com.common.instance.test.entity.WcPendantTab;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import org.ehcache.Cache;
import org.ehcache.CacheManager;
import org.ehcache.config.builders.CacheConfigurationBuilder;
import org.ehcache.config.builders.CacheManagerBuilder;
import org.ehcache.config.builders.ExpiryPolicyBuilder;
import org.ehcache.config.builders.ResourcePoolsBuilder;
import org.ehcache.config.units.EntryUnit;
import org.ehcache.spi.loaderwriter.CacheLoaderWriter;
import org.mapdb.DBMaker;
import org.mapdb.HTreeMap;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.time.Duration;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.TimeUnit;

/**
 * @description 堆内缓存
 * @author tcm
 * @version 1.0.0
 * @date 2021/11/5 17:27
 **/
@Component
public class HeapCache {

    // Guava Cache缓存
    private static LoadingCache<String, List<WcPendantTab>> guavaCache;
    // Ehcache Cache缓存
    private static Cache<String, List<WcPendantTab>> ehcacheCache;
    // MapDB Cache缓存
    private static HTreeMap mapDBCache;
    // 业务处理
    private static WcPendantTabDao wcPendantTabDao;

    @Resource
    public void setWcPendantTabDao(WcPendantTabDao wcPendantTabDao) {
        HeapCache.wcPendantTabDao = wcPendantTabDao;
    }

    public HeapCache(){
        getGuavaCache();
        getEhcacheCache();
        getMapDBCache();
    }

    // 初始化Guava Cache缓存
    public static LoadingCache<String, List<WcPendantTab>> getGuavaCache(){
        if (Objects.isNull(guavaCache)) {
            guavaCache = CacheBuilder.newBuilder()
                    // 并发数量
                    .concurrencyLevel(4)
                    // TTL设置
                    .expireAfterWrite(10, TimeUnit.SECONDS)
                    // 缓存容量，超出按LRU回收
                    .maximumSize(10000)
                    // 软引用，弱引用weakValues
                    .softValues()
                    // 缓存统计
                    .recordStats()
                    // 缓存没有命中，则读DB
                    .build(new CacheLoader<String, List<WcPendantTab>>() {
                        @Override
                        public List<WcPendantTab> load(String mgdbId) throws Exception {
                            WcPendantTab tab = new WcPendantTab();
                            tab.setMgdbId(mgdbId);
                            return wcPendantTabDao.queryAll(tab);
                        }
                    });
        }
        return guavaCache;
    }

    // 初始化Ehcache Cache缓存
    public static Cache<String, List<WcPendantTab>> getEhcacheCache(){
        if (Objects.isNull(ehcacheCache)) {
            CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder().build(true);

            CacheConfigurationBuilder cacheConfig = CacheConfigurationBuilder
                    .newCacheConfigurationBuilder(String.class, List.class,
                            ResourcePoolsBuilder.newResourcePoolsBuilder()
                                    .heap(100, EntryUnit.ENTRIES)) // 堆内缓存
                    .withDispatcherConcurrency(4)
                    // 过期配置
                    .withExpiry(ExpiryPolicyBuilder.timeToLiveExpiration(Duration.ofSeconds(10)))
                    // 缓存没有命中，则读DB
                    .withLoaderWriter(new CacheLoaderWriter<String, List>() {
                        @Override
                        public List load(String mgdbId) throws Exception {
                            WcPendantTab tab = new WcPendantTab();
                            tab.setMgdbId(mgdbId);
                            return wcPendantTabDao.queryAll(tab);
                        }

                        @Override
                        public void write(String s, List list) throws Exception {

                        }

                        @Override
                        public void delete(String s) throws Exception {

                        }
                    });

            ehcacheCache = cacheManager.createCache("myEhcacheCache", cacheConfig);
        }

        return ehcacheCache;
    }

    // 初始化MapDB缓存
    public static HTreeMap<String, List<WcPendantTab>> getMapDBCache(){
        if (Objects.isNull(mapDBCache)) {
            mapDBCache = DBMaker
                    // 对缓存
                    .heapDB()
                    // 并发数
                    .concurrencyScale(4).make().hashMap("myMapDBCache")
                    // 最大缓存条目
                    .expireMaxSize(10000)
                    // 过期时间
                    .expireAfterCreate(10, TimeUnit.SECONDS)
                    .expireAfterUpdate(10, TimeUnit.SECONDS)
                    .expireAfterGet(10, TimeUnit.SECONDS)
                    .create();
        }
        return mapDBCache;
    }

}

3. 调用实例

package com.common.instance.test.service.impl;

import com.common.instance.test.config.heapcache.HeapCache;
import com.common.instance.test.dao.WcPendantTabDao;
import com.common.instance.test.entity.WcPendantTab;
import com.common.instance.test.service.WcPendantTabService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;
import java.util.Objects;
import java.util.UUID;
import java.util.concurrent.ExecutionException;

/**
 * Tab菜单(WcPendantTab)表服务实现类
 *
 * @author tcm
 * @since 2021-01-14 15:02:08
 */
@Service
public class WcPendantTabServiceImpl implements WcPendantTabService {

    @Resource
    private WcPendantTabDao wcPendantTabDao;

    @Override
    public List<WcPendantTab> queryAll(String mgdbId){
        List<WcPendantTab> wcPendantTabs = null;
        try {
            // Cache-As-SoR模式
            // 获取Guava Cache缓存的数据
            wcPendantTabs = HeapCache.getGuavaCache().get(mgdbId);
            // 获取Ehcache Cache缓存的数据
            wcPendantTabs = HeapCache.getEhcacheCache().get(mgdbId);

            // Cache-Aside模式
            // 获取MapDB缓存的数据
            wcPendantTabs = HeapCache.getMapDBCache().get(mgdbId);
            if (Objects.isNull(wcPendantTabs)) {
                WcPendantTab tab = new WcPendantTab();
                tab.setMgdbId(mgdbId);
                wcPendantTabs = wcPendantTabDao.queryAll(tab);

                // 写到缓存
                HeapCache.getMapDBCache().put(mgdbId, wcPendantTabs);
            }
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        return wcPendantTabs;
    }

}

三、参考资料

Guava Cache用法介绍_qianshanding0708的博客-CSDN博客

Ehcache（03）——Ehcache中储存缓存的方式_Elim的博客-CSDN博客

MapDb学习笔记_SmileJosiah的博客-CSDN博客

爱我所爱0505
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot使用GuavaCache做简单缓存处理的方法
08-26
主要介绍了springboot使用GuavaCache做简单缓存处理的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
第七章 企业项目开发--本地缓存guava cache1
08-04
第七章 企业项目开发--本地缓存guava cache1、在实际项目开发中，会使用到很多缓存技术，而且数据库的设计一般也会依赖于有缓存的情况下设计。常用的缓存分
java mapdb_MapDB简介：敏捷的Java数据引擎
07-01 1045
今天，Java开发人员可以使用许多数据库引擎，实际上有100多种选择。 一系列可用的选择中包括一些“纯java”实现，包括H2，Apache Derby等。 我已经在Java和数据库开发领域工作了很多年，当我发现MapDB（及其前身项目）时，立即被这个开源项目提供的自然方法和敏捷性所吸引。 MapDB允许您作为Java开发人员每天做您要做的事情：使用熟悉，自然而强大的Java Collec...
Java中MapDB使用简介
Revivedsun的专栏
11-26 715
在这篇文章中，我们深入研究了MapDB的嵌入式数据库引擎和集合框架。我们首先研究了核心类DB和DBMaker来配置、打开和管理我们的数据库。然后，我们通过一些例子来看MapDB提供的数据结构如何处理我们的记录。最后，我们看了MapDB相比传统数据库或Java集合的优势。
高性能Java架构之堆外缓存与磁盘缓存解决方案：MapDB
2401_83384536的博客
03-08 1011
在互联网项目中，一般以堆内缓存的使用居多，无论Guava Cache还是JDK自带的HashMap、ConcurrentHashMap等，都是在堆内缓存中做数据计算操作。这是因为堆内缓存的响应速度最快，但是堆内缓存的价格也最高。有没有既能节约成本，又能提供较好的性能的工具呢？JVM一旦出现GC或者FULL GC的情况，就然删掉堆内存，此时应如何快速读取缓存数据？
第一篇：从0到1了解数据库——以MapDB为例
诸葛子房的博客
10-14 1474
1、MapDB使用 MapDB是一个基于（Apache 2.0 licensed）开源的Java嵌入式数据库引擎和集合框架。他支持针对Map,Set，Queues,Bitmaps 的范围查询，数据过期，压缩，堆外存储和流的操作。MapDB可能是Java最快的数据库，性能就像操作java中的集合一样。他也支持一些高级功能如：ACID事务，快照和增量备份等。 2.使用 <dependency> <groupId>org.mapdb</groupId>
探讨本地缓存
denclove803的博客
01-13 158
引言 本文主要讨论关于本地缓存的一些见解，主要是基于工作过程中遇到的问题以及是如何解决的。对于缓存穿透，工作中虽然不是常见的问题，但是一旦遇到就是严重的生产事故，所以要对每一次缓存使用做好设计。 本文主要分为一下几部分： 遇到问题 问题的实质 本地缓存的应用 正文 一、背景 公司使用的是高可用的redis cluster,同时会有多个服务共用这个缓存集群，我们主要做的是运营营销的产...
Springboot整合GuavaCache缓存过程解析
08-25
主要介绍了springboot整合GuavaCache缓存过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
SpringBoot加入Guava Cache实现本地缓存代码实例
08-25
主要介绍了SpringBoot加入Guava Cache实现本地缓存代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java内存缓存工具Guava LoadingCache使用解析
08-25
主要介绍了Java内存缓存工具Guava LoadingCache使用解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
嵌入内存的NoSQL键值数据库MapDB，Java
Zhang Phil
10-14 690
MapDB用途多元化，MapDB提供拆箱即用的NoSQL键值数据存储模式。MapDB可以简单的基于内存、只在内存中内建数据库存储键值数据，当JVM关闭后所有数据自动消失。也可以将内存中的数据flush到本地一个文件中。下面一个例子，说明MapDB基于数据库文件存取内存数据.
Mapdb高级用法
最新发布
weixin_44203221的博客
03-14 900
MapDB是一个高性能的嵌入式Java数据库引擎，它提供了丰富的数据结构，如Maps、Sets、Lists、Queues等，并且支持事务、并发控制、数据过期机制、数据压缩、堆外存储和流式操作等高级特性。MapDB允许使用不同的序列化器来控制数据的存储和检索方式，这可以提高性能并支持自定义数据类型。MapDB支持数据压缩，可以减少存储空间的使用。MapDB提供了并发控制机制，如记录级别的锁和先进的并发控制引擎。MapDB提供了快照和增量备份的功能，可以用于数据的备份和恢复。，可以设置不同的并发级别。
java读取mapdb_MapDB 教程一
weixin_33303537的博客
02-28 709
简介MapDB是一个开放源代码(Apache 2.0授权)，嵌入式Java数据库引擎和收集框架。它提供带有范围查询、时效限制、压缩、超栈存储和流功能的map、set、list、queue、Bitmap。MapDB可能是当前最快的Java数据库，性能可与java.util 集合相当。它还提供高级功能，如ACID事务，快照，增量备份等等。本手册是一项正在进行的工作，它将与MapDB 3.0版本一起完成...
mapdb java_mapdb: MapDB是一个快速、易用的嵌入式Java数据库引擎，它提供了基于磁盘或者堆外（off-heap允许Java直接操作内存空间, 类似于C的malloc和free）存...
weixin_42609225的博客
02-16 295
MapDB: database engineMapDB combines embedded database engine and Java collections.It is free under Apache 2 license. MapDB is flexible and can be used in many roles:Drop-in replacement for Maps, List...
Cory Isaacson：MapDB是纯Java数据库，供Java开发人员使用。
06-26 281
CodeFutures（数据库可扩展套件dbShards的供应商，为关系DB提供真正的“无共享”架构的供应商）首席执行官Cory Isaacson向JAXenter谈到了MapDB – MapDB是Apache许可的开源数据库，特别是Java开发人员，有望成为Java。未来的存储引擎。 JAX：您能为我们的读者提供有关MapDB内容的总体看法吗？ 艾萨克森（Isaacson）： MapDB...
MapDB实现本地缓存
qq_43777978的博客
05-28 376
public class Caches { //MapDB数据库对象 private DB db; //私有的本类的静态变量 private static Caches cache = null; private static Map map; //初始化本地缓存 private Caches() { boolean flag=init(); if(flag){ TimedTask.upda
四、常用工具之Guava Cache
panchang199266的博客
06-08 1861
详情参见Guava Cache内存缓存使用实践-定时异步刷新及简单抽象封装
mapdb java_MapDB使用入门
weixin_39559277的博客
02-26 375
背景MapDB官网：http://www.mapdb.org官方翻译之后的话：MapDB基于堆外存储、磁盘存储提供了Java的Maps、Sets、Lists、Queues等功能。它混合了Java集合框架和数据库引擎。它是基于Apache许可的免费的、开源的。个人觉得：MapDB是一个轻量级的本地缓存的框架，它既可以使用对外存储，也可以使用磁盘存储(重启时数据不丢失)。它还提供事务的功能。开发文档：...
Guava cache构建本地缓存
04-01
Guava Cache是Google Guava库中提供的一种本地缓存解决方案。它是一个基于内存的缓存，可以在应用程序内部存储数据，提高应用程序性能。 Guava Cache提供了以下特性： 1. 自动加载：当缓存中不存在某个键的值时，可以自动加载生成该值。 2. 自动移除：缓存中的某些条目可以在一定时间内自动过期，或者可以使用大小限制来限制缓存中的条目数。 3. 针对不同的缓存数据设置不同的过期时间、存活时间、最大值、最小值等。 4. 支持同步和异步缓存。 使用Guava Cache非常简单，只需要按以下步骤操作： 1. 引入Guava库。 2. 创建一个CacheBuilder对象，用于配置缓存。 3. 调用build()方法创建一个Cache对象。 4. 使用put()方法向缓存中添加数据。 5. 使用get()方法从缓存中读取数据，如果缓存中不存在该键对应的值，则可以自动加载。 6. 使用invalidate()方法从缓存中移除数据。 下面是一个简单的示例： ```java import com.google.common.cache.CacheBuilder; import com.google.common.cache.CacheLoader; import com.google.common.cache.LoadingCache; import java.util.concurrent.ExecutionException; import java.util.concurrent.TimeUnit; public class GuavaCacheExample { public static void main(String[] args) throws ExecutionException { // 创建一个CacheBuilder对象 CacheBuilder<Object, Object> cacheBuilder = CacheBuilder.newBuilder() .maximumSize(100) // 设置缓存最大条目数 .expireAfterWrite(10, TimeUnit.MINUTES); // 设置缓存过期时间 // 创建一个Cache对象 LoadingCache<String, String> cache = cacheBuilder.build(new CacheLoader<String, String>() { @Override public String load(String key) throws Exception { System.out.println("loading " + key); // 自动加载数据 return "value-" + key; } }); // 添加数据到缓存中 cache.put("key1", "value1"); cache.put("key2", "value2"); // 从缓存中读取数据 System.out.println(cache.get("key1")); // 输出"value1" System.out.println(cache.get("key3")); // 输出"loading key3"和"value-key3" // 移除缓存中的数据 cache.invalidate("key1"); System.out.println(cache.get("key1", () -> "default")); // 输出"default" } } ``` 在这个示例中，我们使用CacheBuilder对象配置了缓存的最大条目数和过期时间。我们还使用CacheLoader对象创建了一个自动加载的缓存，当缓存中不存在某个键的值时，可以自动加载生成该值。我们使用put()方法向缓存中添加了两个数据，使用get()方法从缓存中读取了两个数据，并使用invalidate()方法从缓存中移除了一个数据。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值