RabbitMQ学习交换机之fanout模型

fanout:广播类型，交换机会将消息发送到所有与之绑定的队列中。
生产者代码

Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();
        //声明一个fanout类型交换机，
        channel.exchangeDeclare("publish_subscribe_exchange", BuiltinExchangeType.FANOUT,true,false,null);
        //声明两个队列
        channel.queueDeclare("publish_subscribe_queue1",true,false,false,null);
        channel.queueDeclare("publish_subscribe_queue2",true,false,false,null);
        //将两个队列与交换机进行绑定，因为是fanout类型，所以绑定时的routingKey可以设为""，
        // 在进行消息发送时的routingKey也设为""就行
        channel.queueBind("publish_subscribe_queue1","publish_subscribe_exchange","");
        channel.queueBind("publish_subscribe_queue2","publish_subscribe_exchange","");
        String body="来自publish_subscribe_exchange的消息";
        //在将消息传递给交换机时指定交换机的名称和routingKey，
        //因为时Fanout类型交换机，所以将此处的routingKey设为与将队列和交换机绑定时的routingKey相同即可，通常设为""
        channel.basicPublish("publish_subscribe_exchange","",null,body.getBytes());

        channel.close();
        connection.close();

消费者1代码

 Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
             AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("publish_subscribe_consumer1接收到消息->"+new String(body));
            }
        };
        channel.basicConsume("publish_subscribe_queue1",true,consumer);

消费者2代码

Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, 
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("publish_subscribe_consumer2接收到消息->"+new String(body));
            }
        };
        channel.basicConsume("publish_subscribe_queue2",true,consumer);

总结
FanOut类型交换机在与队列进行绑定时将routingKey设置为""，在将消息发送给交换机时，指定交换机的名称和routingKey，fanout的routingkey设置为""，与队列和交换机绑定时设置的routingKey相同

与Spring整合
生产者

<!--声明fanout类型交换机-->
    <rabbit:queue id="spring_fanout_queue1" name="spring_fanout_queue1" auto-declare="true"/>
    <rabbit:queue id="spring_fanout_queue2" name="spring_fanout_queue2" auto-declare="true"/>
    <!--交换机与队列绑定-->
    <rabbit:fanout-exchange name="spring_fanout_exchange" auto-declare="true" id="spring_fanout_exchange">
        <rabbit:bindings>
            <!--fanout类型交换机在于队列绑定时不需要指定routingKey-->
            <rabbit:binding queue="spring_fanout_queue1"/>
            <rabbit:binding queue="spring_fanout_queue2"/>
        </rabbit:bindings>
    </rabbit:fanout-exchange>

生产者代码

rabbitTemplate.convertAndSend("spring_fanout_exchange","","消息内容");
//指定交换机名称，fanout类型的routingKey为""

向spring容器中注入：

@Component
public class Sping_mq_listener implements MessageListener {
    public void onMessage(Message message) {
        System.out.println("onMessage");
        System.out.println(new String(message.getBody()));
    }
}

通过在xml中配置队列名进行监听

 <rabbit:listener-container connection-factory="connectionFactory" acknowledge="manual" prefetch="2">
        <!--通过队列名进行监听-->
        <rabbit:listener ref="sping_mq_listener" queue-names="spring_topic_queue1"/>
    </rabbit:listener-container>

总结
在整合时，
生产者通过在xml文件中声明fanoout交换机和队列进行绑定，绑定时指定交换机名称和routingKey("")
消费者通过实现MessageListener接口，将其放入spring容器中，再通过xml配置其监听的队列

 <rabbit:listener-container connection-
        <!--通过队列名进行监听-->
        <rabbit:listener ref="sping_mq_listener" queue-names="spring_topic_queue1"/>
    </rabbit:listener-container>