redis配置多个数据源

已于 2024-09-15 18:30:12 修改
阅读量653 收藏
点赞数 1
分类专栏： java 文章标签： redis 数据库 缓存
于 2024-09-15 18:07:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/darlene2929/article/details/142286902
版权

pom.xml:

  <!-- Redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.8.0</version>
        </dependency>

RedisConfig_0类：

package com.nisco.Configs.Redis;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.RedisTemplate;

@Configuration
public class RedisConfig_0 extends  RedisConfig_N {


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

        @Bean(name = "RedisTemplate0")
        public RedisTemplate<String, Object> redisTemplate(){

            return getRedisTemplate(Database);
        }

}

RedisConfig_N 类：注意序列化

package com.nisco.Configs.Redis;

import com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisPassword;
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.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

@Configuration
@ConditionalOnClass({RedisTemplate.class})

@ConditionalOnProperty(
        prefix = "spring.redis",
        value = {"enabled"},
        matchIfMissing = true

)
public class RedisConfig_N {

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

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

        /**
         * 创建连接池
         *
         * @param database
         * @return
         */
        public LettuceConnectionFactory getLettuceConnectionFactory(int database) {
            GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();

            RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
            redisStandaloneConfiguration.setDatabase(database);
            redisStandaloneConfiguration.setHostName(host);
            redisStandaloneConfiguration.setPort(port);
            LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()
                    .poolConfig(genericObjectPoolConfig)
                    .build();
            LettuceConnectionFactory factory = new LettuceConnectionFactory(redisStandaloneConfiguration, clientConfig);
            // 重新初始化工厂
            factory.afterPropertiesSet();
            return factory;
        }

        /**
         * 获取redis模板实例
         *
         * @param database
         * @return
         */
        public RedisTemplate<String, Object> getRedisTemplate(int database) {
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            redisTemplate.setConnectionFactory(getLettuceConnectionFactory(database));

            redisTemplate.setKeySerializer(new StringRedisSerializer());

            //GenericFastJsonRedisSerializer fastJsonRedisSerializer = new GenericFastJsonRedisSerializer();
            //redisTemplate.setValueSerializer(fastJsonRedisSerializer);
            //redisTemplate.setHashKeySerializer(new StringRedisSerializer());
            //redisTemplate.setHashValueSerializer(fastJsonRedisSerializer);
            
  			StringRedisSerializer stringRedisSerializer =new StringRedisSerializer();
            redisTemplate.setValueSerializer(new StringRedisSerializer());
            redisTemplate.setKeySerializer(stringRedisSerializer);
            redisTemplate.setHashKeySerializer(stringRedisSerializer);
            redisTemplate.setHashValueSerializer(stringRedisSerializer);
            redisTemplate.afterPropertiesSet();


            return redisTemplate;
        }

}

RedisConfig_1 类：

package com.nisco.Configs.Redis;

import com.alibaba.fastjson.support.spring.GenericFastJsonRedisSerializer;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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.StringRedisSerializer;
@Configuration
public class RedisConfig_1 extends  RedisConfig_N {


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

        @Bean(name = "RedisTemplate1")
        public RedisTemplate<String, Object> redisTemplate(){

            return getRedisTemplate(Database);
        }

}

RedisUtil_1类：

package com.nisco.Utils;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Service;

import java.io.Serializable;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Service
@Slf4j
public class RedisUtil_1 implements Serializable {

    @Autowired
    @Qualifier("RedisTemplate1")
    private RedisTemplate redisTemplate;
//    @Autowired
//    @Qualifier("redisTemplate1")
//    private RedisTemplate redisTemplate1;

 public static RedisUtil_1 redisService;

    @PostConstruct
    public void init() {
        redisService = this;

    }


    /**
     * 写入缓存
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
//    public boolean set1(final String key, Object value) {
//        boolean result = false;
//        try {
//            ValueOperations<Serializable, Object> operations = redisTemplate1.opsForValue();
//            operations.set(key, value);
//            result = true;
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        return result;
//    }

    /**
     * 写入缓存设置时效时间
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 批量删除对应的value
     *
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }

    /**
     * 批量删除key
     *
     * @param pattern
     */
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0)
            redisTemplate.delete(keys);
    }

    /**
     * 删除对应的value
     *
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }

    /**
     * 判断缓存中是否有对应的value
     *
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 读取缓存
     *
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }

    /**
     * 哈希 添加
     *
     * @param key
     * @param hashKey
     * @param value
     */
    public void hmSet(String key, Object hashKey, Object value) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        hash.put(key, hashKey, value);
    }

    /**
     * 哈希获取数据
     *
     * @param key
     * @param hashKey
     * @return
     */
    public Object hmGet(String key, Object hashKey) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        return hash.get(key, hashKey);
    }

    /**
     * 列表添加
     *
     * @param k
     * @param v
     */
    public void lPush(String k, Object v) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        list.rightPush(k, v);
    }

    /**
     * 列表获取
     *
     * @param k
     * @param l
     * @param l1
     * @return
     */
    public List<Object> lRange(String k, long l, long l1) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        return list.range(k, l, l1);
    }

    /**
     * 集合添加
     *
     * @param key
     * @param value
     */
    public void add(String key, Object value) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        set.add(key, value);
    }

    /**
     * 集合获取
     *
     * @param key
     * @return
     */
    public Set<Object> setMembers(String key) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        return set.members(key);
    }

    /**
     * 有序集合添加
     *
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key, Object value, double scoure) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.add(key, value, scoure);
    }

    /**
     * 有序集合获取
     *
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     */
    public Set<Object> rangeByScore(String key, double scoure, double scoure1) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.rangeByScore(key, scoure, scoure1);
    }
}

RedisUtil_0类：

package com.nisco.Utils;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Service;

import java.io.Serializable;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Service
@Slf4j
public class RedisUtil_0 implements Serializable {

    @Autowired
    @Qualifier("RedisTemplate0")
    private RedisTemplate redisTemplate;
//    @Autowired
//    @Qualifier("redisTemplate1")
//    private RedisTemplate redisTemplate1;

 public static RedisUtil_0 redisService;

    @PostConstruct
    public void init() {
        redisService = this;

    }


    /**
     * 写入缓存
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
//    public boolean set1(final String key, Object value) {
//        boolean result = false;
//        try {
//            ValueOperations<Serializable, Object> operations = redisTemplate1.opsForValue();
//            operations.set(key, value);
//            result = true;
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//        return result;
//    }

    /**
     * 写入缓存设置时效时间
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 批量删除对应的value
     *
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }

    /**
     * 批量删除key
     *
     * @param pattern
     */
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0)
            redisTemplate.delete(keys);
    }

    /**
     * 删除对应的value
     *
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }

    /**
     * 判断缓存中是否有对应的value
     *
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 读取缓存
     *
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }

    /**
     * 哈希 添加
     *
     * @param key
     * @param hashKey
     * @param value
     */
    public void hmSet(String key, Object hashKey, Object value) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        hash.put(key, hashKey, value);
    }

    /**
     * 哈希获取数据
     *
     * @param key
     * @param hashKey
     * @return
     */
    public Object hmGet(String key, Object hashKey) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        return hash.get(key, hashKey);
    }

    /**
     * 列表添加
     *
     * @param k
     * @param v
     */
    public void lPush(String k, Object v) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        list.rightPush(k, v);
    }

    /**
     * 列表获取
     *
     * @param k
     * @param l
     * @param l1
     * @return
     */
    public List<Object> lRange(String k, long l, long l1) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        return list.range(k, l, l1);
    }

    /**
     * 集合添加
     *
     * @param key
     * @param value
     */
    public void add(String key, Object value) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        set.add(key, value);
    }

    /**
     * 集合获取
     *
     * @param key
     * @return
     */
    public Set<Object> setMembers(String key) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        return set.members(key);
    }

    /**
     * 有序集合添加
     *
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key, Object value, double scoure) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.add(key, value, scoure);
    }

    /**
     * 有序集合获取
     *
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     */
    public Set<Object> rangeByScore(String key, double scoure, double scoure1) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.rangeByScore(key, scoure, scoure1);
    }
}

最后配置文件：
在这里插入图片描述
用法：
redisUtil_0.get(“”);
redisUtil_1.get(“”);

(ღ星辰ღ)
关注
专栏目录
Redis 多数据源配置
yujunyi的博客
03-09 1724
背景 由于项目需求或者性能需求，一个项目可能需要使用多个 redis 数据源，具体使用如下。 配置文件 spring: redis: #默认数据源 expireSeconds: 120 commandTimeout: 10000 #redis操作的超时时间 pool: maxActive: 5000 #最大连接数 maxIdle: 30 #最大空闲连接数 minIdle: 5 #最小空闲连接数 maxWait: 3000
Redis - 多集群数据源配置
qq_36782325的博客
01-31 700
工作时有一个项目配置了多个redis数据源，使用时出现了指定了使用副数据源，数据却依然使用了主数据源的情况。经过排查，发现配置流程较为繁琐易错，此处做一个记录。
Redis 多数据源自定义配置 Spring Boot 升级版
谢文峰的博客
07-05 1077
本文为大家提供一个 redis 配置多数据源的实现方案；为上一篇文章【Redis 多数据源 Spring Boot 实现】的升级版本支持自定义配置无需写任何其他配置 Java 类application.properties 配置完，直接就可以使用请注意 spring boot 的相关依赖版本。//...此处省略N行代码@Override// 获取 application.properties 对应的 java 类对象= null;
Redis配置多数据源
FirstMrRight的博客
03-15 3304
使用场景 Redis具有多个databases，通过CONFIG GET databases命令可查看，Redis不同的database间具有数据隔离性，即在项目中我们配置一个databases 0信息后，并无法获取其他databases的数据，所以，当我们业务中需要获取其他databases时，便需要配置多Redis数据源。 配置文件 以properties为例 #redis databases 1 spring.redis.database=1 spring.redis.host=127.0.0.1
Redis多数据源配置
qq_63431773的博客
04-12 295
yaml文件。
Redis配置多数据源(同一个Redis，多个不同db)
qq_42974262的博客
11-25 2897
redis配置多数据源
redis单机和多数据源配置
weixin_38715694的博客
10-10 354
redis单机和多数据源配置 参考: https://blog.csdn.net/lonely_bin/article/details/100137626. springboot 2.x支持 lettuce 查看spring boot版本 @SpringBootApplication(exclude = DruidDataSourceAutoConfigure.class) public class PartyRedisLibraryApplication { public static void
laravel配置Redis多个库的实现方法
10-17
本文将详细介绍如何配置 Laravel 以支持使用 Redis 的多个库，确保不同的服务能够独立地存储数据，避免数据混乱。 首先，要使用 Redis 在 Laravel 中，我们需要安装 predis 扩展。这可以通过运行 `composer require...
用来对比、校验redis 多个数据库数据一致性的命令行工具.zip
01-03
针对这个需求，标题提及的“用来对比、校验redis 多个数据库数据一致性的命令行工具”正是为了解决这一问题而设计的。 这个工具主要功能是对比和校验Redis的不同实例或集群之间数据的一致性，包括单实例到单实例的...
java redis 多数据库_Spring boot如何快速的配置多个Redis数据源
weixin_32515143的博客
02-24 971
简介redis 多数据源主要的运用场景是在需要使用多个redis服务器或者使用多个redis库,本文采用的是fastdep依赖集成框架，快速集成Redis多数据源并集成lettuce连接池，只需引入依赖后在yaml文件中配置多数据源连接信息即可。源码地址希望大家可以star支持一下，后续还会加入其它依赖的简易整合。https://github.com/louislivi/fastdep引入依赖Ma...
Springmvc多模块集成多数据源及redis
01-24
redis使用请在service中使用注解，有示例代码，亲测可用，环境为jdk1.8
SpringBoot2整合Redis多数据源步骤详解
08-19
主要介绍了SpringBoot2整合Redis多数据源步骤详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
【Redis】Redis配置多数据源
ccystewart的博客
08-16 874
Redis配置多数据源 一般来说单个服务都是只配置一个Redis地址端口指定数据库和一个关系型数据库。 但是也偶尔会出现一个服务需要连接不同的两个或以上的Redis地址进行读写数据，比如说最近的公司需求：员工分散在两个相似的单体服务，在新增员工时，要保证在两个数据库内的工号不重复且自增。 其实这种情况我觉得还是利用消息队列如RabbitMQ好处理的，但苦于目前的小中台内没有搭建完善的消息队列，所以暂时还是只能从数据源下手，再考虑到暂时以后也不会再新增类似服务，且管理新增员工的同事只有一个人，所以暂时不考虑
配置多redis数据源
weixin_38689747的博客
11-19 861
##问题： 一个spring服务需要操作多个redis服务或者同一redis服务下的不同database ##解决思路： 1在配置中添加多个redis配置 2建立对应的多个RedisConnectionFactory 3对应每个RedisConnectionFactory配置redisTemplate设置（如Serializer等）并关联factory ##实战： 1在yml里添加redis配置 Spring: redis: database: 1 # Redis服务器地址
redis配置多数据源发布订阅
henbaidexiaobai的博客
06-29 536
针对于redis在多数据源的场景下进行消息发布，订阅
配置多个redis数据源连接不同库
最新发布
weixin_40798919的博客
07-10 72
配置相关视频讲解：C语言程序设计入门之环境安装如何配置多个redis数据源连接不同库 概述 在开发中，有时候需要连接多个redis数据源，并且这些数据源连接的是不同的数据库。本文将介绍如何配置多个redis数据源连接不同库的步骤和代码示例。 步骤 下面是配置多个redis数据源连接不同库的流程： 步骤 操作 ...
SpringBoot(42) Redis多数据源配置
郑清
09-16 884
文章目录一、前言二、Redis多数据源配置1、`pom.xml`依赖2、`application.yml`配置3、Redis配置类三、测试四、本文案例demo源码 一、前言 SpringBoot整合Redis可参考 https://zhengqing.blog.csdn.net/article/details/103494966 本文将基于以下环境实现Redis的多数据源配置 springboot2.4.0 redis6.0.8 二、Redis多数据源配置 1、pom.xml依赖 <!-- red
Springboot配置多个Redis数据源（非集群）
C_0010的博客
12-01 820
在实际开发场景中我们会遇到整合多数据源的情况，本偏教你springboot如何整合多个redis数据源！
redis配置多数据源
08-17
对于 Redis 的多数据源配置，你可以通过以下步骤来实现： 1. 在 Redis 的配置文件中，一般是 redis.conf 文件，你可以通过 `redis-server --help` 命令查看该文件的位置。开该文件并进行以下操作： 2. 复制一份默认的配置，并为每个数据源设置不同的端口号和数据目录。例如，你可以在配置文件中添加以下内容： ``` # 第一个数据源 port 6379 dir /var/lib/redis/redis1 # 第二个数据源 port 6380 dir /var/lib/redis/redis2 # 其他数据源... ``` 这里我们假设你要配置两个数据源，分别使用端口号 6379 和 6380，并分别使用不同的数据目录。 3. 保存并关闭配置文件。 4. 启动 Redis 服务器时，使用不同的配置文件启动多个实例。可以通过以下命令来启动两个实例： ``` redis-server /path/to/redis.conf redis-server /path/to/redis.conf --port 6380 ``` 这样就会启动两个 Redis 实例，分别使用不同的配置文件和端口号。 5. 现在你就可以通过不同的端口号来访问不同的 Redis 数据库了。例如，使用端口号 6379 访问第一个数据源，使用端口号 6380 访问第二个数据源。 请注意，这只是一种简单的方法来配置 Redis 的多数据源，你也可以使用 Redis Cluster 或者类似的工具来管理多个 Redis 实例。另外，确保每个实例的配置文件中的端口号、数据目录等设置是正确的，并且能够与你的应用程序进行连接。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值