Redis学习笔记-发布订阅PubSub

Redis发布/订阅(Pub/Sub)是一种通信机制,将数据推到某个消息管道中,其他客户端可以通过订阅这些管道来获取推送的信息,以此用于消息的传输。

Redis发布/订阅(Pub/Sub)主要由三部分组成:发布者(Publisher)、频道(Channel)、订阅者(Subscriber)。
Redis发布/订阅(Pub/Sub)的消息分到不同的频道,不需要知道什么样的订阅者订阅。订阅者对一个或多个频道感兴趣,只需要接收自身感兴趣的消息,不需要知道什么样的发布者发布。主要的目的就是解除消息的发布者与订阅者之间的耦合关系。

Redis发布订阅基于RedissonClient简单实现:

java 复制代码
@Slf4j
@AllArgsConstructor
public class RedisCachePubSub {

    private final RedissonClient redissonClient;

    /**
     * publish
     * @param topic
     * @param message
     * @return
     */
    public long publish(String topic, Object message) {
        return redissonClient.getTopic(topic).publish(message);
    }

    /**
     * publish
     * @param topic
     * @param codec
     * @param message
     * @return
     */
    public long publish(String topic, Codec codec, Object message) {
        return redissonClient.getTopic(topic, codec).publish(message);
    }

    /**
     * publish async
     * @param topic
     * @param message
     */
    public void publishAsync(String topic, Object message) {
        redissonClient.getTopic(topic).publishAsync(message);
    }

    /**
     * publish async
     * @param topic
     * @param codec
     * @param message
     */
    public void publishAsync(String topic, Codec codec, Object message) {
        redissonClient.getTopic(topic, codec).publishAsync(message);
    }

    /**
     * subscribe
     * @param topic
     * @param action
     */
    public void subscribe(String topic, Action<Object> action) {
        subscribe(topic, Object.class, (channel, message) -> action.invoke(message));
    }

    /**
     * subscribe
     * @param topic
     * @param messageListener
     */
    public void subscribe(String topic, MessageListener<Object> messageListener) {
        subscribe(topic, Object.class, messageListener);
    }

    /**
     * subscribe
     * @param topic
     * @param t
     * @param messageListener
     * @param <T>
     */
    public <T> void subscribe(String topic, Class<T> t, MessageListener<T> messageListener) {
        redissonClient.getTopic(topic).addListener(t, messageListener);
    }

    /**
     * subscribe async
     * @param topic
     * @param action
     */
    public void subscribeAsync(String topic, Action<Object> action) {
        subscribeAsync(topic, Object.class, (channel, message) -> action.invoke(message));
    }

    /**
     * subscribe async
     * @param topic
     * @param messageListener
     */
    public void subscribeAsync(String topic, MessageListener<Object> messageListener) {
        subscribeAsync(topic, Object.class, messageListener);
    }

    /**
     * subscribe async
     * @param topic
     * @param t
     * @param messageListener
     * @param <T>
     */
    public <T> void subscribeAsync(String topic, Class<T> t, MessageListener<T> messageListener) {
        redissonClient.getTopic(topic).addListenerAsync(t, messageListener);
    }

    /**
     * subscribe listener count
     * @param topic
     * @return
     */
    public int subscribeListenerCount(String topic) {
        return redissonClient.getTopic(topic).countListeners();
    }

    /**
     * subscribe count
     * @param topic
     * @return
     */
    public long subscribeCount(String topic) {
        return redissonClient.getTopic(topic).countSubscribers();
    }

    /**
     * subscribe remove all listener
     * @param topic
     */
    public void subscribeRemoveAllListeners(String topic) {
        redissonClient.getTopic(topic).removeAllListeners();
    }

    /**
     * pattern subscribe
     * @param patternTopic
     * @param action
     */
    public void patternSubscribe(String patternTopic, Action<Object> action) {
        patternSubscribe(patternTopic, Object.class, (pattern, channel, message) -> action.invoke(message));
    }

    /**
     * pattern subscribe
     * @param patternTopic
     * @param patternMessageListener
     */
    public void patternSubscribe(String patternTopic, PatternMessageListener<Object> patternMessageListener) {
        patternSubscribe(patternTopic, Object.class, patternMessageListener);
    }

    /**
     * pattern subscribe
     * @param patternTopic
     * @param t
     * @param patternMessageListener
     * @param <T>
     */
    public <T> void patternSubscribe(String patternTopic, Class<T> t, PatternMessageListener<T> patternMessageListener) {
        redissonClient.getPatternTopic(patternTopic).addListener(t, patternMessageListener);
    }

    /**
     * pattern subscribe async
     * @param patternTopic
     * @param action
     */
    public void patternSubscribeAsync(String patternTopic, Action<Object> action) {
        patternSubscribeAsync(patternTopic, Object.class, (pattern, channel, message) -> action.invoke(message));
    }

    /**
     * pattern subscribe async
     * @param patternTopic
     * @param patternMessageListener
     */
    public void patternSubscribeAsync(String patternTopic, PatternMessageListener<Object> patternMessageListener) {
        patternSubscribeAsync(patternTopic, Object.class, patternMessageListener);
    }

    /**
     * pattern subscribe async
     * @param patternTopic
     * @param t
     * @param patternMessageListener
     * @param <T>
     */
    public <T> void patternSubscribeAsync(String patternTopic, Class<T> t, PatternMessageListener<T> patternMessageListener) {
        redissonClient.getPatternTopic(patternTopic).addListenerAsync(t, patternMessageListener);
    }

    /**
     * pattern subscribe remove all listener
     * @param patternTopic
     */
    public void patternSubscribeRemoveAllListeners(String patternTopic) {
        redissonClient.getPatternTopic(patternTopic).removeAllListeners();
    }

}

自动配置:

java 复制代码
@EnableCaching
@Configuration
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
public class RedisAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public RedisCachePubSub redisCachePubSub(RedissonClient redissonClient) {
        return new RedisCachePubSub(redissonClient);
    }

    @Bean
    @ConditionalOnMissingBean
    public RedissonClient redissonClient(RedisProperties redisProperties) {
        Config config = new Config();
        RedisProperties.Cluster cluster = redisProperties.getCluster();
        if (null == cluster) {
            String address = String.format("redis://%s:%d", redisProperties.getHost(), redisProperties.getPort());
            SingleServerConfig serversConfig = config.useSingleServer().setAddress(address);
            if (StrUtil.isNotBlank(redisProperties.getPassword())) {
                serversConfig.setPassword(redisProperties.getPassword());
                serversConfig.setDatabase(redisProperties.getDatabase());
            }
        } else {
            List<String> nodeAddresses = cluster.getNodes().stream().map(node -> String.format("redis://%s", node))
                .collect(Collectors.toList());
            ClusterServersConfig clusterServersConfig = config.useClusterServers();
            clusterServersConfig.setNodeAddresses(nodeAddresses);
            if (StrUtil.isNotBlank(redisProperties.getPassword())) {
                clusterServersConfig.setPassword(redisProperties.getPassword());
            }
        }
        return Redisson.create(config);
    }

}
相关推荐
workflower3 小时前
单元测试-例子
java·开发语言·算法·django·个人开发·结对编程
YuanlongWang3 小时前
C# 基础——装箱和拆箱
java·开发语言·c#
摇滚侠3 小时前
Spring Boot 3零基础教程,WEB 开发 静态资源默认配置 笔记27
spring boot·笔记·后端
b78gb3 小时前
电商秒杀系统设计 Java+MySQL实现高并发库存管理与订单处理
java·开发语言·mysql
wb043072014 小时前
性能优化实战:基于方法执行监控与AI调用链分析
java·人工智能·spring boot·语言模型·性能优化
LXS_3574 小时前
Day 05 C++ 入门 之 指针
开发语言·c++·笔记·学习方法·改行学it
MicroTech20255 小时前
微算法科技(MLGO)研发突破性低复杂度CFG算法,成功缓解边缘分裂学习中的掉队者问题
科技·学习·算法
天若有情6735 小时前
Java Swing 实战:从零打造经典黄金矿工游戏
java·后端·游戏·黄金矿工·swin
lichong9516 小时前
Android studio 修改包名
android·java·前端·ide·android studio·大前端·大前端++
lichong9516 小时前
Git 检出到HEAD 再修改提交commit 会消失解决方案
java·前端·git·python·github·大前端·大前端++