Bagaimana SpringBoot menyesuaikan Redis untuk melaksanakan penyirian cache

1. Templat Redis Tersuai

1.1. Mekanisme siri lalai Redis API

Pelaksanaan cache Redis berasaskan API menggunakan templat RedisTemplate untuk operasi caching data di sini untuk melihat maklumat kod sumber kelas ini

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());
        }
        ...
    }
        ...
}

Seperti yang dapat dilihat daripada kod sumber teras RedisTemplate di atas, pelbagai kaedah siri untuk kunci data dan nilai cache diisytiharkan di dalam RedisTemplate, dan nilai awalnya kosong; dalam kaedah afterPropertiesSet() , tentukan sama ada parameter siri lalai defaultSerializer kosong, tetapkan kaedah siri lalai data kepada JdkSerializationRedisSerializer

Menurut analisis maklumat kod sumber di atas, dua kesimpulan penting berikut boleh dilukis:

(1) Apabila menggunakan RedisTemplate untuk operasi caching data Redis, kaedah penyerikan lalai dalaman ialah JdkSerializationRedisSerializer, jadi kelas entiti untuk cache data mesti melaksanakan antara muka bersiri JDK sendiri (seperti <🎜); >

( 2) Apabila menggunakan RedisTemplate untuk melaksanakan operasi caching data Redis, jika kaedah siri cache defaultSerializer disesuaikan, kaedah siri tersuai akan digunakan.

Selain itu, dalam kod sumber kelas RedisTemplate, pelbagai jenis siri kunci data cache dan nilai yang dilihat ialah RedisSerializer. Masukkan kod sumber RedisSerializer untuk melihat kaedah bersiri yang disokong oleh RedisSerializer (selepas memasuki kelas, gunakan Ctrl+Alt+klik kiri nama kelas untuk melihat)

Ia boleh dapat dilihat bahawa RedisSerializer ialah antara muka bersiri Redis mempunyai 6 kelas pelaksanaan secara lalai 6 kelas pelaksanaan ini mewakili 6 kaedah bersiri data yang berbeza. Antaranya, JdkSerializationRedisSerializer disertakan dengan JDK dan juga merupakan kaedah siri data lalai yang digunakan dalam RedisTemplate Pembangun boleh memilih kaedah siri lain yang disokong (seperti kaedah JSON) mengikut keperluan mereka

1.2 Mekanisme siri Templat Tersuai

Selepas memperkenalkan pergantungan Redis ke dalam projek, konfigurasi automatik RedisAutoConfiguration yang disediakan oleh Spring Boot akan berkuat kuasa. Buka kelas RedisAutoConfiguration dan lihat definisi RedisTemplate dalam kod sumber dalaman

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

Seperti yang dapat dilihat daripada kod sumber teras RedisAutoConfiguration di atas, dalam kelas konfigurasi automatik Redis, RedisTemplate dimulakan melalui kilang sambungan Redis RedisConnectionFactory; di atas kelas Anotasi @ConditionalOnMissingBean (seperti namanya, berkuat kuasa apabila Bean tidak wujud) ditambah untuk menunjukkan bahawa jika pembangun menyesuaikan Bean bernama redisTemplate, RedisTemplate yang dimulakan secara lalai tidak akan berkuat kuasa.

Jika anda ingin menggunakan RedisTemplate dengan kaedah siri tersuai untuk operasi caching data, anda boleh merujuk kepada kod teras di atas untuk mencipta komponen Bean bernama redisTemplate dan menetapkan kaedah siri yang sepadan dalam komponen

Seterusnya, buat pakej bernama com.lagou.config dalam projek, buat kelas konfigurasi tersuai Redis RedisConfig di bawah pakej dan sesuaikan komponen Bean bernama redisTemplate mengikut idea di atas

@Configuration
public class RedisConfig {
    // 自定义RedisTemplate
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        // 创建一个JSON格式序列化对象，对缓存数据的key和value进行转换
        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);
        // 设置RedisTemplate模板api序列化方式为json
        template.setDefaultSerializer(jackson2JsonRedisSerializer);
        return template;
    }
}

mentakrifkan RedisConfig kelas konfigurasi melalui anotasi @Configuration dan menggunakan anotasi @Bean untuk menyuntik komponen redisTemplate dengan nama lalai nama kaedah (perhatikan bahawa nama komponen Bean mestilah redisTemplate). Dalam komponen Bean yang ditakrifkan, RedisTemplate disesuaikan, menggunakan kaedah siri data Jackson2JsonRedisSerializer tersuai dalam kaedah siri tersuai, ObjectMapper ditakrifkan untuk tetapan penukaran data

1.3, ujian kesan

dapat dilihat bahawa melaksanakan kaedah FindById () dengan betul menanyakan komen maklumat pengguna, dan mengulangi operasi pertanyaan yang sama. cache berkuat kuasa.

Gunakan alat pengurusan visual klien Redis Redis Desktop Manager untuk melihat data cache:

Laksanakan kaedah findById() untuk menanyakan maklumat ulasan pengguna dan Komen disimpan dengan betul dalam Redis Dalam pustaka cache, dan data yang dicache ke perkhidmatan Redis telah disimpan dan dipaparkan dalam format JSON, ia juga sangat mudah untuk dilihat dan diurus, menunjukkan bahawa alat templat API Redis tersuai RedisTemplate berkuat kuasa

2. RedisCacheManager Tersuai

Kami baru sahaja menambah baik kaedah siri tersuai untuk RedisTemplate berasaskan API, sekali gus merealisasikan kaedah siri JSON untuk menyimpan data, RedisTemplate tersuai ini cache Redis berasaskan anotasi.

Seterusnya, kami akan menerangkan mekanisme cache Redis berasaskan anotasi dan kaedah siri tersuai

2.1 mekanisme siri lalai anotasi Redis

Buka Spring Boot untuk menyepadukan komponen Redis yang disediakan. kelas konfigurasi automatik cache RedisCacheConfiguration (di bawah pakej org.springframework.boot.autoconfigure.cache), lihat maklumat kod sumber kelas ini, kod terasnya adalah seperti berikut

@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内部同样通过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;
    }

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

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

Atas ialah kandungan terperinci Bagaimana SpringBoot menyesuaikan Redis untuk melaksanakan penyirian cache. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!