Compartilhamento de tecnologia

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

Introdução

O modo Read Through geralmente se refere a uma estratégia de cache na qual, quando um aplicativo tenta ler dados, o sistema de cache é primeiro verificado para ver se os dados já estão no cache. Se os dados existirem no cache (ou seja, acertos no cache), os dados serão lidos diretamente do cache e retornados ao aplicativo. Se os dados não existirem no cache (ou seja, uma falta de cache), os dados serão lidos do armazenamento de dados subjacente (como um banco de dados), depois carregados no cache e, finalmente, retornados ao aplicativo.

As principais vantagens deste modelo incluem:

1. Melhorar o desempenho: O desempenho da recuperação de dados pode ser significativamente melhorado reduzindo o número de acessos diretos ao armazenamento subjacente.
2. Reduza a latência: o cache normalmente está localizado na memória e pode ser acessado muito mais rápido que o armazenamento em disco, reduzindo assim a latência da recuperação de dados.
3. Reduza a carga do banco de dados: Ao armazenar dados acessados ​​com frequência no cache, a pressão de consulta no banco de dados pode ser reduzida, melhorando assim o rendimento de todo o sistema.

O modo Read Through geralmente é contrastado com estratégias como Lazy Load e Eager Load:

• Carregamento lento: os dados são carregados apenas quando necessário, o que reduz o carregamento desnecessário de dados, mas pode aumentar a latência no primeiro acesso.
• Carregando ansioso: pré-carrega dados, o que pode reduzir a latência do primeiro acesso, mas pode aumentar o uso de memória e o tempo de inicialização do seu aplicativo.

Ao implementar o modo Read Through, você pode considerar o seguinte:

• Estratégia de invalidação de cache: determine quando remover dados do cache, como baseados em tempo (TTL) ou baseados em espaço (quando o cache atinge um determinado tamanho).
• Controle de simultaneidade: trata da situação em que várias instâncias de aplicativos acessam e modificam o cache ao mesmo tempo.
• a consistência dos dados: certifique-se de que os dados no cache sejam consistentes com os dados no armazenamento subjacente, especialmente quando os dados forem atualizados.

concluir

A implementação do padrão Read Through no Spring Boot geralmente pode ser realizada por meio da abstração Spring Cache. Spring Cache fornece uma API unificada em diferentes implementações de cache e oferece suporte a várias soluções de cache, como EhCache, Hazelcast, Infinispan, Redis, etc.

1. Adicionar dependências: primeiro, você precisa adicionar as dependências de cache do Spring Boot e a biblioteca de implementação de cache selecionada (como 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. Habilitar anotações de cache:Adicionar a classe de configuração Spring Boot@EnableCachinganotação para ativar o suporte à anotação de cache.

3. Configurar gerenciador de cache: Configure um ou maisCacheManager, o Spring Boot configurará automaticamente um simplesCacheManager, mas você pode configurar estratégias de cache mais complexas, se necessário.

   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. Use anotações de cache: Usado em métodos que requerem cache@Cacheable Anotações para implementar o modo Read Through. Se não houver dados no cache, o método será chamado e o resultado será armazenado em 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. Chave de cache:existir@CacheableA chave de cache é especificada na anotação, que geralmente é baseada no valor do parâmetro do método.

6. nome do cache: Especifique o nome do cache, que será usado para distinguir diferentes domínios de cache.

7. Configurar parâmetros de cache: Você pode configurar o tempo limite do cache, condições, a menos que condições, etc., conforme necessário

   1. valor ou cacheNames : Especifique o nome do cache. Você pode especificar um ou mais nomes de cache que serão usados ​​para armazenar o cache.

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

   2. chave : defina a estratégia de geração para valores-chave de cache. Expressões SpEL (Spring Expression Language) são geralmente usadas para especificar parâmetros de método como chaves de cache.

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

   3. doença: defina as condições para armazenamento em cache e armazene em cache somente quando as condições forem atendidas.

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

   4. a menos que: Defina as condições para não armazenar em cache econditionEm vez disso, é usado para descartar certas situações.

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

   5. gerador de chaves: especifique uma estratégia de geração de chave de cache customizada. Se precisar de uma lógica de geração de chave mais complexa, você poderá especificar uma.KeyGeneratorNome do feijão.

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

   6. Gerenciador de cache:Especifique qual usarCacheManager, se houver váriosCacheManagerquando usado.

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

   7. expirarApósGravar : defina o tempo de expiração (em milissegundos) após a gravação do item de cache. Esta é uma configuração comumente usada para definir o tempo de vida dos dados armazenados em cache.

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

   8. expirarApósAcesso: defina o tempo de expiração após o último acesso do item de cache, que é aplicável ao tempo que leva para os dados armazenados em cache expirarem após o último acesso.

   9. atualizarApósEscrever: defina por quanto tempo o cache será atualizado após a gravação, adequado para cenários em que o cache é atualizado dinamicamente.

   10. sincronizar: defina se deseja criar itens de cache de forma síncrona para evitar condições de corrida em ambientes simultâneos.

8. Manipulação de exceção: certifique-se de lidar com exceções que podem ser lançadas em métodos de cache para evitar afetar a estabilidade do aplicativo.