rabbitMQ的Exchange类型Direct topic Fanout

Direct

默认的,最简单的
路由关键字 就是队列名"user"

@Bean
public Queue userQueue() {
    return new Queue("user");//Rouning Key
}
//默认就是Direct 不用再绑定交换机 默认路由关键字就是"user"

消息生产者↓

@Autowired  
private RabbitTemplate rabbitTemplate;
public void sendUser() {
    //以路由关键字"user"发送字符串 "xxxxx" 不用指定交换机
   rabbitTemplate.convertAndSend("user", "xxxxx");
 }

消息消费者↓

@Configuration
public class HelloReceiver {
    
    private final static Logger logger = LoggerFactory.getLogger(HelloReceiver.class);
    
    @RabbitListener(queues = "user")//监听队列 "user"
    public void processUser(String msg) {
        logger.info("接收到的消息 : "+msg);
    }
    
}

topic

通配符匹配
队列↓

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

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

topic消息交换机↓ 取名叫"xxExchange" 生产者可以用这个名指定发到它

@Bean
TopicExchange xExchange() {
  return new TopicExchange("xxExchange");
}

Binding(绑定)↓ 交换机和队列 绑定

//以"routingKeyA"为路由关键字 发到交换机"xxExchange"的  队列"Ce"能收到
        @Bean
        Binding bindingExchangeMessage(Queue queueE, TopicExchange xExchange) {
            return BindingBuilder.bind(queueE).to(xExchange).with("routingKeyA");
        }

//路由关键字满足"routingKey#" 发到交换机"xxExchange"的  队列"Cs"能收到        
        @Bean
        Binding bindingExchangeMessages(Queue queueS, TopicExchange xExchange) {
            return BindingBuilder.bind(queueS).to(xExchange).with("routingKey#");
        }

生产者↓

public void send() {
        String msg1 = "I am routingKeyA msg======";
       
        //发送到"xxExchange" 这个信息交换机
        //以 "routingKeyA"为路由关键字
        rabbitTemplate.convertAndSend("xxExchange", "routingKeyA", msg1);
        //队列"Ce""Cs"都会收到
       
 
        String msg2 = "I am routingKeyWmsg########";
        
        //发送到"xxExchange" 这个信息交换机
        //以 "routingKeyW"为路由关键字
        rabbitTemplate.convertAndSend("xxExchange", "routingKeyW", msg2);
         //队列"Cs"会收到
    }

消费者↓

    @RabbitListener(queues = "Ce")//监听队列"Ce"
    public void process(String hello) {
        logger.info("receiver1接收到的消息 : "+hello);
    }
    @RabbitListener(queues = "Cs")//监听队列"Ce"
    public void process(String hello) {
        logger.info("receiver2接收到的消息 : " + hello);
    }

Fanout

广播

队列↓

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

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

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

以上队列 都和一个叫""fExchange""的交换机绑定↓,交换机是FanoutExchange类型

        @Bean
        FanoutExchange fExchange() {
            return new FanoutExchange("fExchange");
        }
        
        @Bean
        Binding bindingExchangeA(Queue AMessage,FanoutExchange fExchange) {
            return BindingBuilder.bind(AMessage).to(fExchange);
        }

        @Bean
        Binding bindingExchangeB(Queue BMessage, FanoutExchange fExchange) {
            return BindingBuilder.bind(BMessage).to(fExchange);
        }

        @Bean
        Binding bindingExchangeC(Queue CMessage, FanoutExchange fExchange) {
            return BindingBuilder.bind(CMessage).to(fExchange);
        }

生产者↓

   public void send() {
        String msgString="fanoutSender";
        logger.info(msgString);
        //把msgString发送到交换机"fExchange" 路由关键字"qerwrwerqw" 这里没用上
        this.rabbitTemplate.convertAndSend("fExchange","qerwrwerqw", msgString);
        //这样发送 绑定到这个交换机"fExchange"的 3个队列  都会收到
    }

一些概念

broker 消息队列服务器实体。
exchange 消息交换机(topic或者fanout类型).与队列绑定。生产者向交换机指定routing key投递信息.交换机按照这个routing key 和自己的类型，把消息投入给相应的队列。
queue:消费者指定队列的名字，来监听队列收到的信息。生产者可以直接指定队列名字来投递(这叫direct的exchange类型)。也可以指定routing key向信息交换机投递，让其再投给队列。
vhost 虚拟主机。一个broker可以有多个。用于不同用户的权限分离。
channel: 消息通道。每个代表一个会话。就是客户端连到消息，队列服务器就会打开一个channel.任务客户端的每个链接里可以建立多个通道。