Java实现本地缓存的常用方案介绍

2025-05-29 16:50
文章标签 java 实现 介绍 常用 本地 缓存 方案

本文主要是介绍Java实现本地缓存的常用方案介绍，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

《Java实现本地缓存的常用方案介绍》本地缓存的代表技术主要有HashMap,GuavaCache,Caffeine和Encahche,这篇文章主要来和大家聊聊java利用这些技术分别实现本地缓存的方...

本地缓存

就是和应用服务器一起的缓存工具，将需要缓存的数据放到本地缓存中，可以大大的提升访问速度。

是指和应用程序在同一个进程内的内存空间去存储数据，数据的读写都是在同一个进程内完成的。

实现方式

本地缓存的代表技术主要有HashMap，Guava Cache，Caffeine和Encahche

  • Map：使用 Java 的 Map 集合来实现本地缓存，将数据存储在内存中，以键值对的形式进行访问。
  • Guava Cache：Google 开源的缓存库，提供了线程安全的本地缓存实现，支持python缓存的自动回收和过期时间设置等功能。
  • Ehcache：一种轻量级的 Java 缓存框架，可以将数据存储在 JVM 中或者磁盘中，支持缓存的自动回收和过期时间设置等功能。
  • Caffeine：由 Google 开源的 Java 缓存框架，提供了高性能和可伸缩的缓存实现，支持缓存的自动回收和多种缓存逐出策略等功能。

HashMap

这是最简单的方式，你可以使用Java的HashMap来存储缓存数据。这种方式在数据量小的情况下是可以的。但是如果你需要在多线程环境下读写缓存，那么这种方式可能会引起线程安全问题。

import java.util.HashMap;  
import java.util.Map;  
  
public class SimpleCache {  
    private Map<String, Object> cache = new HashMap<>();  
  
    public Object get(String key) {  
        return cache.get(key);  
    }  
  
    public void put(String key, Object value) {  
        cache.put(key, value);  
    }  
}

ConcurrentHashMap

ConcurrentHashMap是Java中的一个线程安全的Map实现，可以在多线程环境下安全地读写缓存。

import java.util.concurrent.ConcurrentHashMap;  
import java.util.Map;  
  
public class ConcurrentCache {  
    private Map<String, Object> cache = new ConcurrentHashMap<>();  
  
    public Object get(String key) {  
        return cache.get(key);  
    }  
  
    public void put(String key, Object value) {  
        cache.put(key, value);  
    }  
}

Guava Cache

Guava是Google的Java核心库，提供了强大的缓存功能。它提供了多种缓存策略，例如基于时间的过期策略、基于大小的淘汰策略等。

import com.google.common.cache.Cache;  
import com.google.common.cache.CacheBuilder;  
import java.util.concurrent.TimeUnit;  
  
public class GuavaCache {  
    private Cache<String, Object> cache = CacheBuilder.newBuilder()  
            .expireAfterWrite(10, TimeUnit.MINUTES) // 设置缓存过期时间为10分钟  
            .maximumSize(1000) // 设置缓存最大容量为1000个元素  
            .build();  
  
    public Object get(String key) {  
        return cache.getIfPresent(key);  
    }  
  
    public void put(String key, Object value) {  
        cache.put(key, value);  
    }  
}

Caffeine

是基于java8实现的新一代缓存工具，缓存性能接近理论最优，可以看作是Guava Cache的增强版，功能上两者类似，不同的是Caffeine采用了一种结合LRU、LFU优点的算法：W-TinyLFU，在性能上有明显的优越性。

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;

import java.util.concurrent.TimeUnit;

public class LocalCacheExample {
    public static void main(String[] args) {
        // 创建一个基php于 Caffeine 的缓存实例
        Cache<String, String> cache = Caffeine.newBuilder()
                .expireAfterWrite(10, TimeUnit.MINUTES) // 设置缓存过期时间为10分钟
                .maximumSize(100) // 设置缓存最大容量为100个键值对
                .build();

        // 将数据放入缓存
        cache.put("key1", "value1");
        cache.put("key2", "value2");

        // 从缓存中获取数据
        String value1 = cache.getIfPresent("key1");
        System.out.println("Value for key1: " + value1);

        // 缓存中不存在的键，返回null
        String value3 = cache.getIfPresent("key3");
        System.out.println("Value for key3: " + value3);

        // 缓存中不存在的键，使用自定义的加载函数加载数据并放入缓存
        String value4 = cache.get("key4", key -> "value4");
        System.out.println("Value for key4: " + value4);

        // 手动移除缓存中的数据
        cache.invalidate("key2");

        // 清空缓存
        cache.invalidateAll();
    }
}

上述代码通过 Caffeine.newBuilder() 创建一个缓存实例，并使用 expireAfterWrite 设置缓存过期时间，使用 maximumSize 设置缓存的最大容量。然后通过 put 方法将数据放入缓存，通过 getIfPresent 方法从缓存中获取数据。如果缓存中不存在指定的键，则使用 get 方法并传入自定义的加载函数来加载数据并放入缓存。可以使用 invalidate 方法手动移除缓存中的数据，或者使用 invalidateAll 方法清空整个缓存。

请注意，在使用以上代码时，需要确保已引入 Caffeine 的相关依赖项，并进行相应的配置和初始化操作。

Ehcache

下面是使用 Ehcache 实现本地缓存的示例代码：

import org.ehcache.Cache;
import org.ehcache.CacheManager;
import org.ehcache.config.CacheConfiguration;
import org.ehcache.config.builders.CacheConfigurationBuilder;
import org.ehcache.config.builders.CacheManagerBuilder;
import org.ehcache.config.builders.ResourcePoolsBuilder;

import java.time.Duration;

public class LocalCacheExample {
    public static void main(String[] args) {
        // 创建一个基于 Ehcache 的缓存管理器
        CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder().buildwww.chinasem.cn();
        cacheManager.init();

        // 创建一个缓存配置
        CacheConfiguration<String, String> cacheConfiguration = CacheConfigurationBuilder.newCacheConfigurationBuilder(
                String.class, String.class,
                ResourcePoolsBuilder.heap(100)) // 设置缓存最大容量为100个键值对
                .withExpiry(
                        CacheConfigurationBuilder.newExpiryPolicyBuilder(Duration.ofMinutes(10))) // 设置缓存过期时间为10分钟
                .build();

        // 创建一个缓存实例
        Cache<String, String> cache = cacheManager.createCache("myCache", cacheConfiguration);

        // 将数据放入缓存
        cache.put("key1", "value1");
        cache.put("key2", "value2");

        // 从缓存中获取数据
        String value1 = cache.get("key1");
        System.out.println("Value for key1: " + value1);

        // 缓存中不存在的键，返回null
        String value3 = cache.get("key3");
        System.out.println("Value for key3: " + value3);

        // 手动移除缓存中的数据
        cache.remove("key2");

        // 关闭缓存管理器
        cacheManager.close();
    }
}

上述代码通过 CacheManagerBuilder.newCacheManagerBuilder() 创建一个缓存管理器，并使用 init() 进行初始化操作。然后使用 CacheConfigurationBuilder 创建一个缓存配置，通过 heap 设置缓存最大容量，通过 withExpiry 设置缓存过期时间。接着通过 cacheManager.createCache() 创建一个缓存实例，传入缓存的名称和缓存配置。可以使用 put 方法将数据放入缓存，使用 get 方法从缓存中获取数据，使用 remove 方法手动移除缓存中的数据。最后使用 cacheManager.close() 关闭缓存管理器。

请注意，在使用以上代码时，需要确保已引入 Ehcache 的相关依赖项，并进行相应的配置和初始化操作。

实现方式优缺点

HashMap、ConcurrentHashMap、Guava Cache和Caffeine都是Java中常用的缓存实现方案，它们各自有不同的优缺点。

1.HashMap：

优点：简单、直接，不需要引入第三方包，适合简单的场景。

缺点：没有缓存淘汰策略，定制化开发成本高，且在多线程环境下可能存在线程安全问题。

2. ConcurrentHashMap：

优点：线程安全，可以在多线程环境下安全地读写缓存。

缺点：相比HashMap，ConcurrentHashMap更加复杂，且在缓存淘汰策略方面仍然有所限制。

3. Guava Cache：

优点：功能强大，提供了多种缓存策略，例如基于时间的过期策略、基于大小的淘汰策略等。性能好，支持异步加载和批量操作。

缺点：需要引入Guava库，且组件的缓存同步需要自己实现。

4. Caffeine：

优点：基于Java的高性能缓存库，提供了内存缓存的功能。使用了类似于ConcurrentHashMap的分段锁机制，并提供了更多的缓存策略和配置选项。缓存性能接近理China编程论最优，属于是Guava Cache的增强版。

缺点：需要引入Caffeine库，且需要一定的学习成本。

5.Ehcache：

优点：支持本地缓存和分布式缓存，提供了丰富android的配置选项和缓存策略（如过期时间、最大大小、持久化等）。可以与Spring框架无缝集成。

缺点：在高并发环境下，性能可能不如Caffeine、Memcached和Redis。分布式缓存功能相对较新，可能不如Redis和Memcached成熟稳定。

综上所述，选择哪种本地缓存方案取决于具体的需求和场景。如果需求简单，且不需要考虑线程安全问题，那么HashMap是一个不错的选择。如果需要在多线程环境下读写缓存，那么ConcurrentHashMap是一个更好的选择。如果需要更强大的缓存功能，例如缓存淘汰策略、异步加载等，那么Guava Cache或Caffeine是一个不错的选择。对于需要分布式缓存的场景，Ehcache是一个不错的选择。

到此这篇关于Java实现本地缓存的常用方案介绍的文章就介绍到这了,更多相关Java本地缓存内容请搜索China编程(www.chinasem.cn)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程China编程(www.chinasem.cn)！

这篇关于Java实现本地缓存的常用方案介绍的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1154848。

相关文章

Java中流式并行操作parallelStream的原理和使用方法

Java中流式并行操作parallelStream的原理和使用方法

《Java中流式并行操作parallelStream的原理和使用方法》本文详细介绍了Java中的并行流（parallelStream）的原理、正确使用方法以及在实际业务中的应用案例,并指出在使用并行流... 目录Java中流式并行操作parallelStream0. 问题的产生1. 什么是parallelS
阅读更多...
C++中unordered_set哈希集合的实现

C++中unordered_set哈希集合的实现

《C++中unordered_set哈希集合的实现》std::unordered_set是C++标准库中的无序关联容器,基于哈希表实现,具有元素唯一性和无序性特点,本文就来详细的介绍一下unorder... 目录一、概述二、头文件与命名空间三、常用方法与示例1. 构造与析构2. 迭代器与遍历3. 容量相关4
阅读更多...
Java中Redisson 的原理深度解析

Java中Redisson 的原理深度解析

《Java中Redisson的原理深度解析》Redisson是一个高性能的Redis客户端,它通过将Redis数据结构映射为Java对象和分布式对象,实现了在Java应用中方便地使用Redis,本文... 目录前言一、核心设计理念二、核心架构与通信层1. 基于 Netty 的异步非阻塞通信2. 编解码器三、
阅读更多...
C++中悬垂引用(Dangling Reference) 的实现

C++中悬垂引用(Dangling Reference) 的实现

《C++中悬垂引用(DanglingReference)的实现》C++中的悬垂引用指引用绑定的对象被销毁后引用仍存在的情况,会导致访问无效内存,下面就来详细的介绍一下产生的原因以及如何避免,感兴趣... 目录悬垂引用的产生原因1. 引用绑定到局部变量，变量超出作用域后销毁2. 引用绑定到动态分配的对象，对象
阅读更多...
MyBatis常用XML语法详解

MyBatis常用XML语法详解

《MyBatis常用XML语法详解》文章介绍了MyBatis常用XML语法,包括结果映射、查询语句、插入语句、更新语句、删除语句、动态SQL标签以及ehcache.xml文件的使用,感兴趣的朋友跟随小... 目录1、定义结果映射2、查询语句3、插入语句4、更新语句5、删除语句6、动态 SQL 标签7、ehc
阅读更多...
SpringBoot基于注解实现数据库字段回填的完整方案

SpringBoot基于注解实现数据库字段回填的完整方案

《SpringBoot基于注解实现数据库字段回填的完整方案》这篇文章主要为大家详细介绍了SpringBoot如何基于注解实现数据库字段回填的相关方法,文中的示例代码讲解详细,感兴趣的小伙伴可以了解... 目录数据库表pom.XMLRelationFieldRelationFieldMapping基础的一些代
阅读更多...
一篇文章彻底搞懂macOS如何决定java环境

一篇文章彻底搞懂macOS如何决定java环境

《一篇文章彻底搞懂macOS如何决定java环境》MacOS作为一个功能强大的操作系统,为开发者提供了丰富的开发工具和框架,下面：本文主要介绍macOS如何决定java环境的相关资料,文中通过代码... 目录方法一：使用 which命令方法二：使用 Java_home工具（Apple 官方推荐）那问题来了，
阅读更多...
Java HashMap的底层实现原理深度解析

Java HashMap的底层实现原理深度解析

《JavaHashMap的底层实现原理深度解析》HashMap基于数组+链表+红黑树结构,通过哈希算法和扩容机制优化性能,负载因子与树化阈值平衡效率,是Java开发必备的高效数据结构,本文给大家介绍... 目录一、概述：HashMap的宏观结构二、核心数据结构解析1. 数组（桶数组）2. 链表节点（Node
阅读更多...
Java AOP面向切面编程的概念和实现方式

Java AOP面向切面编程的概念和实现方式

《JavaAOP面向切面编程的概念和实现方式》AOP是面向切面编程,通过动态代理将横切关注点（如日志、事务）与核心业务逻辑分离,提升代码复用性和可维护性,本文给大家介绍JavaAOP面向切面编程的概... 目录一、AOP 是什么？二、AOP 的核心概念与实现方式核心概念实现方式三、Spring AOP 的关
阅读更多...
详解SpringBoot+Ehcache使用示例

详解SpringBoot+Ehcache使用示例

《详解SpringBoot+Ehcache使用示例》本文介绍了SpringBoot中配置Ehcache、自定义get/set方式,并实际使用缓存的过程,文中通过示例代码介绍的非常详细,对大家的学习或者... 目录摘要概念内存与磁盘持久化存储：配置灵活性：编码示例引入依赖：配置ehcache.XML文件：配置
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2