Spring Boot Caching

Spring-Framework bietet Cache transparent in Spring-Anwendungen an. In Spring,Cache-AbstraktionIst ein Mechanismus, der es ermöglicht, verschiedene Cache-Methoden konsistent zu verwenden, ohne den Code zu beeinflussen.

Cache-Abstraktion

Das Cache-Abstraktionsmechanismus ist geeignet für Java-Methode. Der Hauptzweck der Verwendung von Cache-Abstraktionen ist es, basierend auf der Information, die im Cache vorhanden istVerringerungAusführungen. Es ist für teure Methoden wie CPU 或 IO-Bindung.

Bei jedem Aufruf einer Methode wird die Abstraktion das Cache-Verhalten auf diese Methode angewendet. Es überprüft, ob die Methode bereits für die angegebenen Parameter ausgeführt wurde.

Wenn ja, wird die tatsächliche Methode nicht ausgeführt und das gecachte Ergebnis wird zurückgegeben.Wenn nein, wird zunächst diese Methode ausgeführt, und das Ergebnis wird gecacht und dem Benutzer zurückgegeben.

Entwickler beachten bei der Verarbeitung von Cache-Abstraktionen zwei Dinge.

Cache-Aufruf: Es identifiziert die Methoden, die gecacht werden sollen. Cache-Konfiguration: Für den Cache und Lesen von Daten eine Reserve-Cache.

Cache

Cache ist ein Teil der暂时的内存(RAM). Es befindet sich zwischen Anwendung und persistenter Datenbank. Es speichert kürzlich verwendete Daten, um so viele Datenbank-Aufrufe wie möglich zu minimieren. Mit anderen Worten, Cache dient dazu, Daten für zukünftige Referenzen zu speichern.

Warum sollte Cache verwendet werden?

Der Hauptgrund für die Verwendung von Cache ist, den Datenzugriff schneller und kostengünstiger zu gestalten. Wenn hochgeforderte Ressourcen mehrmals angefordert werden, ist es für Entwickler oft vorteilhaft, Cache-Ressourcen bereitzustellen, damit sie schnell reagieren können. Der Einsatz von Cache in Anwendungen kann die Leistung der Anwendung verbessern. Der Zugriff auf Daten aus dem Speicher ist schneller als der Zugriff aus der Datenbank. Es verringert die finanziellen und opportunen Kosten.

Welche Daten sollten gecacht werden?

Daten, die nicht oft geändert werden.Häufige Lesen-Aufrufe, deren Abfrageergebnisse mindestens für eine Weile bei jedem Aufruf unverändert bleiben.

Cache-Typen

Es gibtVierDie folgenden sind Cache-Typen:

Cache im SpeicherDatenbank-Caching Webserver-Caching CDN-Cache

Speicher-Cache

Speicher-Cache kann die Leistung der Anwendung verbessern. Dies ist ein häufig verwendetes Gebiet. Memcached und Redis Beispiel für Cache im Speicher. Es speichert Schlüssel-Wert-Paare zwischen Anwendung und Datenbank. Redis ist eineVirtuell, verteiltHochwertiges Cache-Tool, das für Backup- und Wiederherstellungsfunktionen verwendet werden kann. Wir können auch die Cache in verteilten Clustern verwalten.

Datenbank-Caching

Datenbank-Caching ist ein Mechanismus, der durch das Anfordern von Daten (dynamisch) Webseiten erstellt, die auf Datenbanken basieren. aus. Es ist im Kontext von Client, Webanwendungsserver und Datenbank involviert.Schichtenumgebungen verwendet. Durch die Verteilung der Abfragearbeitlast verbessert esSkalierbarkeitundLeistung. Die beliebtesten Datenbank-Caches sind der erste Cache von Hibernate.

Webserver-Caching

Webserver-Caching ist eine Art, Daten zu speichern, umWiederverwendungMechanismus. Zum Beispiel eine Kopie der von einem Webserver bereitgestellten Webseite. Wenn der Benutzer die Seite zum ersten Mal besucht, wird sie zwischengespeichert. Wenn der Benutzer das gleiche Inhalt erneut anfordert, stellt der Cache eine Kopie der Seite bereit. Dies verhindert eine Überlastung des Servers. Webserver-Caching kann die Geschwindigkeit der Seitenübertragung verbessern und die Arbeit, die der Backend-Server erledigen muss, reduzieren.

CDN-Cache

CDN repräsentiertContent Delivery Network. Es ist ein Bestandteil, der in modernen Webanwendungen verwendet wird. DurchKopierenHäufig verwendete Dateien (z.B. HTML-Seiten, Stylesheets), die das Übertragen von Inhalten verbessern können.Cache-Server.

Das ist der Grund, warum CDN immer beliebter wird. CDN entlastet den Quellcode der Anwendung und verbessert die Benutzererfahrung. Es zieht vonCache Edge(näher am Endbenutzer befindlicher Cache-Server) oderExistenzpunkt (PoP)bietet eine lokale Kopie des Inhalts.

Cache und Puffer

Spring Boot Caching Annotations

@EnableCaching

Dies ist eine Annotation auf Klassenebene. Wir können @EnableCaching-Annotation.Es aktiviert das Caching in der Spring Boot-Anwendung mit der org.springframework.cache.annotation im Paket definiert. Es arbeitet mit @Configuration Klassen zusammen verwendet.

Wenn es keine definierte CacheManager-Instanz gibt, wird die automatische Konfiguration CacheManager Es scannt bestimmte Anbieter, wenn es keine findet, dann verwendet es einen HashMap erstellt eine Cache im Speicher.

Beispiel

In den folgenden Beispielen: @EnableCaching Annotierung aktiviert das Caching-Mechanismus.

@SpringBootApplication
@EnableCaching　
public class SpringBootCachingApplication　
{
public static void main(String[] args)　
{
SpringApplication.run(SpringBootCachingApplication.class,　args);
}
}

@CacheConfig

这是一个类级别的注解，提供了与缓存有关的通用设置。它告诉Spring将类的缓存存储在何处。当我们使用注解为类添加注解时，它为该类中定义的任何缓存操作提供了一组默认设置。使用注解，我们不需要多次声明。

Beispiel

在下面的示例中，员工是缓存的名称。

@CacheConfig(cacheNames={"employee"})　
public class UserService
{
//some code
}

@Caching

当我们同时需要两个注解 @CachePut 或 @CacheEvict 时使用同样的方法。换句话说，当我们要使用相同类型的多个注解时使用。

但是 Java不允许为给定声明相同类型的多个注解方法。为避免此问题，我们使用 @Caching 注解。

Beispiel

在下面的示例中，我们使用了注解 @Caching 并将所有 @CacheEvict 注解分组。

@Caching(evict　=　{@CacheEvict("phone_number"),　@CacheEvict(value="directory",　key="#student.id")　})public　String　getAddress(Student　student)　
{
//some code
}

@Cacheable

它是方法级别的注解。它为方法的返回值定义了一个缓存。Spring框架管理方法对注解属性中指定的缓存的请求和响应。@Cacheable批注包含更多选项。例如，我们可以使用 value 或 cacheNames 属性提供缓存名称。

我们还可以指定注解的 key 属性，用于唯一标识缓存中的每个条目。如果未指定密钥，Spring将使用默认机制来创建密钥。

Beispiel

在以下示例中，我们缓存了< cacheStudentInfo，und id 中方法 studentInfo()的返回值是唯一键，用于标识缓存。

@Cacheable(value="cacheStudentInfo",　key="#id")public　List　studentInfo()
{
//some code　
return studentDetails;
}

我们还可以通过使用condition属性在注解中应用条件。当我们在注解中应用条件时，它称为条件缓存。

例如，如果参数名称的长度短于20,dann speichere die folgenden Methoden im Cache.

@Cacheable(value="student",condition="#name.length<20)publicStudentfindStudent(Stringname)
{
//some code
}

@CacheEvict

Es ist eine Methoden-Level-Annotation. Wenn wir alt oder nicht verwendete Daten aus dem Cache löschen möchten, verwenden wir sie. Sie erfordert eine oder mehrere von der Operation betroffene Caches. Wir können auch Schlüssel oder Bedingungen darin angeben. Wenn wir eine breite Cache-Entfernung wünschen, bietet die @CacheEvict Annotation eine Bezeichnung allEntries der Parameter verwendet wird. Es entfernt alle Einträge, anstatt einen Eintrag basierend auf dem Schlüssel zu entfernen.

Ein wichtiger Punkt über die @CacheEvict Annotation ist, dass sie mit void Methoden verwendet werden kann, da diese als Trigger dienen. Sie vermeidet Rückgabewerte. Andererseits erfordert die @Cacheable Annotation einen Rückgabewert, der zum Hinzufügen/Aktualisiere die Daten im Cache. Wir können @CacheEvict Annotation auf die folgenden Arten verwenden:

entferne den gesamten Cache:

@CacheEvict(allEntries=true)

entferneEinträge durch Schlüssel:

@CacheEvict(key="#student.stud_name")

Beispiel

Die folgenden mit Annotations versehenen Methoden aus dem Cache student_data dieser alle Daten löscht.

@CacheEvict(value="student_data",allEntries=true)　//entfernealleEinträge aus dem Cache
publicStringgetNames(Studentstudent)　
{
//some code
}

@CachePut

Es ist eine Methoden-Level-Annotation. Wenn wir möchtenAktualisierenVerwende sie, um den Cache zu speichern, ohne die Ausführung der Methode zu stören. Dies bedeutet, dass diese Methode immer ausgeführt wird und ihr Ergebnis im Cache gespeichert wird. Sie unterstützt die Attribute der @Cacheable Annotation.

Es ist zu beachten, dass @Cacheable und @CachePut Annotations unterschiedliche Verhaltensweisen haben und daher unterschiedlich sind. Der feine Unterschied zwischen @Cacheable und @CachePut Annotations ist @ Cacheable KommentareÜberspringe die Ausführung der Methodewährend @CachePut KommentareFühre diese Methode ausDann wird das Ergebnis in den Cache eingefügt.

Beispiel

Die folgenden Methoden aktualisieren den Cache selbst.

@CachePut(cacheNames="employee",key="#id")　　//aktualisiereCachepublicEmployeeupdateEmp(IDid,EmployeeData数据)
{
//some code
}

Spring Boot缓存依赖项

如果要在Spring Boot应用程序中启用缓存机制，则需要在pom.xml文件中添加缓存依赖项。它启用缓存并配置CacheManager。

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>

Spring Boot缓存示例

我们创建一个Spring Boot应用程序并在其中实现缓存机制。

steps1: 打开Spring Initializr http://start.spring.io 。

steps2: 选择Spring Boot版本 2.3.0.M1。

steps2: 提供群组名称。我们提供了 com.w3codebox。

steps3: 提供工件 ID。我们提供了 spring-boot-cache-example。

steps5: 添加依赖项 Spring Web und Spring Cache抽象。

steps6: 单击 Generate (生成)按钮。当我们单击"生成"按钮时，它将规格包装在 Jar 文件中，并将其下载到本地系统。

steps7: 提取 Jar文件并将其粘贴到STS工作区中。

steps8: 导入 STS中的项目文件夹。

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

导入需要一些时间。

让我们打开 pom.xml 文件，看看我们已经向其中添加了哪些依赖项。

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.M1</version>
　　　　<relativePath/>　<!--　lookup parent from repository　-->
　　</parent>
　　<groupId>com.w3codebox</groupId>
　　<artifactId>spring-boot-cache-example</artifactId>
　　<version>0.0.1-SNAPSHOT</version>
　　<name>spring-boot-cache-example</name>
　　<description>Demo-Projekt für Spring Boot</description>/description>
　　<properties>
　　　　<java.version>1.8</java.version>
　　</properties>
　　<dependencies>
　　　　<dependency>
　　　　　　<groupId>org.springframework.boot</groupId>
　　　　　　<artifactId>spring-boot-starter-cache</artifactId>
　　　　</dependency>
　　　　<dependency>
　　　　　　<groupId>org.springframework.boot</groupId>
　　　　　　<artifactId>spring-boot-starter-web</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>

steps9: open SpringBootCacheExampleApplication.java Datei, indem Sie den @EnableCaching aktiviert den Cache.

SpringBootCacheExampleApplication.java
package com.w3codebox;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
@SpringBootApplication
//Caching aktivieren
@EnableCaching
public class SpringBootCacheExampleApplication　
{
public static void main(String[] args)　
{
SpringApplication.run(SpringBootCacheExampleApplication.class, args);
}
}

steps10: Im Namen com.w3Ordner codebox.model src/main/java Erstellen Sie ein Paket.

steps11: Erstellen Sie ein Paket namens Customer Klassen und definieren Sie den folgenden Inhalt:

definieren Sie dreiaccountno, customername, acounttypeundbalance。>Verwenden Sie den Konstruktor zum GenerierenKonstruktor 。
Rechtsklick auf die Datei->Quelltext->Verwenden Sie das Feld, um den Konstruktor zu generieren->Alles auswählen->Erstellen>ErstellenGetter und Setter.
Rechtsklick auf die Datei->Quelltext->Getter und Setter generieren->Alles auswählen->Erstellen

Customer.java

package com.w3codebox.model;
public class Customer　
{
　　　　private int accountno;
　　　　private String customername;
　　　　private String accounttype;
　　　　private double balance;
　　　　public Customer(int accountno, String customername, String accounttype, double balance)　
　　　　{
　　　　　　　　this.accountno = accountno;
　　　　　　　　this.customername = customername;
　　　　　　　　this.accounttype = accounttype;
　　　　　　　　this.balance = balance;
　　　　}
　　　　public int getAccountno()　
　　　　{
　　　　　　　　return accountno;
　　　　}
　　　　public void setAccountno(int accountno)　
　　　　{
　　　　　　　　this.accountno = accountno;
　　　　}
　　　　public String getCustomername()　
　　　　{
　　　　　　　　return customername;
　　　　}
　　　　public void setCustomername(String customername)　
　　　　{
　　　　　　　　this.customername = customername;
　　　　}
　　　　public String getAccounttype()}　
　　　　{
　　　　　　　　return accounttype;
　　　　}
　　　　public void setAccounttype(String accounttype)　
　　　　{
　　　　　　　　this.accounttype = accounttype;
　　　　}
　　　　public double getBalance()　
　　　　{
　　　　　　　　return balance;
　　　　}
　　　　public void setBalance(double balance)　
　　　　{
　　　　　　　　this.balance = balance;
　　　　}
}

steps11: Im Verzeichnis src/main/java Erstellen Sie ein Paket namens com.w3codebox.controller

steps12: Im Controller-Paket, erstellen Sie ein Paket namens CustomerController Controller-Klasse und führt dann folgende Aktionen aus:

mit der Annotation @RestController markiert die Klasse als Controller 。 mit der Annotation @RequestMapping für den Controller definiertAbbildung。Wir haben die Abbildung definiert/customerinfo 。zu erstellenCacheum die Annotation @Cacheable abgerufen. Wir haben die Daten mit Hilfe der Annotation value den Cache-Namen in der Eigenschaft definiert.Wir habenwurden zwei Kundeninformationen hinzugefügt

CustomerController.java

package com.w3codebox.controller;
import java.util.Arrays;
import java.util.List;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.w3codebox.model.Customer;
@RestController
public class CustomerController　
{
　　　　@RequestMapping("/customerinfo")
　　　　//defines　a　cache　for　method's　return　value
　　　　@Cacheable(value="customerInfo")
　　　　public　List　customerInformation()
　　　　{
　　　　　　　　System.out.println("customer　information　from　cache");
　　　　　　　　//adding　customer　detail　in　the　List
　　　　　　　　　　List　detail=Arrays.asList(new　Customer(5126890,"Charlie　Puth","Current　A/c",　450000.00),
　　　　　　　　　　　　　　　　　　　　　　　　new　Customer(7620015,"Andrew　Flintoff","Saving　A/c",　210089.00)
　　　　　　　　　　　　　　　　　　　　　　　);
　　　　　　　　return　detail;
　　　　}
}

Now run the application.

steps13: open SpringBootCacheExampleApplication.java file and run it as a Java application.

steps14: openPostman, and sends a URL with http: //locahost: 8080/custmerinfo GET The request returns customer details as follows.