Partage de technologie

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Introduction

Le mode lecture continue fait généralement référence à une stratégie de mise en cache dans laquelle lorsqu'une application tente de lire des données, le système de cache est d'abord vérifié pour voir si les données sont déjà dans le cache. Si les données existent dans le cache (c'est-à-dire en cas d'accès au cache), les données sont lues directement à partir du cache et renvoyées à l'application. Si les données n'existent pas dans le cache (c'est-à-dire en cas d'absence de cache), les données sont lues à partir du magasin de données sous-jacent (comme une base de données), puis chargées dans le cache et enfin renvoyées à l'application.

Les principaux avantages de ce modèle sont les suivants :

1. Améliorer les performances: Les performances de récupération des données peuvent être considérablement améliorées en réduisant le nombre d'accès directs au stockage sous-jacent.
2. Réduire la latence: Le cache est généralement situé en mémoire et est accessible beaucoup plus rapidement que le stockage sur disque, réduisant ainsi la latence de récupération des données.
3. Réduire la charge de la base de données: En stockant les données fréquemment consultées dans le cache, la pression des requêtes sur la base de données peut être réduite, améliorant ainsi le débit de l'ensemble du système.

Le mode Lecture continue est généralement contrasté avec des stratégies telles que Lazy Loading et Eager Loading :

• Chargement paresseux: Les données sont chargées uniquement lorsque cela est nécessaire, ce qui réduit le chargement inutile des données mais peut augmenter la latence au premier accès.
• Chargement impatient: préchargez les données, ce qui peut réduire la latence du premier accès, mais peut augmenter l'utilisation de la mémoire et le temps de démarrage de votre application.

Lors de la mise en œuvre du mode Lecture continue, vous souhaiterez peut-être prendre en compte les éléments suivants :

• Stratégie d'invalidation du cache: déterminez quand supprimer les données du cache, par exemple en fonction du temps (TTL) ou de l'espace (lorsque le cache atteint une certaine taille).
• Contrôle de la concurrence: Gérez la situation dans laquelle plusieurs instances d'application accèdent et modifient le cache en même temps.
• la cohérence des données: assurez-vous que les données du cache sont cohérentes avec les données du stockage sous-jacent, en particulier lorsque les données sont mises à jour.

accomplir

L'implémentation du modèle Read Through dans Spring Boot peut généralement être réalisée via l'abstraction Spring Cache. Spring Cache fournit une API unifiée sur différentes implémentations de cache et prend en charge plusieurs solutions de cache, telles que EhCache, Hazelcast, Infinispan, Redis, etc.

1. Ajouter des dépendances : tout d'abord, vous devez ajouter les dépendances du cache de Spring Boot et la bibliothèque d'implémentation du cache sélectionnée (telle que Redis)

   <!-- Spring Boot Starter Cache -->
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-cache</artifactId>
   </dependency>
    
   <!-- 以Redis为例，添加Redis的Spring Boot Starter -->
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-data-redis</artifactId>
   </dependency>
   

2. Activer les annotations du cache:Ajouter la classe de configuration Spring Boot@EnableCachingannotation pour activer la prise en charge des annotations de cache.

3. Configurer le gestionnaire de cache: Configurer un ou plusieursCacheManager, Spring Boot configurera automatiquement un simpleCacheManager, mais vous pouvez configurer des stratégies de mise en cache plus complexes si nécessaire.

   import org.springframework.context.annotation.Bean;
   import org.springframework.context.annotation.Configuration;
   import org.springframework.data.redis.cache.RedisCacheConfiguration;
   import org.springframework.data.redis.cache.RedisCacheManager;
   import org.springframework.data.redis.connection.RedisConnectionFactory;
    
   @Configuration
   public class RedisCacheConfig {
    
       @Bean
       public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
           RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                   .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(RedisSerializer.string()))
                   .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(GenericJackson2JsonRedisSerializer.json())))
    
   Map<String, RedisCacheConfiguration> customCacheConfigs = new HashMap<>();
   customCacheConfigs.put("mySpecialCache", 
       config.entryTtl(Duration.ofMinutes(15))); // 为特定缓存设置不同的过期时间
    
                   .disableCachingNullValues();
           return RedisCacheManager.builder(connectionFactory)
                   .cacheDefaults(config)
               // 在这里可以自定义添加缓存配置
                   .withInitialCacheConfigurations(customCacheConfigs)
                   .build();
       }
   }
   

4. Utiliser les annotations du cache: Utilisé sur les méthodes qui nécessitent une mise en cache@Cacheable Annotations pour implémenter le mode Lecture continue. S'il n'y a aucune donnée dans le cache, la méthode sera appelée et le résultat sera mis en cache.

   import org.springframework.cache.annotation.Cacheable;
   import org.springframework.stereotype.Service;
    
   @Service
   public class MyService {
    
       @Cacheable(value = "myCache", key = "#id")
       public MyData getDataById(String id) {
           // 从数据库加载数据
           return myDataRepository.findById(id);
       }
   }
   

5. Clé de cache:exister@CacheableLa clé de cache est spécifiée dans l'annotation, qui est généralement basée sur la valeur du paramètre de méthode.

6. nom du cache: Spécifiez le nom du cache, qui sera utilisé pour distinguer les différents domaines de cache.

7. Configurer les paramètres du cache: Vous pouvez configurer le délai d'expiration du cache, les conditions, à moins que les conditions, etc., selon vos besoins

   1. valeur ou cacheNames :Spécifiez le nom du cache. Vous pouvez spécifier un ou plusieurs noms de cache qui seront utilisés pour stocker le cache.

      @Cacheable(value = "myCacheName", key = "#id")
      

   2. clé : Définir la stratégie de génération des valeurs des clés de cache. Les expressions SpEL (Spring Expression Language) sont généralement utilisées pour spécifier les paramètres de méthode comme clés de cache.

      @Cacheable(cacheNames = "myCache", key = "#id")
      

   3. condition: Définissez les conditions de mise en cache et mettez en cache uniquement lorsque les conditions sont remplies.

      @Cacheable(cacheNames = "myCache", key = "#id", condition = "#id.length() > 3")
      

   4. sauf si: Définir les conditions de non-mise en cache, etconditionAu lieu de cela, il est utilisé pour exclure certaines situations.

      @Cacheable(cacheNames = "myCache", key = "#id", unless = "#result == null")
      

   5. Générateur de clés: Spécifiez une stratégie de génération de clé de cache personnalisée. Si vous avez besoin d'une logique de génération de clé plus complexe, vous pouvez spécifier une stratégie de génération de clé de cache personnalisée.KeyGeneratorNom du haricot.

      @Cacheable(cacheNames = "myCache", keyGenerator = "myKeyGenerator")
      

   6. Gestionnaire de cache : Spécifiez lequel utiliserCacheManager, s'il y en a plusieursCacheManagerlorsqu'elle est utilisée.

      @Cacheable(cacheNames = "myCache", cacheManager = "myCacheManager")
      

   7. expire après l'écriture : définissez le délai d'expiration (en millisecondes) après l'écriture de l'élément de cache. Il s'agit d'une configuration couramment utilisée pour définir la durée de vie des données mises en cache.

      @Cacheable(cacheNames = "myCache", key = "#id", expireAfterWrite = 3600000) // 1小时后过期
      

   8. expire après l'accès: définissez le délai d'expiration après le dernier accès à l'élément de cache, qui s'applique au temps après le dernier accès aux données du cache.

   9. actualiserAprèsÉcriture: définissez la durée d'actualisation du cache après l'écriture, adaptée aux scénarios dans lesquels le cache est actualisé dynamiquement.

   10. synchroniser: définissez s'il faut créer des éléments de cache de manière synchrone pour éviter les conditions de concurrence dans les environnements simultanés.

8. Gestion des exceptions: Assurez-vous de gérer les exceptions qui peuvent être générées dans les méthodes de cache pour éviter d'affecter la stabilité de l'application.