Spring Boot 2.x Redis多数据源配置(jedis,lettuce)

96  不敢预言的预言家

 0.1 2018.11.13 14:22* 字数 65 阅读 727评论 0喜欢 2

多数据源最终表现其实就是 redis connection factory 不同

springboot 默认的redis配置维护了一套 connection factory

自己维护一套 connection factory 即可实现

application.yml

spring:

  redis:

#    默认配置

    database: 0

    host: 10.180.29.19

    port: 6379

    password: admin

    timeout: 2000

    lettuce:

      pool:

        max-active: 20

        max-wait: -1

        max-idle: 10

        min-idle: 0

#    自定义配置

    local:

      host: 127.0.0.1

      port: 6379

      password: admin

RedisConfig.java

package site.yuyanjia.template.common.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;

import com.fasterxml.jackson.annotation.PropertyAccessor;

import com.fasterxml.jackson.databind.ObjectMapper;

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

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

import org.springframework.cache.annotation.CachingConfigurerSupport;

import org.springframework.cache.annotation.EnableCaching;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

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

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

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

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.Jackson2JsonRedisSerializer;

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

import org.springframework.util.ObjectUtils;

import java.time.Duration;

/**

 * RedisConfig

 *

 * @author seer

 * @date 2018/5/30 09:32

 */

@Configuration

@EnableCaching

public class RedisConfig extends CachingConfigurerSupport {

    /**

     * 本地数据源 redis template

     *

     * @param database

     * @param timeout

     * @param maxActive

     * @param maxWait

     * @param maxIdle

     * @param minIdle

     * @param hostName

     * @param port

     * @param password

     * @return

     */

    @Bean

    public RedisTemplate redisTemplateLocal(

            @Value("${spring.redis.database}") int database,

            @Value("${spring.redis.timeout}") long timeout,

            @Value("${spring.redis.lettuce.pool.max-active}") int maxActive,

            @Value("${spring.redis.lettuce.pool.max-wait}") int maxWait,

            @Value("${spring.redis.lettuce.pool.max-idle}") int maxIdle,

            @Value("${spring.redis.lettuce.pool.min-idle}") int minIdle,

            @Value("${spring.redis.local.host}") String hostName,

            @Value("${spring.redis.local.port}") int port,

            @Value("${spring.redis.local.password}") String password) {

        /* ========= 基本配置 ========= */

        RedisStandaloneConfiguration configuration = new RedisStandaloneConfiguration();

        configuration.setHostName(hostName);

        configuration.setPort(port);

        configuration.setDatabase(database);

        if (!ObjectUtils.isEmpty(password)) {

            RedisPassword redisPassword = RedisPassword.of(password);

            configuration.setPassword(redisPassword);

        }

        /* ========= 连接池通用配置 ========= */

        GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();

        genericObjectPoolConfig.setMaxTotal(maxActive);

        genericObjectPoolConfig.setMinIdle(minIdle);

        genericObjectPoolConfig.setMaxIdle(maxIdle);

        genericObjectPoolConfig.setMaxWaitMillis(maxWait);

        /* ========= jedis pool ========= */

        /*

        JedisClientConfiguration.DefaultJedisClientConfigurationBuilder builder = (JedisClientConfiguration.DefaultJedisClientConfigurationBuilder) JedisClientConfiguration

                .builder();

        builder.connectTimeout(Duration.ofSeconds(timeout));

        builder.usePooling();

        builder.poolConfig(genericObjectPoolConfig);

        JedisConnectionFactory connectionFactory = new JedisConnectionFactory(configuration, builder.build());

        // 连接池初始化

        connectionFactory.afterPropertiesSet();

        */

        /* ========= lettuce pool ========= */

        LettucePoolingClientConfiguration.LettucePoolingClientConfigurationBuilder builder = LettucePoolingClientConfiguration.builder();

        builder.poolConfig(genericObjectPoolConfig);

        builder.commandTimeout(Duration.ofSeconds(timeout));

        LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(configuration, builder.build());

        connectionFactory.afterPropertiesSet();

        /* ========= 创建 template ========= */

        return createRedisTemplate(connectionFactory);

    }

    /**

     * 默认配置(10.180.29.19) redis template

     *

     * @param redisConnectionFactory

     * @return

     */

    @Bean

    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {

        return createRedisTemplate(redisConnectionFactory);

    }

    /**

     * json 实现 redisTemplate

     * <p>

     * 该方法不能加 @Bean 否则不管如何调用，connectionFactory都会是默认配置

     *

     * @param redisConnectionFactory

     * @return

     */

    public RedisTemplate createRedisTemplate(RedisConnectionFactory redisConnectionFactory) {

        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();

        redisTemplate.setConnectionFactory(redisConnectionFactory);

        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);

        ObjectMapper objectMapper = new ObjectMapper();

        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);

        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);

        redisTemplate.setKeySerializer(new StringRedisSerializer());

        redisTemplate.afterPropertiesSet();

        return redisTemplate;

    }

}

使用

    /**

     * 本地redis

     */

    @Autowired

    private RedisTemplate redisTemplateLocal;

    /**

     * 默认redis

     */

    @Autowired

    private RedisTemplate redisTemplate;

不甚明白的可以了解下 Autowired 的装配机制