RabbitMQ(五) 订阅发布者模式介绍以及代码实现

最新推荐文章于 2022-03-03 23:36:54 发布
最新推荐文章于 2022-03-03 23:36:54 发布
阅读量783 收藏 1
点赞数
分类专栏： RabbitMQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuhenghui5201/article/details/106558371
版权

概述：

        在上一章节介绍的工作模式中，我们的消费会进行轮询发送给所有的消息消费者，每个消费者接受消息之和为全部消息。本章节介绍的订阅发布者模式则为：将消息传递给所有的消息消费者，每个消费者都能接受到全部的消息。并且在订阅发布章节我们将新引入一个新的概念，交换机（Exchange）概念。

一、pom.xml 依赖

只需要引入rabbitMq的依赖即可

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>RabbitMQ</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.6.0</version>
        </dependency>

    </dependencies>

</project>

二、发布者（生产者）代码实现过程：

  1. 创建RabbitMQ连接对象Connection；
  2. 创建信道Channel；
  3. 使用Channel声明交换机信息（名称、类型）,交换机类型有四种 direct，topic，headers 和fanout。本示例使用fanout；
  4. 声明所有的消息队列；
  5. 将消息队列与交换机进行绑定；
  6. 发送消息;
  7. 关闭信道和mq连接;

java代码实现如下：

package com.xiaohui.rabbitmq.publishSubscribe;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.xiaohui.rabbitmq.utils.ConnectionUtils;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Producer {

    //交换机名称
    public static final String FANOUT_EXCHANGE = "fanout_exchange";
    //队列1
    public static final String FANOUT_QUEUE_1 = "fanout_queue_1";
    //队列2
    public static final String FANOUT_QUEUE_2 = "fanout_queue_2";

    public static void main(String[] args) throws IOException, TimeoutException {

        //获取连接
        Connection connection = ConnectionUtils.getConnection();
        //创建信道
        Channel channel = connection.createChannel();
        //声明交换机
        /**
         * 参数一：交换机名称
         * 参数二：交换机类型：fanout \topic \direct
         */
        channel.exchangeDeclare(Producer.FANOUT_EXCHANGE, BuiltinExchangeType.FANOUT);

        /**
         * 声明队列
         * durabe:持久化的消息，mq重启后消息仍在。
         * exclusive :独占的，一个消息队列独占一个连接
         */
        channel.queueDeclare(Producer.FANOUT_QUEUE_1,true,false,false,null);
        channel.queueDeclare(Producer.FANOUT_QUEUE_2,true,false,false,null);

        //队列绑定交换机
        channel.queueBind(Producer.FANOUT_QUEUE_1,Producer.FANOUT_EXCHANGE,"");
        channel.queueBind(Producer.FANOUT_QUEUE_2,Producer.FANOUT_EXCHANGE,"");

        for (int i = 1; i < 5; i++) {
            String msg = "订阅发布模式小兔子来啦........"+i;
            channel.basicPublish(Producer.FANOUT_EXCHANGE,"",null,msg.getBytes());

        }
        channel.close();
        connection.close();
    }
}

三、订阅者代码实现步骤

  1. 创建消费端链接
  2. 创建消费端渠道
  3. 声明交换机
  4. 声明消费队列
  5. 队列绑定到交换机
  6. 监听消息回调处理
  7. 消息监听开启

java代码实现如下：

package com.xiaohui.rabbitmq.publishSubscribe;

import com.rabbitmq.client.*;
import com.xiaohui.rabbitmq.utils.ConnectionUtils;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Cunsumer1 {

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建消费端链接
        Connection connection = ConnectionUtils.getConnection();
        //创建消费端渠道
        Channel channel = connection.createChannel();
        //声明交换机
        channel.exchangeDeclare(Producer.FANOUT_EXCHANGE,BuiltinExchangeType.FANOUT);
        //声明消费队列
        channel.queueDeclare(Producer.FANOUT_QUEUE_1, true,false,false,null);
        //队列绑定到交换机
        channel.queueBind(Producer.FANOUT_QUEUE_1,Producer.FANOUT_EXCHANGE,"");

        //监听消息
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("==================订阅消费者1开始===================");
                System.out.println("路由的key为："+envelope.getRoutingKey());
                System.out.println("交换机为："+envelope.getExchange());
                System.out.println("消息ID为："+envelope.getDeliveryTag());
                System.out.println("收到的消息为："+new String(body,"UTF-8"));
                System.out.println("===================订阅消费者1结束==================");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        /**
         * 第二个参数表示是否 向mqserver自动回复收到
         * 第三个参数表示消息回调
         */
        channel.basicConsume(Producer.FANOUT_QUEUE_1,true,consumer);
    }
}

订阅者2 代码实现:

package com.xiaohui.rabbitmq.publishSubscribe;

import com.rabbitmq.client.*;
import com.xiaohui.rabbitmq.utils.ConnectionUtils;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Cunsumer2 {

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建消费端链接
        Connection connection = ConnectionUtils.getConnection();
        //创建消费端渠道
        Channel channel = connection.createChannel();
        //声明交换机
        channel.exchangeDeclare(Producer.FANOUT_EXCHANGE,BuiltinExchangeType.FANOUT);
        //声明消费队列
        channel.queueDeclare(Producer.FANOUT_QUEUE_2, true,false,false,null);
        //队列绑定到交换机
        channel.queueBind(Producer.FANOUT_QUEUE_2,Producer.FANOUT_EXCHANGE,"");

        //监听消息
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                System.out.println("==================订阅消费者2开始===================");
                System.out.println("路由的key为："+envelope.getRoutingKey());
                System.out.println("交换机为："+envelope.getExchange());
                System.out.println("消息ID为："+envelope.getDeliveryTag());
                System.out.println("收到的消息为："+new String(body,"UTF-8"));
                System.out.println("===================订阅消费者2结束==================");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        /**
         * 第二个参数表示是否 向mqserver自动回复收到
         * 第三个参数表示消息回调
         */
        channel.basicConsume(Producer.FANOUT_QUEUE_2,true,consumer);
    }
}

运行打印（两个控制台一样）：

==================订阅消费者1开始===================
路由的key为：
交换机为：fanout_exchange
消息ID为：10
收到的消息为：订阅发布模式小兔子来啦........1
===================订阅消费者1结束==================
==================订阅消费者1开始===================
路由的key为：
交换机为：fanout_exchange
消息ID为：11
收到的消息为：订阅发布模式小兔子来啦........2
===================订阅消费者1结束==================
==================订阅消费者1开始===================
路由的key为：
交换机为：fanout_exchange
消息ID为：12
收到的消息为：订阅发布模式小兔子来啦........3
===================订阅消费者1结束==================
==================订阅消费者1开始===================
路由的key为：
交换机为：fanout_exchange
消息ID为：13
收到的消息为：订阅发布模式小兔子来啦........4
===================订阅消费者1结束==================

 

liuhenghui5201
关注
专栏目录
SpringBoot 整合 RabbitMQ 并使用发布订阅模式
include_hcj的博客
08-19 1101
我们可以使用 RabbitMQ 的发布订阅模式，实现：用户发布动态，其“粉丝”收到其发布动态的消息用户下订单，库存模块、支付模块等收到消息并处理等等。
RabbitMQ发布与订阅模式
constantH的博客
11-29 624
订阅模式中多了一个Exchange交换机，用来接收和处理信息，Exchange有常见三种类型： Fanout：广播，将消息交给所有绑定到交换机的队列 Direct：定向，把消息交给符合指定routing key 的队列 Topic：通配符，把消息交给符合routing pattern（路由模式） 的队列 例子采用的是广播模式。 因为上一篇文章创建连接的代码有过多的重复，因此创建了一个ConnectionUtil工具类。 public class ConnectionU...
RabbitMQ 发布者订阅者
05-06
基于RabbitMQ消息队列实现的发布者订阅者消息模型
rabbitmq的工作模式测试代码
qq_45453185的博客
09-07 148
package cn.tedu.rabbitmq; import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; import com.rabbitmq.client.ConnectionFactory; import com.rabbitmq.client.QueueingConsumer; import org.junit.Before; import org.junit.Test; import java.io
RabbitMQ的发布订阅(即publish--subscribe)模式示例代码
小志的博客
04-22 814
1、RabbitMQ官网publish–subscribe模式的架构图 2、pom文件需要引入有关MQ的2个依赖包 <dependency> <groupId>org.springframework.amqp</groupId> <artifactId>spring-rabbit</artifactId> &...
Rabbitmq-订阅者模式
qq_37106516的博客
07-08 221
1.分析： 角色：生产者：就是发送消息的程序 消费者：消息的接受者，会一直等待消息的到来 queue:消息队列 exchange角色：交换机，图中的X。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有常见以下3种类型： Fanout：广播，将消息交给所有绑定到交换机的队列 Direct：定向，把消息交给符合指定routing key 的队列 Topic：通配符，把消息
RabbitMQ实例教程：发布/订阅者消息队列
weixin_34275734的博客
10-11 193
　　消息交换机（Exchange）　　RabbitMQ消息模型的核心理念是生产者永远不会直接发送任何消息给队列，一般的情况生产者甚至不知道消息应该发送到哪些队列。　　相反的，生产者只能发送消息给交换机（Exchange）。交换机的作用非常简单，一边接收从生产者发来的消息，另一边把消息推送到队列中。交换机必须清楚的知道消息如何处理它收到的每一条消息。是否应该追加到一个指定的队列？是否应该追加到多个队...
RabbitMQ封装为c++版本，并且使用方式为发布订阅模式
04-02
在这个项目中，我们关注的是RabbitMQ的C++客户端库的封装以及如何实现发布订阅模式。 首先，我们要了解RabbitMQ的基本概念。RabbitMQ是一个消息代理，它接收和转发消息，充当生产者和消费者之间的桥梁。生产者是...
RabbitMQ 五种工作模式C#项目代码
最新发布
02-08
测试普通队列模式--点对点--消费者 #region 测试工作队列模式-- 一个生产者多个消费者 --生产端 #region 发布/订阅模式 #region 路由模式 #region 主题模式
消息队列-RabbitMQ-发布订阅(Publish/Subscribe)模式(代码)-生产者
if_icanfly的博客
03-03 1504
前提是已经有可用的rabbitmq服务端,如果还没有 参考安装 消息队列-RabbitMQ-Centos8安装RabbitMQ_if_icanfly的博客-CSDN博客1.环境安装使用PackageCloud Yum Repository安装依次执行下面这两条命令curl -s https://packagecloud.io/install/repositories/rabbitmq/rabbitmq-server/script.rpm.sh | sudo bashcurl -s https://pa..
SpringBoot + RabbitMQ 实现”订阅模式”
12-22
RabbitMQ官网提供了七种队列模型，分别是：简单队列、工作队列、发布订阅、路由模式、主题模式、RPC模式、发布者确认模式。 本文在SpringBoot+RabbitMQ环境实现“订阅模式”。 一、订阅模式 作者：Felix-Yuan
rabbitmq 发布/订阅 java 实现
08-24
rabbitmq 发布/订阅 java 实现
RabbitMQ （消息队列）专题学习04 Publish/Subscribe(发布者/订阅者)
u014548782的专栏
05-06 2376
基于RabbitMQ的发布者订阅者消息分发模型
六、rabbitMQ订阅模式（publish_subscribe）
hlxx55的博客
07-10 361
1.模型x:交换机（转发器 exchange）解读：(1).一个生产者，多个消费者(2).每个消费者有自己的队列(3).生产者没有将消息发往队列，而是发到交换机。(4).每个队列都要绑定在交换机上(5).生产者发送消息经过交换机到达队列就能实现一个消息被多个消费者消费2.实例（1）生产者import java.io.IOException;import java.util.concurrent.T...
rabbitmq发布订阅模式-生产者
u013008898的博客
09-13 1481
pom: <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> <dependency>
订阅者观察者模式代码
qq_32798243的博客
05-03 248
这个就是一个实现了 function Store() { const event = {}; // 添加事件在某个事件里面 const addEvent = ({ type, payload }) =&gt; { event[type] = event[type] || []; event[type].push(payload); } // 转...
rabbitmq发布订阅模式-消费者
u013008898的博客
09-13 1364
pom: <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> <dependency>
发布订阅模式与观察者模式的简单代码实现及解释
furfur-jiang的博客
12-04 1458
发布订阅模式与观察者模式的代码实例观察者模式观察者模式的实现发布订阅模式发布订阅模式的优点发布订阅模式的缺点发布订阅模式的实现观察者模式VS发布订阅模式 观察者模式 所谓观察者模式，其实就是为了实现松耦合(loosely coupled)。 用《Head First设计模式》里的气象站为例子，每当气象测量数据有更新，changed()方法就会被调用，于是我们可以在changed()方法里面，更新气象仪器上的数据，比如温度、气压等等。 但是这样写有个问题，就是如果以后我们想在changed()方法被调用时，更
消息队列及发布/订阅模式
Stone
02-05 7307
摘自：《大型网站技术架构》 李智慧 1 消息驱动架构     消息驱动架构（Event Driven Architecture） ：通过在底耦合的模块之间传输事件消息，以保持模块的松散耦合，并借助事件消息的通信完成模块间合作，典型的EDA架构就是操作系统中常见的生产者消费者模式。     在大型网站中最常用的是分布式消息队列：               消息队列利用”发布—订阅者模式“
RabbitMQ入门：简单模式下生产者与消费者实现
本文档详细介绍了RabbitMQ的基本消息模式，特别是使用Java语言实现的简单模式。在这个模式下，主要包括生产者（Producer）和消费者（Consumer）的角色以及它们之间的交互过程。 首先，我们从创建一个Java项目开始，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值