pring整合Ehcache管理缓存

最新推荐文章于 2023-07-04 11:24:57 发布
最新推荐文章于 2023-07-04 11:24:57 发布
阅读量308 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013089369/article/details/76535858
版权

Spring整合Ehcache管理缓存

前言

Ehcache 是一个成熟的缓存框架，你可以直接使用它来管理你的缓存。
Spring 提供了对缓存功能的抽象：即允许绑定不同的缓存解决方案（如Ehcache），但本身不直接提供缓存功能的实现。它支持注解方式使用缓存，非常方便。
本文先通过Ehcache独立应用的范例来介绍它的基本使用方法，然后再介绍与Spring整合的方法。

概述

Ehcache是什么？
EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点。它是Hibernate中的默认缓存框架。
Ehcache已经发布了3.1版本。但是本文的讲解基于2.10.2版本。
为什么不使用最新版呢？因为Spring4还不能直接整合Ehcache 3.x。虽然可以通过JCache间接整合，Ehcache也支持JCache，但是个人觉得不是很方便。

安装

Ehcache
如果你的项目使用maven管理，添加以下依赖到你的pom.xml中。

<dependency>
  <groupId>net.sf.ehcache</groupId>
  <artifactId>ehcache</artifactId>
  <version>2.10.2</version>
  <type>pom</type>
</dependency>

如果你的项目不使用maven管理，请在 Ehcache官网下载地址 下载jar包。

Spring
如果你的项目使用maven管理，添加以下依赖到你的pom.xml中。
spring-context-support这个jar包中含有Spring对于缓存功能的抽象封装接口。

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context-support</artifactId>
  <version>4.1.4.RELEASE</version>
</dependency>

Ehcache的使用

HelloWorld范例

接触一种技术最快最直接的途径总是一个Hello World例子，毕竟动手实践印象更深刻，不是吗？

(1) 在classpath下添加ehcache.xml
添加一个名为helloworld的缓存。

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">

  <!-- 磁盘缓存位置 -->
  <diskStore path="java.io.tmpdir/ehcache"/>

  <!-- 默认缓存 -->
  <defaultCache
          maxEntriesLocalHeap="10000"
          eternal="false"
          timeToIdleSeconds="120"
          timeToLiveSeconds="120"
          maxEntriesLocalDisk="10000000"
          diskExpiryThreadIntervalSeconds="120"
          memoryStoreEvictionPolicy="LRU"/>

  <!-- helloworld缓存 -->
  <cache name="helloworld"
         maxElementsInMemory="1000"
         eternal="false"
         timeToIdleSeconds="5"
         timeToLiveSeconds="5"
         overflowToDisk="false"
         memoryStoreEvictionPolicy="LRU"/>
</ehcache>

(2) EhcacheDemo.java
Ehcache会自动加载classpath根目录下名为ehcache.xml文件。
EhcacheDemo的工作步骤如下：
在EhcacheDemo中，我们引用ehcache.xml声明的名为helloworld的缓存来创建Cache对象；
然后我们用一个键值对来实例化Element对象；
将Element对象添加到Cache；
然后用Cache的get方法获取Element对象。

public class EhcacheDemo {
    public static void main(String[] args) throws Exception {
        // Create a cache manager
        final CacheManager cacheManager = new CacheManager();

        // create the cache called "helloworld"
        final Cache cache = cacheManager.getCache("helloworld");

        // create a key to map the data to
        final String key = "greeting";

        // Create a data element
        final Element putGreeting = new Element(key, "Hello, World!");

        // Put the element into the data store
        cache.put(putGreeting);

        // Retrieve the data element
        final Element getGreeting = cache.get(key);

        // Print the value
        System.out.println(getGreeting.getObjectValue());
    }
}

输出

Hello, World!

Ehcache基本操作

Element、Cache、CacheManager是Ehcache最重要的API。

  • Element：缓存的元素，它维护着一个键值对。
  • Cache：它是Ehcache的核心类，它有多个Element，并被CacheManager管理。它实现了对缓存的逻辑行为。

  • CacheManager：Cache的容器对象，并管理着Cache的生命周期。

    创建CacheManager

    下面的代码列举了创建CacheManager的五种方式。
    使用静态方法create()会以默认配置来创建单例的CacheManager实例。
    newInstance()方法是一个工厂方法，以默认配置创建一个新的CacheManager实例。
    此外，newInstance()还有几个重载函数，分别可以通过传入String、URL、InputStream参数来加载配置文件，然后创建CacheManager实例。

// 使用Ehcache默认配置获取单例的CacheManager实例
CacheManager.create();
String[] cacheNames = CacheManager.getInstance().getCacheNames();

// 使用Ehcache默认配置新建一个CacheManager实例
CacheManager.newInstance();
String[] cacheNames = manager.getCacheNames();

// 使用不同的配置文件分别创建一个CacheManager实例
CacheManager manager1 = CacheManager.newInstance("src/config/ehcache1.xml");
CacheManager manager2 = CacheManager.newInstance("src/config/ehcache2.xml");
String[] cacheNamesForManager1 = manager1.getCacheNames();
String[] cacheNamesForManager2 = manager2.getCacheNames();

// 基于classpath下的配置文件创建CacheManager实例
URL url = getClass().getResource("/anotherconfigurationname.xml");
CacheManager manager = CacheManager.newInstance(url);

// 基于文件流得到配置文件，并创建CacheManager实例
InputStream fis = new FileInputStream(new File
("src/config/ehcache.xml").getAbsolutePath());
try {
 CacheManager manager = CacheManager.newInstance(fis);
} finally {
 fis.close();
}

添加缓存

需要强调一点，Cache对象在用addCache方法添加到CacheManager之前，是无效的。
使用CacheManager的addCache方法可以根据缓存名将ehcache.xml中声明的cache添加到容器中；它也可以直接将Cache对象添加到缓存容器中。
Cache有多个构造函数，提供了不同方式去加载缓存的配置参数。
有时候，你可能需要使用API来动态的添加缓存，下面的例子就提供了这样的范例。

// 除了可以使用xml文件中配置的缓存，你也可以使用API动态增删缓存
// 添加缓存
manager.addCache(cacheName);

// 使用默认配置添加缓存
CacheManager singletonManager = CacheManager.create();
singletonManager.addCache("testCache");
Cache test = singletonManager.getCache("testCache");

// 使用自定义配置添加缓存，注意缓存未添加进CacheManager之前并不可用
CacheManager singletonManager = CacheManager.create();
Cache memoryOnlyCache = new Cache("testCache", 5000, false, false, 5, 2);
singletonManager.addCache(memoryOnlyCache);
Cache test = singletonManager.getCache("testCache");

// 使用特定的配置添加缓存
CacheManager manager = CacheManager.create();
Cache testCache = new Cache(
 new CacheConfiguration("testCache", maxEntriesLocalHeap)
 .memoryStoreEvictionPolicy(MemoryStoreEvictionPolicy.LFU)
 .eternal(false)
 .timeToLiveSeconds(60)
 .timeToIdleSeconds(30)
 .diskExpiryThreadIntervalSeconds(0)
 .persistence(new PersistenceConfiguration().strategy(Strategy.LOCALTEMPSWAP)));
 manager.addCache(testCache);

删除缓存

删除缓存比较简单，你只需要将指定的缓存名传入removeCache方法即可。

CacheManager singletonManager = CacheManager.create();
singletonManager.removeCache("sampleCache1");

实现基本缓存操作

Cache最重要的两个方法就是put和get，分别用来添加Element和获取Element。
Cache还提供了一系列的get、set方法来设置或获取缓存参数，这里不一一列举，更多API操作可参考官方API开发手册。

/**
 * 测试：使用默认配置或使用指定配置来创建CacheManager
 *
 * @author victor zhang
 */
public class CacheOperationTest {
    private final Logger log = LoggerFactory.getLogger(CacheOperationTest.class);

    /**
     * 使用Ehcache默认配置(classpath下的ehcache.xml)获取单例的CacheManager实例
     */
    @Test
    public void operation() {
        CacheManager manager = CacheManager.newInstance("src/test/resources/ehcache/ehcache.xml");

        // 获得Cache的引用
        Cache cache = manager.getCache("userCache");

        // 将一个Element添加到Cache
        cache.put(new Element("key1", "value1"));

        // 获取Element，Element类支持序列化，所以下面两种方法都可以用
        Element element1 = cache.get("key1");
        // 获取非序列化的值
        log.debug("key:{}, value:{}", element1.getObjectKey(), element1.getObjectValue());
        // 获取序列化的值
        log.debug("key:{}, value:{}", element1.getKey(), element1.getValue());

        // 更新Cache中的Element
        cache.put(new Element("key1", "value2"));
        Element element2 = cache.get("key1");
        log.debug("key:{}, value:{}", element2.getObjectKey(), element2.getObjectValue());

        // 获取Cache的元素数
        log.debug("cache size:{}", cache.getSize());

        // 获取MemoryStore的元素数
        log.debug("MemoryStoreSize:{}", cache.getMemoryStoreSize());

        // 获取DiskStore的元素数
        log.debug("DiskStoreSize:{}", cache.getDiskStoreSize());

        // 移除Element
        cache.remove("key1");
        log.debug("cache size:{}", cache.getSize());

        // 关闭当前CacheManager对象
        manager.shutdown();

        // 关闭CacheManager单例实例
        CacheManager.getInstance().shutdown();
    }
}

缓存配置

Ehcache支持通过xml文件和API两种方式进行配置。

xml方式

Ehcache的CacheManager构造函数或工厂方法被调用时，会默认加载classpath下名为ehcache.xml的配置文件。如果加载失败，会加载Ehcache jar包中的ehcache-failsafe.xml文件，这个文件中含有简单的默认配置。
ehcache.xml配置参数说明：

  • name：缓存名称。
  • maxElementsInMemory：缓存最大个数。
  • eternal：缓存中对象是否为永久的，如果是，超时设置将被忽略，对象从不过期。
  • timeToIdleSeconds：置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
  • timeToLiveSeconds：缓存数据的生存时间（TTL），也就是一个元素从构建到消亡的最大时间间隔值，这只能在元素不是永久驻留时有效，如果该值是0就意味着元素可以停顿无穷长的时间。
  • maxEntriesLocalDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。
  • overflowToDisk：内存不足时，是否启用磁盘缓存。
  • diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
  • maxElementsOnDisk：硬盘最大缓存个数。
  • diskPersistent：是否在VM重启时存储硬盘的缓存数据。默认值是false。
  • diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
  • memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
  • clearOnFlush：内存数量最大时是否清除。

ehcache.xml的一个范例

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">

  <!-- 磁盘缓存位置 -->
  <diskStore path="java.io.tmpdir/ehcache"/>

  <!-- 默认缓存 -->
  <defaultCache
          maxEntriesLocalHeap="10000"
          eternal="false"
          timeToIdleSeconds="120"
          timeToLiveSeconds="120"
          maxEntriesLocalDisk="10000000"
          diskExpiryThreadIntervalSeconds="120"
          memoryStoreEvictionPolicy="LRU">
    <persistence strategy="localTempSwap"/>
  </defaultCache>

  <cache name="userCache"
         maxElementsInMemory="1000"
         eternal="false"
         timeToIdleSeconds="3"
         timeToLiveSeconds="3"
         maxEntriesLocalDisk="10000000"
         overflowToDisk="false"
         memoryStoreEvictionPolicy="LRU"/>
</ehcache>

API方式

xml配置的参数也可以直接通过编程方式来动态的进行配置（dynamicConfig没有设为false）。

Cache cache = manager.getCache("sampleCache"); 
CacheConfiguration config = cache.getCacheConfiguration(); 
config.setTimeToIdleSeconds(60); 
config.setTimeToLiveSeconds(120); 
config.setmaxEntriesLocalHeap(10000); 
config.setmaxEntriesLocalDisk(1000000);

也可以通过disableDynamicFeatures()方式关闭动态配置开关。配置以后你将无法再以编程方式配置参数。

Cache cache = manager.getCache("sampleCache"); 
cache.disableDynamicFeatures();

Spring整合Ehcache

Spring3.1开始添加了对缓存的支持。和事务功能的支持方式类似，缓存抽象允许底层使用不同的缓存解决方案来进行整合。
Spring4.1开始支持JSR-107注解。
注：我本人使用的Spring版本为4.1.4.RELEASE，目前Spring版本仅支持Ehcache2.5以上版本，但不支持Ehcache3。

绑定Ehcache

org.springframework.cache.ehcache.EhCacheManagerFactoryBean这个类的作用是加载Ehcache配置文件。
org.springframework.cache.ehcache.EhCacheCacheManager这个类的作用是支持net.sf.ehcache.CacheManager。

spring-ehcache.xml的配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:cache="http://www.springframework.org/schema/cache"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/cache
        http://www.springframework.org/schema/cache/spring-cache-3.2.xsd">

  <description>ehcache缓存配置管理文件</description>

  <bean id="ehcache" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
    <property name="configLocation" value="classpath:ehcache/ehcache.xml"/>
  </bean>

  <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager">
    <property name="cacheManager" ref="ehcache"/>
  </bean>

  <!-- 启用缓存注解开关 -->
  <cache:annotation-driven cache-manager="cacheManager"/>
</beans>

使用Spring的缓存注解

开启注解

Spring为缓存功能提供了注解功能，但是你必须启动注解。
你有两个选择：

(1) 在xml中声明
像上一节spring-ehcache.xml中的做法一样，使用<cache:annotation-driven/>

<cache:annotation-driven cache-manager="cacheManager"/>

(2) 使用标记注解
你也可以通过对一个类进行注解修饰的方式在这个类中使用缓存注解。
范例如下：

@Configuration
@EnableCaching
public class AppConfig {
}

注解基本使用方法

Spring对缓存的支持类似于对事务的支持。
首先使用注解标记方法，相当于定义了切点，然后使用Aop技术在这个方法的调用前、调用后获取方法的入参和返回值，进而实现了缓存的逻辑。
下面三个注解都是方法级别：

@Cacheable

表明所修饰的方法是可以缓存的：当第一次调用这个方法时，它的结果会被缓存下来，在缓存的有效时间内，以后访问这个方法都直接返回缓存结果，不再执行方法中的代码段。
这个注解可以用condition属性来设置条件，如果不满足条件，就不使用缓存能力，直接执行方法。
可以使用key属性来指定key的生成规则。

@CachePut

与@Cacheable不同，@CachePut不仅会缓存方法的结果，还会执行方法的代码段。
它支持的属性和用法都与@Cacheable一致。

@CacheEvict

与@Cacheable功能相反，@CacheEvict表明所修饰的方法是用来删除失效或无用的缓存数据。
下面是@Cacheable、@CacheEvict和@CachePut基本使用方法的一个集中展示：

@Service
public class UserService {
    // @Cacheable可以设置多个缓存，形式如：@Cacheable({"books", "isbns"})
    @Cacheable({"users"})
    public User findUser(User user) {
        return findUserInDB(user.getId());
    }

    @Cacheable(value = "users", condition = "#user.getId() <= 2")
    public User findUserInLimit(User user) {
        return findUserInDB(user.getId());
    }

    @CachePut(value = "users", key = "#user.getId()")
    public void updateUser(User user) {
        updateUserInDB(user);
    }

    @CacheEvict(value = "users")
    public void removeUser(User user) {
        removeUserInDB(user.getId());
    }

    @CacheEvict(value = "users", allEntries = true)
    public void clear() {
        removeAllInDB();
    }
}

@Caching

如果需要使用同一个缓存注解（@Cacheable、@CacheEvict或@CachePut）多次修饰一个方法，就需要用到@Caching。

@Caching(evict = { @CacheEvict("primary"), @CacheEvict(cacheNames="secondary", key="#p0") })
public Book importBooks(String deposit, Date date)

@CacheConfig

与前面的缓存注解不同，这是一个类级别的注解。
如果类的所有操作都是缓存操作，你可以使用@CacheConfig来指定类，省去一些配置。

@CacheConfig("books")
public class BookRepositoryImpl implements BookRepository {
    @Cacheable
    public Book findBook(ISBN isbn) {...}
}
普雅雷蒙达
关注
Spring整合Ehcache缓存的配置及使用
小小渔夫
03-28 1274
前言 　　在java项目广泛的使用中。它是一个开源的、设计于提高在数据从RDBMS中取出来的高花费、高延迟采取的一种缓存方案。 正因为Ehcache具有健壮性（基于java开发）、被认证（具有apache 2.0 license）、充满特色（稍后会详细介绍）， 所以被用于大型复杂分布式web application的各个节点中。 特点 1、 够快 　　Ehcache的发行有一段时长了，经...
hibernate整合Ehcache 实现二级缓存
Soul717的博客
10-31 1883
一.hibernate缓存 有一级缓存、二级缓存。 目的是为了减少对数据库的访问次数，提升程序执行效率！ 1 一级缓存 session Hibernate默认是开启一级缓存的,是基于Session的缓存，缓存内容只在当前session有效，session关闭，缓存内容失效！ 特点： 作用范围较小！ 缓存的事件短。 缓存效果不明显。 2 二级缓存 (可拔插式,可开可不开) hibernate...
Spring整合Ehcache管理缓存
weixin_33711647的博客
10-19 305
前言 Ehcache 是一个成熟的缓存框架，你可以直接使用它来管理你的缓存。 Spring 提供了对缓存功能的抽象：即允许绑定不同的缓存解决方案（如Ehcache），但本身不直接提供缓存功能的实现。它支持注解方式使用缓存，非常方便。 本文先通过Ehcache独立应用的范例来介绍它的基本使用方法，然后再介绍与Spring整合的方法。 概述 Ehcache是什么？ EhCache 是一个纯Java的进...
Spring整合EhCache缓存管理
weixin_42184707的博客
05-14 2225
一、ehcache简单介绍    EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，Ehcache是一种广泛使用的开 源Java分布式缓存。主要面向通用缓存,Java EE和轻量级容器。它具有内存和磁盘存储，缓存加载器,缓存扩展，缓存异常处理程序等特点。优点： 1. 快速 、简单 、拥有多种缓存策略。 2. 缓存数据有两级：内存和磁盘，因此无需担心容量问题 3. 缓存数据会在...
SpringBoot中使用EhCacheManager
热门推荐
just4you的博客
03-11 1万+
背景 在原有的项目中的一个工具类中，用到了cacheManager。 import net.sf.ehcache.CacheManager; public class CacheHelper { private static CacheManager cacheManager = ((CacheManager) SpringContextTools.getBean(&quot;ehCacheMana...
Spring Boot 中的 EhCacheCacheManager 是什么，原理，如何使用
徐师兄的博客
06-29 1582
EhCacheCacheManager是Spring Boot提供的一种缓存管理器，它是基于Ehcache实现的。Ehcache是一个Java缓存框架，它提供了快速、可靠的缓存服务，具有高度可配置性和可扩展性。EhCacheCacheManager提供了一种在Spring Boot应用程序中配置和管理Ehcache缓存的方法。在本文中，我们学习了Spring Boot中的EhCacheCacheManager是什么，它的原理以及如何使用它来管理Ehcache缓存。
在Spring上集成使用ehcache缓存框架以及实现集群缓存同步
禤永豪
06-29 2688
周一第一天实习，老大给了个任务给我，让我看看j2cache两级缓存框架，然后我在开源中国了解到，开源中国目前就用到这个缓存框架，主要是为了减少redis的负荷，这个两级缓存框架使用了ehcache作为一级L1缓存，使用redis作为二级L2缓存，了解到这个之后，我果断学习了一波ehcache在spring的使用。一、依赖jar包这里使用maven：<properties> <spring.v
Mybatis整合ehcache，Redis实现二级缓存
trasewell的博客
09-25 168
目录： mybatis整合ehcache 1.pom依赖 2.ehcache.xml 3.applicationContext-mybatis.xml(mybatis.cfg.xml)中去开启二级缓存 4.需要在xxxMapper.xml中配置 5.对比缓存单个与缓存多个的区别 mybatis整合redis 1.pom依赖 redis 2.redis.properties 3.applicatio...
mybatis整合ehcache, redis实现缓存(二级缓存)
程 序 猿的博客
09-25 216
mybatis整合ehcache, redis作为缓存(二级缓存) 文章目录mybatis整合ehcache, redis作为缓存(二级缓存)前言Mybatis集成ehcacheMybatis集成redis 前言 为什么需要缓存 拉高程序的性能 什么样的数据需要缓存 很少被修改或根本不改的数据 业务场景比如：耗时较高的统计分析sql、电话账单查询sql等 ehcache是什么 Ehca...
springboot整合ehcache实现二级缓存踩坑
a20100997的博客
06-21 1322
springboot整合redis+ehcache实现二级缓存
Ehcache（二次封装，每个元素可自定义过期时间）
weixin_39651356的博客
08-29 2676
Ehcache工具简单使用，封装，每个元素可自定义过期时间
Spring整合EhCache详解
weixin_30902675的博客
09-21 188
一、EhCache介绍 EhCache 是一个纯Java的进程内缓存框架，具有快速、精干等特点，是Hibernate中默认的CacheProvider。Ehcache是一种广泛使用的开 源Java分布式缓存。主要面向通用缓存,Java EE和轻量级容器。它具有内存和磁盘存储，缓存加载器,缓存扩展，缓存异常处理程序，一个gzip缓存servlet过滤器，支持REST和SOAP api等特点。 优...
Ehcache封装的工具类
11-28 6185
最近公司公司项目在框架上用到了Ehcache缓存，关于更多Ehcache详细的内容，请参考一下两个系列的博客，讲的都很好。 Ehcache详细解读 Ehcache系列博客 有了上面的两个系列的博客，更多有关于Ehcache细节的地方，就不在这篇博客中展示了，主要是跟大家分享一下，底层框架中封装关于Ehcache的工具类  CacheContainer类  缓存容器类，用来创建Cache对象，并
EhCache
猎户星座
10-24 1137
一、简介 Ehcache是一个用Java实现的使用简单，高速，实现线程安全的缓存管理类库，ehcache提供了用内存，磁盘文件存储，以及分布式存储方式等多种灵活的cache管理方案。同时ehcache作为开放源代码项目，采用限制比较宽松的Apache License V2.0作为授权方式，被广泛地用于Hibernate, Spring，Cocoon等其他开源系统。Ehcache 从 Hibe...
ehcache使用详解
最新发布
xiaonign的博客
07-04 957
ehcache使用详解
玩转EhCache之最简单的缓存框架
weixin_33829657的博客
05-02 518
一、简介 Ehcache是一个用Java实现的使用简单，高速，实现线程安全的缓存管理类库，ehcache提供了用内存，磁盘文件存储，以及分布式存储方式等多种灵活的cache管理方案。同时ehcache作为开放源代码项目，采用限制比较宽松的Apache License V2.0作为授权方式，被广泛地用于Hi...
EhCache缓存学习
04-18 3989
在看hibernate的官方文档时，看到关于缓存的介绍。 hibernate在缓存管理上做的很好，具体使用，本章不做讲解，本篇主要研究EhCache的用法。其中hibernate使用到的缓存提供商列表如下： Cache Provider class Type Cluster Safe Query Cache Supported Hashta
Ehcache缓存回收策略
weixin_34265814的博客
03-23 145
Ehcache缓存 简介 Ehcache是一个用JAVA实现的，使用简单，高速，实现线程安全的缓存管理类库，Ehcache提供了用内存，磁盘文件存储，以及分布式存储方式等多种灵活的Cache管理方案。采用限制比较宽松的Apache License v2.0作为授权方式，被广泛地用于Hibernate,Spring,Cocoon等其他开源框架。 缓存回收就是当缓存满了的时候，Ehcache会根...
SpringBoot整合EhCache实现缓存详细教程
EhCache是一个广泛使用的开源缓存框架，它支持内存和磁盘两级存储，确保了即使在缓存容量有限的情况下也能有效地管理数据。 在Spring Boot中整合EhCache，首先需要理解EhCache的基本概念。EhCache作为一个轻量级的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值