經過springboot的配置建立多個redis實例
因爲在開發的過程當中，有時候程序中的某些redis定義的很亂，一個項目每每有好幾個redis服務，但定義的都不統一，經過使用spring的特性，實現了經過簡單明瞭的配置去讓代碼自動生成多個RedisTemplate bean。java
如下是配置的定義規範：node
spring:
redis:
timeout: 1000
lettuce:
pool:
maxActive: 2500
max-wait: 6000
max-idle: 500
min-idle: 100
sentinels:
temp1:
master: a
nodes: ip1:10201,ip2:10202
password:
temp2:
master: b
nodes: ip3:10201,ip4:10202
password:
primary: true //是否主要的bean
配置中其餘的redis配置仍是遵循springboot官方的，但另外擴展了一個sentinels屬性，這個屬性填充多個redis 配置信息，因爲咱們項目主要使用哨兵模式，故這裏使用sentinel方式實現。redis
其次配置類根據上面的配置信息能夠定義了：spring
@ConfigurationProperties(prefix = "spring.redis.sentinels")
public class RedisExtProperties extends HashMap<String, ExtSentinel>{
private static final long serialVersionUID = 856175258267105532L;
public static class ExtSentinel extends Sentinel {
private String password;
private boolean primary;
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public boolean isPrimary() {
return primary;
}
public void setPrimary(boolean primary) {
this.primary = primary;
}
}
}
以上是獲取配置信息的配置類了，接下來要經過某些手段去生成StringRedisTemplate的bean了，因爲有多個bean，並且bean的名稱要本身經過配置文件中定義的，經過註解@Bean或者xml等方式貌似都沒法達到目的，這裏就利用BeanDefinitionRegistryPostProcessor接口去實現，該接口怎麼使用能夠去查看spring的一些文檔或者網上搜索均可以找到，這裏不在贅述。springboot
這個接口有兩個方法postProcessBeanFactory、postProcessBeanDefinitionRegistry，這兩個方法均可以實現動態註冊bean，你們也能夠去網上搜索，可是呢，這裏卻不能經過這兩個方法去實現動態註冊StringRedisTemplate的bean，由於在初始化BeanDefinitionRegistryPostProcessor這個接口的實現時，還並無徹底加載springboot的相關配置，致使在這兩個方法裏或者經過註解@Autowired都沒法把RedisExtProperties注入進來，即使注入進來，也是沒有把相關配置信息初始化進去的，這把就坑了，後面想了半天直接經過AutowiredAnnotationBeanPostProcessor這個實現，重寫它的postProcessProperties方法去觸發動態註冊bean。app
@Component
public class RedisCustomFactory extends AutowiredAnnotationBeanPostProcessor
implements BeanDefinitionRegistryPostProcessor {
private final Logger logger = LoggerFactory.getLogger(getClass());
BeanDefinitionRegistry registry;
ConfigurableListableBeanFactory factory;
AtomicBoolean open = new AtomicBoolean(false);
@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
if (!open.get()) {
processFields(bean, bean.getClass().getDeclaredFields());
}
return super.postProcessProperties(pvs, bean, beanName);
}
private void processFields(Object bean, Field[] declaredFields) {
for (Field field : declaredFields) {
if (!open.get() && field.getType().isAssignableFrom(RedisOperations.class)) {
register(factory.getBean(RedisProperties.class), factory.getBean(RedisExtProperties.class),
factory.getBeanProvider(LettuceClientConfigurationBuilderCustomizer.class));
open.compareAndSet(false, true);
}
}
}
private LettuceClientConfigurationBuilder createBuilder(Pool pool) {
if (pool == null) {
return LettuceClientConfiguration.builder();
}
return new PoolBuilderFactory().createBuilder(pool);
}
// private void customize(LettuceClientConfiguration.LettuceClientConfigurationBuilder builder,
// ObjectProvider<LettuceClientConfigurationBuilderCustomizer> builderCustomizers) {
// builderCustomizers.orderedStream().forEach((customizer) -> customizer.customize(builder));
// }
private LettuceClientConfigurationBuilder applyProperties(
LettuceClientConfiguration.LettuceClientConfigurationBuilder builder, RedisProperties properties) {
if (properties.isSsl()) {
builder.useSsl();
}
if (properties.getTimeout() != null) {
builder.commandTimeout(properties.getTimeout());
}
if (properties.getLettuce() != null) {
RedisProperties.Lettuce lettuce = properties.getLettuce();
if (lettuce.getShutdownTimeout() != null && !lettuce.getShutdownTimeout().isZero()) {
builder.shutdownTimeout(properties.getLettuce().getShutdownTimeout());
}
}
return builder;
}
private LettuceClientConfiguration getLettuceClientConfiguration(ClientResources clientResources, Pool pool,
RedisProperties properties,
ObjectProvider<LettuceClientConfigurationBuilderCustomizer> builderCustomizers) {
LettuceClientConfigurationBuilder builder = createBuilder(pool);
applyProperties(builder, properties);
builder.clientResources(clientResources);
// customize(builder, builderCustomizers);
return builder.build();
}
private List<RedisNode> createSentinels(RedisProperties.Sentinel sentinel) {
List<RedisNode> nodes = new ArrayList<>();
for (String node : sentinel.getNodes()) {
try {
String[] parts = StringUtils.split(node, ":");
Assert.state(parts.length == 2, "Must be defined as 'host:port'");
nodes.add(new RedisNode(parts[0], Integer.valueOf(parts[1])));
} catch (RuntimeException ex) {
throw new IllegalStateException("Invalid redis sentinel " + "property '" + node + "'", ex);
}
}
return nodes;
}
protected RedisSentinelConfiguration getSentinelConfig(ExtSentinel sentinelProperties, RedisProperties properties) {
if (sentinelProperties != null) {
RedisSentinelConfiguration config = new RedisSentinelConfiguration();
config.master(sentinelProperties.getMaster());
config.setSentinels(createSentinels(sentinelProperties));
if (sentinelProperties.getPassword() != null) {
config.setPassword(RedisPassword.of(sentinelProperties.getPassword()));
}
config.setDatabase(properties.getDatabase());
return config;
}
return null;
}
private LettuceConnectionFactory createLettuceConnectionFactory(LettuceClientConfiguration clientConfiguration,
RedisSentinelConfiguration redisSentinelConfiguration, RedisProperties properties) {
return new LettuceConnectionFactory(redisSentinelConfiguration, clientConfiguration);
}
private LettuceConnectionFactory redisConnectionFactory(ClientResources clientResources,
RedisSentinelConfiguration redisSentinelConfiguration, RedisProperties properties,
ObjectProvider<LettuceClientConfigurationBuilderCustomizer> builderCustomizers)
throws UnknownHostException {
LettuceClientConfiguration clientConfig = getLettuceClientConfiguration(clientResources,
properties.getLettuce().getPool(), properties, null);
return createLettuceConnectionFactory(clientConfig, redisSentinelConfiguration, properties);
}
public synchronized void register(RedisProperties properties, RedisExtProperties extProperties,
ObjectProvider<LettuceClientConfigurationBuilderCustomizer> builderCustomizers) throws BeansException {
if (extProperties == null) {
return;
}
extProperties.forEach((name, sentinel) -> {
try {
if (!factory.containsBeanDefinition(name + "RedisTemplate")) {
logger.info("{} -----> {}", name, sentinel.isPrimary());
DefaultClientResources res = DefaultClientResources.create();
BeanDefinitionBuilder builder0 = BeanDefinitionBuilder
.genericBeanDefinition(DefaultClientResources.class, () -> res);
BeanDefinition beanDefinition0 = builder0.getRawBeanDefinition();
beanDefinition0.setPrimary(sentinel.isPrimary());
beanDefinition0.setDestroyMethodName("shutdown");
registry.registerBeanDefinition(name + "DefaultClientResources", beanDefinition0);
LettuceConnectionFactory ref = redisConnectionFactory(res, getSentinelConfig(sentinel, properties),
properties, builderCustomizers);
BeanDefinitionBuilder builder1 = BeanDefinitionBuilder
.genericBeanDefinition(RedisConnectionFactory.class, () -> ref);
BeanDefinition beanDefinition1 = builder1.getRawBeanDefinition();
beanDefinition1.setPrimary(sentinel.isPrimary());
registry.registerBeanDefinition(name + "RedisConnectionFactory", beanDefinition1);
BeanDefinitionBuilder builder2 = BeanDefinitionBuilder
.genericBeanDefinition(StringRedisTemplate.class, () -> {
StringRedisTemplate template = new StringRedisTemplate();
template.setConnectionFactory(ref);
return template;
});
BeanDefinition beanDefinition2 = builder2.getRawBeanDefinition();
beanDefinition2.setPrimary(sentinel.isPrimary());
registry.registerBeanDefinition(name + "RedisTemplate", beanDefinition2);
}
} catch (Exception ex) {
logger.error("register redisProperties error", ex);
}
});
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory factory) throws BeansException {
this.factory = factory;
}
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
this.registry = registry;
}
@Override
public int getOrder() {
return super.getOrder() - 1;
}
}
public class PoolBuilderFactory {
public LettuceClientConfigurationBuilder createBuilder(Pool properties) {
return LettucePoolingClientConfiguration.builder().poolConfig(getPoolConfig(properties));
}
private GenericObjectPoolConfig<?> getPoolConfig(Pool properties) {
GenericObjectPoolConfig<?> config = new GenericObjectPoolConfig<>();
config.setMaxTotal(properties.getMaxActive());
config.setMaxIdle(properties.getMaxIdle());
config.setMinIdle(properties.getMinIdle());
if (properties.getTimeBetweenEvictionRuns() != null) {
config.setTimeBetweenEvictionRunsMillis(properties.getTimeBetweenEvictionRuns().toMillis());
}
if (properties.getMaxWait() != null) {
config.setMaxWaitMillis(properties.getMaxWait().toMillis());
}
return config;
}
}
根據代碼的細節，能夠看到sentinels實際上是一個map，會把sentinels的key和RedisTemplate拼接成bean的名字，因此在使用的過程當中，若是有primary配置的直接使用@Autowired就能夠直接注入了，其餘的則@Qualifier+@Autowired既能夠注入了。ide
@Autowired
private StringRedisTemplate stringRedisTemplate;//對應的master 爲b的
@Autowired
@Qualifier("temp1RedisTemplate")
private StringRedisTemplate microblogRedisTemplate;//對應的master 爲a的
代碼有點糙，感謝你們閱讀，歡迎吐槽。post
相關文章
- 1. redis多實例配置
- 2. 配置多個Log4net實例
- 3. Redis 建立多個端口
- 4. Java中經過類名建立一個類的實例
- 5. windows環境下建立多個Redis實例
- 6. 建立IndexWriter實例時，經過IndexWriterConfig來設置其相關配置
- 7. springboot配置多數據源實例
- 8. 在vue中建立多個ueditor實例
- 9. redis單主機配置多實例
- 10. Springboot2.2 Redis多個實例簡單的手動配置
- 更多相關文章...
- • Maven 構建配置文件 - Maven教程
- • Redis主從複製的配置方法和執行過程 - Redis教程
- • IDEA下SpringBoot工程配置文件沒有提示
- • IntelliJ IDEA 代碼格式化配置和快捷鍵
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
