Spring Boot EhCaching

2025年3月17日 | 阅读 7 分钟

EhCache

EhCache 是一个开源的、基于 Java 的缓存，用于提高性能。Ehcache 的当前版本是3。它提供了 JSR-107 缓存管理器的实现。我们可以直接使用它。

EhCache 的特性

它快速、轻量级、可扩展和灵活。
它允许我们执行Serializable 和 Object
它提供缓存驱逐策略，如LRU、LFU、FIFO
它将缓存存储在内存和磁盘 (SSD) 中。
它依赖于 SLF4J 进行日志记录。
它完全实现了 JSR-107 和 Jcache
它支持通过 JGroups 或 JMS 和 RMI 进行分布式缓存。
它使用fluent 查询语言进行分布式搜索。

EhCache 使用模式

缓存使用多种访问模式。EhCache 使用以下几种模式

Cache-aside
Cache-as-SoR (系统记录)
Read-through
Write-through
Write-behind

Cache-aside

在 cache-aside 模式中，首先，应用程序咨询缓存。如果找到数据，则直接返回数据。相反，它从 SoR 获取数据，将其存储到缓存中，然后返回。

Cache-as-SoR

cache-as-SoR 模式表示对缓存的 SoR 读取和写入操作。它降低了应用程序的责任。它使用读写模式的组合，包括read-through、write-through 和 write-behind。它降低了应用程序的难度。它允许缓存解决惊群效应问题

Read-through

read-through 模式在从缓存读取数据时也复制 cache-aside 模式。read-through 和 cache-aside 之间的区别在于 read-through 模式实现了 CacheEntryFactory 接口。它指导缓存如何从缓存读取对象。在使用 read-through 模式时，最好使用 SelfPopulatingCache 的实例包装 EhCache 实例。

Write-through

write-through 模式在将数据写入缓存时也复制 cache-aside 模式。write-through 和 cache-aside 模式之间的区别在于 write-through 模式实现了 CacheWriter 接口。它配置缓存以用于 write-through 和 write-behind 模式。它在同一执行线程中将数据写入 SoR。

Write-behind

write-behind 模式与其他三种模式不同。它在可配置的延迟后修改缓存条目。延迟可能以秒、分钟、天、周或很长时间为单位。同时，它还将数据排队，以便在同一执行线程中的稍后时间写入。

使用 write-behind 模式写入的数据发生在事务范围之外。这意味着它创建一个新事务来提交 SoR 中的数据，该事务与主事务不同。

EhCaching 存储层

EhCache 允许我们使用各种数据存储区域，例如堆、磁盘和集群。我们可以配置多存储缓存（使用多个存储区域）。它可以被安排和管理为层。

层按顺序组织。最底层的层称为权威层，另一层称为缓存层。它也被称为附近或近缓存。缓存层可以有多个存储区域。最热门的数据保存在缓存层中，因为它比权威层更快。其他数据保存在权威层中，权威层速度较慢，但与缓存层相比更丰富。

EhCache 支持四种类型的数据存储

On-Heap Store (堆内存储)
Off-Heap Store (堆外存储)
Disk Store (磁盘存储)
Clustered Store (集群存储)

On-Heap Store (堆内存储)

它将缓存条目存储在 Java 堆内存中。它与 Java 应用程序共享存储空间。它速度很快，因为它使用堆，但存储空间有限。垃圾收集器也会扫描堆内存储。

Off-Heap Store (堆外存储)

它使用主内存 (RAM) 来存储缓存条目。垃圾收集器不会扫描它。它比堆内存储慢，因为缓存条目在使用前会移动到堆内存储。它的大小有限。

Disk Store (磁盘存储)

它使用磁盘来存储缓存条目。它比基于 RAM 的存储（堆内和堆外存储）慢得多。如果您使用的是磁盘存储模式，最好使用专用磁盘。它可以提高吞吐量。

Clustered Store (集群存储)

它将缓存条目存储在远程服务器上。它比堆外存储慢。它可能有一个故障转移服务器，提供高可用性。

以上图表显示

一个应用程序可能有多个缓存管理器。
许多缓存可以由一个缓存管理器处理。
缓存可以使用多个层来存储缓存条目。
EhCache 将最近使用或经常使用的数据放在更快的层（缓存层）中。

配置 EhCache

将 EhCache jar 放在类路径中。
配置 xml 并将其放在类路径中。
创建一个
引用一个缓存。

EhCache 示例

在以下示例中，我们将在应用程序中配置 EhCache。

步骤 1：打开 Spring Initializr https://start.spring.io/。

步骤 2：选择 Spring Boot 版本 2.3.0 M2。

步骤 3：提供 Group 名称。我们提供了 Group 名称 com.javatpoint。

步骤 4：提供 Artifact。我们提供了 Artifact spring-boot-ehcache-example。

步骤 5：添加 Spring Web 依赖项。

步骤 6：单击 Generate 按钮。当我们单击 Generate 按钮时，它将与应用程序相关的所有规范包装到 Jar 文件中并将其下载到本地系统。

步骤 7： 提取 jar 文件。

步骤 8： 复制该文件夹并将其粘贴到 STS 工作区中。

步骤 9： 导入项目。

File -> Import -> Existing Maven Projects -> Next -> Browse -> Select the folder spring-boot-ehcache-example -> Select Folder -> Finish

导入项目需要一些时间。

步骤 10：从 Maven Repository https://mvnrepository.com/ 逐个复制以下依赖项并将其粘贴到 pom.xml 文件中。

spring-boot-starter-cache
ehcache 3
cache API。

注意：请勿使用包 net.sf.ehcache 的 ehcache。

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.0.M2</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.javatpoint</groupId>
<artifactId>spring-boot-ehcache-example</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>spring-boot-ehcache-example</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
<groupId>org.ehcache</groupId>
<artifactId>ehcache</artifactId>
</dependency>
<dependency>
<groupId>javax.cache</groupId>
<artifactId>cache-api</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
<repositories>
<repository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/milestone</url>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/milestone</url>
</pluginRepository>
</pluginRepositories>
</project>

现在，我们需要配置 ehcache.xml 文件。它告诉框架在哪里找到该文件。

步骤 11：打开 application.properties 文件并使用以下属性配置 EhCache。

application.properties

#configuring ehcache.xml
spring.cache.jcache.config=classpath:ehcache.xml

步骤 12：打开 SpringBootEhcacheExampleApplication.java 文件并使用注释 @EnableCaching 启用缓存。

SpringBootEhcacheExampleApplication.java

package com.javatpoint;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
@SpringBootApplication
//enables the cache management capability
@EnableCaching
public class SpringBootEhcacheExampleApplication 
{
public static void main(String[] args) 
{
SpringApplication.run(SpringBootEhcacheExampleApplication.class, args);
}
}

注意：如果我们不想在主应用程序文件中使用注释 @EnableCaching，我们可以创建一个单独的 CacheConfig 类并使用该注释注释该调用。

package com.javatpoint;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Configuration;
@Configuration
//enable caching
@EnableCaching
public class CacheConfig 
{
}

步骤 13：创建一个模型类。我们在包 com.javatpoint 中创建了模型类，名称为 Student。在模型类中执行以下操作

创建五个变量 id、name、gender 和
使用字段生成 Constructor。
右键单击该文件 -> Source -> Generate Constructor using Fields -> Select All -> Generate
生成 Getters and Setters。
右键单击该文件 -> Source -> Generate Getters and Setters -> Select All -> Generate
生成 toString()
右键单击文件 -> Source -> Generate toString() -> Generate

完成以上所有步骤后，模型类如下所示。

Student.java

package com.javatpoint;
public class Student 
{
private int id;
private String name;
private String gender;
private String city;
public Student(int id, String name, String gender, String city) 
{
super();
this.id = id;
this.name = name;
this.gender = gender;
this.city = city;
}
public int getId() 
{
return id;
}
public void setId(int id) 
{
this.id = id;
}
public String getName() 
{
return name;
}
public void setName(String name) 
{
this.name = name;
}
public String getGender() 
{
return gender;
}
public void setGender(String gender) 
{
this.gender = gender;
}
public String getCity() 
{
return city;
}
public void setCity(String city) 
{
this.city = city;
}
@Override
public String toString() 
{
return "Student [id=" + id + ", name=" + name + ", gender=" + gender + ", city=" + city + "]";
}
}  

步骤 14：创建一个管理学生的 Service 类。我们创建了名为 StudentManager 的服务类。在此类中，我们完成了以下操作

使用注释 @Service 注释该类。
创建 HashMap 的一个实例。
在静态块中，我们将学生数据添加到 map 中。
通过使用注释 @Cacheable，我们定义了缓存的名称。所有数据将保存在此缓存中。我们在注释的 key 属性中定义了 id。缓存根据 id 搜索学生。
我们创建了一个方法 getStudentById()，它将 id 解析为参数。它返回学生的 id。

StudentManager.java

StudentManager.java
package com.javatpoint;
import java.util.HashMap;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
@Service
public class StudentManager 
{
static HashMap<Integer, Student> student = new HashMap<>();
static 
{
student.put(1, new Student(100, "Alex", "Male", "Berlin"));
student.put(2, new Student(101, "Tony", "Male", "Maxico"));
student.put(3, new Student(102, "Andrew", "Male", "Chicago"));
student.put(4, new Student(103, "Alexa", "Female", "Brussels"));
student.put(5, new Student(104, "Maria", "Female", "Houston"));
}
@Cacheable(cacheNames="demoCache", key="#id")
public Student getStudentById(Integer id) 
{
System.out.println("Fetching student data from cache");
return student.get(id);
}
}

现在我们需要创建 ehcache.xml 文件。它包含与缓存相关的信息，例如缓存的名称、内存中元素的数量、数据在缓存中的生存时间等。

步骤 15：在 src/main/resources 文件夹中创建一个名为 ehcache.xml 的缓存配置文件。

ehcahe.xml

<config
xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'
xmlns='http://www.ehcache.org/v3'
xmlns:jsr107='http://www.ehcache.org/v3/jsr107'>
<ehcache>
<diskStore path="java.io.tmpdir" />
<defaultCache maxElementsInMemory="2000" 
			eternal="true"
			overflowToDisk="false" 
			timeToLiveSeconds="1200" />
	<cache name="demoCache" 
			maxElementsInMemory="2000"
			eternal="false" 
			overflowToDisk="false" 
			timeToLiveSeconds="10000" />
</ehcache>
</config>

现在我们已经创建了所有必需的文件。创建所有文件后，项目目录如下所示

让我们运行该应用程序。

步骤 16：打开 SpringBootEhcacheExampleApplication.java 文件并将其作为 Java Application 运行。

它显示以下输出

Getting Students from Cache
[id=100, name=Alex, gender=Male, city=Berlin]
[id=101, name=Tony, gender=Male, city=Mexico]
[id=102, name=Andrew, gender=Male, city=Chicago]
[id=103, name=Alexa, gender=Female, city=Brussels]
[id=104, name=Maria, gender=Female, city=Houston]

下载 EhCaching 项目

下一个主题如何运行 Spring Boot 应用程序

我们提供所有技术（如 Java 教程、Android、Java 框架）的教程和面试问题

联系信息

G-13, 2nd Floor, Sec-3, Noida, UP, 201301, India

hr@tpointtech.com

+91-9599086977

关注我们

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Spring Boot 教程

创建项目

项目组件

Tool Suite

Spring Boot AOP

Spring Boot 数据库

Spring Boot 视图

SB 缓存

Spring Boot 其他

Spring Boot - RESTful

Spring 教程

Spring Cloud

Spring 微服务

面试题