RabbitMQ之Exchange（五）

Exchange总共有4种类型：direct, topic, fanout and headers，这里主要介绍前三种。

direct转发规则是根据routing key（由消费者来绑定，可以简单理解为消费者感兴趣的事件，如新闻中的：娱乐，社会，汽车，国际），下图中routing key为info，waring，error

生产者发送消息的时候，会指定消息对应的routing key（也就是指定消息的类型，如新闻中的：娱乐，那么所有关注娱乐新闻的人都能看到）

topic也是根据binding key，但是多了" *，# "两个通配符（*匹配单个.号分开的单词，#匹配多个）

发送quick.orange.rabbit或者lazy.orange.elephant，C1，C2均能收到

发送quick.orange.fox只有C1能收到，发送lazy.brown.fox只有C2能收到

lazy.pink.rabbit只会向C2发送一次

quick.brown.fox不被匹配，所以直接丢弃。

fanout转发规则是广播，即转发直连到这个exchange上的queue

 

Exchange-direct

Producer

package direct;

import java.io.IOException;

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

//direct为exchange的一种模式，主要是按照binding key来决定将消息放到哪些队列里
//相对于广播模式fanout就是多了一层routingKey的匹配，向匹配的queue广播
//大致流程时 producer -> exchange -> queue -> consumer
//producer可以选择像哪个exchange中发送数据，同时可以指定routingKey，也可以显示声明queue
//exchange则根据当前的模式决定将消息放到其关联的哪些queue里，广播就是全部，direct就是根据routingKey匹配，routingKey是exchange和queue之间的识别符
//queue就是用来具体的存放数据的队列，其内的同一条消息只会发送给一个consumer（假设多个人绑定同一个queue），可以用来负载均衡
public class Send {
    private static final String EXCHANGE_NAME = "direct_logs";
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        foo();
    }
    
    private static void foo() {
        try {
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("localhost");
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
            //声明一个直连的exchange
            channel.exchangeDeclare(EXCHANGE_NAME, "direct");
            for (int i = 0; i < 3; i++) {
                //设定了routing key为info1，info2，info3
                String serverity = "info"+i;
                String message = "info test"+i;
                //在名为direct_logs的Exchange上绑定了三个routing key，并发送消息
                channel.basicPublish(EXCHANGE_NAME, serverity, null, message.getBytes());
                System.out.println("Send:"+message);
            }
            channel.close();
            connection.close();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }

}

Consumer

package direct;

import java.io.IOException;

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 Recv {
    private static final String EXCHANGE_NAME = "direct_logs";
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        args = new String[]{"info1","info2"};
        foo(args);
    }

    private static void foo(String[] args) {
        try {
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("localhost");
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
            //声明一个直连的exchange，direct的意思是根据routing key进行转发
            channel.exchangeDeclare(EXCHANGE_NAME, "direct");
            String queueName = channel.queueDeclare().getQueue();
            
            //这里将同一个queue绑定了info1，info2两个routing key(binding key),所以可以收到info1，info2的消息
            for(String severity : args) {
                channel.queueBind(queueName, EXCHANGE_NAME, severity);
                System.out.println("routingKey:"+severity);
            }
            Consumer consumer = new DefaultConsumer(channel) {
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                        byte[] body) throws IOException {
                    String message = new String(body,"UTF-8");
                    System.out.println(queueName+" Recv "+message);
                }
            };
            channel.basicConsume(queueName, true, consumer);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}

运行结果

Procuder

Send:info test0
Send:info test1
Send:info test2

Consumer

routingKey:info1
routingKey:info2
amq.gen-tMcTNq9K_Zp3tNLCoNFqEg Recv info test1
amq.gen-tMcTNq9K_Zp3tNLCoNFqEg Recv info test2

备注：这里需要先运行Consumer，然后运行Producer。因为Producer没有绑定Queue，所以如果Producer先运行，那么没有queue来存放数据，导致数据直接丢失。

如下图：

运行结果图解：（与上述代码操作上有些许差别）

下图构造同上述代码，图中圆代表生产者，六边形代表Exchange，长方形代表queue，锯齿形代表消费者（下图中的两个是同一个消费者，队列也是同一个队列，当然可以是不同的队列，这里是为了符合代码）

下面的info1，info2，info3正好代表三个routing key（其中info3没有绑定queue，这里是为了画图方便）

连续发送两条routing key为info1的消息就是下图这种效果

　　

Exchange-topic

Producer

package topic;

import java.io.IOException;

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

//topic与direct的区别是，topic绑定的routingKey支持通配符
public class Send {
    private static final String EXCHANGE_NAME = "topic_logs";
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        foo();
    }
    
    private static void foo() {
        try {
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("localhost");
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
            channel.exchangeDeclare(EXCHANGE_NAME, "topic");
            for (int i = 0; i < 3; i++) {
                String serverity = "info.warn"+i;
                String message = "info.warn"+i;
                channel.basicPublish(EXCHANGE_NAME, serverity, null, message.getBytes());
                System.out.println("Send:"+message);
            }
            channel.close();
            connection.close();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }

}

Consumer

package topic;

import java.io.IOException;

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 Recv {
    private static final String EXCHANGE_NAME = "topic_logs";
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //args = new String[]{"#"};     //可以用来匹配所有的topic,#是指匹配0个或多个关键字
        //args = new String[]{"*"};     //只能匹配一个一个关键字，这里的关键字指的的以.分割的，如:send端topic为"info warn1"可以匹配，为"info.warn1"无法匹配
        args = new String[]{"info.*"};
        foo(args);
    }

    private static void foo(String[] args) {
        try {
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("localhost");
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
            channel.exchangeDeclare(EXCHANGE_NAME, "topic");
            String queueName = channel.queueDeclare().getQueue();
            
            for(String severity : args) {
                channel.queueBind(queueName, EXCHANGE_NAME, severity);
                System.out.println("routingKey:"+severity);
            }
            Consumer consumer = new DefaultConsumer(channel) {
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                        byte[] body) throws IOException {
                    String message = new String(body,"UTF-8");
                    System.out.println(queueName+" Recv: "+message);
                }
            };
            channel.basicConsume(queueName, true, consumer);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}

运行结果：

　　Procuder

Send:info.warn0
Send:info.warn1
Send:info.warn2

Consumer

routingKey:info.*
amq.gen-n5I6CxBz00azD2KPnq7GcA Recv: info.warn0
amq.gen-n5I6CxBz00azD2KPnq7GcA Recv: info.warn1
amq.gen-n5I6CxBz00azD2KPnq7GcA Recv: info.warn2

备注：这里需要先运行Consumer，然后运行Producer。因为Producer没有绑定Queue，所以如果Producer先运行，那么没有queue来存放数据，导致数据直接丢失。

图解：

这里由于工具问题，topic未能正常工作，所以使用广播模式绘制下图（导致看不到routing key，广播fanout不关心routing key），但是结果符合代码实际运行。

 

Exchange-topic

 Producer

package PubSub;

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

public class Send1 {
    private static final String QUEUE_NAME = "workqueue";
    private static final String EXCHANGE_NAME = "ex_log";
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        foo();
    }

    /**
     *  测试Exchange的fanout类型：即广播模式，不关心queue和exchange的binding key。
     *  本例测试场景是发送端发送日志消息到mq，消费者打印实时日志
     *  所以这里没有为exchange绑定queue，这意味着如果生产者先发送数据，那么消息会丢失，消费者只能收到其起来之后生产者发送的消息
     *  因为只有queue才能存数据，本例中只有消费者声明了queue（绑定的是随机queue，生命周期同消费者）
     *  这样做的好处是，一个消费者一个queue，消费者挂了queue也会自动删除
     */
    private static void foo() {
        try{
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("localhost");
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
            
            channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
            String message = "this is a log";
            //下面第一个参数时exchange的名字，之前为空""，表示为匿名，只要对端也为空""即可
            channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes());
            System.out.println("Send:"+message);
            channel.close();
            connection.close();
        } catch(Exception e) {
            e.printStackTrace();
        }
    }
}

Consumer

package PubSub;

import java.io.IOException;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP.BasicProperties;

public class Recv1 {
    private static final String QUEUE_NAME = "workqueue";
    private static final String EXCHANGE_NAME = "ex_log";
    public static void main(String[] args) {
        foo();
    }

    private static void foo() {
        try {
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("localhost");
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
            channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
            //创建一个随机的queue(非持久化、独占的、随着client session断开而自动删除的)
            String queueName = channel.queueDeclare().getQueue();
            channel.queueBind(queueName, EXCHANGE_NAME, "");
            DefaultConsumer consumer = new DefaultConsumer(channel){
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties,
                        byte[] body) throws IOException {
                    String message = new String(body,"UTF-8");
                    System.out.println("Recv:"+message);
                }
            };
            //只能接收到绑定道queue之后producer生产的数据，如果生产者生产数据时没有queue绑定到exchange，那么消息自动丢弃
            channel.basicConsume(queueName, true, consumer);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果：

　　Procuder

　　　　Send:this is a log

　　Consumer

　　　　Recv:this is a log

 　　备注：先运行Consumer再运行Producer才能收到，因为这里Producer没有声明queue

运行图解

注意下面有个命名queue和随机queue的区别（个人理解命名，官方可能没有这两个概念）

　　命名queue指的是Prodocer和Consumer都会去声明的Queue，即双方约定好的

　　随机queue指Producer没有去声明这个queue，其也不知道这个queue的存在，由消费者动态声明，用以接收数据，好处是这个queue的生命周期同consumer（上述代码用的就是随机queue）