下载文档原格式
Java内存缓存⼯具GuavaLoadingCache使⽤解析这篇⽂章主要介绍了Java内存缓存⼯具Guava LoadingCache使⽤解析,⽂中通过⽰例代码介绍的⾮常详细，对⼤家的学习或者⼯作具有⼀定的参考学习价值,需要的朋友可以参考下⼀、Guava介绍Guava是Google guava中的⼀个内存缓存模块，⽤于将数据缓存到JVM内存中。
实际项⽬开发中经常将⼀些公共或者常⽤的数据缓存起来⽅便快速访问。
Guava Cache是单个应⽤运⾏时的本地缓存。
它不把数据存放到⽂件或外部服务器。
如果不符合需求，可以选择Memcached、Redis等⼯具。
⼆、代码⽰例1. POM引⼊<dependency><groupId>com.google.guava</groupId><artifactId>guava</artifactId><version>28.1-jre</version></dependency>2. 封装⼯具类package com.soyoung.ad.engine.util;import mon.cache.*;import lombok.extern.slf4j.Slf4j;import java.util.Map;import java.util.concurrent.TimeUnit;/*** 功能描述** @author 马振全 2020/1/13 16:18*/@Slf4jpublic class CacheManager {/** 缓存项最⼤数量 */private static final long GUAVA_CACHE_SIZE = 100000;/** 缓存时间：天 */private static final long GUAVA_CACHE_DAY = 10;/** 缓存操作对象 */private static LoadingCache<Long, String> GLOBAL_CACHE = null;static {try {GLOBAL_CACHE = loadCache(new CacheLoader<Long, String>() {@Overridepublic String load(Long key) throws Exception {// 处理缓存键不存在缓存值时的处理逻辑return "";}});} catch (Exception e) {log.error("初始化Guava Cache出错", e);}}/*** 全局缓存设置** 缓存项最⼤数量：100000* 缓存有效时间（天）：10*** @param cacheLoader* @return*/private static LoadingCache<Long, String> loadCache(CacheLoader<Long, String> cacheLoader) throws Exception { LoadingCache<Long, String> cache = CacheBuilder.newBuilder()//缓存池⼤⼩，在缓存项接近该⼤⼩时， Guava开始回收旧的缓存项.maximumSize(GUAVA_CACHE_SIZE)//设置时间对象没有被读/写访问则对象从内存中删除(在另外的线程⾥⾯不定期维护).expireAfterAccess(GUAVA_CACHE_DAY, TimeUnit.DAYS)// 设置缓存在写⼊之后设定时间后失效.expireAfterWrite(GUAVA_CACHE_DAY, TimeUnit.DAYS)//移除监听器,缓存项被移除时会触发.removalListener(new RemovalListener<Long, String>() {@Overridepublic void onRemoval(RemovalNotification<Long, String> rn) {//逻辑操作}})//开启Guava Cache的统计功能.recordStats().build(cacheLoader);return cache;}/*** 设置缓存值* 注: 若已有该key值，则会先移除(会触发removalListener移除监听器)，再添加** @param key* @param value*/public static void put(Long key, String value) {try {GLOBAL_CACHE.put(key, value);} catch (Exception e) {log.error("设置缓存值出错", e);}}/*** 批量设置缓存值** @param map*/public static void putAll(Map<? extends Long, ? extends String> map) {try {GLOBAL_CACHE.putAll(map);} catch (Exception e) {log.error("批量设置缓存值出错", e);}}/*** 获取缓存值* 注：如果键不存在值，将调⽤CacheLoader的load⽅法加载新值到该键中** @param key* @return*/public static String get(Long key) {String token = "";try {token = GLOBAL_CACHE.get(key);} catch (Exception e) {log.error("获取缓存值出错", e);}return token;}/*** 移除缓存** @param key*/public static void remove(Long key) {try {GLOBAL_CACHE.invalidate(key);log.error("移除缓存出错", e);}}/*** 批量移除缓存** @param keys*/public static void removeAll(Iterable<Long> keys) {try {GLOBAL_CACHE.invalidateAll(keys);} catch (Exception e) {log.error("批量移除缓存出错", e);}}/*** 清空所有缓存*/public static void removeAll() {try {GLOBAL_CACHE.invalidateAll();} catch (Exception e) {log.error("清空所有缓存出错", e);}}/*** 获取缓存项数量** @return*/public static long size() {long size = 0;try {size = GLOBAL_CACHE.size();} catch (Exception e) {log.error("获取缓存项数量出错", e);}return size;}}三、使⽤总结1. 移除机制guava做cache时候数据的移除分为被动移除和主动移除两种。
java redis 缓存分页实现原理Java Redis缓存是一种用于在Web应用程序中提高数据访问性能的技术。
它通过将常用的数据存储在内存中，以便更快地访问和获取，从而减少了对数据库的访问。
分页是Web应用程序中常见的功能之一，它允许用户在列表或表格中浏览数据，并按页查看数据，以减少数据量和提高用户体验。
Java Redis缓存的分页实现原理是，将查询的结果集划分为多个页，并将每个页的数据存储在Redis缓存中，以供后续的访问和查询。
下面将详细介绍Java Redis缓存分页的实现原理。
1.将查询结果集分页：在数据库查询之后，将结果集按照每页显示的数量划分为多个页，例如每页显示10条数据，将结果集分为若干个包含10条数据的页。
这样可以方便后续的分页访问和查询。
2.将每页的数据存储到Redis缓存中：对于每个分页的数据，将其存储到Redis缓存中。
可以使用Redis 的数据结构Hash或List来存储每页的数据。
对于Hash结构，可以使用页号作为Key，对应的数据作为Value，将所有页的数据存储到一个Hash中。
对于List结构，可以使用一个List来存储所有的分页数据，每个分页数据作为一个元素。
通过使用Redis缓存，可以提高分页的访问速度和性能。
3.使用Redis缓存进行分页查询：当用户请求分页数据时，首先从Redis缓存中获取对应页的数据。
如果缓存中存在该页的数据，则直接返回给用户；如果缓存中不存在该页的数据，则从数据库中查询该页的数据，并存储到Redis缓存中，以供后续的查询和访问。
4.缓存失效和更新：为了保证数据的实时性，需要处理缓存的失效和更新问题。
当用户修改或删除数据时，需要更新对应页的数据缓存，或者将所有缓存的数据进行失效处理，以保证数据的一致性。
可以通过监听数据的修改和删除操作，在数据库操作完成后，更新或失效对应的缓存数据。
5.缓存过期时间设置：为了控制内存使用和避免缓存数据过时，可以设置缓存数据的过期时间。
Java中的分布式缓存框架有哪些随着互联网应用的快速发展，分布式缓存已经成为了提高系统性能和扩展性的关键技术之一。
在Java开发领域，也涌现了许多优秀的分布式缓存框架。
本文将介绍几个Java中常用的分布式缓存框架，并分析它们的特点和适用场景。
一、EhcacheEhcache是一个开源的Java缓存框架，被广泛应用于各种Java应用中。
它提供了基于内存和磁盘的缓存机制，支持分布式部署，能够满足大规模应用的缓存需求。
Ehcache具有轻量级、易于使用和快速的特点，适合用于小型和中型的应用系统。
二、RedisRedis是一种高性能的内存数据存储系统，支持多种数据结构，可以用作分布式缓存的解决方案。
Redis提供了持久化和复制机制，可以实现高可用性和数据持久化。
同时，Redis还具有丰富的功能，如发布订阅、事务管理等，使得它不仅可以作为缓存系统，还可以用于其他用途，如消息队列等。
Redis适用于各种规模的应用系统。
三、MemcachedMemcached是一个简单的高性能分布式内存对象缓存系统。
它使用键值对的方式存储数据，提供了多种API，支持分布式部署。
Memcached具有高速的读写性能和可扩展性，通常被用于缓存数据库查询结果、页面内容等。
它适用于大规模应用和高并发场景，但需要注意的是，Memcached不提供数据持久化功能。
四、HazelcastHazelcast是一个基于Java的开源分布式缓存框架，它提供了分布式数据结构和集群管理功能。
Hazelcast采用了集中式架构，能够实现多节点之间的数据共享和同步。
它具有简单易用的特点，并提供了多种数据结构和并发算法的支持。
Hazelcast适用于构建复杂的分布式应用系统。
五、CaffeineCaffeine是一个在Java中最受欢迎的缓存库之一，它提供了高性能、无锁的内存缓存解决方案。
Caffeine采用了分片策略来管理缓存对象，提供了各种缓存策略和配置选项，可以根据实际需求进行灵活配置。
Java本地缓存⼯具之LoadingCache的使⽤详解⽬录前⾔环境依赖代码演⽰⼀下总结前⾔在⼯作总常常需要⽤到缓存，⽽redis往往是⾸选，但是短期的数据缓存⼀般我们还是会⽤到本地缓存。
本⽂提供⼀个我在⼯作中⽤到的缓存⼯具，该⼯具代码为了演⽰做了⼀些调整。
如果拿去使⽤的话，可以考虑做成注⼊Bean对象，看具体需求了。
环境依赖先添加maven依赖<dependency><groupId>com.google.guava</groupId><artifactId>guava</artifactId><version>30.1.1-jre</version></dependency><dependency><groupId>cn.hutool</groupId><artifactId>hutool-all</artifactId><version>5.5.2</version></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency>代码不废话，上代码了。
package ai.guiji.csdn.tools;import cn.hutool.core.thread.ThreadUtil;import mon.cache.*;import lombok.extern.slf4j.Slf4j;import java.text.MessageFormat;import java.util.Map;import java.util.concurrent.TimeUnit;import java.util.function.Consumer;import java.util.function.Function;import java.util.stream.LongStream;/** @Author 剑客阿良_ALiang @Date 2021/12/30 17:57 @Description: 缓存⼯具 */@Slf4jpublic class CacheUtils {private static LoadingCache<Long, String> cache;/*** 初始化缓存⽅法** @param totleCount 缓存池上限* @param overtime 超时时间* @param unit 时间单位* @param handleNotExist 处理不存在key⽅法* @param handleRemove 移除主键消费*/private static void initCache(Integer totleCount,Integer overtime,TimeUnit unit,Function<Long, String> handleNotExist,Consumer<Long> handleRemove) {cache =CacheBuilder.newBuilder()// 缓存池⼤⼩.maximumSize(totleCount)// 设置时间对象没有被读/写访问则对象从内存中删除.expireAfterWrite(overtime, unit)// 移除监听器.removalListener(new RemovalListener<Long, String>() {@Overridepublic void onRemoval(RemovalNotification<Long, String> rn) { handleRemove.accept(rn.getKey());}}).recordStats().build(new CacheLoader<Long, String>() {@Overridepublic String load(Long aLong) throws Exception {return handleNotExist.apply(aLong);}});("初始化缓存");}/*** 存⼊缓存** @param key 键* @param value 值*/public static void put(Long key, String value) {try {("缓存存⼊:[{}]-[{}]", key, value);cache.put(key, value);} catch (Exception exception) {log.error("存⼊缓存异常", exception);}}/*** 批量存⼊缓存** @param map 映射*/public static void putMap(Map<Long, String> map) {try {("批量缓存存⼊:[{}]", map);cache.putAll(map);} catch (Exception exception) {log.error("批量存⼊缓存异常", exception);}}/*** 获取缓存** @param key 键*/public static String get(Long key) {try {return cache.get(key);} catch (Exception exception) {log.error("获取缓存异常", exception);return null;}}/*** 删除缓存** @param key 键*/public static void removeKey(Long key) {try {cache.invalidate(key);} catch (Exception exception) {log.error("删除缓存异常", exception);}}/*** 批量删除缓存** @param keys 键*/public static void removeAll(Iterable<Long> keys) {try {cache.invalidateAll(keys);} catch (Exception exception) {log.error("批量删除缓存异常", exception);}}/** 清理缓存 */public static void clear() {try {cache.invalidateAll();} catch (Exception exception) {log.error("清理缓存异常", exception);}}/*** 获取缓存⼤⼩** @return 长度*/public static long size() {return cache.size();}public static void main(String[] args) {initCache(Integer.MAX_VALUE,10,TimeUnit.SECONDS,k -> {("缓存:[{}]，不存在", k);return "";},x -> ("缓存:[{}]，已经移除", x));System.out.println(size());LongStream.range(0, 10).forEach(a -> put(a, MessageFormat.format("tt-{0}", a)));System.out.println(cache.asMap());ThreadUtil.sleep(5000);LongStream.range(0, 10).forEach(a -> {System.out.println(get(a));ThreadUtil.sleep(1000);});System.out.println(cache.asMap());ThreadUtil.sleep(10000);System.out.println(cache.asMap());}}代码说明1、在初始化loadingCache的时候，可以添加缓存的最⼤数量、消逝时间、消逝或者移除监听事件、不存在键处理等等。
Java中的缓存技术缓存技术在软件开发中起着至关重要的作用。
它可以提高系统性能、降低对底层资源的访问频率，从而减轻服务器负载并改善用户体验。
在Java开发中，有许多可供选择的缓存技术。
本文将介绍几种常见的Java缓存技术，以及它们的应用场景和原理。
一、内存缓存内存缓存是最常见的缓存技术之一，它将数据保存在内存中，以提高读取速度。
在Java中，可以使用集合框架中的Map接口的实现类来实现内存缓存，如HashMap、ConcurrentHashMap等。
这些类提供了快速的Key-Value存储，通过Key快速查找对应的Value，以实现快速访问缓存数据。
内存缓存适用于数据读取频繁但不经常更新的场景，例如字典数据、配置信息等。
需要注意的是，内存缓存的容量是有限的，当缓存数据超过容量限制时，需要采取一些策略来处理，如LRU（最近最少使用）算法将最久未访问的数据移出缓存。
二、分布式缓存分布式缓存是一种将数据存储在多台服务器节点上的缓存技术。
Java中有多种分布式缓存框架可供选择，如Redis、Memcached等。
这些框架提供了高性能、可扩展的分布式缓存服务，可以在集群中存储大量的数据，并提供分布式缓存的管理和查询接口。
分布式缓存适用于需要同时服务大量客户端并具有高并发读写需求的场景，例如电商网站的商品信息、社交网络的用户数据等。
通过将数据存储在多台服务器上，可以提高系统的可用性和扩展性。
三、页面缓存页面缓存是将网页内容保存在缓存中，以减少对数据库或后端服务的访问频率，从而提高页面的加载速度。
在Java中，可以通过使用Web服务器或反向代理服务器的缓存功能，例如Nginx、Varnish等，来实现页面缓存。
页面缓存适用于内容相对静态或者不经常变化的场景，例如新闻网站的文章、博客网站的页面等。
通过将网页内容保存在缓存中，可以避免每次请求都重新生成页面，大大提高响应速度和系统的并发能力。
四、数据库缓存数据库缓存是将数据库查询结果保存在缓存中，以减少对数据库的频繁查询，提高系统的响应速度和并发能力。
Java中常用缓存Cache机制的实现Java 中常用缓存Cache机制的实现所谓缓存，就是将程序或系统经常要调用的对象存在内存中，一遍其使用时可以快速调用，不必再去创建新的重复的实例。
这样做可以减少系统开销，提高系统效率。
Java 中常用缓存Cache机制的实现缓存主要可分为二大类:一、通过文件缓存,顾名思义文件缓存是指把数据存储在磁盘上，不管你是以XML格式，序列化文件DAT格式还是其它文件格式；二、内存缓存，也就是实现一个类中静态Map,对这个Map进行常规的增删查.代码如下：1. packagelhm.hcy.guge.frameset.cache;2.3. importjava.util.*;4.5. //Description:管理缓存6.7. //可扩展的功能：当chche到内存溢出时必须清除掉最早期的一些缓存对象，这就要求对每个缓存对象保存创建时间8.9. publicclassCacheManager{10. privatestaticHashMapcacheMap=newHashMap();11.12. //单实例构造方法13. privateCacheManager(){14. super();15. }16. //获取布尔值的.缓存17. publicstaticbooleangetSimpleFlag(Stringkey){18. try{19. return(Boolean)cacheMap.get(key);20. }catch(NullPointerExceptione){21. returnfalse;22. }23. }24. publicstaticlonggetServerStartdt(Stringkey){25. try{26. return(Long)cacheMap.get(key);27. }catch(Exceptionex){28. return0;29. }30. }31. //设置布尔值的缓存32. publicsynchronizedstaticbooleansetSimpleFlag(Stringkey,boolea nflag){33. if(flag&&getSimpleFlag(key)){//假如为真不允许被覆盖34. returnfalse;35. }else{36. cacheMap.put(key,flag);37. returntrue;38. }39. }40. publicsynchronizedstaticbooleansetSimpleFlag(Stringkey,longse rverbegrundt){41. if(cacheMap.get(key)==null){42. cacheMap.put(key,serverbegrundt);43. returntrue;44. }else{45. returnfalse;46. }47. }48.49.50. //得到缓存。
Hutool是一个Java工具库，它提供了许多实用的功能和工具类，包括缓存管理。
然而，Hutool 本身并不提供独立的缓存框架或实现，而是使用了其他流行的缓存技术来实现其缓存功能。
具体来说，Hutool可以与以下常见的缓存技术集成：
1.Caffeine：Caffeine是一种基于Java的高性能内存缓存库。
Hutool中的CacheUtil类可以
与Caffeine集成，提供方便易用的缓存管理功能。
2.Ehcache：Ehcache是一个广泛使用的开源Java缓存框架。
Hutool中的CacheUtil类可以
与Ehcache集成，使用Ehcache实现缓存功能。
3.Redis：Redis是一种流行的内存数据结构存储系统，也可以用作缓存。
Hutool中的
CacheUtil类可以与Redis集成，使用Redis作为分布式缓存。
Hutool的缓存原理主要依赖于所选择的具体缓存技术的实现。
它提供了统一的API和封装，使使用者可以轻松地在应用程序中使用缓存功能。
根据所选的缓存技术，Hutool会将数据存储在内存中或者通过与外部缓存服务器进行通信来实现缓存操作。
需要注意的是，Hutool只是作为工具库提供了对缓存技术的封装和简化，并没有重新实现缓存技术本身。
因此，深入了解所选缓存技术的原理和特性，以及与Hutool的集成方式，将有助于更好地理解Hutool的缓存功能。
Java 中的缓存（Cache）是一种提高应用程序性能的技术，它通过在内存中存储经常访问的数据，避免了频繁地访问速度较慢的数据源（如数据库或文件）。
在Java 中，有许多内置的缓存实现，如`java.util.Cache`和`java.util.ConcurrentMap`等。
以下是一个简单的Java 缓存用法示例：1. 首先，导入所需的缓存类：```javaimport java.util.Cache;import java.util.ConcurrentMap;```2. 创建一个缓存实例：```javaCache<String, String> cache = new ConcurrentMap<>();```这里，我们使用`ConcurrentMap`作为缓存实现。
它可以保证在高并发场景下的性能表现。
3. 向缓存中添加数据：```javacache.put("key1", "value1");cache.put("key2", "value2");```4. 从缓存中获取数据：```javaString value1 = cache.get("key1");String value2 = cache.get("key2");```5. 删除缓存中的数据：```javacache.remove("key1");```6. 检查缓存中是否包含某个键：```javaboolean containsKey = cache.containsKey("key1"); ```7. 获取缓存中的所有键：```javaSet<String> keys = cache.keySet();```8. 获取缓存中的所有值：```javaCollection<String> values = cache.values();```9. 清除缓存：```javacache.clear();```10. 关闭缓存：```javacache.invalidate();```此外，Java 还提供了`java.util.expiringmap`类，它可以在缓存中设置过期时间，从而在数据不再需要时自动删除。
Java本地缓存解决⽅案---使⽤Google的CacheBuilder⼀、背景当业务实现上需要⽤到本地缓存，来解决⼀些数据量相对较⼩但是频繁访问数据的场景，可以采⽤Google的CacheBuilder解决⽅案。
⼆、代码实现1. ⾸先在maven中引⼊下⾯的包<dependency><groupId>com.google.guava</groupId><artifactId>guava</artifactId><version>19.0</version></dependency>2. 代码测试案例import mon.cache.CacheBuilder;import mon.cache.CacheLoader;import mon.cache.LoadingCache;import java.util.concurrent.TimeUnit;public class LocalCacheTest {// 测试类public static void main(String[] args) throws Exception {CacheService us = new CacheService();for (int i = 0; i < 6; i++) {System.out.println(us.getName("1001"));TimeUnit.SECONDS.sleep(1);}}// 实现类public static class CacheService {private final LoadingCache<String, String> cache;public CacheService() {/*** 创建本地缓存，当本地缓存不命中时，调⽤load⽅法，返回结果，再缓存结果, 3秒⾃动过期*/cache = CacheBuilder.newBuilder().expireAfterWrite(3, TimeUnit.SECONDS).build(new CacheLoader<String, String>() {public String load(String id) throws Exception {System.out.println("load()method invoke, 执⾏查询数据库, 等其他复杂的逻辑");LISECONDS.sleep(100);return "User:" + id;}});}public String getName(String id) throws Exception {long start = System.currentTimeMillis();String result = cache.get(id);System.out.println("查询 "+id +" 耗时："+ (System.currentTimeMillis()-start) + " ms");return result;}}}3. 控制台输出从控制台输出，可以看出，当本地缓存不命中时，调⽤load⽅法，通过数据库查询结果，返回结果，再缓存结果, 耗时较长。
在软件开发中，缓存是一种常用的优化技术，用于存储频繁访问的数据，使得下一次访问时可以更快地获取数据。
而在Java中，也存在着各种不同的缓存机制，用于提升程序的性能与效率。
一、内存缓存内存缓存是最常见的缓存机制之一。
在Java中，可以使用各种数据结构来实现内存缓存，比如Hashtable、HashMap、ConcurrentHashMap等。
使用内存缓存的好处是可以将数据存储在内存中，而不是频繁地访问数据库或者其他外部存储介质，从而提升访问速度。
同时，内存缓存还可以减轻数据库的负载，提高系统的并发能力。
二、CPU缓存CPU缓存是指CPU内部的高速缓存，用于暂时存储处理器频繁访问的数据。
在Java中，可以通过使用局部变量和静态变量来利用CPU缓存。
局部变量存储在方法栈帧中，相对于对象的实例变量来说，访问局部变量的速度更快。
因此，在开发过程中，应该尽量使用局部变量来存储频繁访问的数据。
静态变量是存储在方法区中的，与对象的实例无关。
由于静态变量只有一个副本，所以可以减少对CPU缓存的竞争，提高程序的性能。
三、磁盘缓存磁盘缓存是将数据存储在磁盘中，并使用相应的缓存算法来提高数据的读写速度。
在Java中，可以通过使用文件缓存或者数据库缓存来实现磁盘缓存。
文件缓存是将数据存储在本地文件系统中，比如将一些配置文件加载到内存中进行处理。
数据库缓存是将数据存储在数据库中，并使用缓存算法来提高数据的访问速度。
一般情况下，数据库缓存会使用LRU（最近最少使用）算法来决定何时移除某个数据。
四、网络缓存网络缓存是将数据存储在网络中，通过网络进行传输。
在Java中，可以通过使用HTTP缓存或者CDN来实现网络缓存。
HTTP缓存是浏览器和服务器之间的缓存，用于存储HTTP请求和响应的数据。
通过合理设定HTTP头信息，可以实现数据的缓存，减少带宽的消耗。
CDN（内容分发网络）是一种将数据分布到全球多台服务器的网络架构，用于存储静态文件，提供更快的数据访问速度。
