springboot 一个redis数据源 操作多个库

 pom引入包

        <!-- redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.9.0</version>
        </dependency>

配置数据源

redis:
    database: 21
    database2: 22
    host: 111.113.6.6
    port: 6379
    password: 1111111
    timeout: 3000 #连接超时
    lettuce:
      pool:
        max-wait: 30000 #连接池最大阻塞等待时间(使用负值表示没有限制)
        max-active: 100 #连接池最大连接数(使用负值表示没有限制)
        max-idle: 20 #连接池中的最大空闲连接
        min-idle: 0 #连接池中的最小空闲连接

配置文件


import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Value;
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.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;

/**
 * redis配置类
 * @Author: www
 */
@Configuration
public class RedisConfig{

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

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

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

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

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

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

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

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

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

    @Value("${spring.redis.lettuce.pool.max-wait}")
    private long maxWait;

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

    public GenericObjectPoolConfig getGenericObjectPoolConfig(){
        GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();
        genericObjectPoolConfig.setMaxIdle(maxIdle);
        genericObjectPoolConfig.setMinIdle(minIdle);
        genericObjectPoolConfig.setMaxTotal(maxActive);
        genericObjectPoolConfig.setMaxWaitMillis(maxWait);
        genericObjectPoolConfig.setTimeBetweenEvictionRunsMillis(1000);
        return genericObjectPoolConfig;
    }
//------------------------数据库1
    public RedisStandaloneConfiguration productEvn(){
        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
        redisStandaloneConfiguration.setDatabase(database);
        redisStandaloneConfiguration.setHostName(host);
        redisStandaloneConfiguration.setPort(port);
        redisStandaloneConfiguration.setPassword(RedisPassword.of(password));

        return redisStandaloneConfiguration;
    }
//------------------------数据库2
    public RedisStandaloneConfiguration previewEvn(){
        RedisStandaloneConfiguration redisStandaloneConfiguration2 = new RedisStandaloneConfiguration();
        redisStandaloneConfiguration2.setDatabase(database2);
        redisStandaloneConfiguration2.setHostName(host);
        redisStandaloneConfiguration2.setPort(port);
        redisStandaloneConfiguration2.setPassword(RedisPassword.of(password));

        return redisStandaloneConfiguration2;
    }


    public LettuceConnectionFactory createFactory(RedisStandaloneConfiguration redisStandaloneConfiguration) {

        LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()
                .commandTimeout(Duration.ofMillis(timeout))
                .poolConfig(getGenericObjectPoolConfig())
                .build();

        LettuceConnectionFactory factory = new LettuceConnectionFactory(redisStandaloneConfiguration, clientConfig);
        factory.afterPropertiesSet();
        return factory;
    }

    public RedisTemplate<String, Object> createRedisTemplate(RedisConnectionFactory redisConnectionFactory){
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);
        //使用Jackson2JsonRedisSerializer替换默认的JdkSerializationRedisSerializer来序列化和反序列化redis的value值
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,
                ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        jackson2JsonRedisSerializer.setObjectMapper(mapper);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        //key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;

    }


    @Bean("redisTemplateProduct")
    public RedisTemplate<String, Object> redisTemplateProduct() {

        return createRedisTemplate(createFactory(productEvn()));
    }
    @Bean("redisTemplatePreview")
    public RedisTemplate<String, Object> redisTemplatePreview() {
        return createRedisTemplate(createFactory(previewEvn()));
    }
}

应该时引入tempale

@Component
public class RedisConstant {

    @Autowired
    @Qualifier("redisTemplateProduct")
    private RedisTemplate redisTemplateProduct;

    @Autowired
    @Qualifier("redisTemplatePreview")
    private RedisTemplate redisTemplatePreview;
   

    //    删除key[库1]
    public BaseRes delete(String key){
        Boolean flag =  redisTemplateProduct.delete(key);

        if(flag == true){
            return  success();
        }else {
            return  error("500","redis key值"+key +"删除失败");
        }
    }

    //    删除key[库2]
    public BaseRes deleteReview(String key){
        Boolean flag =  redisTemplatePreview.delete(key);

        if(flag == true){
            return success();
        }else {
            return error("500","redis key值"+key +"删除失败");
        }
    }
}

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring Boot中集成多个Redis数据源需要进行以下步骤: 1. 添加依赖:在pom.xml文件中添加Spring Boot Redis和Jedis依赖: ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> </dependency> ``` 2. 配置多个数据源:在application.properties或application.yml文件中配置多个Redis数据源的连接信息。示例配置如下: ```properties # 第一个数据源 spring.redis.host=127.0.0.1 spring.redis.port=6379 spring.redis.password= spring.redis.database=0 # 第二个数据源 spring.redis.second.host=127.0.0.1 spring.redis.second.port=6380 spring.redis.second.password= spring.redis.second.database=1 ``` 3. 创建多个RedisTemplate:在配置类中创建多个RedisTemplate,每个Template对应一个Redis数据源。示例代码如下: ```java @Configuration public class RedisConfig { @Bean @Primary public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) { RedisTemplate<String, Object> template = new RedisTemplate<>(); template.setConnectionFactory(redisConnectionFactory); // 设置key和value的序列化器 template.setKeySerializer(new StringRedisSerializer()); template.setValueSerializer(new GenericJackson2JsonRedisSerializer()); return template; } @Bean("secondRedisTemplate") public RedisTemplate<String, Object> secondRedisTemplate(RedisConnectionFactory redisConnectionFactory) { RedisTemplate<String, Object> template = new RedisTemplate<>(); template.setConnectionFactory(redisConnectionFactory); // 设置key和value的序列化器 template.setKeySerializer(new StringRedisSerializer()); template.setValueSerializer(new GenericJackson2JsonRedisSerializer()); return template; } } ``` 4. 使用多个数据源:在需要使用Redis的地方,注入对应的RedisTemplate即可。示例代码如下: ```java @RestController public class RedisController { @Autowired private RedisTemplate<String, Object> redisTemplate; @Autowired @Qualifier("secondRedisTemplate") private RedisTemplate<String, Object> secondRedisTemplate; @RequestMapping("/set") public String set() { redisTemplate.opsForValue().set("key1", "value1"); secondRedisTemplate.opsForValue().set("key2", "value2"); return "success"; } @RequestMapping("/get") public String get() { String value1 = (String) redisTemplate.opsForValue().get("key1"); String value2 = (String) secondRedisTemplate.opsForValue().get("key2"); return "value1: " + value1 + ", value2: " + value2; } } ``` 以上就是在Spring Boot中集成多个Redis数据源的简要步骤。通过配置不同的数据源和创建对应的RedisTemplate,可以实现对多个Redis实例的访问和操作
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值