All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.github.anonymousmister.bootfastconfig.cache.redis.RedisConfig Maven / Gradle / Ivy

package com.github.anonymousmister.bootfastconfig.cache.redis;

import com.github.anonymousmister.bootfastconfig.cache.CacheBeanNameConstant;
import com.github.anonymousmister.bootfastconfig.cache.CacheConfig;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

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

import static com.github.anonymousmister.bootfastconfig.constant.BeanNameConstant.MY_REDIS_SERIALIZER;


/**
 * The type Redis config.
 */
@ConditionalOnClass(value = {RedisSerializer.class, CachingConfigurerSupport.class, RedisTemplate.class})
public class RedisConfig {

    @Qualifier(MY_REDIS_SERIALIZER)
    @Autowired
    private RedisSerializer redisSerializer;

    @Autowired(required = false)
    private List cacheConfigs;


    /**
     * Cache manager cache manager.
     *
     * @param connectionFactory the connection factory
     * @return the cache manager
     */
    @Bean(CacheBeanNameConstant.REDIS_CACHE_MANAGER)
    @ConditionalOnMissingBean(name = {CacheBeanNameConstant.REDIS_CACHE_MANAGER}, value = RedisCacheWriter.class)
    public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        RedisCacheConfig redisCacheConfig = initRedisCacheConfig();
        RedisCacheManager redisCacheManager = redisCacheConfig.buildRedisCacheManager(new MyRedisCacheWriter(connectionFactory));
        return redisCacheManager;
    }


    RedisCacheConfig initRedisCacheConfig() {
        RedisCacheConfig redisCacheConfig = new RedisCacheConfig();
        if (cacheConfigs != null) {
            for (CacheConfig cacheConfig : cacheConfigs) {
                redisCacheConfig.setDefaultRedisCacheConfig(cacheConfig.getDefaultRedisCacheConfig());
                cacheConfig.addRedisCacheConfig(redisCacheConfig);
            }
        }
        //设置CacheManager的值序列化方式为 fastJsonRedisSerializer,但其实RedisCacheConfiguration默认使用StringRedisSerializer序列化key,
        RedisSerializationContext.SerializationPair pair = RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer);
        RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig();
        defaultCacheConfig = defaultCacheConfig.entryTtl(Duration.ofMinutes(30))
                .serializeValuesWith(pair)
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()));
        redisCacheConfig.setDefaultRedisCacheConfig(defaultCacheConfig);

        return redisCacheConfig;
    }


//    public CacheManager cacheManager2(RedisConnectionFactory factory) {
//        RedisCacheConfiguration cacheConfiguration =RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofDays(1))//缓存1天
//                .disableCachingNullValues().computePrefixWith(cacheName -> "miaosha1".concat(":").concat(cacheName).concat(":"))
//                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new
//                        GenericJackson2JsonRedisSerializer()));
//        // 设置一个初始化的缓存空间set集合
//        Set cacheNames =  new HashSet<>();
//        cacheNames.add("my-redis-cache1");
//        cacheNames.add("user");
//
//        // 对每个缓存空间应用不同的配置
//        Map configMap = new HashMap<>();
//        configMap.put("my-redis-cache1", cacheConfiguration);
//        configMap.put("user", cacheConfiguration.entryTtl(Duration.ofSeconds(120)));
//        RedisCacheManager cacheManager = RedisCacheManager.builder(new MyRedisCacheWriter(factory))     // 使用自定义的缓存配置初始化一个cacheManager
//                .initialCacheNames(cacheNames)  // 注意这两句的调用顺序,一定要先调用该方法设置初始化的缓存名,再初始化相关的配置
//                .withInitialCacheConfigurations(configMap).cacheDefaults(cacheConfiguration)
//                .build();
//        return cacheManager;
//    }

    /**
     * Redis template redis template.
     *
     * @param factory the factory
     * @return the redis template
     */
//    @Bean
//    public RedisTemplate redisTemplate(
//            RedisConnectionFactory factory) {
//        StringRedisTemplate template = new StringRedisTemplate(factory);
//        template.setValueSerializer(redisSerializer);
//        template.afterPropertiesSet();
//        return template;
//    }
    @Bean
    public RedisTemplate redisTemplate2(
            RedisConnectionFactory factory) {
        RedisTemplate template = new RedisTemplate<>();
        // 配置连接工厂
        template.setConnectionFactory(factory);
        // 值采用json序列化
        template.setValueSerializer(redisSerializer);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());

        // 设置hash key 和value序列化模式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(redisSerializer);
        template.afterPropertiesSet();
        return template;
    }

}