Redis反序列化失败问题

redis反序列化类似于List ‘<Person’> 数据结构时，需要知道类型信息，
ObjectMapper.DefaultTyping.EVERYTHING 这句代码是关键点，让redis反序列化时知道List是什么类型

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.json.JsonMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.cache.CacheManager;
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.Cursor;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;
import java.util.ArrayList;
import java.util.List;


/**
 * @ClassName RedisConfig
 * @Description redis配置类
 * @Date 2024/12/5 9:11
 */
@Slf4j
@EnableCaching  // 开启缓存
@Configuration
public class RedisConfig {
    // 定义一个Bean，名称为"redisTemplate"，返回类型为RedisTemplate<String, Object>
    @Bean(name = "redisTemplate")
    public RedisTemplate<String, Object> getRedisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(objectMapper(), Object.class);
        redisTemplate.setKeySerializer(stringRedisSerializer);
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Bean("cacheManager")
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer =
                new Jackson2JsonRedisSerializer<>(objectMapper(), Object.class);
        RedisCacheConfiguration cacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(5))
                .disableCachingNullValues()
                .computePrefixWith(name -> name + ":")
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer));
        return RedisCacheManager.builder(redisConnectionFactory)
                .cacheDefaults(cacheConfiguration)
                .build();
    }

    private ObjectMapper objectMapper() {
        ObjectMapper objectMapper = JsonMapper.builder()
                .addModule(new JavaTimeModule())
                .build();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
                ObjectMapper.DefaultTyping.EVERYTHING, JsonTypeInfo.As.PROPERTY);
        return objectMapper;
    }

    @Bean
    @ConditionalOnProperty(name = "app.cache.clear-on-startup", havingValue = "true")
    public CommandLineRunner cacheClearRunner(RedisTemplate<String, Object> redisTemplate,
            @Value("${app.cache.clear-patterns:}") List<String> patterns) {

        return args -> {
            for (String pattern : patterns) {
                safeClearCache(redisTemplate, pattern);
            }
        };
    }

    private void safeClearCache(RedisTemplate<String, Object> redisTemplate, String pattern) {
        try {
            log.info("Clearing cache for pattern: " + pattern);
            int deleted = 0;
            Cursor<String> cursor = redisTemplate.scan(
                    ScanOptions.scanOptions().match(pattern).count(100).build());

            List<String> keysBatch = new ArrayList<>(100);
            while (cursor.hasNext()) {
                keysBatch.add(cursor.next());
                if (keysBatch.size() >= 100) {
                    redisTemplate.delete(keysBatch);
                    deleted += keysBatch.size();
                    keysBatch.clear();
                }
            }
            if (!keysBatch.isEmpty()) {
                redisTemplate.delete(keysBatch);
                deleted += keysBatch.size();
            }
            log.info("Cleared {} keys for pattern: {}", deleted, pattern);
        } catch (Exception e) {
            log.error("Cache clear error for pattern " + pattern + ": " + e.getMessage());
            log.error(e.getMessage(), e);
        }
    }
}