springboot 配置多个Redis数据源详解

最新推荐文章于 2024-06-12 18:27:29 发布
最新推荐文章于 2024-06-12 18:27:29 发布
阅读量2.7k 收藏 7
点赞数
分类专栏： springboot redis 文章标签： spring boot redis 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A_awen/article/details/134141087
版权

实现原理

  1. 需要配置好两个数据源，创建两个RedisTemplate
  2. 在配置类中注入两个RedisConnectionFactory，分别创建对应的RedisTemplate进行操作

详解

配置数据源

我这里是在之前已有一个配置下面另外加了一个

spring：
  redis:
    # 地址
    host: localhost
    # 端口，默认为6379
    port: 6379
    # 数据库索引
    database: 0
    # 密码
    password: xxxx
    # 连接超时时间
    timeout: 10s
    lettuce:
      pool:
        # 连接池中的最小空闲连接
        min-idle: 0
        # 连接池中的最大空闲连接
        max-idle: 8
        # 连接池的最大数据库连接数
        max-active: 8
        # #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1ms
    #第二数据源
    second:
      host: 127.0.0.1
      port: 6379
      password: xxx

创建配置文件


import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
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.jedis.JedisConnectionFactory;


@Configuration
public class RedisConfigs {


    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private int port;

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

    @Value("${spring.redis.second.host}")
    private String secondHost;

    @Value("${spring.redis.second.port}")
    private int secondPort;

    @Value("${spring.redis.second.password}")
    private String secondPassword;


    @Bean(name = "redisConnectionFactory")
    @Primary  //默认选择这个数据源进行执行
    @Qualifier("redisConnectionFactory")
    public RedisConnectionFactory redisConnectionFactory() {
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
        config.setHostName(host);
        config.setPort(port);
        config.setPassword(RedisPassword.of(password));
        return new JedisConnectionFactory(config);
    }

    @Bean(name = "secondRedisConnectionFactory")
    @Qualifier("secondRedisConnectionFactory")
    public RedisConnectionFactory secondRedisConnectionFactory() {
        RedisStandaloneConfiguration config = new RedisStandaloneConfiguration();
        config.setHostName(secondHost);
        config.setPort(port);
        config.setPassword(RedisPassword.of(secondPassword));
        return new JedisConnectionFactory(config);
    }


}

创建工具类

注入配置类中的RedisConnectionFactory分别生成对应的RedisTemplate，然后进行操作就可以啦

import com.bdtd.limit.common.config.FastJson2JsonRedisSerializer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Component
public class RedisUtil {

    private final RedisConnectionFactory redisConnectionFactory;
    private final RedisConnectionFactory secondRedisConnectionFactory;



    @Autowired
    public RedisUtil(RedisConnectionFactory redisConnectionFactory,
                     @Qualifier("secondRedisConnectionFactory")
                             RedisConnectionFactory secondRedisConnectionFactory) {
        this.redisConnectionFactory = redisConnectionFactory;
        this.secondRedisConnectionFactory = secondRedisConnectionFactory;
    }


    public RedisTemplate<String, Object> getRedisTemplate() {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);

        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(serializer);

        // Hash的key也采用StringRedisSerializer的序列化方式
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(serializer);

        redisTemplate.afterPropertiesSet();


        return redisTemplate;
    }

    public RedisTemplate<String, Object> getSecondRedisTemplate() {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(secondRedisConnectionFactory);

        FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);

        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(serializer);

        // Hash的key也采用StringRedisSerializer的序列化方式
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(serializer);

        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    /**
     * 第一数据源
     *  缓存基本的对象，Integer、String、实体类等
     *
     * @param key 缓存的键值
     * @param value 缓存的值
     */
    public <T> void setCacheObject(final String key, final T value)
    {
        getRedisTemplate().opsForValue().set(key, value);
    }

    /**
     *  第一数据源
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key 缓存的键值
     * @param value 缓存的值
     * @param timeout 时间
     * @param timeUnit 时间颗粒度
     */
    public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
    {
        getRedisTemplate().opsForValue().set(key, value, timeout, timeUnit);
    }
    /**
     *  第一数据源
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @param unit 时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit)
    {
        return getRedisTemplate().expire(key, timeout, unit);
    }
    /**
     *  第一数据源
     * 判断 key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public Boolean hasKey(String key)
    {
        return getRedisTemplate().hasKey(key);
    }

    /**
     *  第一数据源
     * 获得缓存的基本对象。
     *
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public Object getCacheObject(final String key)
    {
        ValueOperations<String, Object> operation = getRedisTemplate().opsForValue();
        return operation.get(key);
    }
    /**
     *  第一数据源
     * 删除单个对象
     *
     * @param key
     */
    public boolean deleteObject(final String key)
    {
        return getRedisTemplate().delete(key);
    }

    /**
     *  第一数据源
     * 删除集合对象
     *
     * @param collection 多个对象
     * @return
     */
    public boolean deleteObject(final Collection collection)
    {
        return getRedisTemplate().delete(collection) > 0;
    }

    /**
     *  第一数据源
     * 缓存List数据
     *
     * @param key 缓存的键值
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public <T> long setCacheList(final String key, final List<T> dataList)
    {
        Long count = getRedisTemplate().opsForList().rightPushAll(key, dataList);
        return count == null ? 0 : count;
    }

    /**
     *  第一数据源
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public <T> List<T> getCacheList(final String key)
    {
        return (List<T>) getRedisTemplate().opsForList().range(key, 0, -1);
    }

    /**
     *  第一数据源
     * 缓存Map
     *
     * @param key
     * @param dataMap
     */
    public <T> void setCacheMap(final String key, final Map<String, T> dataMap)
    {
        if (dataMap != null) {
            getRedisTemplate().opsForHash().putAll(key, dataMap);
        }
    }

    /**
     *  第一数据源
     * 获得缓存的Map
     *
     * @param key
     * @return
     */
    public <T> Map<Object, Object> getCacheMap(final String key)
    {
        return getRedisTemplate().opsForHash().entries(key);
    }

 
    /**
     *  第二数据源
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key 缓存的键值
     * @param value 缓存的值
     */
    public <T> void setSencondCacheObject(final String key, final T value)
    {
        getSecondRedisTemplate().opsForValue().set(key, value);
    }

    /**
     *  第二数据源
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key 缓存的键值
     * @param value 缓存的值
     * @param timeout 时间
     * @param timeUnit 时间颗粒度
     */
    public <T> void setSencondCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
    {
        getSecondRedisTemplate().opsForValue().set(key, value, timeout, timeUnit);
    }

    /**
     *  第二数据源
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @param unit 时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean sencondExpire(final String key, final long timeout, final TimeUnit unit)
    {
        return getSecondRedisTemplate().expire(key, timeout, unit);
    }

    /**
     *  第二数据源
     * 判断 key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public Boolean sencondHasKey(String key)
    {
        return getSecondRedisTemplate().hasKey(key);
    }

    /**
     *  第二数据源
     * 获得缓存的基本对象。
     *
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public Object getSencondCacheObject(final String key)
    {
        ValueOperations<String, Object> operation = getSecondRedisTemplate().opsForValue();
        return operation.get(key);
    }
    /**
     *  第一数据源
     * 删除单个对象
     *
     * @param key
     */
    public boolean deleteSencondObject(final String key)
    {
        return getSecondRedisTemplate().delete(key);
    }

    /**
     *  第二数据源
     * 删除集合对象
     *
     * @param collection 多个对象
     * @return
     */
    public boolean deleteSencondObject(final Collection collection)
    {
        return getSecondRedisTemplate().delete(collection) > 0;
    }

    /**
     *  第二数据源
     * 缓存List数据
     *
     * @param key 缓存的键值
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public <T> long setSencondCacheList(final String key, final List<T> dataList)
    {
        Long count = getSecondRedisTemplate().opsForList().rightPushAll(key, dataList);
        return count == null ? 0 : count;
    }

    /**
     *  第二数据源
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public <T> List<T> getSencondCacheList(final String key)
    {
        return (List<T>) getSecondRedisTemplate().opsForList().range(key, 0, -1);
    }
  

    /**
     *  第二数据源
     * 缓存Map
     *
     * @param key
     * @param dataMap
     */
    public <T> void setSencondCacheMap(final String key, final Map<String, T> dataMap)
    {
        if (dataMap != null) {
            getSecondRedisTemplate().opsForHash().putAll(key, dataMap);
        }
    }

    /**
     *  第二数据源
     * 获得缓存的Map
     *
     * @param key
     * @return
     */
    public <T> Map<Object, Object> getSencondCacheMap(final String key)
    {
        return getSecondRedisTemplate().opsForHash().entries(key);
    }

 


}

Redis使用FastJson序列化


import java.nio.charset.Charset;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONReader;
import com.alibaba.fastjson2.JSONWriter;

/**
 * Redis使用FastJson序列化
 * 
 */
public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T>
{
    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

    private Class<T> clazz;

    public FastJson2JsonRedisSerializer(Class<T> clazz)
    {
        super();
        this.clazz = clazz;
    }

    @Override
    public byte[] serialize(T t) throws SerializationException
    {
        if (t == null)
        {
            return new byte[0];
        }
        return JSON.toJSONString(t, JSONWriter.Feature.WriteClassName).getBytes(DEFAULT_CHARSET);
    }

    @Override
    public T deserialize(byte[] bytes) throws SerializationException
    {
        if (bytes == null || bytes.length <= 0)
        {
            return null;
        }
        String str = new String(bytes, DEFAULT_CHARSET);

        return JSON.parseObject(str, clazz, JSONReader.Feature.SupportAutoType);
    }
}
程序猿——小白菜
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot+RedisTemplate多数据源
阿甘的博客
07-07 707
采用的Spring-boot-starter-data中的redis，通过lettuce创建工厂类进行创建bean 第一步 引入依赖 PS：采用的是Spring Boot2.3.4.RELEASE版本 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-configurati.
Spring Boot 多数据源 Redis 配置
r91987的专栏
12-22 1737
概述 本文基于spring boot 2.0.7，讲解如何配置多数据源redis，采用lettuce做为redis客户端，并附上示例代码。 redis配置 配置文件 skyarthur: redis1: host: 127.0.0.1 port: 6378 lettuce: pool: min-idle: 5 max-idle...
详解springboot配置多个redis连接
08-30
Spring Boot为Redis, MongoDB, Elasticsearch, Solr和Gemfire提供自动配置。本文详细介绍了springboot配置多个redis连接，有兴趣的可以了解一下。
Spring Boot 整合多 Redis 数据源配置及操作
qq_45607784的博客
01-04 2880
本文档介绍了如何在Spring Boot应用程序中配置和操作多个Redis数据源。通过配置多个RedisConnectionFactory和RedisTemplate，可以实现对多个Redis数据源的整合，以便在应用程序中灵活地使用不同的Redis实例。通过本文档的指导，您将能够轻松地在Spring Boot应用程序中实现对多个Redis数据源的整合配置和操作，从而满足不同业务场景下对多个Redis实例的需求。
SpringBoot配置多个redis实战
最新发布
06-12 580
如果业务需要一个应用链接不同的redis实例，就不能用SpringBoot的默认配置了，以下是SpringBoot配置多个redis的实战教程，有需要的同学可以作为参考。
SpringBoot配置Redis多数据源，或同一数据源切换database
qq_34957299的博客
08-31 901
今天遇到了需要动态切换database的业务需求，找了几个方法，虽然能切换，但是存在线程安全问题。也就是重新生成一个 redisTemplate，通过修改JedisConnectionFactory连接信息的方法。这种方法通用与MongoDB的多数据源配置，也是通过配置bean工厂实现。在编码过程中经常会遇到需要配置多个redis数据源，或者在同一数据源下切换database的场景。PS:为了简便我没有配置连接池，需要的可以添加配置信息。# Redis服务器连接密码（默认为空）#redis数据源2。
带Lettuce连接池、多数据源配置的RedisTemplate方案
方亮的专栏
05-22 1147
在现实项目中，我们往往会遇到需要使用多个Redis数据源的场景。本文介绍的是一种高度定制化的方案。每个独立的数据源都会使用自己的配置，其中包括针对该数据源的连接池配置。
Springboot配置Redis多数据源
Print_lin的博客
08-02 3819
Springboot默认支持一路redis，项目中有需求用到redis多数据源。本文仅基于Springboot进行多数据源配置，不依赖其它JAR包支持，理论可配置无限多的redis连接。
Springboot配置多个redis连接
尚未佩妥剑 转眼便江湖
08-11 3286
【代码】Springboot配置多个redis连接。
【实践篇】4.11 SpringBoot Redis 配置多数据源
日拱一卒无有尽，功不唐捐终入海
07-20 2429
使用 RedisTemplate 支持多个 Redis 数据库。
springboot配置多个redis
langzichanglu的专栏
08-15 886
【代码】springboot配置多个redis。
SpringBoot配置多个Redis数据源
iGD_Hz的博客
10-28 2897
SpringBoot配置多RedisTemplate
SpringBoot配置多Redis数据源
热门推荐
千夜
07-19 2万+
最近在项目中用到了两个Redis数据源，特此记录一下 一. 添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </depend...
SpringBoot2整合Redis多数据源步骤详解
08-19
在实际项目中，我们可能需要使用多个Redis实例，例如生产环境、测试环境、开发环境等，每个环境都需要单独的Redis实例。使用多数据源可以使我们的项目更加灵活和可靠。 SpringBoot2整合Redis多数据源的步骤 1. ...
SpringBoot+Mybatis+Redis框架Demo
10-12
2. **配置Mybatis**：在`application.yml`或`application.properties`中配置数据源和Mybatis的相关属性，如数据库连接信息、Mapper扫描路径等。 ```yaml spring: datasource: url: jdbc:mysql://localhost:3306/...
Springboot集成Redis
12-21
在现代的Web应用开发中，数据缓存是提高系统性能的重要手段之一，而Redis作为一款高性能的键值存储系统，因其高效、易用和丰富的数据结构，被广泛应用在缓存、消息队列等多个场景。本文将详细介绍如何在SpringBoot...
SpringBoot + JWT + Redis 开源知识社区系统.doc
07-09
同时，SpringBoot 对于日志、数据源、缓存等常用功能都有默认配置，使得开发者能更快地专注于业务逻辑。 2. **JWT (JSON Web Tokens)**: JWT 是一种轻量级的身份认证和授权机制，它通过加密的 token 来传递用户信息...
springboot-mybatis-mysql-redis demo.zip
07-17
首先，需要在`pom.xml`中添加MyBatis和MyBatis-Spring-Boot-Starter依赖，然后定义Mapper接口，配合XML文件或注解编写SQL语句，最后配置数据源和SqlSessionFactory，即可完成基本集成。 三、MySQL数据库连接 MySQL...
Springboot配置多个Redis数据源（非集群）
C_0010的博客
12-01 641
在实际开发场景中我们会遇到整合多数据源的情况，本偏教你springboot如何整合多个redis数据源！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值