SpringBoot EhCaching

EhCache

EhCache ist ein auf Java basierendes Open-Source-Caching, das zur Verbesserung der Leistung verwendet wird. Die aktuelle Version von Ehcache ist 3 . Es bietet JSR-107 Implementierung des Cache-Managers. Wir können es direkt verwenden.

Funktionen von EhCache

esschnell,leicht, erweiterbarundflexibel。 es uns ermöglicht,serialisierbarundObjekte bietet wie LRU, LFU, FIFO und andereEntfernungspolitik des Caches. speichert er den Cache inSpeicherundFestplatte(SSD) gespeichert. basiert auf SLF4J zu protokollieren. ist vollständig implementiert JSR-107 und Jcache unterstützt es, über JGroups oder JMS und RMI distribuierte Cache zu verwalten. verwendetflüssige AbfrageSprachedistribuierte Suche durchzuführen.

EhCache-Muster

Der Cache verwendet verschiedene Zugriffsmuster. EhCache verwendet die folgenden Muster:

Cache-aside Cache-als-SoR (System-von-record) Read-durch Write-durch Write-behind

Cache-aside

在 ErsatzcacheIm Muster wird zunächst die Anwendung den Cache abfragen. Wenn Daten gefunden werden, wird direkt auf diese zugegriffen. Im umgekehrten Fall werden Daten aus dem SoR abgerufen, in den Cache gespeichert und dann zurückgegeben.

Cache-als-SoR

cache-als-SoR Modus stellt die Lese- und Schreiboperationen des SoR auf dem Cache dar. Es verringert die Verantwortung der Anwendung. Es verwendet eine Kombination aus Lese- und Schreibmodi, einschließlich Direkt lesen, direkt schreibenund nachschreiben. Es verringert die Schwierigkeit der Anwendung. Es ermöglicht dem Cache, das Blitzproblem zu lösen

Read-durch

Read-durchModus auch den Cache kopiert-vorbehalten, wenn der Lesemodus verwendet wird. Der Unterschied zwischen dem Lesemodus und dem Cachepreservationmodus liegt darin, dass der Lesemodus CacheEntryFactory Schnittstelle. Es leitet die Cache, wie es Objekte aus dem Cache liest, an. Es ist am besten, den EhCache-Beispiel als SelfPopulatingCache Beispiel.

Write-durch

Write-durchModus kann auch eine Reservecache-Moduskopie während des Schreibens von Daten in den Cache erstellen. Der Unterschied zwischen dem Direktschreibmodus und dem Reservecache-Modus liegt darin, dass der Direktschreibmodus CacheWriter Schnittstelle. Es konfiguriert den Cache für den Direktschreib- und Nachschreibmodus. Es schreibt die Daten im selben Ausführungsthread in den SoR.

Write-behind

Write-behindModus anders als die anderen drei Modi. In konfigurierbaren Verzögerungendanach ändert es die Cache-Einträge. Die Verzögerung kann in der Form von Sekunden, Minuten, ein Tag, eine Woche,oder sehr lange. Gleichzeitig wird die Daten in die Warteschlange eingereiht, um sie später im selben Ausführungsthread zu schreiben.

Daten schreiben, die nach dem Schreibmodus erfolgen, liegt außerhalb des Transaktionsbereichs. Dies bedeutet, dass es eine neue Transaktion erstellt, um Daten im SoR abzuschließen, die von der Haupttransaktion unterschiedlich sind.

EhCaching Storage Layer

EhCache ermöglicht es uns, verschiedene Datenstorage-Bereiche zu verwenden, wie z.B. Heap, Festplatte und Cluster. Wir können einen mehrstufigen Cachespeicher (mit mehreren Speicherbereichen) konfigurieren. Es kann so eingerichtet werden Schicht.

Diese Schichten sind in Ordnung organisiert. Die unterste ist Genehmigungsschichtund eine andere Schicht ist Cacheschicht. Auch bekannt als nearer oder near cache. Der Cacheschicht kann mehrere Speicherbereiche haben. Die heißesten Daten bleiben in der Cacheschicht, weil sie schneller als die genehmigte Schicht ist. Im Vergleich zur Cacheschicht bleiben andere Daten in der Genehmigungsschicht, langsamer aber reicher.

Die von EhCache unterstützten Datenspeichertypen sind Vier:

On-Heap Store Off-Heap Store Disk Store Clustered Store

On-Heap Store

Es speichert Cache-Einträge im Java-Heap-Speicher. Es teilt den Speicher mit der Java-Anwendung. Es ist schnell, weil es den Heap verwendet, aber der Speicherplatz ist begrenzt. Der Müllsammelroboter scannt auch den auf dem Heap gespeicherten Speicher.

Off-Heap Store

Es verwendet den Hauptwerkzeugkasten (RAM), um Cache-Einträge zu speichern. Der Müllsammelroboter scannt ihn nicht. Es ist langsamer als der auf dem Heap gespeicherte Speicher, weil die Cache-Einträge vor ihrer Verwendung in den auf dem Heap gespeicherten Speicher verschoben werden. Seine Größe ist begrenzt.

Disk Store

Es verwendet Festplatten, um Cache-Einträge zu speichern. Es ist viel langsamer als der auf RAM basierende Speicher (Speichern oben und Speichern unten). Wenn der Festplatten-Speichermodus verwendet wird, ist es am besten, einen dedizierten Festplatten zu verwenden.

Clustered Store

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

上图显示了

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

配置EhCache

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

EhCache示例

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

Schritte1: 打开 Spring Initializr https://start.spring.io/。

Schritte2: 选择Spring Boot版本 2.3.0 M2 。

Schritte3: 提供 Group名称。我们提供了组名 com.w3codebox。

Schritte4: 提供 Artifact。我们提供了Artifact spring-boot-ehcache-example。

Schritte5: 添加 Spring Web 依赖项。

Schritte6: 单击 Generate (生成)按钮。当我们单击"生成"按钮时，它将与应用程序相关的所有规范包装到一个 Jar 文件中，并将其下载到本地系统。

Schritte7: 提取 jar文件。

Schritte8: 复制文件夹并将其粘贴到STS工作区中。

第9步骤: 导入项目。

文件->导入->现有 Maven 项目->下一步->浏览->选择文件夹spring-boot-ehcache-example->选择文件夹->完成

导入项目需要时间。

Schritte10: 从 Maven 存储库 https://mvnrepository.com/并将其粘贴到 pom.xml中Datei.

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

Beachten Sie: 请勿使用包net.sf.ehcache的ehcache。

pom.xml

Beispiel

<?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.w3codebox</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>

Jetzt müssen wir konfigurieren ehcache.xml Datei.

Schritte11: Öffnen application.properties Datei und verwenden Sie die folgenden Eigenschaften, um EhCache zu konfigurieren.

application.properties

Beispiel

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

Schritte12: Öffnen SpringBootEhcacheExampleApplication.java Datei und verwenden Sie die Annotation @EnableCaching Aktivieren Sie den Cache.

SpringBootEhcacheExampleApplication.java

Beispiel

package　com.w3codebox;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
@SpringBootApplication
//Aktivieren Sie die Cache-Verwaltungsfunktion
@EnableCaching
public class SpringBootEhcacheExampleApplication　
{
　　　　public static void main(String[] args)　
　　　　{
　　　　　　　　SpringApplication.run(SpringBootEhcacheExampleApplication.class, args);
　　　　}
}

Beachten Sie: Wenn wir nicht die Annotation @EnableCaching in der Hauptanwendungdatei verwenden möchten, können wir eine separate CacheConfig-Klasse erstellen und die Annotationen für den Aufruf annotieren.

Beispiel

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

Schritte13: Erstellen Sie eine Klasse. Wir haben bereits in dem Paket com.w3codebox Erstellte einen Namen Klasse Student. Führen Sie im Klassifizierer folgende Aktionen aus:

Erstellen Sie fünf Variablenid, name, gender,und erstellenVerwenden Sie Constructor
Rechtsklick auf die Datei->Quelle->Verwenden Sie das Feld, um den Builder zu erstellen->Alles auswählen->生成 erstellenGetters and Setters。
Rechtsklick auf die Datei->Quelle->erstellen Getter und Setter->Alles auswählen->生成 erstellen toString() Rechtsklick auf die Datei->Quelle->erstellen toString()->生成

完成上述所有步骤后，类如下所示。

Student.java

Beispiel

package　com.w3codebox;
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　+　"]";
　　　　}
}

Schritte14: 创建用于管理学生的服务类。我们已经创建了名称为 StudentManager的服务类。 在本课程中，我们完成了以下操作:

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

StudentManager.java

Beispiel

StudentManager.java
package　com.w3codebox;
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("从缓存获取学生数据");
　　　　　　　　return　student.get(id);
　　　　}
}

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

第15步骤: 在 src/main/resources 文件夹中缓存名为 ehcache.xml 的配置文件。

ehcahe.xml

Beispiel

<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>

Jetzt haben wir alle erforderlichen Dateien erstellt. Nachdem alle Dateien erstellt wurden, sieht der Projektverzeichnis wie folgt aus:

Lassen Sie uns die Anwendung ausführen.

Schritte16: Öffnen SpringBootEhcacheExampleApplication.java Datei und als Java-Anwendung.

Es zeigt die folgende Ausgabe:

Beispiel

Students aus dem Cache holen
[id=100, name=Alex, Geschlecht=Männlich, Stadt=Berlin]
[id=101, name=Tony, Geschlecht=Männlich, Stadt=Mexiko]
[id=102, name=Andrew, Geschlecht=Männlich, Stadt=Chicago]
[id=103, name=Alexa, Geschlecht=Weiblich, Stadt=Brüssel]
[id=104, name=Maria, Geschlecht=Weiblich, Stadt=Houston]

SpringBoot-Cache-Provider

SpringBoot-Tutorial

SpringBoot EhCaching

EhCache

Funktionen von EhCache

EhCache-Muster

Cache-aside

Cache-als-SoR

Read-durch

Write-durch

Write-behind

EhCaching Storage Layer

On-Heap Store

Off-Heap Store

Disk Store

Clustered Store

配置EhCache

EhCache示例