02、交换机

直连交换机是一种带路由功能的交换机一个队列会和一个交换机绑定除此之外再绑定一个routing_key当消息被发送的时候需要指定一个binding_key这个消息被送达交换机的时候就会被这个交换机送到指定的队列里面去。同样的一个binding_key也是支持应用到多个队列中的。这样当一个交换机绑定多个队列就会被送到对应的队列去处理。

注1什么是路由键
每个消息都有一个称为路由键(routing key)的属性它其实就是一个简单的字符串

注2直连交换机适用场景
有优先级的任务根据任务的优先级把消息发送到对应的队列这样可以指派更多的资源去处理高优先级的队列。

2.2.主题交换机Topic Exchange

直连交换机的缺点
直连交换机的routing_key方案非常简单如果我们希望一条消息发送给多个队列那么这个交换机需要绑定上非常多的routing_key
假设每个交换机上都绑定一堆的routing_key连接到各个队列上。那么消息的管理就会异常地困难。所以RabbitMQ提供了一种主题交换机发送到主题交换机上的消息需要携带指定规则的routing_key
主题交换机会根据这个规则将数据发送到对应的(多个)队列上。

主题交换机的routing_key需要有一定的规则交换机和队列的binding_key需要采用*.#.*.....的格式每个部分用.分开其中
*表示一个单词
#表示任意数量零个或多个单词。

示例
队列Q1绑定键为 *.TT.*
队列Q2绑定键为TT.#

如果一条消息携带的路由键为 A.TT.B那么队列Q1将会收到
如果一条消息携带的路由键为TT.AA.BB那么队列Q2将会收到

2.3.扇形交换机Fanout Exchange

扇形交换机是最基本的交换机类型它所能做的事情非常简单———广播消息。
扇形交换机会把能接收到的消息全部发送给绑定在自己身上的队列。因为广播不需要“思考”所以扇形交换机处理消息的速度也是所有的交换机类型里面最快的。

这个交换机没有路由键概念就算你绑了路由键也是无视的。

2.4.首部交换机Headers exchange

2.5.默认交换机

实际上是一个由RabbitMQ预先声明好的名字为空字符串的直连交换机direct exchange。它有一个特殊的属性使得它对于简单应用特别有用处那就是每个新建队列queue都会自动绑定到默认交换机上绑定的路由键routing key名称与队列名称相同。

如当你声明了一个名为”hello”的队列RabbitMQ会自动将其绑定到默认交换机上绑定binding的路由键名称也是为”hello”。
因此当携带着名为”hello”的路由键的消息被发送到默认交换机的时候此消息会被默认交换机路由至名为”hello”的队列中

类似amq.*的名称的交换机
这些是RabbitMQ默认创建的交换机。这些队列名称被预留做RabbitMQ内部使用不能被应用使用否则抛出403 (ACCESS_REFUSED)错误

2.6.Dead Letter Exchange死信交换机

在默认情况如果消息在投递到交换机时交换机发现此消息没有匹配的队列则这个消息将被悄悄丢弃。
为了解决这个问题RabbitMQ中有一种交换机叫死信交换机。当消费者不能处理接收到的消息时将这个消息重新发布到另外一个队列中等待重试或者人工干预。这个过程中的exchange和queue就是所谓的”Dead Letter Exchange 和 Queue

3、交换机的属性

除交换机类型外在声明交换机时还可以附带许多其他的属性其中最重要的几个分别是
Name交换机名称
Durability是否持久化。如果持久性则RabbitMQ重启后交换机还存在
Auto-delete当所有与之绑定的消息队列都完成了对此交换机的使用后删掉它
Arguments扩展参数

4、综合案例交换机的使用

rabbitmq02 #主模块 maven
rabbitmq-provider #生产者 springboot
rabbitmq-consumer #消费者 springboot

给子模块添加依赖

<dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-amqp</artifactId>
     </dependency>
     <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
     </dependency>
     <dependency>
       <groupId>org.projectlombok</groupId>
       <artifactId>lombok</artifactId>
       <optional>true</optional>
     </dependency>

4.1.直连交换机(Direct Exchange)

1.RabbitmqDirectConfig
2.SendMessageController
关键代码rabbitTemplate.convertAndSend("testDirectExchange", "testDirectRouting", map);
sendDirectMessage进行消息推送也可以改为定时任务具体看需求

3.查看rabbitmq管理界面
我们目前还创建消费者rabbitmq-consumer消息没有被消费的我们去rabbitMq管理页面看看是否推送成功
Overview选项卡可以查看到刚刚创建的消息
4.创建消息接收监听类DirectReceiver

注1新版jdk日期及格式化
LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));

注2rabbitTemplate和amqpTemplate有什么关系
查看源码中会发现rabbitTemplate实现自amqpTemplate接口两者使用起来并无区别功能一致

注3不要@Configuration写成了@Configurable这两个长得很像
@Configuration该注解是可以用来替代XML文件。
手动new出来的对象正常情况下Spring是无法依赖注入的这个时候可以使用

@Configurable注解

生产者

package com.zking.rabbitmqproduct.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 直连交换机
 */
@Configuration
public class RabbitmqDirectConfig {
    /**
     * 定义队列
     * @return
     */
    @Bean
    public Queue directQueue(){
        return new Queue("direct-queue");
    }

    /**
     * 自定义直连交换机
     * @return
     */
    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange("direct-exchange",true,false);
    }

    /**
     * 将队列与交换机进行绑定并设置路由键
     * @return
     */
    @Bean
    public Binding binding(){
        return BindingBuilder.bind(directQueue())
                .to(directExchange())
                .with("direct_routing_key");
    }

}

消费者

package com.zking.rabbitmqconsumer.receiver;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

@Component
@RabbitListener(queues = {"direct-queue"})
public class DirectReceiver {

    @RabbitHandler
    public void handler(Map<String,Object> json){
        System.out.println(json);
    }
}

4.2.主题交换机(Topic Exchange)

RabbitTopicConfig

生产者

package com.zking.rabbitmqproduct.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitmqTopicConfig {

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

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

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

    /**
     * 定义主题交换机
     * @return
     */
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange("topic-exchange",true,false);
    }

    @Bean
    public Binding bindingA(){
        return BindingBuilder.bind(queueA())
                .to(topicExchange())
                .with("topic.person.aa");
    }

    @Bean
    public Binding bindingB(){
        return BindingBuilder.bind(queueB())
                .to(topicExchange())
                .with("topic.person.bb");
    }

    @Bean
    public Binding bindingC(){
        return BindingBuilder.bind(queueC())
                .to(topicExchange())
                .with("topic.person.*");
    }
}

消费者

package com.zking.rabbitmqconsumer.receiver;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

@Component
public class TopicReceiver {

    @RabbitListener(queues = {"queue-a"})
    @RabbitHandler
    public void handlerA(Map<String,Object> json){
        System.out.println("已接受到队列queue-a传递过来的消息"+json);
    }

    @RabbitListener(queues = {"queue-b"})
    @RabbitHandler
    public void handlerB(Map<String,Object> json){
        System.out.println("已接受到队列queue-b传递过来的消息"+json);
    }

    @RabbitListener(queues = {"queue-c"})
    @RabbitHandler
    public void handlerC(Map<String,Object> json){
        System.out.println("已接受到队列queue-c传递过来的消息"+json);
    }
}

4.3.扇形交换机(Fanout Exchange)

//因为是扇型交换机, 路由键无需配置,配置也不起作用两处地方均未配置路由键
     BindingBuilder.bind(queueA()).to(fanoutExchange()); 
     rabbitTemplate.convertAndSend(RabbitFanoutConfig.EXCHANGE_NAME,null, map);

生产者

package com.zking.rabbitmqproduct.config;

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

@Configuration
public class RabbitmqFanoutConfig {

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

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

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

    /**
     * 定义扇形交换机与路由键无关
     * @return
     */
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("fanout-exchange",true,false);
    }

    @Bean
    public Binding bindingX(){
        return BindingBuilder.bind(queueX())
                .to(fanoutExchange());
    }

    @Bean
    public Binding bindingY(){
        return BindingBuilder.bind(queueY())
                .to(fanoutExchange());
    }

    @Bean
    public Binding bindingZ(){
        return BindingBuilder.bind(queueZ())
                .to(fanoutExchange());
    }
}

消费者

package com.zking.rabbitmqconsumer.receiver;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

@Component
public class FanoutReceiver {

    @RabbitListener(queues = {"queue-x"})
    @RabbitHandler
    public void handlerY(Map<String,Object> json){
        System.out.println("已接受到队列queue-x传递过来的消息"+json);
    }

    @RabbitListener(queues = {"queue-y"})
    @RabbitHandler
    public void handlerX(Map<String,Object> json){
        System.out.println("已接受到队列queue-y传递过来的消息"+json);
    }

    @RabbitListener(queues = {"queue-z"})
    @RabbitHandler
    public void handlerZ(Map<String,Object> json){
        System.out.println("已接受到队列queue-z传递过来的消息"+json);
    }
}