SpringBoot整合RabbitMQ

最新推荐文章于 2024-11-01 13:14:04 发布
最新推荐文章于 2024-11-01 13:14:04 发布
阅读量534 收藏
点赞数
分类专栏： spring boot rabbitmq 文章标签： spring boot rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30614345/article/details/132461364
版权

SpringBoot整合RabbitMQ

1、RabbitMQ核心概念

在这里插入图片描述

Broker：接收和分发消息的应用，RabbitMQ Server就是Message Broker。可以看做RabbitMQ的服务节

点，一般请下一个Broker可以看做一个RabbitMQ服务器，简单来说就是消息队列服务器实体。

Virtual host：出于多租户和安全因素设计的，把AMQP的基本组件划分到一个虚拟的分组中，类似于网络中

的namespace概念。当多个不同的用户使用同一个RabbitMQ server提供的服务时，可以划分出多个vhost，

每个用户在自己的vhost创建exchange/queue等。vhost可以作为不同权限隔离的手段(一个典型的例子就是

不同的应用可以跑在不同的vhost中)。

Connection：publisher/consumer和broker之间的TCP连接。

Channel：如果每一次访问RabbitMQ都建立一个Connection，在消息量大的时候建立TCP Connection的开

销将是巨大的，效率也较低。Channel是在connection内部建立的逻辑连接，如果应用程序支持多线程，通

常每个thread创建单独的channel进行通讯，AMQP method包含了channel id帮助客户端和message

broker识别channel，所以channel之间是完全隔离的。Channel作为轻量级的Connection极大减少了操作系

统建立TCP connection的开销。channel消息通道，在客户端的每个连接里，可建立多个channel，每个

channel代表一个会话任务由Exchange、Queue、RoutingKey三个才能决定一个从Exchange到Queue的唯

一的线路。

Exchange：message到达broker的第一站，根据分发规则，匹配查询表中的routing key，分发消息到

queue中去。常用的类型有：headers、direct (point-to-point)，topic (publish-subscribe) and fanout

(multicast)。Exchange生产者将消息发送到交换器，由交换器将消息路由到一个或者多个队列中。当路由不

到时，或返回给生产者或直接丢弃。简言之消息交换机，它指定消息按什么规则，路由到哪个队列。用来接

收生产者发送的消息并将这些消息路由给服务器中的队列。

Queue：消息队列，用来保存消息直到发送给消费者。它是消息的容器，也是消息的终点。一个消息可投入

一个或多个队列。消息一直在队列里面，等待消费者连接到这个队列将其取走。消息最终被送到这里等待

consumer取走。

Binding：exchange和queue之间的虚拟连接，binding中可以包含routing key。Binding信息被保存到

exchange中的查询表中，用于message的分发依据。简言之Binding它的作用就是把exchange和queue按照

路由规则绑定起来。

Routing Key：生产者将消息发送给交换器的时候，会指定一个RoutingKey，用来指定这个消息的路由规

则，这个RoutingKey需要与交换器类型和绑定键(BindingKey)联合使用才能最终生效。路由关键字，

exchange根据这个关键字进行消息投递。

Publisher：消息的生产者，也是一个向交换器发布消息的客户端应用程序。

Consumer：消息的消费者，表示一个从消息队列中取得消息的客户端应用程序。

Message：消息，消息是不具名的，它由消息头和消息体组成。消息体是不透明的，而消息头则由一系列的

可选属性组成，这些属性包括 routing-key(路由键)、priority(相对于其他消息的优先权)、delivery-mode(指

出该消息可能需要持久性存储)等。

2、整合

RabbitMQ版本 3.8.16，SpringBoot版本 2.5.4。

pom文件

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.4</version>
        <relativePath/>
    </parent>
    <groupId>com.example</groupId>
    <artifactId>rabbitmq-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>rabbitmq-demo</name>
    <description>rabbitmq-demo</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <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.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.7</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>

    </dependencies>

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

</project>

注：这里可以不指定AMQP版本，SpringBoot会自动导入与该SpringBoot版本相搭配的AMQP的版本。

配置文件

# RabbitMQ基本配置
# RabbitMQ的主机地址(默认为:localhost)
spring.rabbitmq.host=localhost
# 指定该用户要连接到的虚拟host端(注:如果不指定,那么默认虚拟host为"/")
spring.rabbitmq.virtual-host = /
# amqp协议端口号:5672; 集群端口号:25672;http端口号:15672;
spring.rabbitmq.port=5672
# 登录到RabbitMQ的用户名、密码
spring.rabbitmq.username=zsx242030
spring.rabbitmq.password=zsx242030
# RabbitMQ可选配置(注:这里只用到了特别少的几个)
# broker端没有收到消费者的ACK(即:消费者异常时)时,是否再次向消费者投递消息(默认为false)
# 为false时，如果没有收到消费者的ACK，那么会无限投递;设置为true时,默认投递时次数为3此
spring.rabbitmq.listener.simple.retry.enabled=true
# 设置向消费者投递消息的最大次数
spring.rabbitmq.listener.simple.retry.max-attempts=2
# 投递消息的间隔(单位ms)
spring.rabbitmq.listener.simple.retry.initial-interval=2000ms

用户实体类

package com.example.model;

/**
 * 用户实体类模型
 */
public class User {

	/** 姓名 */
	private String name;

	/** 年龄 */
	private Integer age;

	/** 性别 */
	private String gender;

	/** 座右铭 */
	private String motto;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	public String getGender() {
		return gender;
	}

	public void setGender(String gender) {
		this.gender = gender;
	}

	public String getMotto() {
		return motto;
	}

	public void setMotto(String motto) {
		this.motto = motto;
	}

	@Override
	public String toString() {

		return age + "岁" + gender + "人[" + name + "]的座右铭居然是: " + motto + "!!!";
	}

}

Consumer -> QueueConfiguration配置类 -> 定义队列

这个是公共的队列，每个类型的交换机都会用到这些队列。

package com.example.config;

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

/**
 * Queue队列注入
 */
@Configuration
public class QueueConfiguration {

	/**
	 * 注入第一个Queue队列 实例
	 */
	@Bean(name = "myFirstQueue")
	public Queue getFirstQueue() {
		// 设置队列名为My-First-Queue
		return new Queue("My-First-Queue");
	}

	/**
	 * 注入第二个Queue队列 实例
	 */
	@Bean(name = "myTwoQueue")
	public Queue getTwoQueue() {
		// 设置队列名为My-Two-Queue
		return new Queue("My-Two-Queue");
	}

	/**
	 * 注入第三个Queue队列 实例
	 */
	@Bean(name = "myThreeQueue")
	public Queue getThreeQueue() {
		// 设置队列名为My-Three-Queue
		return new Queue("My-Three-Queue");
	}
	
	/**
	 * 关于MQ传递消息时,实际上用的HttpClient的什么请求方式的测试
	 */
	@Bean(name = "myRequestTestQueue")
	public Queue getRequestTestQueue() {
		// 设置队列名为My-Request-Test-Queue
		return new Queue("My-Request-Test-Queue");
	}
}

Consumer -> DemoMessageListener监听类

这个是公共的监听器，每个类型的交换机都会用到这些监听器。

package com.example.listen;

import com.example.model.User;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSON;

/**
 * 注入消息监听器
 */
@Component
public class DemoMessageListener {

	@RabbitListener(queues = "My-First-Queue") // 指定Queue队列
	public void firstConsumer(String string) {

		System.out.println("我是:My-First-Queue" + "\tString:" + string);
	}

	@RabbitListener(queues = "My-Two-Queue") // 指定Queue队列
	public void twoConsumer(Integer num) {

		System.out.println("我是:My-Two-Queue" + "\tInteger:" + num);
	}

	@RabbitListener(queues = "My-Three-Queue") // 指定Queue队列
	public void threeConsumer() {
		System.out.println("我是:My-Three-Queue");

	}
	
	@RabbitListener(queues = "My-Request-Test-Queue") // 指定Queue队列
	public void requestTestConsumer(String userJsonString) {
		System.out.println("我是:My-Request-Test-Queue队列");
		System.out.println("json字符串为:" + userJsonString);
        // 将json字符串 转换为 User对象
		User user=JSON.parseObject(userJsonString, User.class);
		System.out.println(user.toString());
	}
}

启动类

package com.example;

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

@SpringBootApplication
public class RabbitmqDemoApplication {

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

}

3、Fanout策略

Fanout：路由规则是把所有发送到该Exchange的消息路由到所有与她绑定的Queue中。

在这里插入图片描述

备注：生产者P生产消息1推送到Exchange，由于Exchange Type=fanout这时候会遵循fanout的规则将消息推送

到所有与他绑定的Queue。

Consumer -> FanoutExchangeAndBindingConfiguration配置类 -> 定义交换机，绑定队列与交换机

package com.example.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.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * fanout路由策略(广播机制)的交换机注入、Queue与Exchange的绑定注入
 */
@Configuration
public class FanoutExchangeAndBindingConfiguration {

	/**
	 * 注入Fanout路由策略的Exchange交换机实例
	 */
	@Bean(name = "myFanoutExchange")
	FanoutExchange getFanoutExchange() {
		// 创建并返回名为My-Fanout-Exchange的交换机
		return new FanoutExchange("My-Fanout-Exchange");
	}

	/**
	 * 将myFirstQueue对应的队列，绑定到myFanoutExchange对应的交换机
	 */
	@Bean
	Binding bindingQueueOneToFanoutExchange(@Qualifier("myFirstQueue") Queue myFirstQueue,
			@Qualifier("myFanoutExchange") FanoutExchange myFanoutExchange) {
		return BindingBuilder.bind(myFirstQueue).to(myFanoutExchange);
	}

	/**
	 * 将myTwoQueue对应的队列，绑定到myFanoutExchange对应的交换机
	 */
	@Bean
	Binding bindingQueueTwoToFanoutExchange(@Qualifier("myTwoQueue") Queue myTwoQueue,
			@Qualifier("myFanoutExchange") FanoutExchange myFanoutExchange) {
		return BindingBuilder.bind(myTwoQueue).to(myFanoutExchange);
	}

	/**
	 * 将myThreeQueue对应的队列，绑定到myFanoutExchange对应的交换机
	 */
	@Bean
	Binding bindingQueueThreeToFanoutExchange(@Qualifier("myThreeQueue") Queue myThreeQueue,
			@Qualifier("myFanoutExchange") FanoutExchange myFanoutExchange) {
		return BindingBuilder.bind(myThreeQueue).to(myFanoutExchange);
	}
}

Producer -> 单元测试SimulationMessageProducerTest

package com.example;

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

import com.example.model.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.rabbit.core.RabbitMessagingTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import com.alibaba.fastjson.JSON;

/**
 * 模拟消息生产者 向Exchange发送消息 注:在正常使用时，消息生产者 一般都和 消息消费者 不处在同一个项目或服务下;
 * 这里只是测试，所以本人在同一个项目下，使用单元测试，模拟的消息生产者(用法是一样的)
 */

@SpringBootTest(classes = RabbitmqDemoApplication.class)
@RunWith(SpringRunner.class)
public class MessageProducerTest {

	/** 装配AMQP模板 */
	@Autowired
	private AmqpTemplate amqpTemplate;
	
	/** 装配RabbitMessaging模板 */
	@Autowired
	private RabbitMessagingTemplate rabbitMessagingTemplate;
	
	/**
	 * fanout路由策略(即:广播模式) 测试
	 */
	@Test
	public void fanoutExchangeTest() {

		amqpTemplate.convertAndSend("My-Fanout-Exchange", "", "123");
	}
}

我是:My-Three-Queue
我是:My-First-Queue	String:123
我是:My-Two-Queue	Integer:123

convertAndSend(String exchangeName,String routingKey,Object obj)

提示：当不采用direct或topic策略时，没有路由键，那么对应路由键参数位置使用双引号即可。

4、Direct策略

direct：把消息路由到那些 binding key 与 routing key 完全匹配的Queue中。

在这里插入图片描述

备注：生产者P发送消息时Routing key = booking时，这时候将消息传送到Exchange，Exchange获取到生产者发

送过来的消息后，会根据自身的规则进行与匹配响应的Queue，这时候发现Queue1和Queue2都符合，就会将消

息传送给这两个队列，如果我们以Routing key = create和routing key = confirm发送消息时，这时候消息只会被

推送到Queue2队列中，其他的Routing key 的消息会被丢弃。

Consumer -> DirectExchangeAndBindingConfiguration配置类 -> 定义交换机，绑定队列与交换机

package com.example.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.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * direct路由策略(路由键routingKey)的交换机注入、Queue与Exchange的绑定注入
 */
@Configuration
public class DirectExchangeAndBindingConfiguration {

	/**
	 * 注入Direct路由策略的Exchange交换机实例
	 */
	@Bean(name = "myDirectExchange")
	DirectExchange getDirectExchange() {
		// 创建并返回名为My-Direct-Exchange的交换机
		return new DirectExchange("My-Direct-Exchange");
	}

	/**
	 * 将Queue绑定到此directExchange,并指定路由键为"routingKey.First"
	 *
	 * @date 2018年7月19日 上午12:20:09
	 */
	@Bean
	Binding bindingQueueOneToDirectExchange(@Qualifier("myFirstQueue") Queue myFirstQueue,
			@Qualifier("myDirectExchange") DirectExchange myDirectExchange) {
		return BindingBuilder.bind(myFirstQueue).to(myDirectExchange).with("routingKey.First");
	}

	/**
	 * 将Queue绑定到此directExchange,并指定路由键为"requestTest"
	 *
	 * @date 2018年7月19日 上午12:20:09
	 */
	@Bean
	Binding bindingQueueRequestTestToDirectExchange(@Qualifier("myRequestTestQueue") Queue myRequestTestQueue,
			@Qualifier("myDirectExchange") DirectExchange myDirectExchange) {
		return BindingBuilder.bind(myRequestTestQueue).to(myDirectExchange).with("requestTest.aa");
	}
}

Producer -> 单元测试SimulationMessageProducerTest

package com.example;

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

import com.example.model.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.rabbit.core.RabbitMessagingTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import com.alibaba.fastjson.JSON;

/**
 * 模拟消息生产者 向Exchange发送消息 注:在正常使用时，消息生产者 一般都和 消息消费者 不处在同一个项目或服务下;
 * 这里只是测试，所以本人在同一个项目下，使用单元测试，模拟的消息生产者(用法是一样的)
 */

@SpringBootTest(classes = RabbitmqDemoApplication.class)
@RunWith(SpringRunner.class)
public class MessageProducerTest {

	/** 装配AMQP模板 */
	@Autowired
	private AmqpTemplate amqpTemplate;
	
	/** 装配RabbitMessaging模板 */
	@Autowired
	private RabbitMessagingTemplate rabbitMessagingTemplate;

	/**
	 * direct路由策略---测试HttpClient的请求方法
	 */
	@Test
	public void directExchangeRequestTest() {
		User user = new User();
		user.setAge(18);
		user.setGender("女");
		user.setMotto("不感兴趣！");
		user.setName("喵喵");
		String jsonString = JSON.toJSONString(user);
		amqpTemplate.convertAndSend("My-Direct-Exchange", "requestTest.aa",jsonString);
	}

	/**
	 * direct路由策略(具体的路由键)测试
	 */
	@Test
	public void directExchangeTest() {
		amqpTemplate.convertAndSend("My-Direct-Exchange", "routingKey.First", "1234578");
	}
}

单元测试directExchangeRequestTest()的运行结果为：

我是:My-Request-Test-Queue队列
json字符串为:{"age":18,"gender":"女","motto":"不感兴趣！","name":"喵喵"}
18岁女人[喵喵]的座右铭居然是: 不感兴趣！!!!

单元测试directExchangeTest()的运行结果为：

我是:My-First-Queue	String:1234578

5、Topic策略

topic：模糊匹配，通过通配符满足一部分规则就可以传送，其中注意的是有两个字符 * 和#号，其中*用于匹

配一个单词，#号用于匹配多个单词（可以是0个）。

在这里插入图片描述

备注：当生产者发送消息Routing Key=F.C.E的时候，这时候只满足Queue1，所以会被路由到Queue中，如果

Routing Key=A.C.E这时候会被同是路由到Queue1和Queue2中，如果Routing Key=A.F.B时，这里只会发送一条

消息到Queue2中。

Consumer -> TopicExchangeAndBindingConfiguration配置类 -> 定义交换机，绑定队列与交换机

package com.example.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.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * topic路由策略(路由键routingKey,且支持模糊匹配)的交换机注入、Queue与Exchange的绑定注入
 */
@Configuration
public class TopicExchangeAndBindingConfiguration {

	/**
	 * 注入Topic路由策略的Exchange交换机实例
	 */
	@Bean(name = "myTopicExchange")
	TopicExchange getTopicExchange() {
		// 创建并返回名为My-Topic-Exchange的交换机
		return new TopicExchange("My-Topic-Exchange");
	}
	
	
	/**
	 * 将myFirstQueue对应的Queue绑定到此topicExchange,并指定路由键为"routingKey.#"
	 * 即:此Exchange中,路由键以"routingKey."开头的Queue将被匹配到
	 */
	@Bean
	Binding bindingQueueOneToTopicExchange(@Qualifier("myFirstQueue") Queue myFirstQueue,
			@Qualifier("myTopicExchange") TopicExchange myTopicExchange) {
		return BindingBuilder.bind(myFirstQueue).to(myTopicExchange).with("routingKey.#");
	}
	
	/**
	 * 将myTwoQueue对应的Queue绑定到此topicExchange,并指定路由键为"#.topic"
	 * 即:此Exchange中,路由键以".topic"结尾的Queue将被匹配到
	 */
	@Bean
	Binding bindingQueueTwoToTopicExchange(@Qualifier("myTwoQueue") Queue myTwoQueue,
			@Qualifier("myTopicExchange") TopicExchange myTopicExchange) {
		return BindingBuilder.bind(myTwoQueue).to(myTopicExchange).with("#.topic");
	}
	
	/**
	 * 将myThreeQueue对应的Queue绑定到此topicExchange,并指定路由键为"#"
	 * 即:此topicExchange中,任何Queue都将被匹配到
	 */
	@Bean
	Binding bindingQueueThreeToTopicExchange(@Qualifier("myThreeQueue") Queue myThreeQueue,
			@Qualifier("myTopicExchange") TopicExchange myTopicExchange) {
		return BindingBuilder.bind(myThreeQueue).to(myTopicExchange).with("#");
	}
}

Producer -> 单元测试SimulationMessageProducerTest

package com.example;

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

import com.example.model.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.rabbit.core.RabbitMessagingTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import com.alibaba.fastjson.JSON;

/**
 * 模拟消息生产者 向Exchange发送消息 注:在正常使用时，消息生产者 一般都和 消息消费者 不处在同一个项目或服务下;
 * 这里只是测试，所以本人在同一个项目下，使用单元测试，模拟的消息生产者(用法是一样的)
 */

@SpringBootTest(classes = RabbitmqDemoApplication.class)
@RunWith(SpringRunner.class)
public class MessageProducerTest {

	/** 装配AMQP模板 */
	@Autowired
	private AmqpTemplate amqpTemplate;
	
	/** 装配RabbitMessaging模板 */
	@Autowired
	private RabbitMessagingTemplate rabbitMessagingTemplate;

	/**
	 * topic路由策略(可以通配的路由键)测试
	 */
	@Test
	public void topicExchangeTest1() {
		// 此消息能匹配上 路由键为“routingKey.#”和“#”的队列
		amqpTemplate.convertAndSend("My-Topic-Exchange", "routingKey.myTest", "1");
	}

	@Test
	public void topicExchangeTest2() {
		// 此消息能匹配上 路由键为“#.topic”和“#”的队列
		amqpTemplate.convertAndSend("My-Topic-Exchange", "myTest.topic", "2");
	}

	@Test
	public void topicExchangeTest3() {
		// 此消息能匹配上 路由键为“#”的队列
		amqpTemplate.convertAndSend("My-Topic-Exchange", "myTest", "3");
	}

}

单元测试topicExchangeTest1()的运行结果为：

我是:My-Three-Queue
我是:My-First-Queue	String:1

单元测试topicExchangeTest2()的运行结果为：

我是:My-Three-Queue
我是:My-Two-Queue	Integer:2

单元测试topicExchangeTest3()的运行结果为：

我是:My-Three-Queue

提示：如果输出结果与理想结果不一样;那么最好去MQ里,把原来与Queue绑定的Exchange删除，重新绑定Queue

队列到TopicExchange交换机并放入vhost里(原因分析：该交换机原来绑定的可能是没有通配路由键的Queue，改

成了路由键通配后，需要先删除vhost中原来的该交换机，再重新把绑定了通配路由键队列后的交换机放入vhost

里面)。

即：一旦将绑定了Queue的Exchange放入vhost后，那么该交换机对于其绑定了的Queue的“认知”就固定了；如果

想改变该交换机的认知，那么必须先删除该交换机，然后在放入有新“认知”的交换机。

追注：其他几种策略也一样，修改Queue与Exchange的绑定信息后，也最好去vhost中删除该交换机，再重新放

入新的交换机。

6、Headers策略

headers：单薄模式，1对1。

headers 匹配规则：any、all。

any： 只要在发布消息时携带的有一对键值对headers满足队列定义的多个参数的其中一个就能匹配上，注意这

里是键值对的完全匹配，只匹配到键了，值却不一样是不行的；

all：在发布消息时携带的所有Entry必须和绑定在队列上的所有Entry完全匹配。

缺点：Headers类型的交换器性能会很差。

在这里插入图片描述

Consumer -> HeadersExchangeAndBindingConfiguration配置类 -> 定义交换机，绑定队列与交换机

package com.example.config;

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

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.HeadersExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * headers路由策略的交换机注入、Queue与Exchange的绑定注入
 */
@Configuration
public class HeadersExchangeAndBindingConfiguration {

	/**
	 * 注入Headers路由策略的Exchange交换机实例
	 */
	@Bean(name = "myHeadersExchange")
	HeadersExchange getDirectExchange() {
		// 创建并返回名为My-Headers-Exchange的交换机
		return new HeadersExchange("My-Headers-Exchange");
	}

	/**
	 * 将Queue绑定到此headersExchange(并指定:当headers中所有的“map”被此Queue匹配时,才可使用此队列)
	 * 注:此示例是匹配的.whereAll(Map<String,Object> map);
	 *    也可以只匹配.whereAll(String... headersKeys);
	 */
	@Bean
	Binding bindingQueueOneToHeadersAllExchange(@Qualifier("myFirstQueue") Queue myFirstQueue,
			@Qualifier("myHeadersExchange") HeadersExchange myHeadersExchange) {
		Map<String, Object> headers = new HashMap<>();
		headers.put("name", "邓沙利文");
		headers.put("motto", "justry");
		return BindingBuilder.bind(myFirstQueue).to(myHeadersExchange).whereAll(headers).match();
	}
	
	/**
	 * 将Queue绑定到此headersExchange(并指定:当headers中任意一个map被此Queue匹配时,就会使用此队列)
	 * 注:此示例是匹配的.whereAny(Map<String,Object> map);
	 *    也可以只匹配.whereAny(String... headersKeys);
	 */
	@Bean
	Binding bindingQueueOneToHeadersAnyExchange(@Qualifier("myThreeQueue") Queue myThreeQueue,
			@Qualifier("myHeadersExchange") HeadersExchange myHeadersExchange) {
		Map<String, Object> headers = new HashMap<>();
		headers.put("name", "邓沙利文");
		headers.put("motto", "justry");
		return BindingBuilder.bind(myThreeQueue).to(myHeadersExchange).whereAny(headers).match();
	}

}

注：headers中，可以存放很多用来验证身份的键值对，我们可以用All来指定：当消息生产者传到Exchange中的

headers中的键值对所有都符合(所有Map或所有Key)要求时，才启用该队列；或使用Any来指定：只要消息生产者

传到Exchange中的headers中的键值对有至少一个(至少一个Map或至少一个Key)符合要求时，就启用该队列。

Producer -> 单元测试SimulationMessageProducerTest

package com.example;

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

import com.example.model.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.rabbit.core.RabbitMessagingTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import com.alibaba.fastjson.JSON;

/**
 * 模拟消息生产者 向Exchange发送消息 注:在正常使用时，消息生产者 一般都和 消息消费者 不处在同一个项目或服务下;
 * 这里只是测试，所以本人在同一个项目下，使用单元测试，模拟的消息生产者(用法是一样的)
 */

@SpringBootTest(classes = RabbitmqDemoApplication.class)
@RunWith(SpringRunner.class)
public class MessageProducerTest {

	/** 装配AMQP模板 */
	@Autowired
	private AmqpTemplate amqpTemplate;
	
	/** 装配RabbitMessaging模板 */
	@Autowired
	private RabbitMessagingTemplate rabbitMessagingTemplate;

	/**
	 * headers路由策略---WhereAllMap匹配测试
	 */
	@Test
	public void headersExchangeWhereAllMapTest() {
		Map<String, Object> headers = new HashMap<String, Object>();
		headers.put("name", "邓沙利文");
		headers.put("motto", "justry");
		rabbitMessagingTemplate.convertAndSend("My-Headers-Exchange", "", "通过[头交换机]传递数据咯", headers);
	}

	/**
	 * headers路由策略测试WhereAnyMap匹配测试
	 */
	@Test
	public void headersExchangeWhereAnyMapTest() {
		Map<String, Object> headers = new HashMap<String, Object>();
		headers.put("name", "邓沙利文");
		headers.put("motto", "justry123");
		rabbitMessagingTemplate.convertAndSend("My-Headers-Exchange", "", "", headers);
	}

}

单元测试headersExchangeWhereAllMapTest()的运行结果为：

我是:My-Three-Queue
我是:My-First-Queue	String:通过[头交换机]传递数据咯

单元测试headersExchangeWhereAnyMapTest()的运行结果为：

2021-11-07 18:44:32.556  INFO 13428 --- [           main] com.example.MessageProducerTest          : Started MessageProducerTest in 2.422 seconds (JVM running for 3.182)
我是:My-Three-Queue

提示：本文只是对SpringBoot使用MQ的一个示例介绍；在实际运用时，方式方法注意事项等较多。

如果想传递对象，那么可以：消息生产者将对象转换为json字符串放入MQ，然后消息消费者接受json字符串后，

转换为Java对象即可。

242030
关注
专栏目录
Springboot 整合RabbitMq ，用心看完这一篇就够了
默默不代表沉默
09-04 49万+
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建............
SpringBoot整合RabbitMQ.zip
06-29
SpringBoot整合RabbitMQ的详细过程 **1.该篇博文首先讲述了交换机和队列之间的绑定关系** ①direct、②fanout、③topic **2.然后讲消息的回调** 四种情况下，确认触发哪个回调函数： ①消息推送到server，但是在...
多个springboot整合使用rabbitmq(使用注解的方式)
qq_36138652的博客
08-18 1016
先参考。
SpringBoot整合Rabbitmq
YUZHONg_s的博客
05-26 991
消息队列这个词可能在JS中听到过，消息队列主要是将不需要同步除了的并且耗时长的操作由消息队列通知消息接收方进行异常处理。消息队列还可以将应用程序解耦市面上常见的消息队列有:ActiveMQ,RabbitMQ,ZeroMQ,Kafka。
Spring Boot 配置多个RabbitMQ
LieBrother
01-19 1万+
Spring Boot 中配置多个 RabbitMQ
springboot应用中rabbitmq consume多个集群或者vhost的信息
xiaotongzone的专栏
02-26 5394
  今天项目遇到一个问题，同一个应用中，需要消费不同的vhost中不同queue的消息，目前只实现了multi consumer，如果还需要向不同的集群或vhost发消息，那么应该需要配置不同的RabbitAdmin，不知道有没有坑。 rabbit的大概配置如下: 1. 起初项目只需要监听一个vhost中的queue，所以使用spring-boot-autoconfigure中的默认配置，直接...
SpringBoot 整合RabbitMQ项目安装搭建
不想成为大佬的菜鸟不是好菜鸟的博客
10-26 898
RabbitMQ安装、下载、springboot搭建整合，实现生产、消费
SpringBoot整合RabbitMQ实现消息延迟队列(含源码)
热门推荐
Venus's Blog
07-04 9万+
*** 商户订单号/*** 支付宝订单号//为true,则交换机处理消息到路由失败，则会返回给生产者 配置文件指定，则这里不需指定 rabbitTemplate . setMandatory(true);//开启强制消息投递（mandatory为设置为true），但消息未被路由至任何一个queue，则回退一条消息 rabbitTemplate . setReturnsCallback(returned -> {});
springBoot整合RabbitMQ案例
04-07
SpringBoot整合RabbitMQ是一个常见的后端开发任务，它涉及到分布式消息传递和Java应用程序的集成。RabbitMQ是一个开源的消息代理和队列服务器，而SpringBoot是基于Spring框架的简化版，提供了快速构建应用程序的方式...
springboot整合rabbitmq，开启手工确认。保证消息100%投递
09-16
在Spring Boot应用中整合RabbitMQ，以确保消息100%投递，是一个关键的实践，特别是对于那些需要高可靠性和数据一致性的系统。RabbitMQ是一个流行的开源消息代理，它遵循Advanced Message Queuing Protocol (AMQP)...
Springboot整合RabbitMQ最简单demo
07-11
Springboot整合RabbitMQ最简单demo,适用于springcloud项目,作为消息总线适用,需要安装RabbitMQ,Mac linux可以使用命令行一键安装,在项目配置文件配置好端口即可(已默认配置),启动项目访问8080端口,参数见controller.
springBoot整合rabbitMQ,包括erlang20.3,rabbitmq-server-3.7.14安装包
07-02
springBoot整合rabbitMQ,包括erlang20.3,rabbitmq-server-3.7.14安装包 整合4种常用模式+高级特性死信队列 暂未整合TTL队列 博客地址:...
Spring Boot中发送邮件步骤
qq_33718794的博客
11-01 469
1、添加Starter模块依赖2、添加Spring Boot配置(QQ/网易系/Gmail)3、调用JavaMailSender接口发送邮件开始编码创建springboot项目，添加依赖项目结构项目结构1、添加依赖在 Maven pom.xml 配置文件中加入 spring-boot-starter-mail 依赖。2、添加配置参数然后在 application.yml 文件中加入以下配置。application.yml 配置。
基于Spring Boot的网络考试系统设计与实现(源码+定制+开发）网络考试管理平台、智能考试评估系统、题库管理系统设计、Spring Boot考试平台开发
最新发布
程序员阿龙的博客
11-01 463
博主介绍： ✌我是阿龙，一名专注于Java技术领域的程序员，全网拥有10W+粉丝。作为CSDN特邀作者、博客专家、新星计划导师，我在计算机毕业设计开发方面积累了丰富的经验。同时，我也是掘金、华为云、阿里云、InfoQ等平台的优质作者。通过长期分享和实战指导，我致力于帮助更多学生完成毕业项目和技术提升。 技术范围： 我熟悉的技术领域涵盖SpringBoot、Vue、SSM、HLMT、Jsp、PHP、Nodejs、Python、爬虫、数据可视化、小程序、安卓app、大数据、物联网、机器学习等方
Spring Boot网上摄影工作室：开发与部署
2402_85758349的博客
10-28 566
在整个系统测试中，根据需求文档和设计文档，逐一对功能进行检测并写好测试用例，有效避免残片缺陷，因为产品出现缺陷不仅影响功能，而且可以导致数据的不准确，导致产品质量的降低，经过测试，才能使得产品的稳定性和成熟度得到极大的提升，产品质量也才有保证。不出现字体变形等情况！
Spring Boot的懒加载
Aliano217的博客
11-01 265
在Spring框架中，默认情况下，所有的Bean都是在容器启动时被实例化并初始化的。然而，对于一些大型应用程序，如果有很多Bean，并且其中一些Bean的初始化需要大量的时间和资源，那么整个应用程序的启动时间可能会很长。为了解决这个问题，Spring引入了懒加载的功能。懒加载机制通过将Bean的初始化延迟到第一次使用时，可以减少应用程序启动时的开销。这样不仅可以提高应用程序的启动速度，而且只有在需要时才会实例化和初始化Bean，从而更有效地利用系统资源。
网上摄影工作室：Spring Boot框架的应用实例
2401_85760095的博客
10-28 442
目前，界面设计已经成为对软件质量进行评价的一条关键指标，一个好的用户界面可以使用户使用系统的信心和兴趣增加，从而使工作效率提高，JSP技术是将JAVA语言作为脚本语言的，JSP网页给整个服务器端的JAVA库单元提供了一个接口用来服务HTTP的应用程序。B/S架构给使用管理系统的用户带来极大的便利。6、网络上的客户端和服务器可以用来编程任何独立的编程环境，也有中国，GB2312，BIG5，日文写作，一般基金，用于支持多国语言，并且可以嵌入在数据表和其他软件shift_jis访问柱可以用作的名称。
基于Spring Boot+Vue的健身房管理系统(协同过滤算法、功能非常多)
paopaokaka_luck的博客
10-25 1715
🎈系统亮点：协同过滤算法；
springboot 整合rabbitmq
09-07
- *1* [SpringBoot整合RabbitMQ](https://blog.csdn.net/K_kzj_K/article/details/106642250)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值