Caching 使用redis缓存管理器、redisTemplate和多个序列化程序进行缓存

我需要缓存多种类型，如：

public Country findCountry(String countryName)

以及：

public List<Destination> findAllDestinations(String countryName)

公共列表findAllDestinations（字符串countryName）

---

我使用的是RedisCacheManager，RedisTemplate只支持一个序列化程序。

经过一些研究，现在已经解决了这个问题

将spring数据redis更改为1.4.2.0版本

使用缓存映射到序列化程序（cacheName->serializer）和缓存名称的类扩展RedisCacheManager

重写getCache方法（Cache getCache（String name）），并基于缓存名称在redis模板中设置序列化程序名称

使用定制的缓存管理器

范例-

public class CustomRedisCacheManager extends RedisCacheManager
{
    public static final String CACHE_NAME_DEFAULT = "default";
    public static final String CACHE_NAME_COUNTRY = "country";
    public static final String CACHE_NAME_DESTINATIONS = "destinations";    

    private Map<String, RedisCache> redisCaches = new HashMap<>();

    public CustomRedisCacheManager(Map<String, RedisTemplate> redisTemplates)
    {
        super(redisTemplates.get(CACHE_NAME_DEFAULT), redisTemplates.keySet());

        redisTemplates.keySet().stream().forEach(cacheName ->    redisCaches.put(cacheName, new RedisCache(cacheName, null,   redisTemplates.get(cacheName), 0)));
    }

    @Override
    public Cache getCache(String cacheName)
    {
        return redisCaches.get(cacheName);
    }
}

@Configuration
@EnableCaching
public class RedisConfiguration extends CachingConfigurerSupport
{    
    @Bean
    public JedisConnectionFactory jedisConnectionFactory()
    {
        JedisConnectionFactory factory = new JedisConnectionFactory();
        factory.setHostName(redisHostName);
        factory.setPort(redisPort);            
        factory.setTimeout(100);

        return factory;
    }

    @Bean
    public CacheManager cacheManager()
    {
        Map<String, RedisTemplate> templates = new HashMap<>();
        templates.put(CACHE_NAME_DEFAULT, getDefaultRedisTemplate());
        templates.put(CACHE_NAME_COUNTRY, getMetadataRedisTemplate());
        templates.put(CACHE_NAME_DESTINATIONS, getDestinationsRedisTemplate());        

        SabreRedisCacheManager sabreRedisCacheManager = new    SabreRedisCacheManager(templates);

        return sabreRedisCacheManager;
    }

    @Bean
    public RedisTemplate<Object, Object> getDefaultRedisTemplate()
    {
        return getBaseRedisTemplate();
    }

    @Bean
    public RedisTemplate<Object, Object> getCountryRedisTemplate()
    {
        RedisTemplate<Object, Object> redisTemplate = getBaseRedisTemplate();
          redisTemplate.setValueSerializer(jsonRedisSerializer(Country.class));

        return redisTemplate;
    }

    @Bean
public RedisTemplate<Object, Object> getDestinationsRedisTemplate()
{
    RedisTemplate<Object, Object> redisTemplate = getBaseRedisTemplate();
    redisTemplate.setValueSerializer(jsonRedisSerializer(TypeFactory.defaultInstance().constructCollectionType(List.class, Destination.class)));


    return redisTemplate;
}

private RedisTemplate<Object, Object> getBaseRedisTemplate()
{
    RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
    redisTemplate.setConnectionFactory(jedisConnectionFactory());
    redisTemplate.setKeySerializer(stringRedisSerializer());
    redisTemplate.setHashKeySerializer(stringRedisSerializer());
    redisTemplate.setValueSerializer(jsonRedisSerializer(Object.class));

    return redisTemplate;
}

private Jackson2JsonRedisSerializer jsonRedisSerializer(Class type)
{
    return jsonRedisSerializer(TypeFactory.defaultInstance().constructType(type));
}

private Jackson2JsonRedisSerializer jsonRedisSerializer(JavaType javaType)
{
    Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(javaType);
    jackson2JsonRedisSerializer.setObjectMapper(new JsonObjectMapper());

    return jackson2JsonRedisSerializer;
}
}

公共类CustomRedisCacheManager扩展了RedisCacheManager
{
公共静态最终字符串缓存\u NAME\u DEFAULT=“DEFAULT”；
公共静态最终字符串缓存\u NAME\u COUNTRY=“COUNTRY”；
公共静态最终字符串缓存\u NAME\u DESTINATIONS=“DESTINATIONS”；
私有映射redisCaches=newhashmap（）；
公共CustomRedisCacheManager（地图redisTemplates）
{
super（redisTemplates.get（CACHE_NAME_DEFAULT），redisTemplates.keySet（））；
redisTemplates.keySet（）.stream（）.forEach（cacheName->redisCaches.put（cacheName，new RedisCache（cacheName，null，redisTemplates.get（cacheName），0））；
}
@凌驾
公共缓存getCache（字符串缓存名称）
{
返回redisCaches.get（cacheName）；
}
}
@配置
@启用缓存
公共类配置扩展了CachingConfigurerSupport
{    
@豆子
公共绝地连接工厂绝地连接工厂（）
{
JedisConnectionFactory=新的JedisConnectionFactory（）；
setHostName（redisHostName）；
工厂设置端口（重新端口）；
工厂设置超时（100）；
返回工厂；
}
@豆子
公共缓存管理器缓存管理器（）
{
映射模板=新的HashMap（）；
put（CACHE_NAME_DEFAULT，getDefaultRedisTemplate（））；
put（CACHE_NAME_COUNTRY，getMetadataRedisTemplate（））；
put（缓存\名称\目的地，getDestinationsRedisTemplate（））；
SabreRedisCacheManager SabreRedisCacheManager=新的SabreRedisCacheManager（模板）；
返回sabreRedisCacheManager；
}
@豆子
公共RedisTemplate getDefaultRedisTemplate（）
{
返回getBaseRedisTemplate（）；
}
@豆子
公共RedisTemplate getCountryRedisTemplate（）
{
RedisTemplate RedisTemplate=getBaseRedisTemplate（）；
setValueSerializer（jsonRedisSerializer（Country.class））；
返回模板；
}
@豆子
公共RedisTemplate getDestinationsRedisTemplate（）
{
RedisTemplate RedisTemplate=getBaseRedisTemplate（）；
redisTemplate.setValueSerializer（jsonRedisSerializer（TypeFactory.defaultInstance（）.constructCollectionType（List.class，Destination.class））；
返回模板；
}
私有RedisTemplate getBaseRedisTemplate（）
{
RedisTemplate RedisTemplate=新RedisTemplate（）；
redisTemplate.setConnectionFactory（jedisConnectionFactory（））；
setKeySerializer（stringRedisSerializer（））；
setHashKeySerializer（stringRedisSerializer（））；
setValueSerializer（jsonRedisSerializer（Object.class））；
返回模板；
}
私有Jackson2JsonRedisSerializer jsonRedisSerializer（类类型）
{
返回jsonRedisSerializer（TypeFactory.defaultInstance（）.constructType（type））；
}
私有Jackson2JsonRedisSerializer jsonRedisSerializer（JavaType JavaType）
{
Jackson2JsonRedisSerializer Jackson2JsonRedisSerializer=新的Jackson2JsonRedisSerializer（javaType）；
setObjectMapper（新的JsonObjectMapper（））；
返回jackson2json重新序列化器；
}
}

您是否可以共享一些代码来更好地解释上述问题？您不需要明确的缓存映射。AbstractCacheManager中已经有了它。您只需要使方法addCache（Cache Cache）在CacheManager子类中可见