springboot redis多数据源如何应对高并发访问

在Spring Boot中配置和使用多个Redis数据源以应对高并发访问，可以通过以下步骤实现：

1. 配置多个Redis数据源

首先，你需要在application.yml或application.properties文件中配置多个Redis数据源。例如：

# application.yml
spring:
  redis:
    primary:
      host: localhost
      port: 6379
      password: yourpassword
      database: 0
    secondary:
      host: localhost
      port: 6380
      password: yourpassword
      database: 1

2. 创建多个Redis配置类

接下来，创建两个配置类来分别配置这两个数据源。

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
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.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;

@Configuration
public class RedisConfig {

    @Bean
    @ConfigurationProperties(prefix = "spring.redis.primary")
    public LettuceClientConfiguration primaryRedisClientConfiguration() {
        return LettuceClientConfiguration.builder()
                .commandTimeout(Duration.ofMillis(3000))
                .build();
    }

    @Bean
    public LettuceConnectionFactory primaryRedisConnectionFactory(@Qualifier("primaryRedisClientConfiguration") LettuceClientConfiguration clientConfiguration) {
        return new LettuceConnectionFactory(new RedisStandaloneConfiguration("localhost", 6379), clientConfiguration);
    }

    @Bean
    public RedisTemplate primaryRedisTemplate(@Qualifier("primaryRedisConnectionFactory") LettuceConnectionFactory connectionFactory) {
        RedisTemplate template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return template;
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.redis.secondary")
    public LettuceClientConfiguration secondaryRedisClientConfiguration() {
        return LettuceClientConfiguration.builder()
                .commandTimeout(Duration.ofMillis(3000))
                .build();
    }

    @Bean
    public LettuceConnectionFactory secondaryRedisConnectionFactory(@Qualifier("secondaryRedisClientConfiguration") LettuceClientConfiguration clientConfiguration) {
        return new LettuceConnectionFactory(new RedisStandaloneConfiguration("localhost", 6380), clientConfiguration);
    }

    @Bean
    public RedisTemplate secondaryRedisTemplate(@Qualifier("secondaryRedisConnectionFactory") LettuceConnectionFactory connectionFactory) {
        RedisTemplate template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return template;
    }
}

3. 使用多个RedisTemplate

在你的服务类中，你可以注入多个RedisTemplate来分别操作不同的数据源。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

@Service
public class RedisService {

    @Autowired
    private RedisTemplate primaryRedisTemplate;

    @Autowired
    private RedisTemplate secondaryRedisTemplate;

    public void usePrimary() {
        primaryRedisTemplate.opsForValue().set("key", "value");
        // 其他操作
    }

    public void useSecondary() {
        secondaryRedisTemplate.opsForValue().set("key", "value");
        // 其他操作
    }
}

4. 应对高并发访问

为了应对高并发访问，你可以考虑以下策略：

1. 连接池配置：确保你的Redis连接池配置合理，例如使用LettuceClientConfiguration中的连接池配置。
2. 读写分离：根据业务需求，将读操作和写操作分配到不同的Redis实例上。
3. 缓存策略：使用缓存来减少对Redis的直接访问，例如使用Guava Cache或Caffeine。
4. 限流：使用限流策略来控制并发访问速率，例如使用Guava的RateLimiter。
5. 监控和调优：监控Redis的性能指标，根据实际情况进行调优。

通过以上步骤，你可以在Spring Boot中配置和使用多个Redis数据源，以应对高并发访问。