springAMQP-广播模式(fanout)

广播模式是一个交换机下的所有队列都会收到消息 没有路由键的事情了

package com.example.demo.framework.mq;


import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MqFanout {
    /** 交换机名称 */
    public static String Exchange_Name = "fanoutExchange";
    /** 队列名称  */
    public static String Queue_Name = "fanoutQueue";
    /** 批量队列名称  */
    public static String Queue_Batch_Name = "fanoutQueueBatch";

    /**
     * 声明队列
     * @return
     */
    @Bean
    Queue fanoutQueue() {
        return new Queue(Queue_Name);
    }
    @Bean
    Queue fanoutBatchQueue() {
        return new Queue(Queue_Batch_Name);
    }

    /**
     * SpringAMQP 提供了各种类型的交换机类型
     * DirectExchange  1v1队列  正在使用
     * FanoutExchange  广播模式
     * HeadersExchange  头模式 不是很了解这个模式
     * TopicExchange   模糊匹配模式
     * @return
     */
    @Bean
    FanoutExchange bindFanoutExchange(){
        /**
         * 构造一个新的Exchange，并为其指定名称，持久性标志和自动删除标志以及*参数。
         * @param name 交换的名称。
         * @param durable 如果我们声明一个持久交换（交换将在服务器重启后保留），则为true
         * @param autoDelete 如果服务器在不再使用该交换时应删除该交换，则为true
         * @param arguments 用于声明交换的参数
         */
        return new FanoutExchange(Exchange_Name,false,true,null);
    }

    /**
     * 将交换机与队列绑定
     * @return
     */
    @Bean
    Binding fanoutBindingOne(){
        return BindingBuilder.bind(fanoutQueue()).to(bindFanoutExchange());
    }
    @Bean
    Binding fanoutBindingBatch(){
        return BindingBuilder.bind(fanoutBatchQueue()).to(bindFanoutExchange());
    }
}

消息监听

package com.example.demo.modules.rabbitMQ;


import com.example.demo.framework.mq.MqDirect;
import com.sun.istack.internal.logging.Logger;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public class MQListener {

    private Logger log = Logger.getLogger(MQListener.class);

    /**
     * 消息一条一条打印
     * @param msg
     */
    @RabbitListener(queues = "fanoutQueue")
    public void fanout(String msg){
        log.info("fanoutQueue监听到的消息----->"+msg);
    }

    @RabbitListener(queues = "fanoutQueueBatch",containerFactory = "batchQueueRabbitListenerContainerFactory")
    public void fanoutBatch(List<Message> messages){
        log.info("fanoutQueueBatch监听到的数量----->"+messages.size());
        log.info("fanoutQueueBatch监听到的消息----->"+messages.get(0).toString());
    }
}

消息发送

package com.example.demo;

import com.example.demo.framework.mq.MqDirect;
import com.example.demo.framework.mq.MqFanout;
import com.example.demo.framework.mq.MqTopic;
import com.rabbitmq.client.Channel;
import org.junit.jupiter.api.Test;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.connection.Connection;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.BatchingRabbitTemplate;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;

@SpringBootTest
class RabbmitMqApplicationTests {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Autowired
    private ConnectionFactory connectionFactory;

    @Autowired
    private BatchingRabbitTemplate batchingRabbitTemplate;

  
    //fanout模式下不需要路由键 参数为null就行
    @Test
    void fanout(){
        rabbitTemplate.convertAndSend(MqFanout.Exchange_Name,null,"fanout消息");
    }

查看打印结果