Comment utiliser @Cacheable dans l'intégration de Springboot et Redis

Nous devons d'abord configurer un gestionnaire de cache, puis nous pouvons utiliser des annotations de cache pour gérer le cache

package com.cherish.servicebase.handler;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
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;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        template.setConnectionFactory(factory);
        //key序列化方式
        template.setKeySerializer(redisSerializer);
        //value序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //value hashmap序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        return template;
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        //解决查询缓存转换异常的问题
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 配置序列化（解决乱码的问题）,过期时间600秒
        RedisCacheConfiguration config = RedisCacheConfiguration
                .defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(600))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                .disableCachingNullValues();

        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
             // 可以给每个cacheName不同的RedisCacheConfiguration  设置不同的过期时间
            //.withCacheConfiguration("Users",config.entryTtl(Duration.ofSeconds(100)))
                .transactionAware()
                .build();
        return cacheManager;
    }
}

1, @Cacheable

est marqué sur la méthode ou classe, et l'identifiant Cette méthode ou classe prend en charge la mise en cache. Après que Spring ait appelé la méthode d'identification d'annotation, la valeur de retour sera mise en cache dans Redis pour garantir que la prochaine fois que la méthode sera appelée avec les mêmes conditions, la valeur de retour sera obtenue directement du cache. De cette manière, il n’est pas nécessaire de réexécuter le processus de traitement métier de cette méthode, ce qui améliore l’efficacité.

@Cacheable Les trois paramètres couramment utilisés sont les suivants :

cacheNames nom du cache
key cached key, vous devez faire attention à l'écriture de la clé # 🎜🎜#exécution du cache de conditions La condition sera exécutée lorsque true sera renvoyée. Utilisez l'outil de visualisation redis dans redis pour afficher les informations mises en cache

La deuxième requête. va à la console de cache et il n'y a pas de sortie, donc le cache redis est dans redis Obtenez le résultat et renvoyez-le directement.

@CacheEvict

est marqué sur la méthode. Une fois la méthode exécutée, le cache correspondant sera supprimé en fonction de. l'état ou la clé. Attributs couramment utilisés :

allEntries type booléen, indiquant si tous les éléments du cache doivent être effacés

#🎜🎜 #key La clé mise en cache qui doit être supprimée

    //查询所有用户，缓存到redis中
    @GetMapping("/selectFromRedis")
    @Cacheable(cacheNames = "Users",key = "'user'")
    public ResultData getUserRedis(){
        List<User> list = userService.list(null);
        return ResultData.ok().data("User",list);
    }

 //调用这个接口结束后，删除指定的Redis缓存
    @PostMapping("updateUser")
    @CacheEvict(cacheNames ="Users",key = "'user'")
    public ResultData updateUser(@RequestBody User user){
        String id = user.getId();
        QueryWrapper<User> wrapper=new QueryWrapper<>();
        wrapper.eq("id",id);
        boolean b = userService.update(user, wrapper);
        return ResultData.ok().data("flag",b);
    }

• Lorsque nous mettons à jour les données dans la base de données, nous devons vider le cache Redis. Sinon, les données que nous interrogeons sont les données du cache Redis, ce qui entraînera une incohérence entre la base de données et les données mises en cache.
  Exemple : Appelez l'interface sans annotation @CacheEvict pour modifier les données Les données obtenues dans la requête sont avant modification.
Ainsi, lorsque nous appelons l'interface pour modifier des données, nous devons vider le cache

Ajouter l'annotation @CacheEvict pour effacer le cache correspondant A ce moment, lors de l'interrogation des données, il s'avère que les données sont les plus récentes et cohérentes avec la base de données.

Délai d'expiration

Nous avons implémenté les fonctions de base de Spring Cache et intégré Redis comme

annoté Parfois, il il est impossible de donner au cache un délai d'expiration. Mais parfois, dans certains scénarios, nous devons vraiment donner au cache un délai d'expiration ! Il s'agit de la date d'expiration par défaut. Définissez l'heure d'expiration

Utilisez la nouvelle configuration Redis et interrogez à nouveau les données mises en cache pour voir la période de validité des données#🎜🎜 #

# 🎜🎜#

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!