1. RedisTemplate personnalisé

1.1, mécanisme de sérialisation par défaut de l'API Redis

L'implémentation du cache Redis basée sur l'API utilise le modèle RedisTemplate pour les opérations de mise en cache des données. Ouvrez la classe RedisTemplate ici pour afficher les informations sur le code source de cette classe

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;
...
    // 進(jìn)行默認(rèn)序列化方式設(shè)置，設(shè)置為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());
        }
        ...
    }
        ...
}

Depuis. ci-dessus Il ressort du code source principal de RedisTemplate que diverses méthodes de sérialisation pour la clé et la valeur des données mises en cache sont déclarées dans RedisTemplate et que les valeurs initiales sont toutes vides dans la méthode afterPropertiesSet() ; Le paramètre de sérialisation par défaut defaultSerializer est vide, les données La méthode de sérialisation par défaut est définie sur JdkSerializationRedisSerializer

Sur la base de l'analyse des informations de code source ci-dessus, les deux conclusions importantes suivantes peuvent être tirées?:

(1) Lors de l'utilisation de RedisTemplate pour exécuter Redis opérations de mise en cache des données, la méthode de sérialisation interne par défaut est JdkSerializationRedisSerializer. Par conséquent, la classe d'entité pour la mise en cache des données doit implémenter la propre interface de sérialisation du JDK (telle que Serialisable) (2) Lors de l'utilisation de RedisTemplate pour effectuer des opérations de mise en cache de données Redis ; méthode de sérialisation du cache defaultSerializer est personnalisé, puis celui personnalisé sera utilisé comme méthode de sérialisation.

De plus, dans le code source de la classe RedisTemplate, les différents types de sérialisation des clés et valeurs de données mises en cache vues sont RedisSerializer. Entrez le code source de RedisSerializer pour afficher les méthodes de sérialisation prises en charge par RedisSerializer (après être entré dans la classe, utilisez Ctrl+Alt+clic gauche sur le nom de la classe pour afficher)

On peut voir que RedisSerializer est une interface de sérialisation Redis, avec 6 implémentations par classe par défaut, ces 6 classes d'implémentation représentent 6 méthodes de sérialisation de données différentes. Parmi eux, JdkSerializationRedisSerializer est fourni avec JDK et est également la méthode de sérialisation des données par défaut utilisée dans RedisTemplate. Les développeurs peuvent choisir d'autres méthodes de sérialisation prises en charge (telles que la méthode JSON) en fonction de leurs besoins

1.2. La dépendance Redis est introduite dans le projet, la configuration automatique RedisAutoConfiguration fournie par Spring Boot prendra effet. Ouvrez la classe RedisAutoConfiguration et vérifiez la définition de RedisTemplate dans le code source interne

public class RedisAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean(
            name = {"redisTemplate"}
    )
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
...
}

Comme le montre le code source principal de RedisAutoConfiguration mentionné ci-dessus, dans la classe de configuration automatique Redis, un RedisTemplate est initialisé via la fabrique de connexion Redis RedisConnectionFactory?; @ConditionalOnMissingBean est ajouté au-dessus de la classe Annotation (comme son nom l'indique, prend effet lorsqu'un certain Bean n'existe pas), utilisée pour indiquer que si le développeur personnalise un Bean nommé redisTemplate, le RedisTemplate initialisé par défaut ne prendra pas effet.

Si vous souhaitez utiliser RedisTemplate avec une méthode de sérialisation personnalisée pour les opérations de mise en cache des données, vous pouvez vous référer au code principal ci-dessus pour créer un composant Bean nommé redisTemplate et définir la méthode de sérialisation correspondante dans le composant

Ensuite, créez un package nommé com.lagou.config dans le projet, créez une classe de configuration personnalisée Redis RedisConfig sous le package et personnalisez le composant Bean nommé redisTemplate selon les idées ci-dessus

@Configuration
public class RedisConfig {
    // 自定義RedisTemplate
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        // 創(chuàng)建一個(gè)JSON格式序列化對(duì)象，對(duì)緩存數(shù)據(jù)的key和value進(jìn)行轉(zhuǎn)換
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        // 解決查詢緩存轉(zhuǎn)換異常的問(wèn)題
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 設(shè)置RedisTemplate模板api序列化方式為json
        template.setDefaultSerializer(jackson2JsonRedisSerializer);
        return template;
    }
}

Définissez un RedisConfig via l'annotation @Configuration Configurez la classe et utilisez le @ Annotation Bean pour injecter un composant redisTemplate avec le nom par défaut du nom de la méthode (notez que le nom du composant Bean doit être redisTemplate). Dans le composant Bean défini, un RedisTemplate est personnalisé, à l'aide de la méthode de sérialisation des données Jackson2JsonRedisSerializer personnalisée?; dans la méthode de sérialisation personnalisée, un ObjectMapper est défini pour les paramètres de conversion des données

1.3, les tests d'effet

On peut voir que le informations sur les commentaires de l'utilisateur Le commentaire est correctement interrogé en exécutant la méthode findById(). Si la même opération de requête est répétée, la base de données n'exécute l'instruction SQL qu'une seule fois, ce qui montre que le cache Redis personnalisé prend effet.

Utilisez l'outil de gestion visuelle du client Redis Redis Desktop Manager pour afficher les données mises en cache?:

Exécutez la méthode findById() pour interroger les informations du commentaire de l'utilisateur. Le commentaire est correctement stocké dans la bibliothèque de cache Redis et les données mises en cache dans. le service Redis a été utilisé. L'affichage, la visualisation et la gestion du stockage au format JSON sont également très pratiques, ce qui indique que l'outil de modèle d'API Redis personnalisé RedisTemplate est efficace

2. RedisCacheManager personnalisé

vient d'améliorer la méthode de sérialisation personnalisée pour l'API. basé sur RedisTemplate pour réaliser la méthode de sérialisation JSON est utilisé pour mettre en cache les données, mais ce RedisTemplate personnalisé n'a aucun effet sur la mise en cache Redis basée sur les annotations.

Ensuite, nous expliquerons le mécanisme de mise en cache Redis basé sur les annotations et la méthode de sérialisation personnalisée

2.1, mécanisme de sérialisation par défaut des annotations Redis

Ouvrez la classe de configuration automatique du cache RedisCacheConfiguration (paquet org.springframework. boot.autoconfigure.cache), vue les informations sur le code source de cette classe, son code principal est le suivant

@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;
        }
    }
}

從上述核心源碼中可以看出，同RedisTemplate核心源碼類似，RedisCacheConfiguration內(nèi)部同樣通過(guò)Redis連接工廠RedisConnectionFactory定義了一個(gè)緩存管理器RedisCacheManager；同時(shí)定制RedisCacheManager時(shí)，也默認(rèn)使用了JdkSerializationRedisSerializer序列化方式。

如果想要使用自定義序列化方式的RedisCacheManager進(jìn)行數(shù)據(jù)緩存操作，可以參考上述核心代碼創(chuàng)建一個(gè)名為cacheManager的Bean組件，并在該組件中設(shè)置對(duì)應(yīng)的序列化方式即可

在Spring Boot 2.X版本中，RedisCacheManager是獨(dú)立構(gòu)建的。因此，在SpringBoot 2.X版本中，對(duì)RedisTemplate進(jìn)行自定義序列化機(jī)制構(gòu)建后，仍然無(wú)法對(duì)RedisCacheManager內(nèi)部默認(rèn)序列化機(jī)制進(jìn)行覆蓋（這也就解釋了基 于注解的Redis緩存實(shí)現(xiàn)仍然會(huì)使用JDK默認(rèn)序列化機(jī)制的原因），想要基于注解的Redis緩存實(shí)現(xiàn)也使用自定義序列化機(jī)制，需要自定義RedisCacheManager

2.2、自定義RedisCacheManager

在項(xiàng)目的Redis配置類RedisConfig中，按照上一步分析的定制方法自定義名為cacheManager的Bean組件

    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        // 分別創(chuàng)建String和JSON格式序列化對(duì)象，對(duì)緩存數(shù)據(jù)key和value進(jìn)行轉(zhuǎn)換
        RedisSerializer<String> strSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer jacksonSerial = new Jackson2JsonRedisSerializer(Object.class);
        // 解決查詢緩存轉(zhuǎn)換異常的問(wèn)題
        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); // 上面注釋過(guò)時(shí)代碼的替代方法
        jacksonSerial.setObjectMapper(om);
        // 定制緩存數(shù)據(jù)序列化方式及時(shí)效
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofDays(1)) // 設(shè)置緩存數(shù)據(jù)的時(shí)效（設(shè)置為了1天）
                .serializeKeysWith(RedisSerializationContext.SerializationPair
                        .fromSerializer(strSerializer)) // 對(duì)當(dāng)前對(duì)象的key使用strSerializer這個(gè)序列化對(duì)象，進(jìn)行轉(zhuǎn)換
                .serializeValuesWith(RedisSerializationContext.SerializationPair
                        .fromSerializer(jacksonSerial)) // 對(duì)value使用jacksonSerial這個(gè)序列化對(duì)象，進(jìn)行轉(zhuǎn)換
                .disableCachingNullValues();
        RedisCacheManager cacheManager = RedisCacheManager
                .builder(redisConnectionFactory).cacheDefaults(config).build();
        return cacheManager;
    }

上述代碼中，在RedisConfig配置類中使用@Bean注解注入了一個(gè)默認(rèn)名稱為方法名的cacheManager組件。在定義的Bean組件中，通過(guò)RedisCacheConfiguration對(duì)緩存數(shù)據(jù)的key和value分別進(jìn)行了序列化方式的定制，其中緩存數(shù)據(jù)的key定制為StringRedisSerializer（即String格式），而value定制為了Jackson2JsonRedisSerializer（即JSON格式），同時(shí)還使用entryTtl(Duration.ofDays(1))方法將緩存數(shù)據(jù)有效期設(shè)置為1天

完成基于注解的Redis緩存管理器RedisCacheManager定制后，可以對(duì)該緩存管理器的效果進(jìn)行測(cè)試（使用自定義序列化機(jī)制的RedisCacheManager測(cè)試時(shí)，實(shí)體類可以不用實(shí)現(xiàn)序列化接口）

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!