RabbitMQ交换机类型

小码哥呀2024-11-05 17:07

RabbitMQ交换机类型

  • 1、RabbitMQ工作模型
  • 2、RabbitMQ交换机类型
    • [2.1、Fanout Exchange（扇形）](#2.1、Fanout Exchange（扇形）)
    • [2.2、Direct Exchange（直连）](#2.2、Direct Exchange（直连）)
    • [2.3、Topic Exchange（主题交换机）](#2.3、Topic Exchange（主题交换机）)
      • [2.3.1 介绍](#2.3.1 介绍)
      • [2.3.2 示例](#2.3.2 示例)
        • [2.3.2.1 配置文件appication.yml](#2.3.2.1 配置文件appication.yml)
        • [2.3.2.2 配置类RabbitConfig](#2.3.2.2 配置类RabbitConfig)
        • [2.3.2.3 发送消息MessageService](#2.3.2.3 发送消息MessageService)
        • [2.3.2.4 启动类Application](#2.3.2.4 启动类Application)
        • [2.3.2.5 pom.xml配置文件](#2.3.2.5 pom.xml配置文件)
        • [2.3.2.6 测试](#2.3.2.6 测试)
    • [2.4、Headers Exchange（头部交换机）](#2.4、Headers Exchange（头部交换机）)
      • 2.4.1、介绍
      • 2.4.2、示例
        • [2.4.2.1 配置文件appication.yml](#2.4.2.1 配置文件appication.yml)
        • [2.4.2.2 配置类RabbitConfig](#2.4.2.2 配置类RabbitConfig)
        • [2.4.2.3 发送消息MessageService](#2.4.2.3 发送消息MessageService)
        • [2.4.2.4 启动类Application](#2.4.2.4 启动类Application)
        • [2.4.2.5 pom.xml配置文件](#2.4.2.5 pom.xml配置文件)
        • [2.4.2.6 测试](#2.4.2.6 测试)

1、RabbitMQ工作模型

  • broker 相当于mysql服务器；
  • virtual host相当于数据库（可以有多个数据库）；
  • queue相当于表；
  • 消息相当于记录。

消息队列有三个核心要素： 消息生产者、消息队列、消息消费者；
生产者（Producer） ：发送消息的应用；（java程序，也可能是别的语言写的程序）
消费者（Consumer） ：接收消息的应用；（java程序，也可能是别的语言写的程序）
代理（Broker） ：就是消息服务器，RabbitMQ Server就是Message Broker；
连接（Connection） ：连接RabbitMQ服务器的TCP长连接；
信道（Channel） ：连接中的一个虚拟通道，消息队列发送或者接收消息时，都是通过信道进行的；
虚拟主机（Virtual host） ：一个虚拟分组，在代码中就是一个字符串，当多个不同的用户使用同一个RabbitMQ服务时，可以划分出多个Virtual host，每个用户在自己的Virtual host创建exchange/queue等；（分类比较清晰、相互隔离）
交换机（Exchange） ：交换机负责从生产者接收消息，并根据交换机类型分发到对应的消息队列中，起到一个路由的作用；
路由键（Routing Key） ：交换机根据路由键来决定消息分发到哪个队列，路由键是消息的目的地址；
绑定（Binding） ：绑定是队列和交换机的一个关联连接（关联关系）；
队列（Queue） ：存储消息的缓存；
消息（Message）：由生产者通过RabbitMQ发送给消费者的信息；（消息可以任何数据，字符串、user对象，json串等等）

2、RabbitMQ交换机类型

Exchange（X） 可翻译成交换机/交换器/路由器

  • Fanout Exchange（扇形）
  • Direct Exchange（直连）
  • Topic Exchange（主题）
  • Headers Exchange（头部）

2.1、Fanout Exchange（扇形）

2.1.1、介绍

Fanout 扇形的，散开的； 扇形交换机

投递到所有绑定的队列，不需要路由键，不需要进行路由键的匹配，相当于广播、群发；

2.1.2、示例

2.1.2.1、生产者

1、配置类

java 复制代码 
package com.power.config;

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

@Configuration
public class RabbitConfig {
    //rabbitmq三部曲
    //1、定义交换机
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange("exchange.fanout");
    }

    //2、定义队列
    @Bean
    public Queue queueA() {
        return new Queue("queue.fanout.a");
    }

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

    //3、绑定交换机何队列
    @Bean
    public Binding bingingA(FanoutExchange fanoutExchange, Queue queueA) {
        //将队列A绑定到扇形交换机
        return BindingBuilder.bind(queueA).to(fanoutExchange);
    }

    @Bean
    public Binding bingingB(FanoutExchange fanoutExchange, Queue queueB) {
        //将队列B绑定到扇形交换机
        return BindingBuilder.bind(queueB).to(fanoutExchange);
    }
}

2、生产者

java 复制代码 
package com.power.service;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.Date;

@Component
@Slf4j
public class MessageService {
    @Resource
    private RabbitTemplate rabbitTemplate;

    public void sendMsg() {
        //定义要发送的消息
        String msg = "hello world";
        Message message = new Message(msg.getBytes());
        rabbitTemplate.convertAndSend("exchange.fanout", "", message);
        log.info("消息发送完毕，发送时间为：" + new Date());
    }
}

2、启动类

java 复制代码 
package com.power;

import com.power.service.MessageService;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import javax.annotation.Resource;

@SpringBootApplication
public class FanoutApplication implements ApplicationRunner {

    @Resource
    private MessageService messageService;

    public static void main(String[] args) {
        SpringApplication.run(FanoutApplication.class,args);
    }

    /**
     * 程序一启动就运行该方法
     *
     * @param args
     * @throws Exception
     */
    @Override
    public void run(ApplicationArguments args) throws Exception {
        messageService.sendMsg();
    }
}

4、配置文件application.yml

java 复制代码 
server:
  port: 8080

spring:
  application:
    name: fanout-learn

  rabbitmq:
    host: 你的RabbitMQ服务器主机IP #rabbitmq的主机
    port: 5672
    username: 登录账号
    password: 登录密码
    virtual-host: power #虚拟主机

5、项目配置文件pom.xml

java 复制代码 
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.power</groupId>
    <artifactId>rabbit_01_fanout</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.13</version>
        <relativePath/>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
2.1.2.2、消费者

1、消费者

java 复制代码 
package com.power.message;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@Slf4j
public class ReceiveMessage {
    //接收两个队列的消息
    @RabbitListener(queues = {"queue.fanout.a","queue.fanout.b"})
    public void receiveMsg(Message message){
        byte[] body = message.getBody();
        String msg = new String(body);
        log.info("接收到的消息为："+msg);

    }
}

2、配置文件application.yml

java 复制代码 
server:
  port: 9090

spring:
  application:
    name: receive-msg

  rabbitmq:
    host: 你的RabbitMQ服务器主机IP #rabbitmq的主机
    port: 5672
    username: 登录账号
    password: 登录密码
    virtual-host: power #虚拟主机

3、配置文件pom.xml

java 复制代码 
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.power</groupId>
    <artifactId>rabbit_01_receiveMessage</artifactId>
    <version>1.0-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.13</version>
        <relativePath/>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

4、启动类

java 复制代码 
package com.power;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ReceiveFanoutMsgApplication {
    public static void main(String[] args) {
        SpringApplication.run(ReceiveFanoutMsgApplication.class,args);
    }
}
2.1.2.3、测试

先启动生产者：

再启动消费者：

消费者启动会会一直监听

2.2、Direct Exchange（直连）

2.2.1、介绍

根据路由键精确匹配（一模一样）进行路由消息队列；

2.2.2、示例

2.2.2.1、生产者

1、配置类

java 复制代码 
package com.power.config;

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

@Configuration
//@ConfigurationProperties(prefix = "my")
public class RabbitConfig {
    //交换机的名字
    @Value("${my.exchangeName}")
    private String exchangeName;
    //队列A的名字
    @Value("${my.queueAName}")
    private String queueAName;
    //队列B的名字
    @Value("${my.queueBName}")
    private String queueBName;

    //1、定义交换机
    @Bean
    public DirectExchange directExchange() {
        //使用建造者模式创建
        return ExchangeBuilder.directExchange(exchangeName).build();
    }

    //2、定义队列
    @Bean
    public Queue queueA() {
        return QueueBuilder.durable(queueAName).build();
    }

    @Bean
    public Queue queueB() {
        return QueueBuilder.durable(queueBName).build();
    }

    //3、交换机和队列A进行绑定
    @Bean
    public Binding bindingA(DirectExchange directExchange, Queue queueA) {
        return BindingBuilder.bind(queueA).to(directExchange).with("error");
    }

    //交换机和队列B进行绑定
    @Bean
    public Binding bindingB1(DirectExchange directExchange, Queue queueB) {
        return BindingBuilder.bind(queueB).to(directExchange).with("error");
    }

    @Bean
    public Binding bindingB2(DirectExchange directExchange, Queue queueB) {
        return BindingBuilder.bind(queueB).to(directExchange).with("info");
    }

    @Bean
    public Binding bindingB3(DirectExchange directExchange, Queue queueB) {
        return BindingBuilder.bind(queueB).to(directExchange).with("warning");
    }

}

2、发送消息

java 复制代码 
package com.power.service;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.Date;

@Service
@Slf4j
public class MessageService {

    @Resource
    private RabbitTemplate rabbitTemplate;

    @Bean
    public void sendMsg() {
        //使用建造者模式创建消息
        Message message = MessageBuilder.withBody("hello world".getBytes()).build();
        //参数1:交换机   参数2:路由key    参数3:消息
        rabbitTemplate.convertAndSend("exchange.direct", "info", message);
        log.info("消息发送完毕，发送时间："+new Date());
    }
}

3、配置文件application.yml

java 复制代码 
server:
  port: 8080

spring:
  application:
    name: receive-msg

  rabbitmq:
    host: <你的RqaabitMQ服务器IP> #rabbitmq的主机
    port: 5672
    username: 登录名
    password: 登录密码
    virtual-host: power #虚拟主机

my:
  exchangeName: exchange.direct
  queueAName: queue.direct.a
  queueBName: queue.direct.b

4、启动类

java 复制代码 
package com.power;

import com.power.service.MessageService;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import javax.annotation.Resource;

@SpringBootApplication
public class DirectApplication implements ApplicationRunner {
    @Resource
    private MessageService messageService;

    public static void main(String[] args) {
        SpringApplication.run(DirectApplication.class, args);
    }

    @Override
    public void run(ApplicationArguments args) throws Exception {
        messageService.sendMsg();
    }
}

5、配置文件pom.xml

java 复制代码 
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.power</groupId>
    <artifactId>rabbit_02_direct</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.13</version>
        <relativePath/>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>
2.2.2.2、测试

运行启动类。

登录服务器查看Exchange：

登录服务器查Queues：

2.3、Topic Exchange（主题交换机）

2.3.1 介绍

java 复制代码 
通配符匹配，相当于模糊匹配；
# 匹配多个单词，用来表示任意数量（零个或多个）单词
* 匹配一个单词（必须有一个，而且只有一个），用.隔开的为一个单词：
beijing.# == beijing.queue.abc, beijing.queue.xyz.xxx
beijing.* == beijing.queue, beijing.xyz


案例 ：发送时指定的路由键：lazy.orange.rabbit，可以进入上图的那个队列
答：可以进入Q1和Q2队列，其中Q2队列只能进入一条消息

2.3.2 示例

2.3.2.1 配置文件appication.yml
java 复制代码 
server:
  port: 8080
spring:
  application:
    name: topic-exchange

  rabbitmq:
    host: 你的主机IP
    port: 5672
    username: 你的管理员账号
    password: 你的管理员密码
    virtual-host: power

my:
  exchangeName: exchange.topic
  queueAName: queue.topic.a
  queueBName: queue.topic.b
2.3.2.2 配置类RabbitConfig
java 复制代码 
package com.power.config;

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

@Configuration
public class RabbitConfig {
    //交换机的名字
    @Value("${my.exchangeName}")
    private String exchangeName;
    //队列A的名字
    @Value("${my.queueAName}")
    private String queueAName;
    //队列B的名字
    @Value("${my.queueBName}")
    private String queueBName;

    //创建交换机
    @Bean
    public TopicExchange topicExchange(){
        return ExchangeBuilder.topicExchange(exchangeName).build();
    }

    //创建队列
    @Bean
    public Queue queueA(){
        return QueueBuilder.durable(queueAName).build();
    }
    @Bean
    public Queue queueB(){
        return QueueBuilder.durable(queueBName).build();
    }

    //创建绑定
    @Bean
    public Binding bindingA(TopicExchange topicExchange,Queue queueA){
        return BindingBuilder.bind(queueA).to(topicExchange).with("*.orange.*");
    }
    @Bean
    public Binding bindingB1(TopicExchange topicExchange,Queue queueB){
        return BindingBuilder.bind(queueB).to(topicExchange).with("*.*.rabbit");
    }
    @Bean
    public Binding bindingB2(TopicExchange topicExchange,Queue queueB){
        return BindingBuilder.bind(queueB).to(topicExchange).with("lazy.#");
    }
}
2.3.2.3 发送消息MessageService
java 复制代码 
package com.power.service;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class MessageService {

    @Resource
    private AmqpTemplate amqpTemplate;

    public void sendMsg(){
        Message message = MessageBuilder.withBody("hello world".getBytes()).build();
        //参数1：交换机，参数2：发送路由key，参数3：消息
        amqpTemplate.convertAndSend("exchange.topic","hello.world",message);
    }
}
2.3.2.4 启动类Application
java 复制代码 
package com.power;

import com.power.service.MessageService;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import javax.annotation.Resource;

@SpringBootApplication
public class Application implements ApplicationRunner {

    @Resource
    private MessageService messageService;

    public static void main(String[] args) {
        SpringApplication.run(Application.class);
    }

    @Override
    public void run(ApplicationArguments args) throws Exception {
        messageService.sendMsg();
    }
}
2.3.2.5 pom.xml配置文件
java 复制代码 
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.power</groupId>
    <artifactId>rabbit_03_topic</artifactId>
    <version>1.0-SNAPSHOT</version>

    <name>rabbit_03_topic</name>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.13</version>
        <relativePath/>
    </parent>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>
2.3.2.6 测试

2.4、Headers Exchange（头部交换机）

2.4.1、介绍

基于消息内容中的headers属性进行匹配；

2.4.2、示例

2.4.2.1 配置文件appication.yml
java 复制代码 
server:
  port: 8080
spring:
  application:
    name: topic-exchange

  rabbitmq:
    host: 你的服务器IP
    port: 5672
    username: 你的账号
    password: 你的密码
    virtual-host: power

my:
  exchangeName: exchange.headers
  queueAName: queue.headers.a
  queueBName: queue.headers.b
2.4.2.2 配置类RabbitConfig
java 复制代码 
package com.power.config;

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

import java.util.HashMap;
import java.util.Map;

@Configuration
public class RabbitConfig {
    //交换机的名字
    @Value("${my.exchangeName}")
    private String exchangeName;
    //队列A的名字
    @Value("${my.queueAName}")
    private String queueAName;
    //队列B的名字
    @Value("${my.queueBName}")
    private String queueBName;

    //创建交换机
    @Bean
    public HeadersExchange headersExchange(){
        return ExchangeBuilder.headersExchange(exchangeName).build();
    }

    //创建队列
    @Bean
    public Queue queueA(){
        return QueueBuilder.durable(queueAName).build();
    }
    @Bean
    public Queue queueB(){
        return QueueBuilder.durable(queueBName).build();
    }

    //创建绑定
    @Bean
    public Binding bindingA(HeadersExchange headersExchange,Queue queueA){
        Map<String, Object> headerValues = new HashMap<>();
        headerValues.put("type","m");
        headerValues.put("status",1);
        return BindingBuilder.bind(queueA).to(headersExchange).whereAll(headerValues).match();
    }

    @Bean
    public Binding bindingB(HeadersExchange headersExchange,Queue queueB){
        Map<String, Object> headerValues = new HashMap<>();
        headerValues.put("type","s");
        headerValues.put("status",0);
        return BindingBuilder.bind(queueB).to(headersExchange).whereAll(headerValues).match();
    }
}
2.4.2.3 发送消息MessageService
java 复制代码 
package com.power.service;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;

@Service
@Slf4j
public class MessageService {

    @Resource
    private RabbitTemplate rabbitTemplate;
    @Value("${my.exchangeName}")
    private String exchangeName;

    public void sendMsg(){
        MessageProperties messageProperties = new MessageProperties();
        Map<String,Object> headers = new HashMap<>();
        headers.put("type","s");
        headers.put("status",0);
        //设置消息头
        messageProperties.setHeaders(headers);
        Message message = MessageBuilder.withBody("hello world".getBytes())
                .andProperties(messageProperties).build();
        rabbitTemplate.convertAndSend(exchangeName,"",message);
        log.info("消息发送完毕");
    }

}
2.4.2.4 启动类Application
java 复制代码 
package com.power;

import com.power.service.MessageService;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import javax.annotation.Resource;

@SpringBootApplication
public class HeadersExchangeApplication implements ApplicationRunner {

    @Resource
    private MessageService messageService;


    public static void main(String[] args) {
        SpringApplication.run(HeadersExchangeApplication.class,args);
    }

    @Override
    public void run(ApplicationArguments args) throws Exception {
        messageService.sendMsg();
    }
}
2.4.2.5 pom.xml配置文件
java 复制代码 
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.power</groupId>
  <artifactId>rabbit_04_headers</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>rabbit_04_headers</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.6.13</version>
    <relativePath/>
  </parent>

  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.24</version>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>

</project>
2.4.2.6 测试
相关推荐
_oP_i1 小时前
Pinpoint 是一个开源的分布式追踪系统
java·分布式·开源
攻心的子乐3 小时前
Kafka可视化工具 Offset Explorer (以前叫Kafka Tool)
分布式·kafka
小林想被监督学习4 小时前
RabbitMQ 的7种工作模式
分布式·rabbitmq
初晴~5 小时前
【Redis分布式锁】高并发场景下秒杀业务的实现思路（集群模式）
java·数据库·redis·分布式·后端·spring·锁
有一个好名字5 小时前
zookeeper分布式锁模拟12306买票
分布式·zookeeper·云原生
yukai080089 小时前
【最后203篇系列】002 - 两个小坑(容器时间错误和kafka模块报错
分布式·kafka
老猿讲编程10 小时前
OMG DDS 规范漫谈：分布式数据交互的演进之路
分布式·dds
C++忠实粉丝10 小时前
服务端高并发分布式结构演进之路
分布式
洛神灬殇11 小时前
彻底认识和理解探索分布式网络编程中的SSL安全通信机制
网络·分布式·ssl
wy02_11 小时前
Linux下载RabbitMQ，并解决Github拒绝访问443的问题
linux·rabbitmq·github
热门推荐
0119个Web前端交互式3D JavaScript框架和库02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04RAG 实践- Ollama+RagFlow 部署本地知识库05【一文读懂】NTN（非地面网络）技术介绍06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07ZZ038 物联网应用与服务赛题第J套08组基轨迹建模 GBTM的介绍与实现（Stata 或 R）09Docker 夺命连环 15 问10VSCode插件 —— Cody AI （免费AI助手！）