有选择的接收消息。

上一节我们使用的是fanout exchange来实现消息的发布/订阅模式，这并没有给我们带来多大的灵活性——它只能够让人盲目地进行广播。而本节我们采用direct类型的交换器来实现有选择的接收消息。直接交换器背后的路由算法很简单——消息传递到绑定键与消息的路由键完全匹配的队列。

如上这个设置中，我们可以看到与它绑定的两个队列的直接交换X。第一个队列用绑定键橙色绑定，第二个队列有两个绑定，一个绑定键为黑色，另一个绑定键为绿色。

在这个设置里面，一个被发布到交换器里的带有橙色路由键的消息将被路由到队列Q1中，带有黑色或绿色路由键的消息将去往队列Q2中，所有其他消息将被舍弃掉。

下面这个是多重绑定，该绑定相似与上一节的发布/订阅模式

使用相同的绑定键绑定多个队列是完全合法的。在我们的示例中，我们可以在X和Q1之间添加绑定键黑。在这种情况下，直接交换将表现为fanout类型，并将消息广播给所有匹配的队列。带有black路由键的消息将被发送到Q1和Q2。

接下来，我们将采用这个模型，代替fanout来发送消息，以这种方式进行，接收程序放可以选择性的接收消息。

该篇与上篇区别仅在于，发布和订阅方的交换器的类型变为direct，同时设置发布消息的路由键，本篇将其设置为“error”，将订阅方其中一个队列的路由键设置为“error”,另一个设置为“bug”,则运行后，只有路由键和队列名称相同的一方能够收到消息，另一个bug路由键的收不到消息。

代码如下（在上篇代码上改造,修改的代码加上了下划线以便区分）：

发布方：

package com.rabbitmq.HelloWorld;

import java.io.IOException;

import java.util.concurrent.TimeoutException;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

public class Publish {

	private static final String EXCHANGE_NAME = "exchangeB";

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

		// TODO Auto-generated method stub

//		创建工厂

		ConnectionFactory factory = new ConnectionFactory();

		factory.setHost("192.168.10.185");

		factory.setUsername("admin");

		factory.setPassword("123456");

		factory.setPort(5672);

//		创建连接

		Connection connetion = factory.newConnection();

//		获得信道

		Channel channel = connetion.createChannel();

//		声明交换器（声明了一个名字位exchangeA,类型修改fanout为direct类型的交换器）

		channel.exchangeDeclare(EXCHANGE_NAME, "direct");

		String message = "555,2,2,33,66";

//		发送消息,将第二项参数routingkey修改为error

		channel.basicPublish(EXCHANGE_NAME, "error", null, message.getBytes());

		System.out.println(" [x] Sent '" + message + "'");

		channel.close();

		connetion.close();

	}

}

订阅方一，路由键为“error”

package com.rabbitmq.HelloWorld;

import java.io.IOException;

import java.util.concurrent.TimeoutException;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

import com.rabbitmq.client.Consumer;

import com.rabbitmq.client.DefaultConsumer;

import com.rabbitmq.client.Envelope;

import com.rabbitmq.client.AMQP.BasicProperties;

public class Subscribe {

	private static final String EXCHANGE_NAME = "exchangeB";

	private static final String QUEUE_NAME = "queueA";

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

		// TODO Auto-generated method stub

//		创建工厂

		ConnectionFactory factory = new ConnectionFactory();

		factory.setHost("192.168.10.185");

		factory.setUsername("admin");

		factory.setPassword("123456");

		factory.setPort(5672);

//		创建连接

		Connection connetion = factory.newConnection();

//		获得信道

		Channel channel = connetion.createChannel();

//		声明交换器（声明了一个名字位exchangeA,类型修改fanout为direct的交换器）

		channel.exchangeDeclare(EXCHANGE_NAME, "direct");

//		声明一个队列，在此采用临时队列

		String queueName = channel.queueDeclare().getQueue();

//		channel.queueDeclare(QUEUE_NAME, true, false, false, null);

//		队列和交换器进行绑定,并设定路由键为error

		channel.queueBind(queueName, EXCHANGE_NAME, "error");

		System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

		Consumer consumer = new DefaultConsumer(channel){

			@Override

			public void handleDelivery(String consumerTag, Envelope envelope,

					BasicProperties properties, byte[] body) throws IOException {

				// TODO Auto-generated method stub

				String message = new String(body,"utf-8");

				System.out.println("[x] received'"+message+"'");

			}

		};

		channel.basicConsume(queueName, consumer);

	}

}

订阅方二（路由键为“bug”）

import java.io.IOException;

import java.util.concurrent.TimeoutException;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

import com.rabbitmq.client.Consumer;

import com.rabbitmq.client.DefaultConsumer;

import com.rabbitmq.client.Envelope;

import com.rabbitmq.client.AMQP.BasicProperties;

public class Subscribe {

	private static final String EXCHANGE_NAME = "exchangeB";

	private static final String QUEUE_NAME = "queueA";

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

		// TODO Auto-generated method stub

//		创建工厂

		ConnectionFactory factory = new ConnectionFactory();

		factory.setHost("192.168.10.185");

		factory.setUsername("admin");

		factory.setPassword("123456");

		factory.setPort(5672);

//		创建连接

		Connection connetion = factory.newConnection();

//		获得信道

		Channel channel = connetion.createChannel();

//		声明交换器（声明了一个名字位exchangeA,修改fanout类型为direct类型的交换器�?

		channel.exchangeDeclare(EXCHANGE_NAME, "direct");

//		声明�?个队列，在此采用临时队列

		String queueName = channel.queueDeclare().getQueue();

//		channel.queueDeclare(QUEUE_NAME, true, false, false, null);

//		队列和交换器进行绑定,未设定路由键

		channel.queueBind(queueName, EXCHANGE_NAME, "bug");

		System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

		Consumer consumer = new DefaultConsumer(channel){

			@Override

			public void handleDelivery(String consumerTag, Envelope envelope,

					BasicProperties properties, byte[] body) throws IOException {

				// TODO Auto-generated method stub

				String message = new String(body,"utf-8");

				System.out.println("[x] received'"+message+"'");

			}

		};

		channel.basicConsume(queueName, consumer);

	}

}

运行结果：

下面这个是在另一个项目中，没有引进日志打印的包，红色忽略即可

效果已经呈现了。

有选择的接收消息。

上一节我们使用的是fanout exchange来实现消息的发布/订阅模式，这并没有给我们带来多大的灵活性——它只能够让人盲目地进行广播。而本节我们采用direct类型的交换器来实现有选择的接收消息。直接交换器背后的路由算法很简单——消息传递到绑定键与消息的路由键完全匹配的队列。

如上这个设置中，我们可以看到与它绑定的两个队列的直接交换X。第一个队列用绑定键橙色绑定，第二个队列有两个绑定，一个绑定键为黑色，另一个绑定键为绿色。

在这个设置里面，一个被发布到交换器里的带有橙色路由键的消息将被路由到队列Q1中，带有黑色或绿色路由键的消息将去往队列Q2中，所有其他消息将被舍弃掉。

下面这个是多重绑定，该绑定相似与上一节的发布/订阅模式

使用相同的绑定键绑定多个队列是完全合法的。在我们的示例中，我们可以在X和Q1之间添加绑定键黑。在这种情况下，直接交换将表现为fanout类型，并将消息广播给所有匹配的队列。带有black路由键的消息将被发送到Q1和Q2。

接下来，我们将采用这个模型，代替fanout来发送消息，以这种方式进行，接收程序放可以选择性的接收消息。

该篇与上篇区别仅在于，发布和订阅方的交换器的类型变为direct，同时设置发布消息的路由键，本篇将其设置为“error”，将订阅方其中一个队列的路由键设置为“error”,另一个设置为“bug”,则运行后，只有路由键和队列名称相同的一方能够收到消息，另一个bug路由键的收不到消息。

代码如下（在上篇代码上改造,修改的代码加上了下划线以便区分）：

发布方：

[java] view plain copy

 
  1. package com.rabbitmq.HelloWorld;
  2. import java.io.IOException;
  3. import java.util.concurrent.TimeoutException;
  4. import com.rabbitmq.client.Channel;
  5. import com.rabbitmq.client.Connection;
  6. import com.rabbitmq.client.ConnectionFactory;
  7. public class Publish {
  8. <u>private static final String EXCHANGE_NAME = "exchangeB";</u>
  9. public static void main(String[] args) throws IOException, TimeoutException {
  10. // TODO Auto-generated method stub
  11. //      创建工厂
  12. ConnectionFactory factory = new ConnectionFactory();
  13. factory.setHost("192.168.10.185");
  14. factory.setUsername("admin");
  15. factory.setPassword("123456");
  16. factory.setPort(5672);
  17. //      创建连接
  18. Connection connetion = factory.newConnection();
  19. //      获得信道
  20. Channel channel = connetion.createChannel();
  21. //      <u>声明交换器（声明了一个名字位exchangeA,类型修改fanout为direct类型的交换器）
  22. channel.exchangeDeclare(EXCHANGE_NAME, "direct");</u>
  23. String message = "555,2,2,33,66";
  24. //      <u>发送消息,将第二项参数routingkey修改为error
  25. channel.basicPublish(EXCHANGE_NAME, "error", null, message.getBytes());</u>
  26. System.out.println(" [x] Sent '" + message + "'");
  27. channel.close();
  28. connetion.close();
  29. }
  30. }

订阅方一，路由键为“error”

[java] view plain copy

 
  1. package com.rabbitmq.HelloWorld;
  2. import java.io.IOException;
  3. import java.util.concurrent.TimeoutException;
  4. import com.rabbitmq.client.Channel;
  5. import com.rabbitmq.client.Connection;
  6. import com.rabbitmq.client.ConnectionFactory;
  7. import com.rabbitmq.client.Consumer;
  8. import com.rabbitmq.client.DefaultConsumer;
  9. import com.rabbitmq.client.Envelope;
  10. import com.rabbitmq.client.AMQP.BasicProperties;
  11. public class Subscribe {
  12. <u>private static final String EXCHANGE_NAME = "exchangeB";</u>
  13. private static final String QUEUE_NAME = "queueA";
  14. public static void main(String[] args) throws IOException, TimeoutException {
  15. // TODO Auto-generated method stub
  16. //      创建工厂
  17. ConnectionFactory factory = new ConnectionFactory();
  18. factory.setHost("192.168.10.185");
  19. factory.setUsername("admin");
  20. factory.setPassword("123456");
  21. factory.setPort(5672);
  22. //      创建连接
  23. Connection connetion = factory.newConnection();
  24. //      获得信道
  25. Channel channel = connetion.createChannel();
  26. //      <u>声明交换器（声明了一个名字位exchangeA,类型修改fanout为direct的交换器）
  27. channel.exchangeDeclare(EXCHANGE_NAME, "direct");</u>
  28. //      声明一个队列，在此采用临时队列
  29. String queueName = channel.queueDeclare().getQueue();
  30. //      channel.queueDeclare(QUEUE_NAME, true, false, false, null);
  31. //      队列和交换器进行绑定,并设定路由键为error
  32. <u>channel.queueBind(queueName, EXCHANGE_NAME, "error");</u>
  33. System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
  34. Consumer consumer = new DefaultConsumer(channel){
  35. @Override
  36. public void handleDelivery(String consumerTag, Envelope envelope,
  37. BasicProperties properties, byte[] body) throws IOException {
  38. // TODO Auto-generated method stub
  39. String message = new String(body,"utf-8");
  40. System.out.println("[x] received'"+message+"'");
  41. }
  42. };
  43. channel.basicConsume(queueName, consumer);
  44. }
  45. }

订阅方二（路由键为“bug”）

[java] view plain copy

 
  1. import java.io.IOException;
  2. import java.util.concurrent.TimeoutException;
  3. import com.rabbitmq.client.Channel;
  4. import com.rabbitmq.client.Connection;
  5. import com.rabbitmq.client.ConnectionFactory;
  6. import com.rabbitmq.client.Consumer;
  7. import com.rabbitmq.client.DefaultConsumer;
  8. import com.rabbitmq.client.Envelope;
  9. import com.rabbitmq.client.AMQP.BasicProperties;
  10. public class Subscribe {
  11. <u>private static final String EXCHANGE_NAME = "exchangeB";</u>
  12. private static final String QUEUE_NAME = "queueA";
  13. public static void main(String[] args) throws IOException, TimeoutException {
  14. // TODO Auto-generated method stub
  15. //      创建工厂
  16. ConnectionFactory factory = new ConnectionFactory();
  17. factory.setHost("192.168.10.185");
  18. factory.setUsername("admin");
  19. factory.setPassword("123456");
  20. factory.setPort(5672);
  21. //      创建连接
  22. Connection connetion = factory.newConnection();
  23. //      获得信道
  24. Channel channel = connetion.createChannel();
  25. //      <u>声明交换器（声明了一个名字位exchangeA,修改fanout类型为direct类型的交换器�?
  26. channel.exchangeDeclare(EXCHANGE_NAME, "direct");</u>
  27. //      声明�?个队列，在此采用临时队列
  28. String queueName = channel.queueDeclare().getQueue();
  29. //      channel.queueDeclare(QUEUE_NAME, true, false, false, null);
  30. //      <u>队列和交换器进行绑定,未设定路由键
  31. channel.queueBind(queueName, EXCHANGE_NAME, "bug");</u>
  32. System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
  33. Consumer consumer = new DefaultConsumer(channel){
  34. @Override
  35. public void handleDelivery(String consumerTag, Envelope envelope,
  36. BasicProperties properties, byte[] body) throws IOException {
  37. // TODO Auto-generated method stub
  38. String message = new String(body,"utf-8");
  39. System.out.println("[x] received'"+message+"'");
  40. }
  41. };
  42. channel.basicConsume(queueName, consumer);
  43. }
  44. }

运行结果：

下面这个是在另一个项目中，没有引进日志打印的包，红色忽略即可

效果已经呈现了。

官网英文版学习——RabbitMQ学习笔记（六）Routing的更多相关文章

  1. 官网英文版学习——RabbitMQ学习笔记（一）认识RabbitMQ

    鉴于目前中文的RabbitMQ教程很缺,本博主虽然买了一本rabbitMQ的书,遗憾的是该书的代码用的不是java语言,看起来也有些不爽,且网友们不同人学习所写不同,本博主看的有些地方不太理想,为此本 ...

  2. 官网英文版学习——RabbitMQ学习笔记（十）RabbitMQ集群

    在第二节我们进行了RabbitMQ的安装,现在我们就RabbitMQ进行集群的搭建进行学习,参考官网地址是:http://www.rabbitmq.com/clustering.html 首先我们来看 ...

  3. Unity shader 官网文档全方位学习（一）

    转载:https://my.oschina.net/u/138823/blog/181131 摘要: 这篇文章主要介绍Surface Shaders基础及Examples详尽解析 What?? Sha ...

  4. 利用JQ实现的，高仿 彩虹岛官网导航栏（学习HTML过程中的小记录）

    利用JQ实现的,高仿 彩虹岛官网导航栏(学习HTML过程中的小记录)   作者:王可利(Star·星星) 总结: 今天学习的jQ类库的使用,代码重复的比较多需要完善.严格区分大小写,在 $(" ...

  5. 官网英文版学习——RabbitMQ学习笔记（二）RabbitMQ安装

    一.安装RabbitMQ的依赖Erlang 要进行RabbitMQ学习,首先需要进行RabbitMQ服务的安装,安装我们可以根据官网指导进行http://www.rabbitmq.com/downlo ...

  6. 官网英文版学习——RabbitMQ学习笔记（三）Hello World!

    参考http://www.rabbitmq.com/tutorials/tutorial-one-java.html,我们直接上代码,由于我们的RabbitMQ服务是安装在虚拟机上的,具体参考上一节. ...

  7. 官网英文版学习——RabbitMQ学习笔记（八）Remote procedure call (RPC)

    在第四篇学习笔记中,我们学习了如何使用工作队列在多个工作者之间分配耗时的任务.   但是,如果我们需要在远程计算机上运行一个函数并等待结果呢?这是另一回事.这种模式通常称为远程过程调用或RPC.   ...

  8. 官网英文版学习——RabbitMQ学习笔记（七）Topic

    在上一篇中使用直接交换器改进了我们的系统,使得它能够有选择的进行接收消息,但它仍然有局限性——它不能基于多个条件进行路由.本节我们就进行能够基于多个条件进行路由的topics exchange学习. ...

  9. 官网英文版学习——RabbitMQ学习笔记（五）Publish/Subscribe

    发布/订阅模式:把一个消息发送给多个消费者. 前几篇文章的思想是,我们好像看到了生产者将消息直接发送给queue,然后消费者也从queue中进行消费.其实并非如此,RabbitMQ中的消息传递模型的核 ...

随机推荐

  1. R语言 table()函数

    table函数 用 table() 函数统计因子各水平的出现次数(称为频数或频率).也可以对一般的向量统计每个不同元素的出现次数.如 sex = c("女","女&quo ...

  2. centos7一步一步搭建docker phpmyadmin 及nginx配置phpmyadmin非根目录重点讲解

    系统环境:centos7.7  镜像image 版本:phpmyadmin/phpmyadmin(截止2020.01.10最新版) 参考文章:https://blog.csdn.net/a258929 ...

  3. zookeeper和eureka的区别在哪?

    zookeeper和eureka的区别在哪?传统的关系型数据库是ACID(原子性,一致性,独立性,持久性), nosql数据库是CAP(强一致性,可用性,分区容错性),分布式系统只能3进2,三个选两个 ...

  4. UITextField的使用、介绍、讲解、全解、简介、说明

    [2018年中秋节良心写作]文章将尽可能的全面介绍UITextField的所有相关知识,逻辑连贯,需要认真理解,一气呵成. 关键词: 屏幕键盘(onscreen keyboard).键盘自定义.键盘类 ...

  5. 洛谷 P3320 [SDOI2015]寻宝游戏

    因为寻宝路径是一个环,所以寻宝花费的最小时间与起点无关.宝应当按照所有宝藏所在位置的 dfs 序进行才能够使得花费的时间最短.设 \(dist_i\) 表示 \(i\) 到树根的最短距离,那么树上任意 ...

  6. 实变函数（Real Analysis）

    针对实数函数的分析理论 首先引入集合和映射的概念 ------------------------------------- 集合交,并,差. 集合的势:有限集,无限集(可列,不可列) 再考虑实数点集 ...

  7. docker源码安装

    概述:Docker目前分为两个版本:EE版本(企业版本).CE版本(社区版本).推荐的内核版本是3.8或者更高.必须是64位的操作系统. 安装Docker的先决条件: 运行64位CPU架构的计算机(x ...

  8. TCP 3次握手 && 4次分手

    原文:https://github.com/jawil/blog/issues/14 3次握手 第一次握手:建立连接.客户端发送连接请求报文段,将SYN位置为1,Sequence Number为x:然 ...

  9. Qt中QListWidget的verticalScrollMode选项设置为ScrollPerPixel无效果的原因

    设置为ScrollPerPixel无效果,根据Qt手册的描述,需要在设置一次setSingleStep()的值,才会生效

  10. DeepCTR-Torch

    仅作学习使用 在ubuntu安装成功了,可以运行example.jump2 但是在mac没有成功,报错 ImportError: No module named torch