springboot redis使用lettuce配置多数据源的实现

springboot redis使用lettuce配置多数据源的实现

目前项目上需要连接两个redis数据源，一个redis数据源是单机模式，一个redis数据源是分片集群模式，这里将具体配置列一下。

项目用的springboot版本为

org.springframework.boot

spring-boot-starter-parent

2.2.1.RELEASE

一、在yml中配置redis数据源信息

redis:

cluster:

nodes: 127.0.0.1:9001

lettuce:

#连接池配置

pool:

#连接池最大连接数

max-active: 20

#连接池最大等待时间，负数表示不做限制

max-wait: -1

#最大空闲连接

max-idle: 9

#最小空闲连接

min-idle: 0

timeout: 500000

redis2:

host: 127.0.0.1

port: 6385

lettuce:

pool:

max-active: 20

max-idle: 8

max-wait: -1

min-idle: 0

timeout: 500000

（这里的redis都没有配置密码）

二、添加redis配置类

package com.cq.config;

import cn.hutool.core.convert.Convert;

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.boot.context.properties.ConfigurationProperties;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.context.annotation.Primary;

import org.springframework.core.env.Environment;

import org.springframework.core.env.MapPropertySource;

import org.springframework.data.redis.connection.RedisClusterConfiguration;

import org.springframework.data.redis.connection.RedisConnectionFactory;

import org.springframework.data.redis.connection.RedisStandaloneConfiguration;

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.serializer.RedisSerializer;

import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.io.Serializable;

import java.util.HashMap;

import java.util.Map;

/**

* @author cccccloud on 2020/11/16 17:16

*/

@Configuration

public class RedisConfig {

@Autowired

private Environment environment;

@Value("${spring.redis2.host}")

private String host;

@Value("${spring.redis2.port}")

private String port;

@Value("${spring.redis2.lettuce.pool.max-active}")

private String max_active;

@Value("${spring.redis2.lettuce.pool.max-idle}")

private String max_idle;

@Value("${spring.redis2.lettuce.pool.max-wait}")

private String max_wait;

@Value("${spring.redis2.lettuce.pool.min-idle}")

private String min_idle;

/**

* 配置lettuce连接池

*

* @return

*/

@Bean

@Primary

@ConfigurationProperties(prefix = "spring.redis.cluster.lettuce.pool")

public GenericObjectPoolConfig redisPool() {

return new GenericObjectPoolConfig();

}

/**

* 配置第一个数据源的

*

* @return

*/

@Bean("redisClusterConfig")

@Primary

public RedisClusterConfiguration redisClusterConfig() {

Map source = new HashMap<>(8);

source.put("spring.redis.cluster.nodes", environment.getProperty("spring.redis.cluster.nodes"));

RedisClusterConfiguration redisClusterConfiguration;

redisClusterConfiguration = new RedisClusterConfiguration(new MapPropertySource("RedisClusterConfiguration", source));

redisClusterConfiguration.setPassword(environment.getProperty("spring.redis.password"));

return redisClusterConfiguration;

}

/**

* 配置第一个数据源的连接工厂

* 这里注意：需要添加@Primary 指定bean的名称，目的是为了创建两个不同名称的LettuceConnectionFactory

*

* @param redisPool

* @param redisClusterConfig

* @return

*/

@Bean("lettuceConnectionFactory")

@Primary

public LettuceConnectionFactory lettuceConnectionFactory(GenericObjectPoolConfig redisPool, @Qualifier("redisClusterConfig") RedisClusterConfiguration redisClusterConfig) {

LettuceClientConfiguration clientConfiguration = LettucePoolingClientConfiguration.builder().poolConfig(redisPool).build();

return new LettuceConnectionFactory(redisClusterConfig, clientConfiguration);

}

/**

* 配置第一个数据源的RedisTemplate

* 注意：这里指定使用名称=factory 的 RedisConnectionFactory

* 并且标识第一个数据源是默认数据源 @Primary

*

* @param redisConnectionFactory

* @return

*/

@Bean("redisTemplate")

@Primary

public RedisTemplate redisTemplate(@Qualifier("lettuceConnectionFactory") RedisConnectionFactory redisConnectionFactory) {

RedisTemplate template = new RedisTemplate<>();

template.setConnectionFactory(redisConnectionFactory);

StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

// key采用String的序列化方式

template.setKeySerializer(stringRedisSerializer);

// hash的key也采用String的序列化方式

template.setHashKeySerializer(stringRedisSerializer);

// value序列化方式采用jackson

template.setValueSerializer(stringRedisSerializer);

// hash的value序列化方式采用jackson

template.setHashValueSerializer(stringRedisSerializer);

template.afterPropertiesSet();

return template;

}

@Bean

public GenericObjectPoolConfig redisPool2() {

GenericObjectPoolConfig config = new GenericObjectPoolConfig();

config.setMinIdle(Convert.toInt(min_idle));

config.setMaxIdle(Convert.toInt(max_idle));

config.setMaxTotal(Convert.toInt(max_active));

config.setMaxWaitMillis(Convert.toInt(max_wait));

return config;

}

@Bean

public RedisStandaloneConfiguration redisConfig2() {

RedisStandaloneConfiguration redisConfig = new RedisStandaloneConfiguration(host,Convert.toInt(port));

return redisConfig;

}

@Bean("factory2")

public LettuceConnectionFactory factory2(@Qualifier("redisPool2") GenericObjectPoolConfig config,

@Qualifier("redisConfig2") RedisStandaloneConfiguration redisConfig) {//注意传入的对象名和类型RedisStandaloneConfiguration

LettuceClientConfiguration clientConfiguration = LettucePoolingClientConfiguration.builder().poolConfig(config).build();

return new LettuceConnectionFactory(redisConfig, clientConfiguration);

}

/**

* 单实例redis数据源

*

* @param connectionFactory

* @return

*/

@Bean("redisTemplateSingle")

public RedisTemplate redisTemplateSingle(@Qualifier("factory2")LettuceConnectionFactory connectionFactory) {//注意传入的对象名

RedisTemplate redisTemplate = new RedisTemplate<>();

redisTemplate.setConnectionFactory(connectionFactory);

RedisSerializer redisSerializer = new StringRedisSerializer();

redisTemplate.setKeySerializer(redisSerializer);

redisTemphttp://late.setValueSerializer(redisSerializer);

redisTemplate.setHashKeySerializer(redisSerializer);

redisTemplate.setHashValueSerializer(redisSerializer);

return redisTemplate;

}

}

三、使用redis

使用单实例redis

/**

* redis 单节点

*/

@Resource(name = "redisTemplateSingle")

private RedisTemplate redisTemplateSingle;

使http://用redis集群

/**

* redis 集群

*/

@Resource(name = "redisTemplate")

private RedisTemplate redisTemplate;

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。