So verwenden Sie @Cacheable bei der Integration von Springboot und Redis

Zuerst müssen wir einen Cache-Manager konfigurieren, und dann können wir Cache-Annotationen verwenden, um den Cache zu verwalten.

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

ist in der Methode markiert oder Klasse und der Bezeichner. Diese Methode oder Klasse unterstützt Caching. Nachdem Spring die Annotationsidentifizierungsmethode aufgerufen hat, wird der Rückgabewert in Redis zwischengespeichert, um sicherzustellen, dass der Rückgabewert beim nächsten Aufruf der Methode unter denselben Bedingungen direkt aus dem Cache abgerufen wird. Auf diese Weise ist es nicht erforderlich, den Geschäftsverarbeitungsprozess dieser Methode erneut auszuführen, was die Effizienz verbessert.

@Cacheable Die drei häufig verwendeten Parameter lauten wie folgt:

cacheNames Cache-Name
Schlüssel zwischengespeicherter Schlüssel, Sie müssen auf die Schreibweise des Schlüssels achten # 🎜🎜#Ausführung des Bedingungscaches Die Bedingung wird ausgeführt, wenn true zurückgegeben wird. Verwenden Sie das Redis-Visualisierungstool in Redis, um zwischengespeicherte Informationen anzuzeigen.

Die zweite Abfrage Geht zur Cache-Konsole und es gibt keine Ausgabe, also ist der Redis-Cache in redis Holen Sie sich das Ergebnis und geben Sie es direkt zurück.

@CacheEvict

wird auf der Methode markiert, der entsprechende Cache wird basierend auf gelöscht die Bedingung oder der Schlüssel. Häufig verwendete Attribute:

allEntries boolescher Typ, der angibt, ob alle Elemente im Cache gelöscht werden müssen

#🎜🎜 #key Der zwischengespeicherte Schlüssel, der gelöscht werden muss

    //查询所有用户，缓存到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);
    }

• Wenn wir die Daten in der Datenbank aktualisieren, müssen wir den Redis-Cache leeren. Andernfalls handelt es sich bei den von uns abgefragten Daten um Daten im Redis-Cache, was zu Inkonsistenzen zwischen der Datenbank und den zwischengespeicherten Daten führt.
  Beispiel: Rufen Sie die Schnittstelle ohne @CacheEvict-Annotation auf, um die Daten zu ändern. Die in der Abfrage erhaltenen Daten liegen vor der Änderung.
Wenn wir also die Schnittstelle aufrufen, um Daten zu ändern, müssen wir den Cache leeren

Fügen Sie die Annotation @CacheEvict zum Löschen hinzu der entsprechende Cache Zu diesem Zeitpunkt wird beim Abfragen der Daten festgestellt, dass die Daten die neuesten sind und mit der Datenbank übereinstimmen.

Ablaufzeit

Wir haben die Grundfunktionen von Spring Cache implementiert und Redis als

mit Anmerkungen versehen Manchmal ist es so Es ist unmöglich, dem Cache eine Ablaufzeit zu geben. Aber manchmal müssen wir in manchen Szenarien dem Cache wirklich eine Ablaufzeit geben! Dies ist das Standardablaufdatum. Definieren Sie die Ablaufzeit

Verwenden Sie die neue Redis-Konfiguration und fragen Sie die zwischengespeicherten Daten erneut ab, um den Gültigkeitszeitraum der Daten anzuzeigen#🎜🎜 #

# 🎜🎜#

Das obige ist der detaillierte Inhalt vonSo verwenden Sie @Cacheable bei der Integration von Springboot und Redis. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!