RabbitMQ：Bindings的介绍和使用

1.声明

当前内容用于本人学习和使用，当前内容主要就是Bindings的分析

2.官方的Bindings介绍

Bindings are rules that exchanges use (among other things) to route messages to queues. To instruct an exchange E to route messages to a queue Q, Q has to be bound to E. Bindings may have an optional routing key attribute used by some exchange types. The purpose of the routing key is to select certain messages published to an exchange to be routed to the bound queue. In other words, the routing key acts like a filter.

Bindings是：exchange通过特定的规则绑定到queue(Bindings就是规则)，例如一个Exchange E通过路由方式发送消息到Queue Q上面，那么Q就被绑定到E上面。Bindins可能有一个操作路由属性一般用在一些Exchange 类型上面。路由key一般都是由exchange通过路由方式将消息推送到被绑定的队列上，这个路由key就像一个过滤器一样

解析：bindins就是一套规则，用于描述exchange到queue之间的规则，可以使用路由key,路由key相当于exchange到queue之间的过滤器

To draw an analogy:

Queue is like your destination in New York city
Exchange is like JFK airport
Bindings are routes from JFK to your destination. There can be zero or many ways to reach it

打个比方

队列就像目的地纽约市

交换机就像JFk机场

绑定就是从JFK机场到纽约，可能由0个或者多个路径到达纽约

if a message cannot be routed to any queue (for example, because there are no bindings for the exchange it was published to) it is either dropped or returned to the publisher, depending on message attributes the publisher has set.

如果一个消息不能被路由到任何一个queue中(例如，这个没有任何一个绑定到交换机，但是这个消息被推送)，那么这个消息将会被删除抛弃或者被返回到消息发布者，返回或者抛弃都必须依赖于消息发布者设置的属性

3.查看ui界面的绑定

Exchange界面的绑定

可以发现Exchange上面上面可以Binding到queue也可以Binding到Exchange上面

这个可以理解为：比如物流直达、或者物流中转，最后的结果都是目的地

Queue界面的绑定

Queue界面中如果绑定必须填写Exchange

也就是说：Bindings有两种形式

1. 通过Exchange直接绑定到Queue（合作和Exchange绑定到Exchange然后再绑定到Queue）
2. 通过Queue绑定到Exchange

4.使用代码方式实现Queue到Exchange的绑定

基本步骤

1. 声明一个Exchange:JFK airport
2. 声明一个Queue:New York city
3. 使用绑定规则将Exchange和Queue之间绑定

具体代码实现

/**
 * @description 用于测试Bindings，通过Exchange绑定到queue
 * @author hy
 * @date 2020-05-14
 */
public class BindingsTest {
	public static void main(String[] args) {
		RabbitMqUtils mqUtils = new RabbitMqUtils();
		Connection connection = mqUtils.getConnection();

		try (Channel channel = connection.createChannel();) {

			// 首先声明一个Exchange
			String exchangeName = "JFK airport";
			String queueName = "New York city";
			DeclareOk exchangeDeclare = channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC);
			System.out.println(exchangeDeclare);
			// 然后创建一个Queue
			com.rabbitmq.client.AMQP.Queue.DeclareOk queueDeclare = channel.queueDeclare(queueName, true, false, false,
					null);
			String queue = queueDeclare.getQueue();
			int messageCount = queueDeclare.getMessageCount();
			int consumerCount = queueDeclare.getConsumerCount();
			System.out.println("队列名称=" + queueName + ",当前队列的消息数量=" + messageCount + ",当前队列的消费者数量=" + consumerCount);
			// 最后通过Bindings方式将Exchange 绑定到Queue上面
			// 使用Exchange 绑定到Queue上面,destination 目的地，source来源第，routingKey 路由键null
			
			//BindOk exchangeBind = channel.exchangeBind(exchangeName, queue, "");// 绑定一个exchange到另外一个exchange
			//这个才是将queue绑定到exchange上面,注意这里的routingKey不能为null
			com.rabbitmq.client.AMQP.Queue.BindOk queueBind = channel.queueBind(queueName, exchangeName, "");
			System.out.println(queueBind);
		} catch (IOException e) {
			e.printStackTrace();
		} catch (TimeoutException e) {
			e.printStackTrace();
		} finally {
			mqUtils.close(connection);
		}

	}
}

期间发生的错误：

1. 不能使用exchangeBind(这个是Exchange与Exchange之间的绑定)
2. 如果使用Queue和Exchange绑定必须使用queueBind
3. 注意当前Routing Key不能为null

执行结果

ui界面的结果

5.使用代码方式实现Exchange到Exchange之间的绑定

具体步骤

1. 声明两个Exchange
2. 直接将两个Exchange进行绑定(需要注意目的地和来源地)

/**
 * @description 用于测试Bindings，通过Exchange绑定到Exechange,实现中国机场绑定到JFK 机场到纽约
 * @author hy
 * @date 2020-05-14
 */
public class EToEBindingsTest {
	public static void main(String[] args) {
		RabbitMqUtils mqUtils = new RabbitMqUtils();
		Connection connection = mqUtils.getConnection();

		try (Channel channel = connection.createChannel();) {

			// 首先声明一个ChinaExchange
			String chinaAirport = "China airport";
			String jfkAirport = "JFK airport";

			DeclareOk chinaDeclare = channel.exchangeDeclare(chinaAirport, BuiltinExchangeType.TOPIC);
			System.out.println(chinaDeclare);
			
			// 然后声明一个JFK Exchange
			DeclareOk jfkDeclare = channel.exchangeDeclare(jfkAirport, BuiltinExchangeType.TOPIC);
			System.out.println(jfkDeclare);
			
			// 使用Exchange 绑定到Exchange上面,destination 目的地，source来源第，routingKey 路由键不能为null
			BindOk exchangeBind = channel.exchangeBind(jfkAirport,chinaAirport , "");// 绑定一个exchange到另外一个exchange
			
			System.out.println(exchangeBind);
		} catch (IOException e) {
			e.printStackTrace();
		} catch (TimeoutException e) {
			e.printStackTrace();
		} finally {
			mqUtils.close(connection);
		}

	}
}

执行结果(控制台)

ui界面上的结果


queue界面结果

6.测试Exchange到Exchange

1.首先创建一个客户端用于接收Queue的New York city的消息

2.然后直接从China airport上面发送一条消息到New York city的Queue队列中，并最后查看结果

public class EToEToQConsumer {
	public static void main(String[] args) throws Exception {
		RabbitMqUtils mqUtils = new RabbitMqUtils();
		mqUtils.reciver("New York city", true, (x, y) -> {
			System.out.println("New York city 接收到消息：" + new String(y.getBody(), "utf-8"));
		});
	}
}

ui界面发送消息

控制台结果

测试成功

7.分析上面ExchangeToExchange的结果

由于前面的路由key都是""空字符串，所以在ui界面的时候不需要添加routing key,但是需要注意的是，现实中China airport到JFK airport到New York city之间应该是具有routing key（建议这个routing key就直接为New York city）

通过测试发现我们向一个China airport发送消息的时候，如果指定的路由key,那么他会遍历所有的指向的Exchange并判断是否符合当前的规则，符合就会继续往下面发送，如果不符合则可能产生消息丢弃或者消息返回到消息生产者中

8.总结

1.Bindings就是一种规则，用于描述Exchange到Exchange或者Exchange到Queue之间的过滤规则

2.注意ui界面的绑定和代码的绑定是不一致的，ui界面允许Queue到Exchange之间的两方绑定，但是代码中只能使用Queue到Exchange之间的绑定

3.如果存在多个Exchange之间的绑定，还是基于Bindings规则进行匹配往下面发送的

以上纯属个人见解，如有问题请联系本人！