com.yuweix.kuafu.data.springboot.lettuce.LettuceClusterConf Maven / Gradle / Ivy
package com.yuweix.kuafu.data.springboot.lettuce;
import com.yuweix.kuafu.core.json.Json;
import com.yuweix.kuafu.data.cache.redis.lettuce.LettuceCache;
import com.yuweix.kuafu.data.serializer.JsonSerializer;
import com.yuweix.kuafu.data.serializer.Serializer;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.time.Duration;
import java.util.List;
/**
* redis集群
* @author yuwei
*/
public class LettuceClusterConf {
@Bean(name = "lettuceClientConfiguration")
public LettuceClientConfiguration clientConfiguration(@Value("${kuafu.redis.pool.max-total:20}") int maxTotal
, @Value("${kuafu.redis.pool.max-idle:10}") int maxIdle
, @Value("${kuafu.redis.pool.min-idle:10}") int minIdle
, @Value("${kuafu.redis.pool.max-wait-millis:10000}") long maxWaitMillis
, @Value("${kuafu.redis.pool.time-between-eviction-runs-millis:-1}") long timeBetweenEvictionRunsMillis
, @Value("${kuafu.redis.pool.test-on-borrow:false}") boolean testOnBorrow
, @Value("${kuafu.redis.timeoutMillis:5000}") long timeoutMillis) {
GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
poolConfig.setMaxTotal(maxTotal);
poolConfig.setMaxIdle(maxIdle);
poolConfig.setMinIdle(minIdle);
poolConfig.setMaxWaitMillis(maxWaitMillis);
poolConfig.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
poolConfig.setTestOnBorrow(testOnBorrow);
LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()
.commandTimeout(Duration.ofMillis(timeoutMillis))
.poolConfig(poolConfig)
.build();
return clientConfig;
}
@Bean(name = "redisClusterConfiguration")
public RedisClusterConfiguration redisClusterConfiguration(@Qualifier("redisNodeList") List redisNodeList
, @Value("${kuafu.redis.cluster.timeout:300000}") int timeout
, @Value("${kuafu.redis.cluster.max-redirections:6}") int maxRedirections) {
RedisClusterConfiguration conf = new RedisClusterConfiguration(redisNodeList);
conf.setMaxRedirects(maxRedirections);
return conf;
}
@Bean(name = "lettuceConnectionFactory")
public LettuceConnectionFactory lettuceConnectionFactory(@Qualifier("lettuceClientConfiguration") LettuceClientConfiguration clientConfig
, @Qualifier("redisClusterConfiguration") RedisClusterConfiguration config) {
LettuceConnectionFactory connFactory = new LettuceConnectionFactory(config, clientConfig);
connFactory.setValidateConnection(false);
connFactory.setShareNativeConnection(true);
return connFactory;
}
@Bean(name = "redisTemplate")
public RedisTemplate redisTemplate(@Qualifier("lettuceConnectionFactory") LettuceConnectionFactory connFactory) {
RedisSerializer redisSerializer = new StringRedisSerializer();
RedisTemplate template = new RedisTemplate<>();
template.setConnectionFactory(connFactory);
template.setKeySerializer(redisSerializer);
template.setValueSerializer(redisSerializer);
template.setEnableDefaultSerializer(true);
// template.setEnableTransactionSupport(true);
return template;
}
@ConditionalOnMissingBean(RedisMessageListenerContainer.class)
@Bean
public RedisMessageListenerContainer messageContainer(@Qualifier("lettuceConnectionFactory") LettuceConnectionFactory connFactory) {
RedisMessageListenerContainer container = new RedisMessageListenerContainer();
container.setConnectionFactory(connFactory);
return container;
}
@ConditionalOnMissingBean(Serializer.class)
@Bean
public Serializer cacheSerializer(Json json) {
return new JsonSerializer(json);
}
@ConditionalOnMissingBean(name = "redisCache")
@Bean(name = "redisCache")
public LettuceCache redisCache(@Qualifier("redisTemplate") RedisTemplate template
, Serializer serializer
, RedisMessageListenerContainer messageContainer) {
LettuceCache cache = new LettuceCache(template, serializer);
cache.setMessageContainer(messageContainer);
return cache;
}
}