【RabbitMQ】三种类型交换器 Fanout,Direct,Topic

RabbitMQ服务器会根据路由键将消息从交换器路由到队列中，如何处理投递到多个队列的情况？这里不同类型的交换器起到了重要的作用。分别是fanout,direct，topic，每一种类型实现了不同的路由算法。

Fanout Exchange 

  不处理路由键。你只需要简单的将队列绑定到交换机上。一个发送到交换机的消息都会被转发到与该交换机绑定的所有队列上。很像子网广播，每台子网内的主机都获得了一份复制的消息。Fanout交换机转发消息是最快的。 

      

生产者

[java]  view plain  copy

1. package com.dynamic.rabbitmy.ps;  
2.   
3. /** 
4.  * Created by fxq on 2017/3/10. 
5.  */  
6.   
7. import com.dynamic.rabbitmy.util.ConnectionUtil;  
8. import com.rabbitmq.client.Channel;  
9. import com.rabbitmq.client.Connection;  
10.   
11. /** 
12.  * 生产者 
13.  */  
14. public class Send {  
15.     private final static  String  EXCHANGE_NAME="test_exchange_fanout";  
16.     public static void main(String[] args) throws  Exception{  
17.         //获取到连接以及mq通道  
18.         Connection connection = ConnectionUtil.getConnection();  
19.         Channel channel = connection.createChannel();  
20.         //声明交换器  
21.         channel.exchangeDeclare(EXCHANGE_NAME,"fanout");//fanout交换器  
22.         //消息内容  
23.         String message = "商品已经删除，id=1000";  
24.         channel.basicPublish(EXCHANGE_NAME,"",null,message.getBytes());  
25.         System.out.println(" [x] Sent'"+message+"'" );  
26.         channel.close();  
27.         connection.close();  
28.     }  
29. }  

消费者

[java]  view plain  copy

1. package com.dynamic.rabbitmy.ps;  
2. /** 
3.  * Created by fxq on 2017/3/10. 
4.  */  
5. import com.dynamic.rabbitmy.util.ConnectionUtil;  
6. import com.rabbitmq.client.Channel;  
7. import com.rabbitmq.client.Connection;  
8. import com.rabbitmq.client.QueueingConsumer;  
9. /** 
10.  * 消费者 
11.  */  
12. public class Recv  
13. {  
14.     private final static String QUEUE_NAME="test_queue_fanout_1";  
15.     private final static String EXCHANGE_NAME="test_exchange_fanout";  
16.     public static void main(String[] args) throws Exception{  
17.         //获取到连接以及通道  
18.         Connection connection = ConnectionUtil.getConnection();  
19.         Channel channel = connection.createChannel();  
20.         channel.queueDeclare(QUEUE_NAME,false,false,false,null);  
21.         //绑定队列到交换器  
22.         channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,""); //不设置路由键  
23.         //统一时刻服务器只会发一条消息给消费者;  
24.         channel.basicQos(1);  
25.         //定义队列的消费者  
26.         QueueingConsumer consumer = new QueueingConsumer(channel);  
27.         //监听队列，手动返回完成  
28.         channel.basicConsume(QUEUE_NAME,false,consumer);  
29.         //获取消息  
30.         while (true)  
31.         {  
32.             QueueingConsumer.Delivery delivery = consumer.nextDelivery();  
33.             String message = new String(delivery.getBody());  
34.             System.out.println(" 前台系统：'" + message + "'");  
35.             Thread.sleep(10);  
36.             //手动返回  
37.             channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);  
38.         }  
39.     }  
40. }  

Direct Exchange 

  处理路由键。需要将一个队列绑定到交换机上，要求该消息与一个特定的路由键完全匹配。这是一个完整的匹配。如果一个队列绑定到该交换机上要求路由键 “test”，则只有被标记为“test”的消息才被转发，不会转发test.aaa，也不会转发dog.123，只会转发test。 

     

生产者：

[java]  view plain  copy

1. package com.dynamic.rabbitmy.routing;  
2.   
3. /** 
4.  * Created by fxq on 2017/3/10. 
5.  */  
6.   
7. import com.dynamic.rabbitmy.util.ConnectionUtil;  
8. import com.rabbitmq.client.Channel;  
9. import com.rabbitmq.client.Connection;  
10.   
11. /** 
12.  * 生产者 
13.  */  
14. public class Send {  
15.     private final static String EXCHANGE_NAME="test_exchange_direct";  
16.     public static void main(String[] args)  throws Exception{  
17.         //获取到连接以及通道  
18.         Connection connection = ConnectionUtil.getConnection();  
19.         Channel channel = connection.createChannel();  
20.         //声明exchange  
21.         channel.exchangeDeclare(EXCHANGE_NAME,"direct");  
22.         //消息内容  
23.         String message = "删除商品，id = 1001";  
24.         channel.basicPublish(EXCHANGE_NAME,"delete",null,message.getBytes()); //此处delete为路由键；  
25.         System.out.println(" [x] Sent '"+ message+"'");  
26.         channel.close();  
27.         connection.close();  
28.     }  
29. }  

生产者：

[java]  view plain  copy

1. package com.dynamic.rabbitmy.routing;  
2.   
3. /** 
4.  * Created by fxq on 2017/3/10. 
5.  */  
6.   
7. import com.dynamic.rabbitmy.util.ConnectionUtil;  
8. import com.rabbitmq.client.AMQP;  
9. import com.rabbitmq.client.Channel;  
10. import com.rabbitmq.client.Connection;  
11. import com.rabbitmq.client.QueueingConsumer;  
12.   
13. /** 
14.  * 消费者1 
15.  */  
16. public class Recv {  
17.   
18.     private final static String QUEUE_NAME="test_queue_direct_1";  
19.     private final static String EXCHANGE_NAME="test_exchange_direct";  
20.     public static void main(String[] args) throws Exception{  
21.         //获取连接以及mq通道  
22.         Connection connection = ConnectionUtil.getConnection();  
23.         Channel channel = connection.createChannel();  
24.         //声明队列  
25.         channel.queueDeclare(QUEUE_NAME,false,false,false,null);  
26.         //绑定队列到交换机;  
27.         channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"update");  //匹配路由键为update  
28.         channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"delete");  //匹配路由键是delete  
29.         //同一时刻服务器只会发送一条消息给消费者;  
30.         channel.basicQos(1);  
31.         QueueingConsumer consumer = new QueueingConsumer(channel);  
32.         //监听队列，手动返回完成  
33.         channel.basicConsume(QUEUE_NAME,false,consumer);  
34.         //获取消息  
35.         while (true)  
36.         {  
37.             QueueingConsumer.Delivery delivery = consumer.nextDelivery();  
38.             String message = new String(delivery.getBody());  
39.             System.out.println("前台系统：'"+message+"'");  
40.             Thread.sleep(10);  
41.             channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);  
42.         }  
43.     }  
44. }  

  该绑定在交换器上的队列，它可以匹配delete,update的路由键,但不是能匹配insert;必须和生产者声明是一模一样；

Topic Exchange 

  将路由键和某模式进行匹配。此时队列需要绑定要一个模式上。符号“#”匹配一个或多个词，符号“*”匹配不多不少一个词。因此“audit.#”能够匹配到“audit.irs.corporate”，但是“audit.*” 只会匹配到“audit.irs”。

    

生产者：

[java]  view plain  copy

1. package com.dynamic.rabbitmy.topic;  
2.   
3. /** 
4.  * Created by fxq on 2017/3/10. 
5.  */  
6.   
7. import com.dynamic.rabbitmy.util.ConnectionUtil;  
8. import com.rabbitmq.client.Channel;  
9. import com.rabbitmq.client.Connection;  
10. /** 
11.  * 发送者 
12.  */  
13. public class Send {  
14.     private final  static String EXCHANGE_NAME="test_exchange_topic" ;  
15.     public static void main(String[] args) throws  Exception{  
16.         //获取到连接以及mq通道  
17.         Connection connection = ConnectionUtil.getConnection();  
18.         Channel channel = connection.createChannel();  
19.         //声明exchange  
20.         channel.exchangeDeclare(EXCHANGE_NAME,"topic");  
21.         //消息内容  
22.         String message = "插入商品，id=100";  
23.         //发布消息  
24.         channel.basicPublish(EXCHANGE_NAME,"item.insert",null,message.getBytes());  
25.         System.out.println(" [x] Sent '"+message + "'");  
26.         channel.close();  
27.         connection.close();  
28.     }  
29. }  

消费者：

[java]  view plain  copy

1. package com.dynamic.rabbitmy.topic;  
2.   
3. import com.dynamic.rabbitmy.util.ConnectionUtil;  
4. import com.rabbitmq.client.Channel;  
5. import com.rabbitmq.client.Connection;  
6. import com.rabbitmq.client.QueueingConsumer;  
7. import com.sun.media.sound.SF2InstrumentRegion;  
8.   
9. /** 
10.  * Created by fxq on 2017/3/10. 
11.  */  
12. public class Recv2 {  
13.   
14.     private final  static  String QUEUE_NAME="test_queue_topic2";  
15.     private final  static String EXCHANGE_NAME="test_exchange_topic" ;  
16.     public static void main(String[] args) throws  Exception{  
17.         //获得连接和mq通道  
18.         Connection connection = ConnectionUtil.getConnection();  
19.         Channel channel = connection.createChannel();  
20.         //声明通道  
21.         channel.queueDeclare(QUEUE_NAME,false,false,false,null);  
22.         //绑定exchange  
23.         channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"item.#");   //使用item.# 匹配所有的以item开头的  
24.         //同一时刻服务器只能发送一条消息给消费者；  
25.         channel.basicQos(1);  
26.         //声明消费者  
27.         QueueingConsumer consumer = new QueueingConsumer(channel);  
28.         //监控队列，设置手动完成  
29.         channel.basicConsume(QUEUE_NAME,false,consumer);  
30.         while (true)  
31.         {  
32.             QueueingConsumer.Delivery delivery = consumer.nextDelivery();  
33.             String message = new String(delivery.getBody());  
34.             System.out.println("搜索系统 '" + message + "'");  
35.             Thread.sleep(10);  
36.             channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);  
37.         }  
38.     }  
39. }  

  以上就是三种交换器的类型以及他们的使用场景，基于消息的路由键和交换器的类型，服务器会决定将消息投递到那个队列中。