精华内容
下载资源
问答
  • Redis消息订阅发布 1、subscribe channel:订阅频道,例如:subscrible mychat,订阅mychat这个频道 2、psubscribe channel* :批量订阅频道。例如:psubscrible s*,订阅以“s”开头的频道 3、publish channel content:...
  • 主要介绍了Spring boot+redis实现消息发布与订阅,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值需要的朋友可以参考下
  • Java实现Redis消息订阅发布源码
  • Java实现Redis消息订阅发布实例。
  • 基于ssm实现websocket长连接+redis发布/订阅消息,服务端实时推送消息至前端页面,实时通信。内含前端代码,如需sql文件请下载https://download.csdn.net/download/gmetbtgbki/10824890
  • redis订阅与发布.zip

    2020-03-18 12:47:32
    redispubandsub订阅发布,本包使用C#编写的代码,在使用之前需要有redis的服务,否则无法使用
  • java实现Redis消息发布订阅

    千次阅读 2019-06-18 14:57:29
    Redis发布订阅架构 Redis提供了发布订阅功能,可以用于消息的传输,Redis发布订阅机制包括三个部分,发布者,订阅...Redis的这种发布订阅机制基于主题的发布订阅类似,Channel相当于主题。 Redis发布订阅功能 (...

    Redis发布订阅架构

    Redis提供了发布订阅功能,可以用于消息的传输,Redis的发布订阅机制包括三个部分,发布者,订阅者和Channel。
    发布者和订阅者都是Redis客户端,Channel则为Redis服务器端,发布者将消息发送到某个的频道,订阅了这个频道的订阅者就能接收到这条消息。Redis的这种发布订阅机制与基于主题的发布订阅类似,Channel相当于主题。

    Redis发布订阅功能

    (1)发送消息
    Redis采用PUBLISH命令发送消息,其返回值为接收到该消息的订阅者的数量。
    这里写图片描述
    (2)订阅某个频道
    Redis采用SUBSCRIBE命令订阅某个频道,其返回值包括客户端订阅的频道,目前已订阅的频道数量,以及接收到的消息,其中subscribe表示已经成功订阅了某个频道。

    上代码:

    首先引入相关依赖

        <dependency>
          <groupId>redis.clients</groupId>
          <artifactId>jedis</artifactId>
          <version>2.9.0</version>
        </dependency>
    

    定义消息发布者类-Publisher

    package com.cicc.config.management.subsciber;
    
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    public class Publisher extends Thread{
    
        private final JedisPool jedisPool;
    
        public Publisher(JedisPool jedisPool) {
            this.jedisPool = jedisPool;
        }
    
        @Override
        public void run() {
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            Jedis jedis = jedisPool.getResource();   //连接池中取出一个连接
            while (true) {
                try {
                    jedis.publish("mychannel", reader.readLine());   //从 mychannel 的频道上推送消息
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    

    定义消息订阅类-SubThread

    package com.cicc.config.management.subsciber;
    
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    
    public class SubThread extends Thread {
    
        private final JedisPool jedisPool;
        private final Subscriber subscriber = new Subscriber();
    
        private final String channel = "mychannel";
    
        public SubThread(JedisPool jedisPool) {
            super("SubThread");
            this.jedisPool = jedisPool;
        }
    
        @Override
        public void run() {
            System.out.println(String.format("subscribe redis, channel %s, thread will be blocked", channel));
            Jedis jedis = null;
            try {
                jedis = jedisPool.getResource();   //取出一个连接
                jedis.subscribe(subscriber, channel);    //通过subscribe 的api去订阅,入参是订阅者和频道名
            } catch (Exception e) {
                System.out.println(String.format("subsrcibe channel error, %s", e));
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
        }
    }
    
    

    定义订阅消息处理类-Subscriber 继承了JedisPubSub,其中onMessage可以根据业务需求来重写

    package com.cicc.config.management.subsciber;
    
    import redis.clients.jedis.JedisPubSub;
    
    public class Subscriber extends JedisPubSub {
    
        public Subscriber(){}
        @Override
        public void onMessage(String channel, String message) {       //收到消息会调用
            System.out.println(String.format("receive redis published message, channel %s, message %s", channel, message));
        }
    
        @Override
        public void onSubscribe(String channel, int subscribedChannels) {    //订阅了频道会调用
            System.out.println(String.format("subscribe redis channel success, channel %s, subscribedChannels %d",
                    channel, subscribedChannels));
        }
        @Override
        public void onUnsubscribe(String channel, int subscribedChannels) {   //取消订阅 会调用
            System.out.println(String.format("unsubscribe redis channel, channel %s, subscribedChannels %d",
                    channel, subscribedChannels));
    
        }
    }
    

    编写测试类:PSTest

    package com.cicc.config.management.test;
    
    import com.cicc.config.management.subsciber.Publisher;
    import com.cicc.config.management.subsciber.SubThread;
    import redis.clients.jedis.JedisPool;
    import redis.clients.jedis.JedisPoolConfig;
    
    public class PSTest{
    
        public static void main( String[] args )
        {
            // 连接本地redis服务端
            JedisPool jedisPool = new JedisPool(new JedisPoolConfig(), "127.0.0.1", 6379);
    
            Publisher publisher = new Publisher(jedisPool);    //发布者
            publisher.start();
    
            SubThread subThread = new SubThread(jedisPool);  //订阅者
            subThread.start();
        }
    }
    
    展开全文
  • C# Redis发布订阅Demo

    2018-10-23 13:30:55
    Redis支持跨进程发布订阅机制。代码实现了key过期的notification.
  • Redis 的SUBSCRIBE命令可以让客户端订阅任意数量的频道, 每当有新信息发送到被订阅的频道时, 信息就会被发送给所有订阅指定频道的客户端。 作为例子, 下图展示了频道channel1, 以及订阅这个频道的三个客户端 ...

    Redis 的 SUBSCRIBE 命令可以让客户端订阅任意数量的频道, 每当有新信息发送到被订阅的频道时, 信息就会被发送给所有订阅指定频道的客户端。

    作为例子, 下图展示了频道 channel1 , 以及订阅这个频道的三个客户端 —— client2 、 client5 和 client1 之间的关系:

    digraph pubsub_relation {      rankdir = BT;      node [style = filled];      edge [style = bold];      channel1 [label = "channel1", fillcolor = "#A8E270"];      node [shape = box, fillcolor = "#95BBE3"];      client2 [label = "client2"];     client5 [label = "client5"];     client1 [label = "client1"];      client2 -> channel1 [label = "subscribe"];     client5 -> channel1 [label = "subscribe"];     client1 -> channel1 [label = "subscribe"]; }

    当有新消息通过 PUBLISH 命令发送给频道 channel1 时, 这个消息就会被发送给订阅它的三个客户端:

    digraph send_message_to_subscriber {          node [style = filled];      edge [style = "dashed, bold"];          message [label = "PUBLISH channel1 message", shape = plaintext, fillcolor = "#FADCAD"];      message -> channel1 [color = "#B22222]"];      channel1 [label = "channel1", fillcolor = "#A8E270"];      node [shape = box];      client2 [label = "client2", fillcolor = "#95BBE3"];     client5 [label = "client5", fillcolor = "#95BBE3"];     client1 [label = "client1", fillcolor = "#95BBE3"];      /*     client2 -> channel1 [label = "subscribe"];     client5 -> channel1 [label = "subscribe"];     client1 -> channel1 [label = "subscribe"];     */      channel1 -> client2 [label = "message", color = "#B22222"];     channel1 -> client5 [label = "message", color = "#B22222"];     channel1 -> client1 [label = "message", color = "#B22222"]; }

     

    代码实现:

      定义一个类,实现了订阅发布的方法:

      

    # -*- coding:utf-8 -*-
    import redis
    
    
    class SubscribePublished(object):
        '''
        用redis实现消息订阅与发布
        '''
    
        def __init__(self):
            # 初始化与redis的连接
            self.connect = redis.Redis(host='127.0.0.1')
            # 消息发布的通道
            self.put_channel = 'channel1'
            # 被订阅的通道
            self.sub_channel = 'channel1'
    
        def publish(self, message):
            # 接受消息,并发送到指定通道
            self.connect.publish(self.put_channel, message)
            return True
    
        def subscribe(self):
            pub = self.connect.pubsub()
            # 连接到指定通道
            pub.subscribe(self.sub_channel)
            # 接受消息
            pub.parse_response()
            return pub

     

     

      publish

    # -*- coding:utf-8 -*-
    from redis_test import SubscribePublished
    
    redis_obj = SubscribePublished()
    
    while True:
        # 模拟创建消息
        message = input('please input message:')
        # 消息发往指定通道
        redis_obj.publish(message)

      

      Subscribe
    # -*- coding:utf-8 -*-
    
    from redis_test import SubscribePublished
    
    redis_obj = SubscribePublished()
    # 客户端和要订阅的频道在 pubsub_channels 字典中关联起来
    redis_sub = redis_obj.subscribe()
    
    while True:
        # parse_response 接受消息
        message = redis_sub.parse_response()
        print(message)

     

    先启动2个Subscribe,等待订阅消息:

      python3 redis_sub.py

    在启动一个Published发布消息:

      python3 redis_pub.py

     

    看结果:

      发布消息:

      

     

      订阅消息:

      

      

     

     

      

      

     

    转载于:https://www.cnblogs.com/wangbaojun/p/11269429.html

    展开全文
  • 本篇文章主要介绍了.net core如何使用Redis发布订阅,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 下面我将Spring Boot使用Redis进行消息发布与订阅具体的流程分享给大家 首先引入依赖 &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;...

    Redis 不仅提供一个NoSQL数据库,同时还提供了一套消息系统。
    下面我将Spring Boot使用Redis进行消息的发布与订阅具体的流程分享给大家

    首先引入依赖

    <dependency>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-starter-redis</artifactId>
    	<version>1.4.7.RELEASE</version>
    </dependency>
    

    #####1.发送消息

    @SpringBootApplication
    @EntityScan(basePackages= {"cn.sh.sttri.app.messagepush"})
    @EnableCaching
    @EnableScheduling
    public class MessagepushApplication {
    
    	public static void main(String[] args) {
    
    		ApplicationContext ct=SpringApplication.run(MessagepushApplication.class, args);
    
    		StringRedisTemplate template = ct.getBean(StringRedisTemplate.class);
    		template.convertAndSend("messagepush", "Hello message !");
    		template.convertAndSend("messagepush3", "Hello message3 !");
    
    	}
    }
    

    发送消息我们使用StringRedisTemplate来发送键和值均为字符串的消息。在main()方法中我们创建一个Spring应用的Context,初始化消息监听者容器,开始监听消息。然后获取StringRedisTemplate的实例,往messagepush和messagepush3两个主题发送消息

    #####2.Redis 配置消息通道
    创建一个Redis消息配置类
    连接工程我们使用Spring Boot默认的RedisConnectionFactory
    我们将在listenerAdapter方法中定义的Bean注册为一个消息监听者,它将监听messagepush和messagepush3两个主题的消息。

    因为Receiver类是一个POJO,要将它包装在一个消息监听者适配器(实现了MessageListener接口),这样才能被监听者容器RedisMessageListenerContainer的addMessageListener方法添加到连接工厂中。有了这个适配器,当一个消息到达时,就会调用receiveMesage()方法进行响应。

    @Configuration
    public class RedisChannelConfig {
        @Bean
        RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
                                                MessageListenerAdapter listenerAdapter) {
            RedisMessageListenerContainer container = new RedisMessageListenerContainer();
            container.setConnectionFactory(connectionFactory);
            //订阅主题messagepush和messagepush3
            container.addMessageListener(listenerAdapter, new PatternTopic("messagepush"));
            container.addMessageListener(listenerAdapter, new PatternTopic("messagepush3"));
            //这个container 可以添加多个 messageListener
            return container;
        }
    
        @Bean
        MessageListenerAdapter listenerAdapter(MessageReceive receiver) {
            //这个地方 是给messageListenerAdapter 传入一个消息接受的处理器,利用反射的方法调用“receiveMessage”
            //也有好几个重载方法,这边默认调用处理器的方法 叫handleMessage 可以自己到源码里面看
            return new MessageListenerAdapter(receiver, "receiveMessage");
        }
    
        @Bean //注入操作数据的template(这里不需要操作redis数据,和消息队列功能无关)
        StringRedisTemplate template(RedisConnectionFactory connectionFactory) {
            return new StringRedisTemplate(connectionFactory);
        }
    
    }
    

    #####3.处理MessageReceive 消息接收类的receiveMessage()处理业务

    
    /**redis 消息处理器*/
    @Component
    public class MessageReceive {
    
        @Autowired
        private MessageReceiveHandler messageReceiveHandler;
        /**接收消息的方法*/
        public void receiveMessage(String message){
            //System.out.println(message);
    
            messageReceiveHandler.messagePush(message);
        }
    
    }
    

    到MessageReceiveHandler 类中调用messagePush()

    @Component
    public class MessageReceiveHandler {
      public void messagePush(String message){
         
       System.out.println("----------收到消息了message:"+message);
    
     }
    }
    
    

    到这里一个完整的Spring Boot使用Redis进行消息的发布与订阅过程就打通了
    图片.png

    展开全文
  • SpringBoot整合Redis实现消息发布订阅

    千次阅读 2019-10-01 14:51:40
    前言: SpringBoot整合Redis此处不作赘述 为减少篇幅,只有部分代码(不影响使用) 本文基于lombok插件以及logback日志,所以如果某些注解报错或者无法导入基本是这两处的问题... * 消息订阅点赞主题 */ pub...

    前言:

    • SpringBoot整合Redis此处不作赘述
    • 为减少篇幅,只有部分代码(不影响使用)
    • 本文基于lombok插件以及logback日志,所以如果某些注解报错或者无法导入基本是这两处的问题
    • 勿喷

    正文

    • Redis常量配置(个人习惯,本类按需求而定)

      public class RedisConstant {
          /**
         	 * 消息订阅点赞主题
         	 */
         	public static final String TOPIC_PRAISE = "TOPIC_PRAISE";
         	/**
         	 * 消息订阅收藏主题
         	 */
         	public static final String TOPIC_COLLECT = "TOPIC_COLLECT";
         	/**
         	 * 消息订阅评论主题
         	 */
         	public static final String TOPIC_COMMENT = "TOPIC_COMMENT";
         	/**
         	 * 消息订阅关注主题
         	 */
         	public static final String TOPIC_FOCUS = "TOPIC_FOCUS";
      }
      
    • 配置消息处理器

      package com.java.single.service.impl;
      import java.util.concurrent.CountDownLatch;
      import com.java.single.entity.res.MessageCollect;
      import com.java.single.entity.res.MessageComment;
      import com.java.single.entity.res.MessageFocus;
      import com.java.single.util.PushUtil;
      import org.springframework.beans.factory.annotation.Autowired;
      import org.springframework.stereotype.Service;
      import com.alibaba.fastjson.JSONObject;
      import lombok.extern.slf4j.Slf4j;
      
      @Slf4j
      @Service
      public class ReceiverServiceImpl {
      
      	private CountDownLatch latch;
      
      	@Autowired
      	public ReceiverServiceImpl(CountDownLatch latch) {
      		this.latch = latch;
      	}
      
      	public void praiseReceive(MessagePraise messagePraise) {
      		log.info("消费点赞数据:[{}]", messagePraise);
      		PushUtil.pushOne(messagePraise.getToUserId(), "新消息",
      				messagePraise.getUserName() + "点赞您的" + messagePraise.getTitle() + " 作品");
      		latch.countDown();
      	}
      
      	public void collectReceive(MessageCollect messageCollect) {
      		log.info("消费收藏数据:[{}]", messageCollect);
      		PushUtil.pushOne(messageCollect.getToUserId(), "新消息",
      				messageCollect.getUserName() + "收藏了您的" + messageCollect.getTitle() + " 作品");
      		latch.countDown();
      	}
      
      	public void commentReceive(MessageComment messageComment) {
      		log.info("消费评论数据:[{}]", messageComment);
      		PushUtil.pushOne(messageComment.getToUserId(), "您有新的评论",
      				messageComment.getUserName() + "对" + messageComment.getTitle() + "进行了评论:" + messageComment.getText());
      		latch.countDown();
      	}
      
      	public void focusReceive(MessageFocus messageFocus) {
      		log.info("消费关注数据:[{}]", messageFocus);
      		PushUtil.pushOne(messageFocus.getToUserId(), "新消息", messageFocus.getUserName() + "关注了您");
      		latch.countDown();
      	}
      }
      

      上述为消息处理器,目前无用。需要后面配置,PushUtil为个人封装的个推消息推送工具类,可以删除,根据自己逻辑决定相关操作。
      上述一共写了四种主题,以其中一种主题为例,实际项目中按照自己需求更改

       package com.java.single.entity.res;
       import java.io.Serializable;
       import lombok.Data;
       import lombok.NoArgsConstructor;
       
       @Data
       @NoArgsConstructor
       public class MessageCollect implements Serializable {
       	/**
       	 * 
       	 */
       	private static final long serialVersionUID = 1L;
       	/**
       	 * 收藏数据标识
       	 */
       	private String id;
       	/**
       	 * 收藏用户标识
       	 */
       	private String userId;
       	/**
       	 * 收藏用户名字
       	 */
       	private String userName;
       	/**
       	 * 收藏数据名称
       	 */
       	private String title;
       	/**
       	 * 收藏目标用户
       	 */
       	private String toUserId;
       	/**
       	 * 
       	 * @param id
       	 *            收藏数据标识
       	 * @param userId
       	 *            收藏用户标识
       	 * @param userName
       	 *            收藏用户名字
       	 * @param title
       	 *            收藏数据名称
       	 * @param toUserId
       	 *            收藏目标用户
       	 */
       	public MessageCollect(String id, String userId, String userName, String title, String toUserId) {
       		super();
       		this.id = id;
       		this.userId = userId;
       		this.userName = userName;
       		this.title = title;
       		this.toUserId = toUserId;
       	}
      }
      

      注意,这个类有两点需要注意:1、必须实现序列化。2、必须有无参构造方法。

    • 配置RedisMessageListener配置类

      import java.util.concurrent.CountDownLatch;
      import com.java.single.constant.RedisConstant;
      import com.java.single.service.impl.ReceiverServiceImpl;
      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.PatternTopic;
      import org.springframework.data.redis.listener.RedisMessageListenerContainer;
      import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;
      import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
      import com.fasterxml.jackson.annotation.JsonAutoDetect;
      import com.fasterxml.jackson.annotation.PropertyAccessor;
      import com.fasterxml.jackson.databind.ObjectMapper;
      
      @Configuration
      public class RedisMessageListener {
      
      	/**
      	 * redis消息监听器容器
      	 * 
      	 * @param connectionFactory
      	 * @param praiseListenerAdapter
      	 *            点赞消息订阅处理器
      	 * @param collectListenerAdapter
      	 *            收藏消息订阅处理器
      	 * @param commentListenerAdapter
      	 *            评论消息订阅处理器
      	 * @param focusListenerAdapter
      	 *            关注消息订阅处理器
      	 * @return
      	 */
      	@Bean
      	RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
      			MessageListenerAdapter praiseListenerAdapter, MessageListenerAdapter collectListenerAdapter,
      			MessageListenerAdapter commentListenerAdapter, MessageListenerAdapter focusListenerAdapter) {
      		RedisMessageListenerContainer container = new RedisMessageListenerContainer();
      		container.setConnectionFactory(connectionFactory);
      		
      		// 以下为修改默认的序列化方式,网上大多数消息发布订阅都是String类型,但是实际中数据类型肯定不止String类型
      		Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(
      				Object.class);
      		ObjectMapper objectMapper = new ObjectMapper();
      		objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
      		objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
      		jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
      		
      		// 针对每一个消息处理可以设置不同的序列化方式
      		
      		praiseListenerAdapter.setSerializer(jackson2JsonRedisSerializer);
      		// 点赞主题并绑定消息订阅处理器
      		container.addMessageListener(praiseListenerAdapter, new PatternTopic(RedisConstant.TOPIC_PRAISE));
      		// 收藏主题并绑定消息订阅处理器
      		collectListenerAdapter.setSerializer(jackson2JsonRedisSerializer);
      		container.addMessageListener(collectListenerAdapter, new PatternTopic(RedisConstant.TOPIC_COLLECT));
      		// 评论主题并绑定消息订阅处理器
      		commentListenerAdapter.setSerializer(jackson2JsonRedisSerializer);
      		container.addMessageListener(commentListenerAdapter, new PatternTopic(RedisConstant.TOPIC_COMMENT));
      		// 关注主题并绑定消息订阅处理器
      		focusListenerAdapter.setSerializer(jackson2JsonRedisSerializer);
      		container.addMessageListener(focusListenerAdapter, new PatternTopic(RedisConstant.TOPIC_FOCUS));
      		return container;
      	}
      
      	/**
      	 * 点赞消息订阅处理器,并指定处理方法
      	 * 
      	 * @param receiver
      	 * @return
      	 */
      	@Bean
      	MessageListenerAdapter praiseListenerAdapter(ReceiverServiceImpl receiver) {
      		MessageListenerAdapter messageListenerAdapter = new MessageListenerAdapter(receiver, "praiseReceive");
      		return messageListenerAdapter;
      	}
      
      	/**
      	 * 收藏消息订阅处理器,并指定处理方法
      	 * 
      	 * @param receiver
      	 * @return
      	 */
      	@Bean
      	MessageListenerAdapter collectListenerAdapter(ReceiverServiceImpl receiver) {
      		MessageListenerAdapter messageListenerAdapter = new MessageListenerAdapter(receiver, "collectReceive");
      		return messageListenerAdapter;
      	}
      
      	/**
      	 * 评论消息订阅处理器,并指定处理方法
      	 * 
      	 * @param receiver
      	 * @return
      	 */
      	@Bean
      	MessageListenerAdapter commentListenerAdapter(ReceiverServiceImpl receiver) {
      		MessageListenerAdapter messageListenerAdapter = new MessageListenerAdapter(receiver, "commentReceive");
      		return messageListenerAdapter;
      	}
      
      	/**
      	 * 关注消息订阅处理器,并指定处理方法
      	 * 
      	 * @param receiver
      	 * @return
      	 */
      	@Bean
      	MessageListenerAdapter focusListenerAdapter(ReceiverServiceImpl receiver) {
      		MessageListenerAdapter messageListenerAdapter = new MessageListenerAdapter(receiver, "focusReceive");
      		return messageListenerAdapter;
      	}
      
      	@Bean
      	ReceiverServiceImpl receiver(CountDownLatch latch) {
      		return new ReceiverServiceImpl(latch);
      	}
      
      	@Bean
      	CountDownLatch latch() {
      		return new CountDownLatch(1);
      	}
      }
      

      注释应该已经足够,注意一定要修改序列化方法,否则使用的是默认是String类型的序列化方法,ReceiverServiceImpl方法接收到String类型的参数还需要再次转化为指定类!!!!

    • 发布消息

      redisTemplate.convertAndSend(RedisConstant.TOPIC_COLLECT,
      					new MessageCollect(id, userPublish.getUserId(), userName, title, userId));
      

      在使用的时候需要将构造函数的参数设置成自己的,这样项目启动之后执行上述方法后ReceiverServiceImpl的collectReceive方法就会自动处理这条消息,决定什么方法执行什么操作的配置在RedisMessageListener中实现。

    日志打印:

    消费收藏数据:[MessageCollect(id=c8738aed3ef9421898ebb4be62a11111, userId=6e5c7e33cbd34453b3273ed775e11111, userName=single_cong, title=CSDN博客, toUserId=d8e87f6615f64368a53bd6b4dbebc111)]
    

    总结

    网上绝大部分都是String类型的消息发布订阅,肯定无法满足现实需求,所以要自定义序列化方式并实现主题与对应的处理方法的配置,在这里需要注意两点,第一点是序列化类型的选择,第二是这里序列化的类需要有无参构造方法(给人的感觉类似MyBatis返回结果集时报构造函数不存在时添加无参构造函数就能解决一样)。

    展开全文
  • redis-消息订阅与发布

    千次阅读 2018-04-23 13:28:43
    (笔记来自黑马&amp;传智播客视频)1.订阅频道subscribe channel 例如:...在指定的频道中发布消息publish channel content【应用】想要完成发布订阅的操作,首先需要开两个窗口首先,第一个窗口,订阅my1subscri...
  • redis消息订阅发布

    2017-08-25 15:27:25
    redis消息订阅发布
  • 文章目录Redis发布订阅功能介绍使用redis-cli客户端测试Redis发布订阅生产使用场景java代码demo消息订阅消息订阅 线程类消息发布类Spring Boot启动类功能和性能测试功能测试性能测试 Redis发布订阅功能介绍 Redis...
  • Spring-redis消息订阅与发布

    千次阅读 2018-07-04 09:17:51
    消息发布与订阅概述 消息订阅发布模型如图所示 消息生产者负责消息的发布,通过约定的通信方式,让消费者消费相应的消息。下面使用redis简单了实现了消息的订阅与发布。 1.消息的订阅方 1.1配置文件   &...
  • redis订阅,redis发布

    2019-10-22 14:00:28
    redis开启服务后,用付服务端发送订阅,客户端将实时收到数据。
  • 本文Redis所在系统:Linux,详细安装步骤可参考:https://www.cnblogs.com/zhaoyan001/p/6143170.html ... 1 启动redis 服务端:redis-server  2 启动redis 客户端:redis-cli  3 关闭redis 服务...
  • 最新项目中用到了这个,研究了一番没看懂,于是在github上找了个小案例自己动手写了一下,...首先消息发布与订阅是基于队列的方式实现的,对于简便的功能,使用redis提供的此功能则完美解决,而对于数据量大且复杂...
  • Java实现Redis发布订阅消息通信模式 环境 阿里云ECS CentOS Linux release 8.1.1911 (Core) Redis server v=6.0.9 java version "12.0.1" 2019-04-16 IntelliJ IDEA 2020.2.3 (Ultimate Edition) 实现代码 Main ...
  • 目录 基于Redis消息订阅发布应用场景 1.应用背景 2.困境 2.1 锁表风险 2.2 实时性差 2.3 增加编程复杂性 2.4 实时效果 3.解决方案 3.1 前端传值给服务端 ...
  • 1.订阅命令,可一次性订阅多个:SUBSCRIBE d1 d2 d3 2,发布命令:PUBLISH d1 hello订阅窗口接受信息:3. 订阅多个,通配符*,命令:PSUBSCRIBE c*4. 发布消息命令:PUBLISH c1 HelloRedis ...
  • redis发布订阅小案例

    2018-08-22 09:29:28
    实现redis发布订阅的一个小Demo,一个发布消息,其他订阅了的都能接收消息
  • laravel扩展使用redis消息发布与订阅业务场景shell测试redis发布publish和订阅subscribe结合laravel订阅消息并处理 业务场景 项目业务场景中需要去订阅兄弟部门的数据,技术栈这块经过商讨决定采用了redis发布...
  • 相比于kafka,rabbitMQ,redis消息队列是一款轻量级的实现,消息不会存储补发,只能用在不重要的信息上。 六个函数 1、发布端 publish 将信息发送到指定的频道 pubsub 查看订阅与发布系统状态 pubsub ...
  • 最近在一个老项目中需要用消息队列,本来想着用卡夫卡,但是试了几个版本之后发现jdk和卡夫卡版本一直对不上,最后选择用redis来实现消息队列的发布/订阅模式。感谢这位大佬的博客给了我很多的帮助,...
  • self.red.publish(self.msg_key, msg) # 开始发布消息 if msg == "over": print("停止发送") break ``` # 接收 import redis class SubscribeRedis(object): def __init__(self): self....
  • Redis发布订阅和应用场景

    万次阅读 热门讨论 2017-11-10 08:46:39
    Pub/Sub 从字面上理解就是发布(Publish)与订阅(Subscribe),在Redis中,你可以设定对某一个key值进行消息发布消息订阅,当一个key值上进行了消息发布后,所有订阅它的客户端都会收到相应的消息。 这一功能最...
  • Redis发布与订阅功能可以让用户将消息同时发送给多个客户端。 这个功能由几个不同的角色 协作组成: • 发布者(publisher):发布消息的客户端。 • 频道(channel):构建在服务器内部,负责接收发布者发送的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 47,005
精华内容 18,802
关键字:

redis消息订阅与发布

redis 订阅