在RabbitMQ中，生产者发送消息不会直接将消息投递到队列中，而是先将消息投递到交换机中，在由交换机转发到具体的队列，
   队列再将消息以推送或者拉取方式给消费者进行消费

   创建消息              路由键              pull/push
   生产者------------>交换机------------>队列------------>消费者

Exchange(交换机)的类型

1.直连交换机：Direct Exchange

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

这样当一个交换机绑定多个队列，就会被送到对应的队列去处理。

2.主题交换机：Topic Exchange

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

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

 

3.扇形交换机：Fanout Exchange

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

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

4.首部交换机：Headers exchange

 

5.默认交换机

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

     如：当你声明了一个名为”hello”的队列，RabbitMQ会自动将其绑定到默认交换机上，绑定（binding）的路由键名称也是为”hello”。
     因此，当携带着名为”hello”的路由键的消息被发送到默认交换机的时候，此消息会被默认交换机路由至名为”hello”的队列中
  
     类似amq.*的名称的交换机：
     这些是RabbitMQ默认创建的交换机。这些队列名称被预留做RabbitMQ内部使用，不能被应用使用，否则抛出403 (ACCESS_REFUSED)错误 

6.Dead Letter Exchange（死信交换机）

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

代码示例：

 

第一种：直连交换机

新建一个springcloud项目，在新建一个生产者和一个消费者，在生产者中新建一个包rabbitmq，在新建一个直连交换机的类

依赖：

<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>

生产者：

package com.ywy.rabbitmq;

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 {//直连交换机
    /*
    * 创建一个队列  队列名为direct1
    * */
    @Bean
    public Queue queue01(){
        return new Queue("direct1",true);
    }

    /*
    * 创建一个直连交换机 名为directExchange
    * */
    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange("directExchange");
    }

    /*
    * 在让队列和直连交换机绑定在一起
    * */
    @Bean
    public Binding binding(){
        Binding binding= BindingBuilder.bind(queue01()).to(directExchange()).with("routingKey01");
        return binding;
    }
}

然后再来一个controller的包，中新建一个调用的类

@RestController
public class DirectController {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    //直连的方式
    @RequestMapping("manages1")
    public String Manages1(){
        //convertAndSend(交换机的名字,交换机中路由键名称,参数)
        rabbitTemplate.convertAndSend("directExchange","routingKey01",getData());
        return "success01";
    }

}

修改application.yml

server:
  port: 8080
  servlet:
    context-path: /
spring:
  rabbitmq:
    #虚拟机主机ip地址
    host: 192.168.118.130
    #虚拟主机名
    virtual-host: my_vhost
    #用户名
    username: ywy
    #密码
    password: 123456
    #端口号
    port: 5672

消费者：

新建一个消费者的类：

@Component
@RabbitListener(queues = {"direct1"})//队列名
public class DirectExchange {//直连交换机的消费者
    @RabbitHandler
    public void direct(Map<String,String> map){
        System.out.println(map);
        System.out.println("直连交换机");
    }

}

第二种：主题交换机

yml和依赖和上面第一种一样

生产者：生产者的类

@Configuration
public class RabbitmqTopicConfig {//主题交换机

    /*
    * 创建队列   名为topic01
    * */
    @Bean
    public Queue queuet01(){
        return new Queue("topic01",true);
    }
    @Bean
    public Queue queuet02(){
        return new Queue("topic02",true);
    }
    @Bean
    public Queue queuet03(){
        return new Queue("topic03",true);
    }

    /*
    * 创建主题交换机 名为topicExchange01
    * */
    @Bean
    public TopicExchange topicExchange01(){
        return new TopicExchange("topicExchange01");
    }


    /*
    * 将队列和主题交换机绑定
    * */
    @Bean
    public Binding bindingt01(){
        Binding b= BindingBuilder.bind(queuet01()).to(topicExchange01()).with("topic.ywy.a");
        return b;
    }
    @Bean
    public Binding bindingt02(){
        Binding b= BindingBuilder.bind(queuet02()).to(topicExchange01()).with("topic.ywy.b");
        return b;
    }
    /*这里的*意思就是通配符，可以到a,b任意的一个地方*/
    /*如果是topic.ywy.a,就进了01的队列，还会进03的队列中*/
    @Bean
    public Binding bindingt03(){
        Binding b=BindingBuilder.bind(queuet03()).to(topicExchange01()).with("topic.ywy.*");
        return b;
    }


}

controller中

//主题交换机的方式01
    @RequestMapping("manages2")
    public String Manages2(String routing){
        rabbitTemplate.convertAndSend("topicExchange01",routing,getData());
        return "success2";
    }

消费者：消费者的类

@Component
@RabbitListener(queues = {"topic01"})//队列名
public class TopicExchange01 {

    @RabbitHandler
    public void topic01(Map<String,String> map){
        System.out.println(map);
        System.out.println("主题交换机a");
    }
}

第三种：扇形交换机

生产者：

@Configuration
public class RabbitFanoutConfig {//扇形交换机
    /*
    * 创建队列  名为fanout01
    * */
    @Bean
    public Queue queuef01(){
        return new Queue("fanout01",true);
    }
    @Bean
    public Queue queuef02(){
        return new Queue("fanout02",true);
    }
    @Bean
    public Queue queuef03(){
        return new Queue("fanout03",true);
    }

    /*
    * 创建扇形交换机  名为fanoutExchange01
    * */
    @Bean
    public FanoutExchange fanoutExchange01(){
        return new FanoutExchange("fanoutExchange01");
    }

    /*
    * 绑定队列和扇形交换机
    * */
    /*
    这里没有with，会给每一个队列都发送一条消息
    */
    @Bean
    public Binding bindingf01(){
        Binding b= BindingBuilder.bind(queuef01()).to(fanoutExchange01());
        return b;
    }
    @Bean
    public Binding bindingf02(){
        Binding b= BindingBuilder.bind(queuef02()).to(fanoutExchange01());
        return b;
    }
    @Bean
    public Binding bindingf03(){
        Binding b= BindingBuilder.bind(queuef03()).to(fanoutExchange01());
        return b;
    }



}

controller中：

//扇形交换机的方法
    @RequestMapping("manages03")
    public String Mananges3(){
        rabbitTemplate.convertAndSend("fanoutExchange01",null,getData());
        return "sucess3";
    }

消费者：

@Component
@RabbitListener(queues = {"fanout01"})//队列名
public class FanoutExchange01 {

    @RabbitHandler
    public void fanout01(Map<String,String> map){
        System.out.println(map);
        System.out.println("扇形交换机a");
    }
}

附：

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

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