Stratégie de cache hybride dans Spring Boot: A Guide to Redisson and Cafeine Intégration

Stratégie de cache hybride: cache hybride dans le démarrage de printemps

Dans le développement des applications modernes, les performances et l'évolutivité sont le facteur clé qui détermine le succès ou l'échec du système. En réduisant les charges de base de données, en réduisant les retards et en assurant une expérience utilisateur transparente, il joue un rôle clé dans l'amélioration de ces aspects. Cependant, aucune solution de cache unique ne peut s'adapter parfaitement à toutes les scènes.

Le cache local (tel que caféine ) peut fournir une vitesse extrêmement rapide car il fonctionne dans la mémoire et proche de l'application. Ils sont très adaptés pour réduire le temps de réponse de l'accès fréquent aux données. D'un autre côté, le cache distribué (tel que Redisson ) fournit une évolutivité et une cohérence entre plusieurs instances de l'application. Le cache distribué garantit que tous les nœuds du système distribué accèdent aux mêmes dernières données, ce qui est très important dans les environnements multi-nœuds.

Cependant, le simple fait de s'appuyer sur les caches locaux ou distribués apportera des défis:

• Cache local Il peut devenir incohérent dans un environnement distribué, car les mises à jour des données ne seront pas synchronisées entre les nœuds.
Le cache distribué
• introduira la latence du réseau mineure, qui peut ne pas convenir aux scènes de retard ultra-locales.
C'est l'endroit où le cache mixte

devient une solution efficace. En combinant les avantages du cache local et distribué de Caffeine

et Redisson , vous pouvez obtenir les performances élevées apportées par la vitesse du cache locale, tout en utilisant un cache distribué pour maintenir la cohérence et l'évolutivité sexe. Cet article examine comment réaliser un cache mixte dans l'application Spring Boot pour assurer les performances optimales et la cohérence des données.

étapes d'implémentation

Étape 1: Ajouter la dépendance

Tout d'abord, ajoutez les dépendances nécessaires à votre fichier

:

Étape 2: Configurez le cache

Ce qui suit est la configuration du cache: pom.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>

Composant clé Explication détaillée

1. Cache Manager (CacheManager)

Responsable de la gestion du cycle de vie du cache et de l'accès à une implémentation de cache appropriée (comme local ou distribué). Dans cet exemple, nous utilisons le pour activer le cache de mémoire et configurer la stratégie d'expiration via la configuration

@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());
    }
}

.

2. Cache Parsolver (Cacheresolver)

Déterminez dynamiquement quel cache utiliser pour une opération spécifique. Ici,

connectez le cache local (caféine) et un cache de redisson pour assurer une application efficace des stratégies hybrides. CacheManager CaffeineCacheManager Caffeine

3. CachentryReMovedListener

Les entrées qui obéissent au cache distribué (redis) et assurez-vous qu'ils sont également retirés du cache local de chaque nœud pour maintenir la cohérence.

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

Hybrid Cache Workflow

L'article de cache ajoute

Lorsque la méthode d'annotation est exécutée, la méthode @Cacheable est appelée. Cela stockera les données dans le cache local et le cache distribué (redis): put

@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());
    }
}

Acquisition d'article de cache

Pour récupérer les données, le système vérifie d'abord si la clé existe dans le cache local. Si vous ne trouvez pas la clé, interrogez le cache distribué. Si cette valeur existe dans le cache distribué, ajoutez-le au cache local pour faire des visites de suivi -UP plus rapidement:

@Component
public class LocalCacheResolver implements CacheResolver {
    // ... (代码与原文相同) ...
}

La barre de cache est expulsée

Lorsque le cache est expulsé (par exemple, via l'annotation

), la clé sera supprimée du cache distribué. Le cache local des autres nœuds sera informé par @CacheEvict pour supprimer la même clé: CacheEntryRemovedListener

public class LocalCache implements Cache {
    // ... (代码与原文相同) ...
}

---

Résumé

Le cache mixte combine la vitesse du cache de mémoire local et l'évolutivité et la cohérence du cache distribué. Cette méthode résout les limites des caches locales ou distribuées. En intégrant

de la caféine

et redisson dans les applications de démarrage de printemps, vous pouvez obtenir une amélioration significative des performances et assurer la cohérence des données entre les nœuds d'application. en utilisant et

peut garantir que la bande altoscopique est synchronisée entre toutes les couches de cache et fournit une stratégie de cache efficace et fiable pour les applications évolutives modernes. Cette méthode hybride est particulièrement précieuse dans les systèmes distribués, car dans ces systèmes, les performances et la cohérence sont cruciales.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!