rabbitmq内置交换机消息发送接收例子

最新推荐文章于 2023-11-23 08:30:00 发布
最新推荐文章于 2023-11-23 08:30:00 发布
阅读量542 收藏
点赞数
分类专栏： MQ 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_16493273/article/details/115531840
版权
本文介绍了RabbitMQ中队列的使用，包括多个消费者从同一队列获取消息的公平分配，发布订阅模式下消息的广播，路由匹配实现精确分发，以及主题订阅实现灵活过滤。详细展示了不同场景下的代码实现，如消费者权重调整、路由键匹配以及主题订阅的多条件过滤。
摘要由CSDN通过智能技术生成

准备

创建一个工具类，用来建立连接，定义队列名

import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class RabbitUtil {
	
	public static String HELLO_QUEUE = "helloworld";
	public static String WORK_QUEUE = "workqueue";
	public static String PUBSUB_QUEUE = "pubsub";
		
	public static String EXCHG_FRIENDMSG = "friend.msg";
	public static String EXCHG_ROUTEMSG = "route.msg";
	public static String EXCHG_TOPIC = "topic.msg";
	
	public static Connection getConn() throws Exception {
		ConnectionFactory factory = new ConnectionFactory();
		factory.setHost("127.0.0.1");
		factory.setPort(5672);
		factory.setUsername("guest");
		factory.setPassword("guest");
		Connection conn = factory.newConnection();
		return conn;
	}
}

1.一个队列多个消费者

创建队列

String QUEUE_NAME = RabbitUtil.WORK_QUEUE;
channel.queueDeclare(QUEUE_NAME, false, false, false, null);

启动消费者1:

Connection conn = RabbitUtil.getConn();
Channel channel = conn.createChannel();
channel.basicQos(1);//每次只取一条
channel.basicConsume(RabbitUtil.WORK_QUEUE, false, new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties      properties, byte[] body)    throws IOException {
    System.out.println("处理消息:"+new String(body));
    channel.basicAck(envelope.getDeliveryTag(), false);
    }
});
System.out.println("consumer1 start");

启动消费者2：

Connection conn = RabbitUtil.getConn();
Channel channel = conn.createChannel();
channel.basicQos(1);每次取1条
channel.basicConsume(RabbitUtil.WORK_QUEUE, false, new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)    throws IOException {
    System.out.println("处理消息:"+new String(body));
    try {
        //休眠一会，权重降低
        Thread.sleep(100);
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    channel.basicAck(envelope.getDeliveryTag(), false);

}
});
System.out.println("consumer2 start");

生产消息：

String QUEUE_NAME = RabbitUtil.WORK_QUEUE;
String message = "hello";
for(int i=0;i<10;i++) {
  channel.basicPublish("", QUEUE_NAME, null, (message+i).getBytes());
}
System.out.println("send message over");

最后打印结果：

consumer1 start
处理消息:hello0
处理消息:hello2
处理消息:hello3
处理消息:hello4
处理消息:hello5
处理消息:hello7
处理消息:hello8
处理消息:hello9

consumer2 start
处理消息:hello1
处理消息:hello6

两个消费者都能重队列获取到消息。第二个队列处理消息时睡眠100毫秒，很明显获取到消息数变少。

2.发布订阅

准备一个fanout类型的exchange，创建两个队列同时获取相同的一条消息。

类似朋友圈发消息，一个发圈，另外两个好友都可看到。

定义交换机与队列

channel.exchangeDeclare(RabbitUtil.EXCHG_FRIENDMSG, "fanout");
channel.queueDeclare("follower1", false, false, false, null);
channel.queueDeclare("follower2", false, false, false, null);
//将队列与交换机绑定
channel.queueBind("follower1", RabbitUtil.EXCHG_FRIENDMSG, "");
channel.queueBind("follower2", RabbitUtil.EXCHG_FRIENDMSG, "");

启动第一个队列消费者

String QUEUE_NAME = "follower1";
Connection conn = RabbitUtil.getConn();
Channel channel = conn.createChannel();
channel.basicConsume(QUEUE_NAME, false, new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)    throws IOException {
    System.out.println("处理消息:"+new String(body));
    channel.basicAck(envelope.getDeliveryTag(), false);
    }
});
System.out.println("follower1 start");

启动第二个队列消费者

String QUEUE_NAME = "follower2";
Connection conn = RabbitUtil.getConn();
Channel channel = conn.createChannel();
channel.basicConsume(QUEUE_NAME, false, new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)    throws IOException {
    System.out.println("处理消息:"+new String(body));
    channel.basicAck(envelope.getDeliveryTag(), false);
    }
});
System.out.println("follower2 start");

发布一条消息

Connection conn = RabbitUtil.getConn();
Channel channel = conn.createChannel();
String message = "today ok";
channel.basicPublish(RabbitUtil.EXCHG_FRIENDMSG, "", null, (message).getBytes());

输出结果

follower2 start
处理消息:today ok

follower1 start
处理消息:today ok

两个队列都能收到发布的消息。

3.路由匹配

使用route类型的交换机，根据routeKey精确匹配

定义交换机和队列

//direct类型的exchange
channel.exchangeDeclare(RabbitUtil.EXCHG_ROUTEMSG, "direct");
//模拟两个朋友圈分组，定义两个队列
String QUEUE1 = "follower_colleague";//同事组队列
String QUEUE2 = "follower_familiy";//家庭组队列
channel.queueDeclare(QUEUE1, false, false, false, null);
channel.queueDeclare(QUEUE2, false, false, false, null);
//同事组绑定两个路由key值colleague、all
channel.queueBind(QUEUE1, RabbitUtil.EXCHG_ROUTEMSG, "colleague");
channel.queueBind(QUEUE1, RabbitUtil.EXCHG_ROUTEMSG, "all");
//家庭组绑定两个路由key值family、all
channel.queueBind(QUEUE2, RabbitUtil.EXCHG_ROUTEMSG, "family");
channel.queueBind(QUEUE2, RabbitUtil.EXCHG_ROUTEMSG, "all");
/*
* 这样就有三个组,all，family，colleague。
* 如果发消息路由key是all，则两个队列都能收到消息。
* 如果发消息路由key是family，则colleague第一个队列收不到消息，相当于被屏蔽了。
*/

发布消息

Connection conn = RabbitUtil.getConn();
Channel channel = conn.createChannel();
//第一条消息 routeKey是all两个队列都能收到
String message = "hello";
String routeKey = "all";
channel.basicPublish(RabbitUtil.EXCHG_ROUTEMSG, routeKey, null, message.getBytes());

//第二条消息，routeKey是family只有QUEUE2收到
message = "work is hard";
routeKey = "family";
channel.basicPublish(RabbitUtil.EXCHG_ROUTEMSG, routeKey, null, message.getBytes());

//第三条消息。routeKey是colleague只有QUEUE1收到
message = "my father is fanny";
routeKey = "colleague";
channel.basicPublish(RabbitUtil.EXCHG_ROUTEMSG, routeKey, null, message.getBytes());

//第四条消息。routeKey是none，没有队列绑定。两个队列都未绑定，都收不到该条消息，会被丢弃。
String message = "life is cool";
/*
* 没有人关注绑定我这个routeKey,也没有人能看到我这条消息
*/
String routeKey = "none";
channel.basicPublish(RabbitUtil.EXCHG_ROUTEMSG, routeKey, null, message.getBytes());

family队列消费者

String QUEUE_NAME = "follower_familiy";
Connection conn = RabbitUtil.getConn();
Channel channel = conn.createChannel();
channel.basicQos(1);
channel.basicConsume(QUEUE_NAME, false, new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)    throws IOException {
    System.out.println("处理消息:"+new String(body));
    channel.basicAck(envelope.getDeliveryTag(), false);
    }
});
System.out.println("family start");
/**
输出结果：
family start
处理消息:hello
处理消息:work is hard
*/

colleague队列消费者

String QUEUE_NAME = "follower_colleague";
Connection conn = RabbitUtil.getConn();
Channel channel = conn.createChannel();
channel.basicQos(1);
channel.basicConsume(QUEUE_NAME, false, new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)    throws IOException {
    System.out.println("处理消息:"+new String(body));
    channel.basicAck(envelope.getDeliveryTag(), false);
    }
});
System.out.println("colleague start");
/**
输出结果：
colleague start
处理消息:hello
处理消息:my father is fanny
*/

4.主题订阅

模拟新闻资讯主题订阅

交互机与队列定义

//topic类型的exchange
channel.exchangeDeclare(RabbitUtil.EXCHG_TOPIC, "topic");

String QUEUE1 = "topic_q1";//用户1
String QUEUE2 = "topic_q2";//用户2
String QUEUE3 = "topic_q3";//用户3
String QUEUE4 = "topic_q4";//用户4
channel.queueDeclare(QUEUE1, false, false, false, null);
channel.queueDeclare(QUEUE2, false, false, false, null);
channel.queueDeclare(QUEUE3, false, false, false, null);
channel.queueDeclare(QUEUE4, false, false, false, null);
//QUEUE1只关注生活
channel.queueBind(QUEUE1, RabbitUtil.EXCHG_TOPIC, "*.*.life");
//QUEUE2只关注新闻
channel.queueBind(QUEUE2, RabbitUtil.EXCHG_TOPIC, "news.*.*");
//QUEUE3只关注体育
channel.queueBind(QUEUE3, RabbitUtil.EXCHG_TOPIC, "sport.*.*");
//QUEUE4只关注nba和英超
channel.queueBind(QUEUE4, RabbitUtil.EXCHG_TOPIC, "*.*.nba");
channel.queueBind(QUEUE4, RabbitUtil.EXCHG_TOPIC, "*.*.yingchao");

发送不同主题类型消息

Connection conn = RabbitUtil.getConn();
Channel channel = conn.createChannel();

HashMap<String, String> msgs = new HashMap<String, String>();
msgs.put("news.beijing.life", "news.bj.life");
msgs.put("news.beijing.ecnomic", "news.bj.ecnomic");
msgs.put("news.beijing.story", "news.bj.story");
msgs.put("news.shanghai.life", "news.shanghai.life");
msgs.put("sport.foot.yingchao", "sport.foot.yingchao");
msgs.put("sport.foot.xijia", "sport.foot.xijia");
msgs.put("sport.bask.nba", "sport.bask.nba");
msgs.put("sport.bask.cba", "sport.bask.cba");
for(Entry<String, String> msg: msgs.entrySet()) {
channel.basicPublish(RabbitUtil.EXCHG_TOPIC, msg.getKey(),
null, msg.getValue().getBytes());
}

user1消费者：

String QUEUE_NAME = "topic_q1";
Connection conn = RabbitUtil.getConn();
Channel channel = conn.createChannel();
String routeKey = "*.*.life";
channel.basicConsume(QUEUE_NAME, false, new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)    throws IOException {
    System.out.println("处理消息:"+new String(body));
    channel.basicAck(envelope.getDeliveryTag(), false);
    }
});
System.out.println("user1 "+routeKey+":start");
/**
输出结果：
user1 *.*.life:start
处理消息:news.shanghai.life
处理消息:news.bj.life
*/

user2消费者：

String QUEUE_NAME = "topic_q2";
Connection conn = RabbitUtil.getConn();
Channel channel = conn.createChannel();
String routeKey = "news.*.*";
channel.basicConsume(QUEUE_NAME, false, new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)    throws IOException {
    System.out.println("处理消息:"+new String(body));
    channel.basicAck(envelope.getDeliveryTag(), false);
    }
});
System.out.println("user2 "+routeKey+":start");
/**
输出结果：
user2 news.*.*:start
处理消息:news.shanghai.life
处理消息:news.bj.ecnomic
处理消息:news.bj.life
处理消息:news.bj.story
*/

user3消费者：

String QUEUE_NAME = "topic_q3";
Connection conn = RabbitUtil.getConn();
Channel channel = conn.createChannel();
String routeKey = "sport.*.*";
//与交换机绑定
channel.basicConsume(QUEUE_NAME, false, new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)    throws IOException {
    System.out.println("处理消息:"+new String(body));
    channel.basicAck(envelope.getDeliveryTag(), false);
    }
});
System.out.println("user3 "+routeKey+":start");
/**
输出结果：
user3 sport.*.*:start
处理消息:sport.foot.yingchao
处理消息:sport.foot.xijia
处理消息:sport.bask.cba
处理消息:sport.bask.nba
*/

user4消费者

String QUEUE_NAME = "topic_q4";
Connection conn = RabbitUtil.getConn();
Channel channel = conn.createChannel();
channel.basicConsume(QUEUE_NAME, false, new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)    throws IOException {
    System.out.println("处理消息:"+new String(body));
    channel.basicAck(envelope.getDeliveryTag(), false);
    }
});
System.out.println("user4 [nba&yingchao]:start");
/**
输出结果：
user4 [nba&yingchao]:start
处理消息:sport.foot.yingchao
处理消息:sport.bask.nba
*/

5.多属性匹配

队列交换机定义

String queue = "headerqueue";
String exchange = RabbitUtil.EXCHG_HEADER;
//header类型的交换机
channel.exchangeDeclare(exchange, BuiltinExchangeType.HEADERS);
channel.queueDeclare(queue, false, false, false, null);
//设置队列header属性
Map<String, Object> headers = new HashMap<String, Object>();
//x-match : all所有属性都要匹配/ any 任意一个匹配即可
headers.put("x-match", "all");
headers.put("sex", "boy");
headers.put("city", "beijing");
//将队列与交换机绑定 设置以上header信息
channel.queueBind(queue, exchange, "",headers);

发送一条与上面队列绑定属性完全相符的消息

Connection conn = RabbitUtil.getConn();
Channel channel = conn.createChannel();
String message = "bj ok";
//设置发布消息属性
Map<String, Object> headers = new HashMap<String, Object>();
headers.put("x-match", "all");
headers.put("sex", "boy");
headers.put("city", "beijing");
AMQP.BasicProperties props = new AMQP.BasicProperties.Builder()
.headers(headers).build();
channel.basicPublish(RabbitUtil.EXCHG_HEADER, "", props, (message).getBytes());

启动队列消费者

String QUEUE_NAME = "headerqueue";
Connection conn = RabbitUtil.getConn();
Channel channel = conn.createChannel();
channel.basicConsume(QUEUE_NAME, false, new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)
    throws IOException {
    System.out.println("处理消息:"+new String(body));
    channel.basicAck(envelope.getDeliveryTag(), false);
    }
});
System.out.println("headerqueue start");
/**
headerqueue start
处理消息:bj ok
*/

发送一个不匹配的消息

Connection conn = RabbitUtil.getConn();
Channel channel = conn.createChannel();
String message = "shanghai ok";
Map<String, Object> headers = new HashMap<String, Object>();
headers.put("x-match", "all");
headers.put("sex", "boy");
headers.put("city", "shanghai");
AMQP.BasicProperties props = new AMQP.BasicProperties.Builder()
.headers(headers).build();
//添加消息被退回监听
channel.addReturnListener(new ReturnCallback() {

    @Override
    public void handle(Return returnMessage) {
        int replyCode = returnMessage.getReplyCode();
        String replyText = returnMessage.getReplyText();
        System.out.println("消息被退回了,code:"+replyCode+",text:"+replyText);
    }
});
/*
* mandatory 参数设置true表示消息不能路由到队列时会被return
* basicPublish(String exchange, String routingKey, boolean mandatory, boolean immediate, BasicProperties props, byte[] body) 
*/
channel.basicPublish(RabbitUtil.EXCHG_HEADER, "",true,false, props, (message).getBytes());
/**
输出结果：
消息被退回了,code:312,text:NO_ROUTE
*/

官方关于mandatory 的解释：

https://www.rabbitmq.com/publishers.html

When a published message cannot be routed to any queue (e.g. because there are no bindings defined for the target exchange), and the publisher set the mandatory message property to false (this is the default), the message is discarded or republished to an alternate exchange, if any.

When a published message cannot be routed to any queue, and the publisher set the mandatory message property to true, the message will be returned to it. The publisher must have a returned message handler set up in order to handle the return (e.g. by logging an error or retrying with a different exchange)

immediate：

方法给的提示Note that the RabbitMQ server does not support this flag.

应该是以后不会再继续支持该参数了。本来作用百度看是当路由投递到的队列如果没有消费者时也被推回。

曹朋羽
关注
专栏目录
深入详解高性能消息队列中间件 RabbitMQ
dvlinker的技术专栏
11-06 1万+
深入详解高性能消息队列中间件 RabbitMQ
rabbitmq 实战例子_RabbitMQ实战
weixin_39851408的博客
12-21 1291
RabbitMQ是采用Erlang语言实现AMQP(Advanced Message Queuing Protocol，高级消息队列协议)。RabbitMQ的具体特定包括下面几点：可靠性：有持久化、传输确认以及发布确认等机制保证可靠性灵活的路由：在消息进入队列之前，通过交换器来路由消息。典型的路由有一些内置交换器实现，复制的路由可能将多个交换器绑定在一起，也可以通过插件机制来实现自己的交换器。扩展...
RabbitMQ 交换机的三种发送方式
m0_57446742的博客
10-23 612
方式一： Topic 匹配模式 发送发 EmitLogsTopic.java package com.zheng.seven; import com.rabbitmq.client.Channel; import com.zheng.utils.RabbitMqUtil; //匹配模式 import java.util.HashMap; import java.util.Map; public class EmitLogTopic { public static final Stri.
硬卷消息中间件系列（六）：RabbitMQ 消息收发与交换机详解
民工哥的博客
09-13 189
点击下方名片，设为星标！回复“1024”获取2TB学习资源！前面介绍了 RabbitMQ基础入门、安装与简单使用、基础配置、管理界面介绍、常用 API等相关的知识点，今天我将详细的为大家介绍 RabbitMQ 消息收发与交换机相关知识，希望大家能够从中收获多多！如有帮助，请点在看、转发支持一波！！！七种消息收发方式Hello World1.先由生产者发送到消息交换机（有默认，可配置）2.消息交换...
RabbitMQ：简单的消息发送和接收demo
A20001230T的博客
07-09 363
System.out.println("接受到消息" + msg);host: 192.168.201.128 # rabbitMQ的ip地址。4、在发送和接收消息的工程中分别配置application.yml。--AMQP依赖，包含RabbitMQ-->1、启动虚拟机，docker命令启动mq。port: 5672 # 端口。6、可以看到此时mq已经接收到消息。3、在项目父工程中引入依赖。5、运行发送端demo。7、运行接收端demo。2、创建queues。
RabbitMQ - RabbitMQ交换机；事务；发送、接收消息
MinggeQingchun的博客
06-08 1534
消息队列（Message Queue）MQ 产品从模型抽象上来说都是一样的过程：消费者（consumer）订阅某个队列，生产者（producer）创建消息，然后发布到队列（queue）中，最后将消息发送到监听的消费者AMQP（高级消息队列协议）是一个网络协议。它支持符合要求的客户端应用（application）和消息中间件代理（messaging middleware broker）之间进行通信AMQP 协议中的核心思想就是生产者和消费者的解耦，生产者从不直接将消息发送给队列AMQP的机制如下图所示：消息（
RabbitMQ 使用direct交换机发送和接收消息
m0_50163856的博客
09-03 269
依赖 <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>5.13.0</version> </dependency> public class MyRabbitFactory { public static Connection getConnecti
RabbitMQ从原理到实战—基于Golang【万字详解】
weixin_44545838的博客
08-27 5136
最近秋招开始找工作，顺便回顾消息队列并且总结。
动力节点RabbitMQ学习笔记，超详细的入门使用教程
DDDYSz的博客
12-28 1373
RabbitMQ是流行的开源消息队列系统，用erlang语言开发，RabbitMQ是AMQP(高级消息队列协议)的标准实现。采用该技术，我们可以实现异步处理、流量削峰、系统解耦。 RabbitMQ 整体是一个与其他中间件相同的模型，主要是负责接收、存储和转发消息。可以把消息传递的过程想想成快递：将一个快递送到快递公司，快递公司由快递员送到收件人的人中，RabbitMQ就类似于一个快递公司，也就是RabbitMQ的交换机模型。 什么是消息队列（MQ） 消息是在不同应用间传递的数据。这里的消息可以非常简单
rabbitmq的三种交换器
曹学成的博客
12-04 145
fanout:广播模式，把消息路由到所有绑定的路由键上 topic：按照匹配的方式来路由消息 direct：准确路由到某个路由键上
RabbitMq的三种交换方式
码上红尘仙的博客
11-16 633
RabbitMq的三种交换方式
用RabbitMq的5种交换机类型实现发送和接收消息
Ciao's blog
02-10 422
用RabbitMq的5种交换机类型实现发送和接收消息
《Spring Boot 实战派》--12.集成RabbitMQ,实现系统间的 数据交换
tumu6889的博客
05-28 3340
第12章集成RabbitMQ,实现系统间的数据交换 RabbitMQ是近年来使用非常广泛的消息中间件。 本章首先介绍它的原理、概念、6种工作模式、常用的注解； 然后用实例讲解在Spring Boot 中如何使用AmqpTemplate接口实现消息的发送和监听。 12.1认识RabbitMQ 12.1.1介绍RabbitMQ RabbitMQ 是开源的高级消息队列协议(Advanced Message Queueing Protocol, AMQP) 的实现，用Erlang语言编写，...
SpringBoot整合RabbitMQ中交换机的使用（完成消息的发送和接收案例）
最新发布
心态的博客
11-23 722
`注：在学习交换机前，先要学习SpringBoot整合RabbitMQ的步骤和队列间的消息发送和接收：` 因为以前写过《SpringBoot整合RabbitMQ并实现消息发送与接收》的文章，所以这篇文章设计到上篇文章的内容不会再进行讲解。如果有什么代码看不懂，请先查看上一篇文章：[SpringBoot整合RabbitMQ并实现消息发送与接收](https://blog.csdn.net/weixin_52258054/article/details/133887033?spm=1001.2014.3001.
RabbitMQ的常用交换机在springboot中的使用
w13966597931的博客
09-29 1159
所有发送到主机交换机的消息都会被转发到所有的路由ley中，所指定的topic的queue上去， 交换机会将路由key和topic模糊匹配，此时，队列需要绑定一个topic。所有被发送到direct交换机上的消息，都会被转发到路由key中指定的一个queue。广播模式，把队列和交换机进行绑定，转发消息是最快的，因为他不需要去处理路由键。发送到交换机的消息，会被转发到和这个交换机绑定的所有队列上（发布订阅模式。看到管控台可以看到，对应的交换机，队列，和队列对应的key。#可以替代0个或多个词、
「RabbitMQ」使用Fanout交换机实现消息的路由与投递
技术路上的探险家
06-07 418
使用 「Bean」 配置 Fanout交换机 /** * fanout配置 * * @author xiang * @date 2023/06/07 */ @Configuration public class FanoutConfig { @Bean(name = "fanoutExchange") public FanoutExchange exchange() { return new FanoutExchange("fanout_exchang
RabbitMQ之交换机详解
m0_55993923的博客
05-16 553
RabbitMQ交换机详解，交换机的四种类型， 直接(direct)，主题(topic) ，扇出(fanout)，三种类型的实战和详细说明
RabbitMQ之交换机
热门推荐
m0_53151031的博客
02-27 1万+
一、RabbitMQ交换机 二、RabbitMQ交换机实例讲解
rabbitMQ:绑定Exchange发送和接收消息（direct）
weixin_59334478的博客
11-06 2183
在这种模式下生产者只面向 Exchange 发布消息，消费者只面向 Queue 消费消息，Exchange 定义了消息路由到 Queue 的规则，将各个层面的消息传递隔离开，使每一层只需要关心自己面向的下一层，降低了整体的耦合度。Exchange 就类似于一个交换机，将各个消息分发到相应的队列中。AMQP 协议中的核心思想就是生产者和消费者的解耦，生产者从不直接将消息发送给队列。注意：使用direct消息模式时必须要指定RoutingKey（路由键），将指定的消息绑定到指定的路由键上。
RabbitMQ实战：Java发送与接收消息示例
内容涵盖RabbitMQ的开发语言背景、AMQP协议、消息类型以及如何通过Java代码发送和接收消息。 在RabbitMQ中，路由模式是一种消息传递方式，允许生产者将消息发布到交换机，然后交换机根据预定义的路由键将消息路由到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值