RabbitMQ代码记录

RabbitMQ是消息中间件的一种，消息中间件即分布式系统中完成消息的发送和接收的基础软件。

用于跨进程，跨计算机，跨语言等通信。简单方便，得到分布式的广泛应用。对于RabbitMQ来说，除了生产者，消息队列，消费者三个基本模块以外，还添加了一个模块，即交换机(Exchange)。它使得生产者和消息队列之间产生了隔离，生产者将消息发送给交换机，而交换机则根据调度策略把相应的消息转发给对应的消息队列。

     Direct是RabbitMQ默认的交换机模式，也是最简单的模式。即创建消息队列的时候，指定一个BindingKey.当发送者发送消息的时候，指定对应的Key。当Key和消息队列的BindingKey一致的时候，消息将会被发送到该消息队列中。

　　Topic转发信息主要是依据通配符，队列和交换机的绑定主要是依据一种模式(通配符+字符串)，而当发送消息的时候，只有指定的Key和该模式相匹配的时候，消息才会被发送到该消息队列中。

　　Headers也是根据一个规则进行匹配，在消息队列和交换机绑定的时候会指定一组键值对规则，而发送消息的时候也会指定一组键值对规则，当两组键值对规则相匹配的时候，消息会被发送到匹配的消息队列中。

　　Fanout是路由广播的形式,将会把消息发给绑定它的全部队列，即便设置了key，也会被忽略。

四种不同的交换机可以适应不同的业务要求。

maven：

版本号请自行控制

在application.properties配置文件中，请自行配置

spring.application.name=spring-boot-rabbitmq-sender
spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5672

spring.rabbitmq.username=name
spring.rabbitmq.password=password

code：

Direct模式

指定一个queue：

    @Bean
    public Queue queue() {
    return new Queue("queue");
    }

发送：

@Autowired

private AmqpTemplate template;

public void send() {

template.convertAndSend("queue","hello,rabbit~" );

}

接收：

    @RabbitListener(queues="queue")
    public void processC(String str) {
        System.out.println(str);
    }

Topic模式

需要配置队列Queue,再配置交换机Exchange：---------------------------------------------------------------

        @Bean(name="message")
        public Queue queueMessage() {
            return new Queue("topic.message");
        }

        @Bean(name="messages")
        public Queue queueMessages() {
            return new Queue("topic.messages");
        }

        @Bean
        public TopicExchange exchange() {
            return new TopicExchange("exchange");
        }

        @Bean
        Binding bindingExchangeMessage(@Qualifier("message") Queue queueMessage, TopicExchange exchange) {
            return BindingBuilder.bind(queueMessage).to(exchange).with("topic.message");
        }

        @Bean
        Binding bindingExchangeMessages(@Qualifier("messages") Queue queueMessages, TopicExchange exchange) {
            return BindingBuilder.bind(queueMessages).to(exchange).with("topic.#");//*表示一个词,#表示零个或多个词
        }

发送：

template.convertAndSend("exchange","topic.message","hello,rabbit~");

接收：

    @RabbitListener(queues="topic.message")    //监听器监听指定的Queue
    public void process1(String str) {    
        System.out.println("message:"+str);
    }
    @RabbitListener(queues="topic.messages")    //监听器监听指定的Queue
    public void process2(String str) {
        System.out.println("messages:"+str);
    }

Fanout 模式

指定：

        @Bean(name="Amessage")
        public Queue AMessage() {
            return new Queue("fanout.A");
        }


        @Bean(name="Bmessage")
        public Queue BMessage() {
            return new Queue("fanout.B");
        }

        @Bean(name="Cmessage")
        public Queue CMessage() {
            return new Queue("fanout.C");
        }

        @Bean
        FanoutExchange fanoutExchange() {
            return new FanoutExchange("fanoutExchange");//配置广播路由器
        }

        @Bean
        Binding bindingExchangeA(@Qualifier("Amessage") Queue AMessage,FanoutExchange fanoutExchange) {
            return BindingBuilder.bind(AMessage).to(fanoutExchange);
        }

        @Bean
        Binding bindingExchangeB(@Qualifier("Bmessage") Queue BMessage, FanoutExchange fanoutExchange) {
            return BindingBuilder.bind(BMessage).to(fanoutExchange);
        }

        @Bean
        Binding bindingExchangeC(@Qualifier("Cmessage") Queue CMessage, FanoutExchange fanoutExchange) {
            return BindingBuilder.bind(CMessage).to(fanoutExchange);
        }

发送：

template.convertAndSend("fanoutExchange","","hello,rabbit~");//第二个参数没有实际意义

接收：

    @RabbitListener(queues="fanout.A")
    public void processA(String str) {
        System.out.println("ReceiveA:"+str);
    }
    @RabbitListener(queues="fanout.B")
    public void processB(String str) {
        System.out.println("ReceiveB:"+str);
    }
    @RabbitListener(queues="fanout.C")
    public void processC(String str) {
        System.out.println("ReceiveC:"+str);
    }