Hybrid-Cache-Strategie in Spring Boot: Ein Leitfaden zur Redisson- und Koffein-Integration

Effiziente Caching-Strategie: Hybrid-Caching in Spring Boot-Anwendungen

In der modernen Anwendungsentwicklung sind Leistung und Skalierbarkeit Schlüsselfaktoren, die über Erfolg oder Misserfolg des Systems entscheiden. Caching spielt eine Schlüsselrolle bei der Verbesserung dieser Probleme, indem es die Datenbanklast reduziert, die Latenz verringert und ein nahtloses Benutzererlebnis gewährleistet. Allerdings ist keine einzige Caching-Lösung für alle Szenarien perfekt.

Lokale Caches (wie Caffeine) sorgen für rasante Geschwindigkeiten, da sie im Speicher und in der Nähe der Anwendung ausgeführt werden. Sie eignen sich hervorragend zur Verkürzung der Antwortzeiten für häufig abgerufene Daten. Verteilte Caches (wie Redisson von Redisson) hingegen bieten Skalierbarkeit und Konsistenz über mehrere Instanzen einer Anwendung hinweg. Durch verteiltes Caching wird sichergestellt, dass alle Knoten in einem verteilten System Zugriff auf die gleichen aktuellen Daten haben, was in einer Umgebung mit mehreren Knoten von entscheidender Bedeutung ist. Es kann jedoch Herausforderungen mit sich bringen, sich ausschließlich auf lokales oder verteiltes Caching zu verlassen:

Lokaler Cache
• kann in einer verteilten Umgebung inkonsistent werden, da Datenaktualisierungen nicht zwischen Knoten synchronisiert werden.
Verteilter Cache
• führt zu einer leichten Netzwerklatenz, die möglicherweise nicht für Szenarien mit extrem niedriger Latenz geeignet ist.
Hier wird

Hybrid Caching

zu einer effektiven Lösung. Durch die Kombination der Vorteile von lokalem und verteiltem Caching mit Caffeine und Redisson erhalten Sie die hohe Leistung lokaler Caching-Geschwindigkeiten bei gleichzeitiger Beibehaltung der Konsistenz und Skalierbarkeit mit verteiltem Caching-Sex. In diesem Artikel wird untersucht, wie Hybrid-Caching in Spring Boot-Anwendungen implementiert wird, um optimale Leistung und Datenkonsistenz sicherzustellen.

Implementierungsschritte

Schritt 1: Abhängigkeiten hinzufügen

Fügen Sie zunächst die erforderlichen Abhängigkeiten zu Ihrer

-Datei hinzu:

pom.xml

Schritt 2: Cache konfigurieren

<code class="language-xml"><dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>3.2.0</version>
</dependency>
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.43.0</version>
</dependency></code>

Das Folgende ist die Cache-Konfiguration:

Detaillierte Erläuterung der wichtigsten Komponenten

<code class="language-java">@Configuration
@EnableCaching
public class CacheConfig implements CachingConfigurer {

    @Value("${cache.server.address}")
    private String cacheAddress;

    @Value("${cache.server.password}")
    private String cachePassword;

    @Value("${cache.server.expirationTime:60}")
    private Long cacheExpirationTime;

    @Bean(destroyMethod = "shutdown")
    RedissonClient redisson() {
        Config config = new Config();
        config.useSingleServer().setAddress(cacheAddress).setPassword(cachePassword.trim());
        config.setLazyInitialization(true);
        return Redisson.create(config);
    }

    @Bean
    @Override
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder().expireAfterWrite(cacheExpirationTime, TimeUnit.MINUTES));
        return cacheManager;
    }

    @Bean
    public CacheEntryRemovedListener cacheEntryRemovedListener() {
        return new CacheEntryRemovedListener(cacheManager());
    }

    @Bean
    @Override
    public CacheResolver cacheResolver() {
        return new LocalCacheResolver(cacheManager(), redisson(), cacheEntryRemovedListener());
    }
}</code>

1. Cache-Manager (CacheManager)

ist für die Verwaltung des Cache-Lebenszyklus und die Bereitstellung des Zugriffs auf entsprechende Cache-Implementierungen (z. B. lokal oder verteilt) verantwortlich. In diesem Beispiel verwenden wir

, um In-Memory-Caching zu aktivieren und die Ablaufrichtlinie über CacheManager zu konfigurieren. CaffeineCacheManager Caffeine2. CacheResolver

Bestimmen Sie dynamisch, welcher Cache für einen bestimmten Vorgang verwendet werden soll. Hier verbindet

lokale (Caffeine) und verteilte (Redisson) Caches, um sicherzustellen, dass die Hybridstrategie effektiv angewendet wird. CacheResolver LocalCacheResolver

<code class="language-java">@Component
public class LocalCacheResolver implements CacheResolver {
    // ... (代码与原文相同) ...
}</code>

3. Cache-Eintrag entfernt-Listener (CacheEntryRemovedListener)

<code class="language-java">public class LocalCache implements Cache {
    // ... (代码与原文相同) ...
}</code>

Lauscht auf Einträge, die aus dem verteilten Cache (Redis) entfernt werden, und stellt sicher, dass sie auch aus dem lokalen Cache jedes Knotens entfernt werden, wodurch die Konsistenz gewahrt bleibt.

<code class="language-xml"><dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>3.2.0</version>
</dependency>
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.43.0</version>
</dependency></code>

Hybrid-Caching-Workflow

Cache-Eintrag hinzugefügt

Wenn eine mit @Cacheable annotierte Methode ausgeführt wird, wird die put-Methode aufgerufen. Dadurch werden die Daten in einem lokalen Cache (Caffeine) und einem verteilten Cache (Redis) gespeichert:

<code class="language-java">@Configuration
@EnableCaching
public class CacheConfig implements CachingConfigurer {

    @Value("${cache.server.address}")
    private String cacheAddress;

    @Value("${cache.server.password}")
    private String cachePassword;

    @Value("${cache.server.expirationTime:60}")
    private Long cacheExpirationTime;

    @Bean(destroyMethod = "shutdown")
    RedissonClient redisson() {
        Config config = new Config();
        config.useSingleServer().setAddress(cacheAddress).setPassword(cachePassword.trim());
        config.setLazyInitialization(true);
        return Redisson.create(config);
    }

    @Bean
    @Override
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder().expireAfterWrite(cacheExpirationTime, TimeUnit.MINUTES));
        return cacheManager;
    }

    @Bean
    public CacheEntryRemovedListener cacheEntryRemovedListener() {
        return new CacheEntryRemovedListener(cacheManager());
    }

    @Bean
    @Override
    public CacheResolver cacheResolver() {
        return new LocalCacheResolver(cacheManager(), redisson(), cacheEntryRemovedListener());
    }
}</code>

Cache-Eintragserfassung

Um Daten abzurufen, prüft das System zunächst, ob der Schlüssel im lokalen Cache vorhanden ist. Wenn der Schlüssel nicht gefunden wird, wird der verteilte Cache abgefragt. Wenn der Wert im verteilten Cache vorhanden ist, wird er für einen schnelleren nachfolgenden Zugriff zum lokalen Cache hinzugefügt:

<code class="language-java">@Component
public class LocalCacheResolver implements CacheResolver {
    // ... (代码与原文相同) ...
}</code>

Cache-Eintragsbeseitigung

Wenn eine Cache-Räumung erfolgt (z. B. über die Annotation @CacheEvict), wird der Schlüssel aus dem verteilten Cache entfernt. Lokale Caches anderer Knoten werden über CacheEntryRemovedListener benachrichtigt, um denselben Schlüssel zu entfernen:

<code class="language-java">public class LocalCache implements Cache {
    // ... (代码与原文相同) ...
}</code>

---

Zusammenfassung

Hybrid-Cache kombiniert die Geschwindigkeit des lokalen Speichercaches mit der Skalierbarkeit und Konsistenz des verteilten Caches. Dieser Ansatz beseitigt die Einschränkungen, die sich aus der ausschließlichen Verwendung lokaler oder verteilter Caches ergeben. Durch die Integration von Caffeine und Redisson in Ihre Spring Boot-Anwendung können Sie erhebliche Leistungsverbesserungen erzielen und gleichzeitig die Datenkonsistenz zwischen Anwendungsknoten sicherstellen.

Durch die Verwendung von CacheEntryRemovedListener und CacheResolver wird sichergestellt, dass Cache-Einträge über alle Caching-Ebenen hinweg synchron gehalten werden, wodurch eine effiziente und zuverlässige Caching-Strategie für moderne skalierbare Anwendungen bereitgestellt wird. Dieser Hybridansatz ist besonders wertvoll in verteilten Systemen, in denen sowohl Leistung als auch Konsistenz von entscheidender Bedeutung sind.

Das obige ist der detaillierte Inhalt vonHybrid-Cache-Strategie in Spring Boot: Ein Leitfaden zur Redisson- und Koffein-Integration. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!