基于Redis键空间通知实现缓存过期与数据库同步更新的教程

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.listener.KeyExpirationEventMessageListener;
import org.springframework.data.redis.listener.PatternTopic;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    /**
     * 配置RedisTemplate，用于操作Redis数据
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        // 设置key的序列化器
        template.setKeySerializer(new StringRedisSerializer());
        // 设置value的序列化器，这里使用JSON，也可以根据需要选择其他
        template.setValueSerializer(new StringRedisSerializer()); // 或 GenericJackson2JsonRedisSerializer
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(new StringRedisSerializer());
        template.afterPropertiesSet();
        return template;
    }

    /**
     * Redis消息监听器容器
     * 这个容器是Spring Data Redis中用于处理Redis消息的关键组件。
     * 它负责管理Redis的订阅连接，并分发接收到的消息给相应的监听器。
     */
    @Bean
    public RedisMessageListenerContainer redisMessageListenerContainer(RedisConnectionFactory connectionFactory) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        return container;
    }

    /**
     * 键过期事件监听器
     * Spring Data Redis提供了一个KeyExpirationEventMessageListener，
     * 专门用于处理Redis键过期事件。
     */
    @Bean
    public KeyExpirationEventMessageListener keyExpirationEventMessageListener(
            RedisMessageListenerContainer listenerContainer,
            CacheExpirationEventHandler handler) {

        // __keyevent@*__:expired 是Redis键空间通知中过期事件的固定频道模式
        // 它表示监听所有数据库中键过期的事件
        KeyExpirationEventMessageListener listener = 
            new KeyExpirationEventMessageListener(listenerContainer);

        // 注册一个消息处理器，当过期事件发生时，会调用此处理器
        listener.addMessageListener(handler);
        return listener;
    }
}

import org.springframework.data.redis.connection.Message;
import org.springframework.data.redis.connection.MessageListener;
import org.springframework.stereotype.Component;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

@Component
public class CacheExpirationEventHandler implements MessageListener {

    // 假设有一个服务来处理数据库更新
    @Autowired
    private CompanyAccountService companyAccountService; 

    @Override
    @Transactional // 确保数据库操作的原子性
    public void onMessage(Message message, byte[] pattern) {
        String expiredKey = new String(message.getBody());
        String channel = new String(message.getChannel());

        System.out.println("接收到Redis过期事件：");
        System.out.println("  频道：" + channel);
        System.out.println("  过期键：" + expiredKey);

        // 假设我们的缓存键是 "company:account:123"
        // 我们需要从中提取出公司ID "123"
        if (expiredKey.startsWith("company:account:")) {
            try {
                String companyIdStr = expiredKey.substring("company:account:".length());
                Long companyId = Long.parseLong(companyIdStr);

                // 调用服务层方法更新数据库
                // 例如，更新公司账户的某个日期字段
                companyAccountService.updateCompanyAccountLastAccessDate(companyId);
                System.out.println("成功更新公司ID为 " + companyId + " 的账户访问日期。");

            } catch (NumberFormatException e) {
                System.err.println("无法解析公司ID：" + expiredKey + ", 错误：" + e.getMessage());
            } catch (Exception e) {
                System.err.println("更新数据库失败，过期键：" + expiredKey + ", 错误：" + e.getMessage());
                // 实际项目中应记录日志或触发告警
            }
        }
    }
}

import org.springframework.stereotype.Service;

@Service
public class CompanyAccountService {

    public void updateCompanyAccountLastAccessDate(Long companyId) {
        // 实际的数据库更新逻辑，例如使用JPA或MyBatis
        // companyAccountRepository.updateLastAccessDate(companyId, new Date());
        System.out.println("模拟：更新数据库中公司ID为 " + companyId + " 的账户访问日期。");
        // 这里可以加入实际的DAO层调用
    }
}

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;

@Service
public class CacheService {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public void cacheCompanyAccount(Long companyId, Object accountData) {
        String key = "company:account:" + companyId;
        redisTemplate.opsForValue().set(key, accountData, 10, TimeUnit.SECONDS); // 设置10秒过期
        System.out.println("缓存公司ID为 " + companyId + " 的账户数据，10秒后过期。");
    }

    public Object getCompanyAccountFromCache(Long companyId) {
        String key = "company:account:" + companyId;
        return redisTemplate.opsForValue().get(key);
    }
}