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

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

项目用的springboot版本为

    <parent>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-parent</artifactid>
        <version>2.2.1.release</version>
        <relativepath/> <!-- lookup parent from repository -->
    </parent>

一、在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<string, object> 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<string, object> 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<string, object> redistemplatesingle(@qualifier("factory2")lettuceconnectionfactory connectionfactory) {//注意传入的对象名
        redistemplate<string, object> redistemplate = new redistemplate<>();
        redistemplate.setconnectionfactory(connectionfactory);
 
        redisserializer<string> redisserializer = new stringredisserializer();
        redistemplate.setkeyserializer(redisserializer);
        redistemplate.setvalueserializer(redisserializer);
        redistemplate.sethashkeyserializer(redisserializer);
        redistemplate.sethashvalueserializer(redisserializer);
        return redistemplate;
    }
}

三、使用redis

使用单实例redis

    /**
     * redis 单节点
     */
    @resource(name = "redistemplatesingle")
    private redistemplate redistemplatesingle;

使用redis集群

    /**
     * redis 集群
     */
    @resource(name = "redistemplate")
    private redistemplate redistemplate;

到此这篇关于springboot redis使用lettuce配置多数据源的实现的文章就介绍到这了,更多相关springboot lettuce多数据源内容请搜索www.887551.com以前的文章或继续浏览下面的相关文章希望大家以后多多支持www.887551.com！

黄山市民网：https://www.huangshanshimin.com/