Wie SpringBoot Redis anpasst, um die Cache-Serialisierung zu implementieren-Redis-php.cn

1, Benutzerdefinierte RedisTemplate

1.1, Standard-Serialisierungsmechanismus der Redis-API

Die API-basierte Redis-Cache-Implementierung verwendet die RedisTemplate-Vorlage für Daten-Caching-Vorgänge. Öffnen Sie hier die RedisTemplate-Klasse und zeigen Sie die Quellcodeinformationen dieser Klasse an sind leer; bestimmen Sie in der Methode afterPropertiesSet(), ob der Standard-Serialisierungsparameter defaultSerializer leer ist, und setzen Sie die Standard-Serialisierungsmethode der Daten auf JdkSerializationRedisSerializer

Entsprechend der obigen Analyse Mit den Quellcodeinformationen können wir die folgenden zwei wichtigen Schlussfolgerungen ziehen:

(1) Wenn RedisTemplate zum Ausführen von Redis-Daten-Caching-Vorgängen verwendet wird, ist die interne Standardserialisierungsmethode JdkSerializationRedisSerializer, daher muss die Entitätsklasse für das Daten-Caching verwendet werden Implementieren Sie die eigene Serialisierungsschnittstelle des JDK (z. B. Serializable);

(2) Wenn Sie RedisTemplate zum Ausführen von Redis-Daten-Caching-Vorgängen verwenden und die Cache-Serialisierungsmethode defaultSerializer angepasst ist, wird die angepasste Serialisierungsmethode verwendet .

Darüber hinaus sind im Quellcode der RedisTemplate-Klasse die verschiedenen Serialisierungstypen der zwischengespeicherten Datenschlüssel und -werte RedisSerializer. Geben Sie den RedisSerializer-Quellcode ein, um die von RedisSerializer unterstützten Serialisierungsmethoden anzuzeigen (nach Eingabe der Klasse verwenden Sie Strg+Alt+Linksklick auf den Klassennamen, um ihn anzuzeigen)

# 🎜🎜#Sie können sehen, dass RedisSerializer standardmäßig eine Redis-Serialisierungsschnittstelle mit 6 Implementierungsklassen ist. Diese 6 Implementierungsklassen repräsentieren 6 verschiedene Datenserialisierungsmethoden. Darunter ist JdkSerializationRedisSerializer im Lieferumfang von JDK enthalten und ist auch die standardmäßige Datenserialisierungsmethode, die in RedisTemplate verwendet wird. Entwickler können nach Bedarf andere unterstützte Serialisierungsmethoden (z. B. die JSON-Methode) auswählen. 🎜🎜# Wie SpringBoot Redis anpasst, um die Cache-Serialisierung zu implementieren Nach der Einführung der Redis-Abhängigkeit in das Projekt wird die von Spring Boot bereitgestellte automatische Konfiguration RedisAutoConfiguration wirksam. Öffnen Sie die RedisAutoConfiguration-Klasse und sehen Sie sich die Definition von RedisTemplate im internen Quellcode an Verbindungsfabrik RedisConnectionFactory; Die Annotation @ConditionalOnMissingBean (wird, wie der Name schon sagt, wirksam, wenn keine Bean vorhanden ist) wird über der Klasse hinzugefügt, um anzuzeigen, dass die standardmäßig initialisierte RedisTemplate nicht wirksam wird, wenn der Entwickler eine Bean namens redisTemplate anpasst.

Wenn Sie RedisTemplate mit einer benutzerdefinierten Serialisierungsmethode für Daten-Caching-Vorgänge verwenden möchten, können Sie auf den obigen Kerncode zurückgreifen, um eine Bean-Komponente mit dem Namen redisTemplate zu erstellen und die entsprechende Serialisierungsmethode in der Komponente festzulegen

Als nächstes erstellen Sie im Projekt ein Paket mit dem Namen com.lagou.config, erstellen unter dem Paket eine benutzerdefinierte Redis-Konfigurationsklasse RedisConfig und passen die Bean mit dem Namen redisTemplate gemäß den oben genannten Ideen an. Komponente

public class RedisTemplate<K, V> extends RedisAccessor implements RedisOperations<K, V>, BeanClassLoaderAware {
    // 声明了key、value的各种序列化方式，初始值为空
    @Nullable
    private RedisSerializer keySerializer = null;
    @Nullable
    private RedisSerializer valueSerializer = null;
    @Nullable
    private RedisSerializer hashKeySerializer = null;
    @Nullable
    private RedisSerializer hashValueSerializer = null;
...
    // 进行默认序列化方式设置，设置为JDK序列化方式
    public void afterPropertiesSet() {
        super.afterPropertiesSet();
        boolean defaultUsed = false;
        if (this.defaultSerializer == null) {
            this.defaultSerializer = new JdkSerializationRedisSerializer(
                    this.classLoader != null ?
                            this.classLoader : this.getClass().getClassLoader());
        }
        ...
    }
        ...
}

Nach dem Login kopieren

definiert eine RedisConfig-Konfigurationsklasse über die Annotation @Configuration und verwendet die Annotation @Bean, um eine redisTemplate-Komponente mit dem Standardnamen des Methodennamens einzufügen (beachten Sie, dass der Name der Bean-Komponente redisTemplate lauten muss). In der definierten Bean-Komponente wird ein RedisTemplate angepasst, wobei die angepasste Datenserialisierungsmethode Jackson2JsonRedisSerializer verwendet wird. In der angepassten Serialisierungsmethode wird ein ObjectMapper für Datenkonvertierungseinstellungen definiert

1.3, Effekttest

# 🎜🎜#

Es ist ersichtlich, dass die Ausführung der findById()-Methode die Kommentarinformationen des Benutzers korrekt abfragt und denselben Abfragevorgang wiederholt. Die Datenbank führt nur eine SQL-Anweisung aus zeigt, dass der angepasste Redis-Cache wirksam wird.

Verwenden Sie das visuelle Verwaltungstool des Redis-Clients Redis Desktop Manager, um zwischengespeicherte Daten anzuzeigen:

Wie SpringBoot Redis anpasst, um die Cache-Serialisierung zu implementieren Führen Sie die Methode findById() aus, um Fragen Sie den Benutzer ab. Die Kommentarinformationen werden korrekt in der Redis-Cache-Bibliothek gespeichert und die im Redis-Dienst zwischengespeicherten Daten wurden im JSON-Format gespeichert und angezeigt. Dies ist auch sehr bequem anzuzeigen und zu verwalten, was darauf hinweist, dass die angepasste Redis-API-Vorlage Das Tool RedisTemplate ist effektiv Dieses benutzerdefinierte RedisTemplate ist nicht für das API-basierte RedisTemplate geeignet. Für den annotierten Redis-Cache hat es keine Auswirkung.

Als nächstes erklären wir den Redis-Caching-Mechanismus und die benutzerdefinierte Serialisierungsmethode basierend auf Anmerkungen

2.1, Standard-Serialisierungsmechanismus für Redis-Annotationen

Öffnen Sie den Cache Die automatische Konfigurationsklasse RedisCacheConfiguration (unter dem Paket org.springframework.boot.autoconfigure.cache) wird von der in Spring Boot integrierten Redis-Komponente bereitgestellt und zeigt die Quellcodeinformationen dieser Klasse an. Der Kerncode lautet wie folgt: Wie SpringBoot Redis anpasst, um die Cache-Serialisierung zu implementieren

@Configuration
class RedisCacheConfiguration {
    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory, ResourceLoader resourceLoader) {
        RedisCacheManagerBuilder builder = RedisCacheManager
                .builder(redisConnectionFactory)
                .cacheDefaults(this.determineConfiguration(resourceLoader.getClassLoader()));
        List<String> cacheNames = this.cacheProperties.getCacheNames();
        if (!cacheNames.isEmpty()) {
            builder.initialCacheNames(new LinkedHashSet(cacheNames));
        }
        return (RedisCacheManager) this.customizerInvoker.customize(builder.build());
    }
    private org.springframework.data.redis.cache.RedisCacheConfiguration
    determineConfiguration(ClassLoader classLoader) {
        if (this.redisCacheConfiguration != null) {
            return this.redisCacheConfiguration;
        } else {
            Redis redisProperties = this.cacheProperties.getRedis();
            org.springframework.data.redis.cache.RedisCacheConfiguration config = org.springframework.data.redis.cache.RedisCacheConfiguration.defaultCacheConfig();
            config = config.serializeValuesWith(SerializationPair.fromSerializer(
                            new JdkSerializationRedisSerializer(classLoader)));
            ...
            return config;
        }
    }
}

Nach dem Login kopieren

从上述核心源码中可以看出，同RedisTemplate核心源码类似，RedisCacheConfiguration内部同样通过Redis连接工厂RedisConnectionFactory定义了一个缓存管理器RedisCacheManager；同时定制RedisCacheManager时，也默认使用了JdkSerializationRedisSerializer序列化方式。

如果想要使用自定义序列化方式的RedisCacheManager进行数据缓存操作，可以参考上述核心代码创建一个名为cacheManager的Bean组件，并在该组件中设置对应的序列化方式即可

在Spring Boot 2.X版本中，RedisCacheManager是独立构建的。因此，在SpringBoot 2.X版本中，对RedisTemplate进行自定义序列化机制构建后，仍然无法对RedisCacheManager内部默认序列化机制进行覆盖（这也就解释了基于注解的Redis缓存实现仍然会使用JDK默认序列化机制的原因），想要基于注解的Redis缓存实现也使用自定义序列化机制，需要自定义RedisCacheManager

2.2、自定义RedisCacheManager

在项目的Redis配置类RedisConfig中，按照上一步分析的定制方法自定义名为cacheManager的Bean组件

    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        // 分别创建String和JSON格式序列化对象，对缓存数据key和value进行转换
        RedisSerializer<String> strSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jacksonSerial = new Jackson2JsonRedisSerializer(Object.class);
        // 解决查询缓存转换异常的问题
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY); // 上面注释过时代码的替代方法
        jacksonSerial.setObjectMapper(om);
        // 定制缓存数据序列化方式及时效
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofDays(1)) // 设置缓存数据的时效（设置为了1天）
                .serializeKeysWith(RedisSerializationContext.SerializationPair
                        .fromSerializer(strSerializer)) // 对当前对象的key使用strSerializer这个序列化对象，进行转换
                .serializeValuesWith(RedisSerializationContext.SerializationPair
                        .fromSerializer(jacksonSerial)) // 对value使用jacksonSerial这个序列化对象，进行转换
                .disableCachingNullValues();
        RedisCacheManager cacheManager = RedisCacheManager
                .builder(redisConnectionFactory).cacheDefaults(config).build();
        return cacheManager;
    }

Nach dem Login kopieren

上述代码中，在RedisConfig配置类中使用@Bean注解注入了一个默认名称为方法名的cacheManager组件。在定义的Bean组件中，通过RedisCacheConfiguration对缓存数据的key和value分别进行了序列化方式的定制，其中缓存数据的key定制为StringRedisSerializer（即String格式），而value定制为了Jackson2JsonRedisSerializer（即JSON格式），同时还使用entryTtl(Duration.ofDays(1))方法将缓存数据有效期设置为1天

完成基于注解的Redis缓存管理器RedisCacheManager定制后，可以对该缓存管理器的效果进行测试（使用自定义序列化机制的RedisCacheManager测试时，实体类可以不用实现序列化接口）

Das obige ist der detaillierte Inhalt vonWie SpringBoot Redis anpasst, um die Cache-Serialisierung zu implementieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!