堆缓存 — Guava Cache/Ehcache/MapDB

最新推荐文章于 2024-09-11 07:00:00 发布
最新推荐文章于 2024-09-11 07:00:00 发布
阅读量1.2k 收藏 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
关注
专栏目录
一文深入了解史上最强的Java堆内缓存框架Caffeine
码大叔
03-15 1649
它提供了一个近乎最佳的命中率。从性能上秒杀其他一堆进程内缓存框架，Spring5更是为了它放弃了使用多年的GuavaCache 缓存，在我们的日常开发中用的非常多，是我们应对各种性能问题支持高并发的一大利器。我们熟知的缓存有堆缓存（Ehcache3.x、Guava Cache等）、堆外缓存（Ehcache3.x、MapDB等）、分布式缓存（Redis、 memcached等）等等。今天要上场的...
Java缓存库对比-以及OHCache总结
Jermy的专栏
02-25 4002
堆内缓存： LinkedHashMap：Java自带类，内置LRU驱逐策略的实现（access-order）；多线程访问需要自己实现同步。 Guava Cache：Google Guava工具包中的缓存实现，支持LRU驱逐策略；支持多线程并发访问，支持按时间过期，但只有在访问时才清除过期数据。 Ehcache：支持多种驱逐策略：LFU、LRU、FIFO，支持持久化和集群。性能跟Guava Cac...
Guava堆缓存
10-01 129
通过Guava可以方便的实现堆缓存，Guava实现了很多的缓存失效策略,下面是使用案例。 import java.util.concurrent.TimeUnit; import com.google.common.cache.CacheBuilder; import com.google....
Java缓存机制：Ehcache与Guava Cache的比较
最新发布
微赚淘客系统开发者博客
09-11 480
缓存是一种通过将数据存储在快速访问的存储介质中，以减少对慢速数据源的访问次数的技术。
3种堆内缓存算法，赠源码和设计思路
小姐姐味道
05-11 584
原创：小姐姐味道（微信公众号ID：xjjdog），欢迎分享，转载请保留出处。要说计算机系统里，什么技术把tradeoff体现的淋漓尽致，那肯定是缓存无疑。为了协调高速部件和低速部件的速度...
24-多级缓存架构-服务本地堆缓存：完成spring boot整合ehcache的搭建以支持服务本地堆缓存
weixin_40663800的博客
06-10 349
因为之前跟大家提过，三级缓存，多级缓存，服务本地堆缓存 + redis分布式缓存 + nginx本地缓存组成的 每一层缓存在高并发的场景下，都有其特殊的用途，需要综合利用多级的缓存，才能支撑住高并发场景下各种各样的特殊情况 服务本地堆缓存，作用，预防redis层的彻底崩溃，作为缓存的最后一道防线，避免数据库直接裸奔 服务本地堆缓存，我们用什么来做缓存，难道我们自己手写一个类或者程序去管理内...
MapDB实现本地缓存
qq_43777978的博客
05-28 452
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
高并发服务设计——缓存
楚兴
09-17 3187
缓存回收策略1 基于空间即设置缓存的存储空间，如设置为10MB，当达到存储空间时，按照一定的策略移除数据。2 基于容量基于容量指缓存设置了最大大小，当缓存的条目超过最大大小，则按照一定的策略将旧数据移除。3 基于时间TTL(Time To Live)：存活期，即缓存数据从缓存中创建时间开始直到它到期的一个时间段(不管在这个时间段内有没有访问都将过期)。TTI(Time To Idle)：空闲期，即缓
九、应用级缓存——应用级缓存总述
流楚丶格念的博客
08-24 626
缓存的核心目的是将数据尽可能地靠近使用者，以提高访问速度。其工作机制是：首先尝试从缓存中读取数据，如果缓存中没有，则从慢速设备（如磁盘或网络）中读取数据，并将数据同步到缓存中。缓存通常用于存储频繁访问的数据、热点数据、计算昂贵的数据、符合“5分钟法则”的数据等。及时更新：频繁访问的数据在5分钟内应及时更新缓存，以保持数据的最新状态。优先缓存热点：优先缓存那些在短时间内被频繁访问的数据，确保热点数据始终在缓存中。减少失效：定期检查和更新缓存，特别是可能短时间内变化的数据，以减少缓存失效，提高数据准确性。
Java堆外缓存OHC在马蜂窝推荐引擎的应用
qq_16046891的博客
10-21 1339
在推荐系统中，通常由推荐引擎提供线上推荐服务。推荐引擎的工作流程主要包括召回、排序等阶段，每个阶段都需要大量的数据支撑，快速读取这些数据对提升推荐引擎的性能起着重要的作用。 缓存在企业级Web系统中使用非常广泛，举例来说，业务程序和数据库通常运行在不同的物理服务器上，并通过网络访问数据库。网络传输的耗时，自然会增加系统的响应时间。为了降低响应时间，业务程序可以将从数据库中读取到的部分数据，缓存在本地服务器以供后续使用。 缓存框架OHC基于Java语言实现，并以类库的形式供其他Java程序调用，是一种以单机模
阿里三面必问JVM知识点- 使用堆外内存减少Full GC
wdj_yyds的博客
03-27 518
问题: 大部分主流互联网企业线上Server JVM选用了CMS收集器(如Taobao、LinkedIn、Vdian), 虽然CMS可与用户线程并发GC以降低STW时间, 但它也并非十分完美, 尤其是当出现Concurrent Mode Failure由并行GC转入串行时, 将导致非常长时间的Stop The World(详细可参考JVM初探- 内存分配、GC原理与垃圾收集器). 解决: 由GCIH可以联想到: 将长期存活的对象(如Local Cache)移入堆外内存(off-heap, 又名直接内存/.
guava jar包
03-27
Guava工程包含了若干被Google的 Java项目广泛依赖 的核心库，例如：集合 [collections] 、缓存 [caching] 、原生类型支持 [primitives support] 、并发库 [concurrency libraries] 、通用注解 [common annotations] 、字符串处理 [string processing] 、I/O 等等。
google开源项目guava.jar包
01-19
在网上下了几个包，都不对，节操何在，现在特奉献出自己历经千辛万苦才找到的包，经测试，正确
guava多个版本jar包
12-11
guava多个版本jar包，有guava-2.6.2.jar、guava-18.0.jar、guava-19.0.jar、guava-23.0.jar。
mapdb：MapDB提供由磁盘存储或堆外内存支持的并发Maps，Sets和Queues。 它是一种易于使用的嵌入式Java数据库引擎
02-28
MapDB：数据库引擎 MapDB结合了嵌入式数据库引擎和Java集合。 根据Apache 2许可，它是免费的。 MapDB是灵活的，可以在许多角色中使用： 可以直接替换地图，列表，队列和其他集合。 不受垃圾收集器影响的堆外收集 具有到期和磁盘溢出的多级缓存。 用事务，MVCC，增量备份等替换RDBM ... 本地数据处理和过滤。 MapDB具有实用程序，可以在合理的时间内处理大量数据。 你好，世界 Maven代码段，VERSION为 < dependency> < groupId>org.mapdb</ groupId> < artifactId>mapdb</ artifactId> < version>VERSION</ version> </ dependency> 你好，世界： // import org.mapdb.* D
mapdb,mapdb提供由磁盘存储或堆外内存支持的并发映射、集合和队列。它是一种快速、易于使用的嵌入式Java数据库引擎。.zip
09-26
MAPB结合了嵌入式数据库引擎和Java集合。
Java堆内缓存框架Caffeine
fulong0406的博客
04-26 601
转载：http://www.zyiz.net/tech/detail-118644.html 码大叔2020/3/16 12:17:21319次 它提供了一个近乎最佳的命中率。从性能上秒杀其他一堆进程内缓存框架，更是为了它放弃了使用多年的缓存，在我们的日常开发中用的非常多，是我们应对各种性能问题支持高并发的一大利器。我们熟知的缓存有堆缓存（、等）、堆外缓存（ > 它提供了一个近乎最佳的命中率。从性能上秒杀其他一堆进程内缓存框架，Spring5更是为了它放弃了使用多年的GuavaCache ...
GuavaCacheUtil包
熊浪的博客
05-28 622
package com.book.common.util; import com.google.common.cache.CacheBuilder; import com.google.common.cache.CacheLoader; import com.google.common.cache.LoadingCache; import com.google.common.cache.RemovalListener; import com.google.common.cache.RemovalNoti.
缓存
吴阳春的博客
07-18 831
缓存 利用项目闲暇时间，对缓存知识进行了一次梳理，整理成了脑图，这里配合脑图进行一下说明。 脑图：缓存知识点整理 [TOC] 缓存简介 缓存的本质是让数据更接近使用者，如何设计缓存、哪些数据适合进行缓存、缓存的方式、缓存的回收策略都是我们需要考量的点。 java应用缓存 http缓存 redis缓存 数据库缓存 mybatis缓存 nginx缓存 ...
企业项目开发：Guava Cache 本地缓存实践
第七章企业项目开发深入探讨了本地缓存技术，特别是使用Guava Cache在实际项目中的应用。在现代软件开发中，缓存技术是提高系统性能的关键组件，特别是在处理大量数据或频繁查询时，通过存储常用数据在内存中，能够...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值