io.meshware.cache.redis.autoconfigure.RedisAutoConfigure Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of cache-redis Show documentation
There is a newer version: 0.1.3
package io.meshware.cache.redis.autoconfigure;

import io.meshware.cache.api.Cache;
import io.meshware.cache.api.CacheManager;
import io.meshware.cache.api.RedisCache;
import io.meshware.cache.api.properties.CacheAdapterProperties;
import io.meshware.cache.redis.config.RedisCacheConfig;
import io.meshware.cache.redis.implement.RedisClient;
import io.meshware.cache.redis.listener.RedisMessageSubscriber;
import io.meshware.cache.redis.publisher.RedisMessagePublisher;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.AutoConfigureBefore;
import org.springframework.boot.autoconfigure.condition.*;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.DependsOn;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.context.annotation.Import;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.listener.ChannelTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;
import org.springframework.data.redis.serializer.RedisSerializer;

/**
 * Redis AutoConfigure
 *
 * @author Zhiguo.Chen
 */
@Slf4j
@ConditionalOnClass(Cache.class)
@EnableAspectJAutoProxy(proxyTargetClass = true)
@AutoConfigureBefore({RedisAutoConfiguration.class})
@EnableConfigurationProperties(CacheAdapterProperties.class)
@Import({RedisCacheConfig.class})
@ConditionalOnExpression(value = "${cache.adapter.enable:true} and '${cache.adapter.cache-type}' eq '" + RedisAutoConfigure.CACHE_TYPE + "'")
public class RedisAutoConfigure {

    public static final String CACHE_TYPE = "redis";

    @Bean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
        return new StringRedisTemplate(redisConnectionFactory);
    }

    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        template.setKeySerializer(RedisSerializer.string());
        template.setValueSerializer(RedisSerializer.json());
        template.setHashKeySerializer(RedisSerializer.string());
        template.setHashValueSerializer(RedisSerializer.json());
        template.afterPropertiesSet();
        return template;
    }

    @Bean
    @ConditionalOnBean(StringRedisTemplate.class)
    @ConditionalOnMissingBean(RedisCache.class)
    @DependsOn({"stringRedisTemplate", "redisMessagePublisher"})
    @ConditionalOnProperty(prefix = "cache.adapter", value = "enable", havingValue = "true")
    public RedisCache redisCache(CacheAdapterProperties cacheAdapterProperties, StringRedisTemplate stringRedisTemplate,
                                 RedisMessagePublisher redisMessagePublisher) {
        if (CACHE_TYPE.equalsIgnoreCase(cacheAdapterProperties.getCacheType())) {
            return new RedisClient(stringRedisTemplate, cacheAdapterProperties, redisMessagePublisher);
        } else {
            log.error("CacheType is not 'redis', create bean error!");
            throw new IllegalArgumentException("CacheType setting is not 'redis'!");
        }
    }

    @Bean
    @ConditionalOnBean(StringRedisTemplate.class)
    @DependsOn("stringRedisTemplate")
    public RedisMessagePublisher redisMessagePublisher(StringRedisTemplate stringRedisTemplate) {
        return new RedisMessagePublisher(stringRedisTemplate);
    }

    @Bean
    public MessageListenerAdapter messageListener(ApplicationContext applicationContext) {
        return new MessageListenerAdapter(new RedisMessageSubscriber(applicationContext));
    }

    @Bean
    @ConditionalOnExpression(value = "'${cache.adapter.discard-channel:}' ne ''")
    public ChannelTopic topic(CacheAdapterProperties cacheAdapterProperties) {
        return new ChannelTopic(cacheAdapterProperties.getDiscardChannel());
    }

    @Bean
    @DependsOn({"messageListener", "topic"})
    @ConditionalOnBean(ChannelTopic.class)
    public RedisMessageListenerContainer redisContainer(RedisConnectionFactory redisConnectionFactory, MessageListenerAdapter messageListener, ChannelTopic topic) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(redisConnectionFactory);
        container.addMessageListener(messageListener, topic);
        return container;
    }

    @Bean
    public CacheManager cacheManager(ApplicationContext applicationContext) {
        CacheManager cacheManager = new CacheManager(applicationContext);
        return cacheManager;
    }
}