springboot连接redis并动态切换database的实现方法

下面我会详细讲解“springboot连接redis并动态切换database的实现方法”的完整攻略。

1. 引入依赖

首先需要在 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>3.6.0</version>
</dependency>

注意：使用 jedis 最好指定版本号，避免出现不兼容问题。

2. 配置 Redis Bean

接下来配置 Redis 连接工厂类和 Redis 模板类 Bean。

@Configuration
public class RedisConfig {

    @Bean
    public JedisConnectionFactory jedisConnectionFactory() {
        RedisStandaloneConfiguration standaloneConfiguration = new RedisStandaloneConfiguration(host, port);
        return new JedisConnectionFactory(standaloneConfiguration);
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(jedisConnectionFactory());
        // 配置序列化方式
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer<>(Object.class));
        return redisTemplate;
    }

}

3. 动态切换 Database

为了实现动态切换 Redis 的 Database，需要创建一个 RedisContextHolder 类。这个类使用 ThreadLocal 对象来保存当前线程使用的 Database。

public class RedisContextHolder {

    private static final ThreadLocal<Integer> contextHolder = new ThreadLocal<>();

    public static void setDatabase(int database) {
        contextHolder.set(database);
    }

    public static Integer getDatabase() {
        return contextHolder.get();
    }

    public static void clear() {
        contextHolder.remove();
    }

}

4. 自定义 Redis Cache 注解

为了区分不同的 Cache，我们自定义了一个 RedisCacheable 注解，使用时需要指定所要使用的 Database。

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RedisCacheable {

    /**
     * Redis Database index
     */
    int database();

    /**
     * Cache key prefix
     */
    String prefix() default "";

    /**
     * Cache value expiration in seconds
     */
    int expire() default 0;

}

5. 自定义 Redis Cache 切面

最后，我们创建一个 RedisCacheAspect 切面，在被 @RedisCacheable 注解起来的方法上自动添加缓存和切换 Database。

@Aspect
@Component
public class RedisCacheAspect {

    private final RedisTemplate<String, Object> redisTemplate;

    public RedisCacheAspect(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    @Around("@annotation(redisCacheable)")
    public Object cacheableAdvice(ProceedingJoinPoint joinPoint, RedisCacheable redisCacheable) throws Throwable {
        Integer databaseIndex = RedisContextHolder.getDatabase();
        if (databaseIndex == null) {
            throw new IllegalArgumentException("Redis database index cannot be null.");
        }

        String cacheKey = redisCacheable.prefix() + Arrays.toString(joinPoint.getArgs());
        Object cacheValue = redisTemplate.opsForValue().get(cacheKey);

        if (cacheValue != null) {
            return cacheValue;
        }

        RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
        try {
            connection.select(databaseIndex);

            Object returnValue = joinPoint.proceed();
            if (returnValue != null) {
                redisTemplate.opsForValue().set(cacheKey, returnValue, redisCacheable.expire(), TimeUnit.SECONDS);
            }
            return returnValue;
        } finally {
            connection.close();
            RedisContextHolder.clear();
        }
    }

    @Before("@annotation(redisCacheable)")
    public void beforeAdvice(RedisCacheable redisCacheable) {
        RedisContextHolder.setDatabase(redisCacheable.database());
    }

}

示例一

接下来为了更好的理解其实现过程，我们创建一个简单的 UserService，里面有两个方法：

@Service
public class UserService {

    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }

    @RedisCacheable(database = 1, prefix = "getUserByUserName-", expire = 3600)
    public User getUserByUserName(String userName) {
        return userRepository.findByUserName(userName).orElse(null);
    }

}

我们看到 getUserByUserName 方法上使用了 @RedisCacheable，表示使用 Redis 缓存结果，并使用 Database 1。

一般的 Repository 接口也需要实现：

@Repository
public interface UserRepository extends JpaRepository<User, Long> {

    Optional<User> findByUserName(String userName);

}

示例二

我们为例子二创建一个新的 Service，名为 OrderService，他也有两个方法：

@Service
public class OrderService {

    private final OrderRepository orderRepository;

    public OrderService(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }

    public Order getOrderById(Long id) {
        return orderRepository.findById(id).orElse(null);
    }

    @RedisCacheable(database = 2, prefix = "getOrdersByUserId-", expire = 3600)
    public List<Order> getOrdersByUserId(Long userId) {
        return orderRepository.findByUserId(userId);
    }

}

我们看到 getOrdersByUserId 上使用了 @RedisCacheable，表示使用 Redis 缓存结果，并使用 Database 2。

该 Repository 接口实现如下：

@Repository
public interface OrderRepository extends JpaRepository<Order, Long> {

    List<Order> findByUserId(Long userId);

}