1. Verwendung
Im Frühjahr umfasst die Verwendung von Caching normalerweise die folgenden Schritte:
1. Cache-Abhängigkeiten hinzufügen : Stellen Sie sicher, dass dem Projekt Cache-bezogene Abhängigkeiten hinzugefügt werden. Wenn Sie Maven verwenden, können Sie die Spring Cache-Abhängigkeit in der pom.xml-Datei des Projekts hinzufügen.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
2. Konfigurieren Sie den Cache : Führen Sie die Grundkonfiguration des Caches in der Spring-Konfigurationsdatei durch. Wenn Sie Spring Boot verwenden, ist normalerweise keine zusätzliche Konfiguration erforderlich, da Spring Boot eine Standard-Cache-Konfiguration bereitstellt.
Schritt 1: Annotation @EnableCaching zur Startup-Klasse hinzufügen
Schritt 2: Annotationen [@CachePut, @CacheEvict, @Caching] zu bestimmten Methoden hinzufügen oder @Cacheable-Annotationen zu Methoden hinzufügen: Verwenden Sie @Cacheable für Methoden, die Caching erfordern. Annotation, Cache-Namen angeben , Schlüssel und andere Informationen.
3. Cache auslösen : Beim Aufrufen einer Methode mit der Annotation @Cacheable prüft Spring, ob sich das entsprechende Ergebnis bereits im Cache befindet. Wenn dies der Fall ist, wird das zwischengespeicherte Ergebnis direkt zurückgegeben. Wenn nicht, wird der Methodenkörper ausgeführt, das Ergebnis berechnet und das Ergebnis zwischengespeichert.
2. Ausführliche Erklärung
1、@Cacheable
@Cacheable ist eine Annotation im Spring Framework, die verwendet wird, um zu deklarieren, dass die Ergebnisse einer Methode zwischengespeichert werden sollen, damit die zwischengespeicherten Ergebnisse bei nachfolgenden Aufrufen direkt zurückgegeben werden können, ohne dass der Methodenkörper erneut ausgeführt werden muss. Diese Annotation wird häufig verwendet, um die Ausführungseffizienz von Methoden zu verbessern, insbesondere von solchen, die rechenintensiv sind.
Grundlegende Verwendung
import org.springframework.cache.annotation.Cacheable;
public class MyService {
@Cacheable(value = "myCache", key = "#input")
public String getResult(String input) {
// 如果缓存中存在以input为key的结果，则直接返回缓存结果
// 否则，执行方法体，并将结果缓存起来
// ...
}
}
Im obigen Beispiel:
Die Annotation @Cacheable ist in der getResult-Methode markiert und zeigt an, dass die Ergebnisse dieser Methode zwischengespeichert werden.
Das Wertattribut gibt den Namen des Caches an (es können mehrere Caches mit jeweils einem Namen vorhanden sein).
Das Schlüsselattribut gibt den Cache-Schlüssel an. Hier wird der SpEL-Ausdruck (Spring Expression Language) verwendet, was bedeutet, dass der Wert des Eingabeparameters als Cache-Schlüssel verwendet wird. Manchmal wird es wie folgt geschrieben:
@Cacheable(value = "myCache", key = "#p0+','+#p1")
key = "#p0+','+#p1" : Gibt den Cache-Schlüssel unter Verwendung der Spring Expression Language (SpEL)-Syntax an. #p0 repräsentiert den ersten Parameter der Methode, #p1 repräsentiert den zweiten Parameter der Methode. In diesem Beispiel wird der Schlüssel durch Komma gebildet, das den ersten Parameter und den zweiten Parameter verkettet. Das heißt, wenn die beiden Parameter bei zweimaligem Aufruf der Methode denselben Wert haben, teilen sie sich dasselbe zwischengespeicherte Ergebnis. Wenn Sie den Cache-Wert jedes Mal ändern möchten, wenn Sie eine Methode aufrufen, können Sie andere Verbindungszeichen wie Bindestriche, Leerzeichen oder Doppelpunkte verwenden oder den Methodennamen als Teil des Schlüsselwerts verwenden.
key = "#p0 + '_' + #p1" // 使用下划线
key = "#p0 + ',' + #p1 + ',' + #p2" // 添加额外的参数或常量
key = "methodName + ',' + #p0 + ',' + #p1" //使用方法名作为一部分
Vorsichtsmaßnahmen:
Die Annotation @Cacheable muss in der Spring-Umgebung wirksam werden, daher muss die Cache-Funktion normalerweise in der Spring-Konfigurationsdatei aktiviert werden.
Der Rückgabewerttyp der Methode sollte serialisierbar sein, damit er im Cache gespeichert werden kann.
Der Cache-Schlüssel wird basierend auf dem Schlüsselattribut generiert. Stellen Sie daher sicher, dass er die Eingabeparameter der Methode eindeutig identifiziert.
@Cacheable ist Teil der Spring Cache-Abstraktion und die spezifische Cache-Implementierung kann auf verschiedenen Backends basieren, z. B. speicherbasiert, Redis, Ehcache usw.
Wir verwenden es oft zusammen mit der @SqlQuery-Annotation. Wenn eine Methode sowohl die @Cacheable-Annotation als auch die @SqlQuery-Annotation verwendet, läuft der Ausführungsprozess normalerweise wie folgt ab:
-
Erster Aufruf: Wenn die Methode zum ersten Mal aufgerufen wird, überprüft Spring zunächst den Cache (
verwaltet durch die Annotation @Cacheable). Wenn das entsprechende Ergebnis im Cache vorhanden ist, wird es direkt aus dem Cache abgerufen und zurückgegeben, ohne dass die eigentliche SQL-Abfrage ausgeführt wird. -
Cache-Fehler: Wenn das entsprechende Ergebnis nicht im Cache vorhanden ist, wird der Methodenkörper ausgeführt. Im Methodenkörper
kann eine SQL-Abfrage (verwaltet durch die Annotation @SqlQuery) ausgeführt und die Abfrageergebnisse dem Rückgabetyp der Methode zugeordnet werden. -
Ergebnis-Caching: Wenn die Annotation @Cacheable aktiviert ist
, werden die berechneten Ergebnisse nach der Ausführung der Methode zwischengespeichert, sodass sie beim nächsten Aufruf derselben Methode direkt aus dem Cache abgerufen werden können.
Daher kann es sein, dass die eigentliche SQL-Abfrage nicht ausgeführt wird, wenn sich das entsprechende Ergebnis bereits im Cache befindet. Dadurch kann der Druck auf den Datenbankzugriff wirksam verringert und die Ausführungseffizienz der Methode verbessert werden. Stellen Sie bei der Verwendung dieser beiden Anmerkungen sicher, dass Cache-Schlüssel und SQL-Abfrageparameter keine Verwirrung stiften, damit der Cache korrekt identifiziert und verwaltet werden kann.
2、@CacheEvict
@CacheEvict ist eine Annotation im Spring-Framework, die zum Löschen des Caches verwendet wird. Es wird verwendet, um eine Methode zu markieren, die die Daten im angegebenen Cache löscht, wenn die Methode ausgeführt wird. Im Folgenden sind die Haupteigenschaften und die Verwendung der Annotation @CacheEvict aufgeführt:
Hauptattribute:
Wert (oder CacheNames) : Gibt die Namen der zu löschenden Caches an, bei denen es sich um ein Array von Zeichenfolgen handeln kann. Zum Beispiel: @CacheEvict(value = „myCache“) oder @CacheEvict(cacheNames = {“cache1“, „cache2“}).
Schlüssel : Gibt den SpEL-Ausdruck an, der zum Generieren des Cache-Schlüssels verwendet wird. Zum Beispiel:@CacheEvict(value = "myCache", key = "#userI
Bedingung : Gibt die Bedingung zum Löschen des Caches an, bei der es sich um einen SpEL-Ausdruck handelt. Wenn der Wert des Ausdrucks falsch ist, wird der Cache nicht geleert. Zum Beispiel:@CacheEvict(value = "myCache", condition = "#userId > 0")。
allEntries : Wenn auf true gesetzt, werden alle Einträge im angegebenen Cache gelöscht. Zum Beispiel: @CacheEvict(value = "myCache", allEntries = true).
beforeInvocation : Wenn auf „true“ gesetzt, wird der Cache geleert, bevor die Methode aufgerufen wird; wenn auf „false“ (Standard) gesetzt, wird der Cache geleert, nachdem die Methode aufgerufen wird. Zum Beispiel: @CacheEvict(value = "myCache", beforeInvocation = true).
Beispielverwendung:
@Service
public class MyService {
@CacheEvict(value = "myCache", key = "#userId")
public void clearCacheByUserId(long userId) {
// 此方法执行时，会清除名为 "myCache" 中 key 为 userId 的缓存条目
}
@CacheEvict(value = "myCache", allEntries = true)
public void clearEntireCache() {
// 此方法执行时，会清除名为 "myCache" 中的所有缓存条目
}
}
Im obigen Beispiel wird die Methode „clearCacheByUserId“ zum Löschen des Cache-Eintrags „myCache“ mit der Schlüssel-Benutzer-ID verwendet, während die Methode „clearEntireCache“ zum Löschen aller Cache-Einträge in „myCache“ verwendet wird.
Beachten Sie, dass die Annotation @CacheEvict normalerweise zum Löschen des Caches verwendet wird, wenn eine Methode ausgeführt wird. Wenn die Methodenausführung eine Ausnahme auslöst, erfolgt das Löschen des Caches möglicherweise nicht, es sei denn, beforeInvocation = true ist festgelegt. Daher muss sichergestellt werden, dass der Cache-Löschvorgang sicher ist und nicht aufgrund von Ausnahmen zu Fehlern beim Cache-Löschen führt.
3、@CachePut
@CachePut ist eine Annotation im Spring-Framework, die zum Aktualisieren des Caches verwendet wird. Es wird verwendet, um eine Methode zu markieren. Wenn die Methode ausgeführt wird, werden die Ergebnisse im Cache abgelegt. Im Gegensatz zu @Cacheable prüft @CachePut nicht zunächst, ob das Ergebnis bereits im Cache liegt, sondern legt den Rückgabewert der Methode direkt in den Cache .
Im Folgenden sind die Haupteigenschaften und die Verwendung der @CachePut-Annotation aufgeführt:
Hauptattribute:
Wert (oder CacheNames) : Gibt den Namen des zu aktualisierenden Caches an, der ein Array von Zeichenfolgen sein kann. Zum Beispiel: @CachePut(value = "myCache") 或 @CachePut(cacheNames = {"cache1", "cache2"}).
Schlüssel : Gibt den SpEL-Ausdruck an, der zum Generieren des Cache-Schlüssels verwendet wird. Zum Beispiel: @CachePut(value = "myCache", key = "#userId").
Bedingung : Gibt die Bedingung für die Platzierung im Cache an, bei der es sich um einen SpEL-Ausdruck handelt. Wenn der Wert des Ausdrucks falsch ist, wird er nicht im Cache platziert. Zum Beispiel: @CachePut(value = "myCache", condition = "#userId > 0").
es sei denn : Wenn der Wert des Ausdrucks im Gegensatz zur Bedingung wahr ist, wird er nicht im Cache abgelegt. Zum Beispiel: @CachePut(value = "myCache", unless = "#result == null").
Beispielverwendung:
@Service
public class MyService {
@CachePut(value = "myCache", key = "#userId")
public String updateCacheByUserId(long userId) {
// 此方法执行时，会将返回值放入名为 "myCache" 中 key 为 userId 的缓存条目
// 注意：不会先检查缓存中是否已有结果，直接将方法的返回值放入缓存中
// ...
return "Updated Value";
}
}
Im obigen Beispiel wird die Methode „updateCacheByUserId“ verwendet, um den Rückgabewert mit dem Schlüssel „userId“ in den Cache-Eintrag „myCache“ zu platzieren. Wenn diese Methode ausgeführt wird, prüft sie nicht zunächst, ob ein Ergebnis im Cache vorhanden ist, sondern legt den Rückgabewert der Methode direkt im Cache ab.
@CachePut wird normalerweise verwendet, um die neuesten Ergebnisse nach einem Aktualisierungsvorgang in den Cache zu legen, um die Cache-Konsistenz aufrechtzuerhalten. Es ist zu beachten, dass @CachePut im Gegensatz zu @Cacheable die Ausführung der Methode nicht verhindert und selbst wenn der Cache-Vorgang fehlschlägt, die normale Ausführung der Methode nicht beeinträchtigt wird.
4. @Caching
@Caching ist eine Annotation im Spring-Framework, die zum Kombinieren mehrerer Cache-Annotationen verwendet wird. Es ermöglicht die gleichzeitige Verwendung mehrerer Cache-bezogener Anmerkungen für eine Methode, einschließlich @Cacheable, @CachePut, @CacheEvict usw., wodurch eine flexiblere Cache-Konfiguration bereitgestellt wird.
Beispielverwendung:
@Service
public class MyService {
@Caching(
cacheable = {
@Cacheable(value = "cache1", key = "#userId")},
put = {
@CachePut(value = "cache2", key = "#result.id")}
)
public User getUserById(long userId) {
// 先尝试从 "cache1" 缓存中获取结果
// 如果获取成功，则返回结果，不执行方法体
// 如果获取失败，则执行方法体，并将结果放入 "cache1" 和 "cache2" 缓存中
// ...
return new User(userId, "John Doe");
}
}
Im obigen Beispiel wird die Annotation @Caching sowohl mit der Annotation @Cacheable als auch mit der Annotation @CachePut verwendet. Speziell:
Mit der Annotation @Cacheable wird versucht, das Ergebnis aus dem Cache mit dem Namen „cache1“ abzurufen. Wenn die Erfassung erfolgreich ist, wird das Ergebnis direkt zurückgegeben, ohne dass der Methodenkörper ausgeführt werden muss.
Die Annotation @CachePut wird verwendet, um den Rückgabewert der Methode in den Cache mit dem Namen „cache2“ zu legen, unabhängig davon, ob sich derselbe Schlüssel bereits im Cache befindet.
Durch die @Caching-Annotation können mehrere Caching-Annotationen flexibler kombiniert werden, um komplexe Caching-Anforderungen zu erfüllen.
3. Konfiguration der Cache-Ablaufzeit
1. Festlegen im Annotationsattribut
Wenn Sie die Annotation @Cacheable verwenden, können Sie die Cache-Ablaufzeit konfigurieren, indem Sie das Attribut „expire“ oder „expireAfterWrite“ festlegen. Dies hängt vom verwendeten Cache-Manager ab, da verschiedene Cache-Manager möglicherweise unterschiedliche Konfigurationen unterstützen.
Wenn Sie beispielsweise Spring Boot verwenden und der zugrunde liegende Cache-Manager auf Caffeine basiert, können Sie die ExpireAfterWrite-Eigenschaft verwenden, um die Ablaufzeit festzulegen. Hier ist ein Beispiel:
@Cacheable(value = "myCache", key = "#input", expireAfterWrite = 5, timeUnit = TimeUnit.MINUTES)
public String getResult(String input) {
// 如果缓存中存在以 input 为 key 的结果，则直接返回缓存结果
// 否则，执行方法体，并将结果缓存起来，缓存时间为 5 分钟
// ...
}
Im obigen Beispiel:
expireAfterWrite = 5 bedeutet, dass das Cache-Element 5 Minuten nach dem Schreiben abläuft.
timeUnit = TimeUnit.MINUTES gibt an, dass die Zeiteinheit Minuten sind.
Die genaue Konfiguration hängt vom verwendeten Cache-Manager ab. Wenn Sie andere Cache-Manager wie EhCache, Redis usw. verwenden, können die spezifischen Konfigurationsmethoden unterschiedlich sein. Überprüfen Sie die relevanten Eigenschaften in der Konfigurationsdatei oder den Anmerkungen, um sicherzustellen, dass die Cache-Ablaufzeit korrekt eingestellt ist.
2. Redis-Manager-Einstellungen
Bei Verwendung von Redis als Cache-Manager kann die Ablaufzeit des Redis-Cache über die Spring Boot-Konfigurationsdatei oder die Java-Konfiguration festgelegt werden. Hier ist ein Beispiel:
-
Legen Sie die Ablaufzeit des Redis-Cache in der Spring Boot-Konfigurationsdatei fest:
Fügen Sie die folgende Konfiguration in der Datei application.properties oder application.yml hinzu:# Redis 服务器地址 spring.redis.host=localhost # Redis 服务器端口 spring.redis.port=6379 # 缓存的默认失效时间，单位秒 spring.cache.redis.time-to-live=600 -
spring.cache.redis.time-to-live in der obigen Konfiguration
gibt an, dass die Standard-Cache-Ablaufzeit 600 Sekunden (10 Minuten) beträgt. Dieser Wert wird auf alle Caches angewendet, die über die Annotationen @Cacheable und @CachePut konfiguriert wurden.
Legen Sie die Ablaufzeit des Redis-Cache in der Java-Konfiguration fest: Wenn Sie die Java-Konfigurationsklasse verwenden, können Sie die Ablaufzeit des Caches über RedisCacheConfiguration in der Konfigurationsklasse festlegen. Hier ist ein Beispiel:java @Configuration @EnableCaching public class CacheConfig extends CachingConfigurerSupport { @Bean public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) { RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig() .entryTtl(Duration.ofSeconds(600)); // 设置缓存失效时间为600秒（10分钟） return RedisCacheManager.builder(connectionFactory) .cacheDefaults(config) .build(); } }In der obigen Konfiguration
entryTtl(Duration.ofSeconds(600))bedeutet dies, dass die Cache-Ablaufzeit auf 600 Sekunden festgelegt wird. Dieser Wert gilt auch für alle Caches, die über die Annotationen @Cacheable und @CachePut konfiguriert wurden.
Abhängig von Ihren spezifischen Anforderungen können Sie unterschiedliche Ablaufzeiten basierend auf der Cache-Spezifität konfigurieren. Das obige Beispiel dient nur zur Veranschaulichung. In tatsächlichen Anwendungen kann die entsprechende Cache-Ablaufzeit entsprechend den Geschäftsanforderungen festgelegt werden.