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

目录

• 本地缓存
• 实现方式
• HashMap
• ConcurrentHashMap
• Guava Cache
• Caffeine
• Ehcache
• 实现方式优缺点

本地缓存

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

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

实现方式

本地缓存的代表技术主要有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.devze.com();
        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的分段锁机制，并提供了更多的缓存策略和配置选项。缓存性能接近理编程客栈论最优，属于是Guava Cache的增强版。

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

5.Ehcache：

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

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

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

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