Condivisione della tecnologia

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

introduzione

La modalità Read Through si riferisce generalmente a una strategia di memorizzazione nella cache in cui quando un'applicazione tenta di leggere i dati, il sistema di cache viene prima controllato per verificare se i dati sono già nella cache. Se i dati esistono nella cache (ovvero in caso di cache hit), i dati vengono letti direttamente dalla cache e restituiti all'applicazione. Se i dati non esistono nella cache (ad esempio, un errore nella cache), i dati vengono letti dall'archivio dati sottostante (come un database), quindi caricati nella cache e infine restituiti all'applicazione.

I principali vantaggi di questo modello includono:

1. Migliorare la prestazione: Le prestazioni di recupero dei dati possono essere notevolmente migliorate riducendo il numero di accessi diretti allo spazio di archiviazione sottostante.
2. Ridurre la latenza: la cache si trova generalmente in memoria ed è accessibile molto più velocemente rispetto all'archiviazione su disco, riducendo così la latenza nel recupero dei dati.
3. Ridurre il carico del database: Memorizzando nella cache i dati a cui si accede frequentemente, è possibile ridurre la pressione delle query sul database, migliorando così il rendimento dell'intero sistema.

La modalità Read Through è solitamente in contrasto con strategie come Lazy Loading e Eager Loading:

• Caricamento lento: i dati vengono caricati solo quando necessario, il che riduce il caricamento di dati non necessario ma potrebbe aumentare la latenza al primo accesso.
• Caricamento rapido: precarica i dati, che possono ridurre la latenza del primo accesso ma possono aumentare l'utilizzo della memoria e il tempo di avvio dell'applicazione.

Quando implementi la modalità Read Through, potresti prendere in considerazione quanto segue:

• Strategia di invalidazione della cache: determina quando rimuovere i dati dalla cache, ad esempio in base al tempo (TTL) o in base allo spazio (quando la cache raggiunge una determinata dimensione).
• Controllo della concorrenza: gestire la situazione in cui più istanze dell'applicazione accedono e modificano la cache contemporaneamente.
• coerenza dei dati: assicurarsi che i dati nella cache siano coerenti con i dati nell'archivio sottostante, soprattutto quando i dati vengono aggiornati.

compiere

L'implementazione del modello Read Through in Spring Boot può in genere essere eseguita tramite l'astrazione Spring Cache. Spring Cache fornisce un'API unificata tra diverse implementazioni di cache e supporta più soluzioni di cache, come EhCache, Hazelcast, Infinispan, Redis, ecc.

1. Aggiungi dipendenze: innanzitutto devi aggiungere le dipendenze della cache di Spring Boot e la libreria di implementazione della cache selezionata (come 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. Abilita annotazioni cache:Aggiunta alla classe di configurazione Spring Boot@EnableCachingannotazione per abilitare il supporto delle annotazioni nella cache.

3. Configura il gestore della cache: Configurarne uno o piùCacheManager, Spring Boot configurerà automaticamente un sempliceCacheManager, ma puoi configurare strategie di memorizzazione nella cache più complesse, se necessario.

   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. Utilizza le annotazioni della cache: utilizzato su metodi che richiedono la memorizzazione nella cache@Cacheable Annotazioni per implementare la modalità Read Through. Se non sono presenti dati nella cache, verrà chiamato il metodo e il risultato verrà memorizzato nella 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. Chiave della cache:esistere@CacheableLa chiave della cache è specificata nell'annotazione, che in genere si basa sul valore del parametro del metodo.

6. nome della cache: specificare il nome della cache, che verrà utilizzato per distinguere i diversi domini della cache.

7. Configura i parametri della cache: è possibile configurare il timeout della cache, le condizioni, le condizioni di meno, ecc. in base alle necessità

   1. valore o cacheNames :Specifica il nome della cache. È possibile specificare uno o più nomi di cache che verranno utilizzati per archiviare la cache.

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

   2. chiave : definisce la strategia di generazione dei valori delle chiavi della cache. Le espressioni SpEL (Spring Expression Language) vengono solitamente utilizzate per specificare i parametri del metodo come chiavi di cache.

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

   3. condizione: definisce le condizioni per la memorizzazione nella cache e memorizza nella cache solo quando le condizioni sono soddisfatte.

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

   4. salvo che: Definire le condizioni per non memorizzare nella cache econditionViene invece utilizzato per escludere determinate situazioni.

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

   5. generatore di chiavi: Specificare una strategia di generazione della chiave cache personalizzata Se è necessaria una logica di generazione della chiave più complessa, è possibile specificare aKeyGeneratorNome del fagiolo.

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

   6. gestore della cache:Specificare quale utilizzareCacheManager, se ce ne sono piùCacheManagerquando utilizzato.

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

   7. scadereDopoScrittura : imposta il tempo di scadenza (in millisecondi) dopo la scrittura dell'elemento nella cache. Questa è una configurazione comunemente utilizzata per definire la durata dei dati memorizzati nella cache.

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

   8. scadenzaDopoAccesso: imposta la scadenza dopo l'ultimo accesso all'elemento della cache, che è applicabile al tempo trascorso dall'ultimo accesso ai dati della cache.

   9. AggiornaDopoScrittura: imposta per quanto tempo aggiornare la cache dopo la scrittura, adatto per scenari in cui la cache viene aggiornata dinamicamente.

   10. sincronizzare: imposta se creare elementi della cache in modo sincrono per prevenire condizioni di competizione in ambienti simultanei.

8. La gestione delle eccezioni: assicurati di gestire le eccezioni che potrebbero essere generate nei metodi della cache per evitare di compromettere la stabilità dell'applicazione.