spring rabbitmq 创建队列绑定交换机

转载

mob64ca141139a2 2024-07-15 00:30:21

文章标签 rabbitmq 分布式 spring java System 文章分类 架构后端开发

一. Exchange(交换机)的作用

二. Exchange(交换机)的类型

1.直连交换机：Direct Exchange

2.主题交换机：Topic Exchange

3.扇形交换机：Fanout Exchange

4.首部交换机：Headers exchange5.默认交换机

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

三. 交换机的属性

五. 综合案例：交换机的使用

0.给子模块添加依赖

1.直连交换机(Direct Exchange)

yml:

1.RabbitmqDirectConfig

2.SendMessageController

3.查看rabbitmq管理界面

4.创建消息接收监听类DirectReceiver

2.主题交换机(Topic Exchange)

RabbitTopicConfig

当传入参数为xx时 a 与 c队列收到消息 xx 校验

当传入参数为yy时 b 与 c队列收到消息 yy校验

当传入参数为zz时 c队列收到消息 * 校验

TopicReceiver

3.扇形交换机(Fanout Exchange)

RabbitmqFanoutConfig

FanoutReceiver

生产者Controller （直连主题扇形）

一. Exchange(交换机)的作用

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

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

交换机原理图:

spring rabbitmq 创建队列绑定交换机_System

二. Exchange(交换机)的类型

1.直连交换机：Direct Exchange

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

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

直连交换机-单个绑定：

spring rabbitmq 创建队列绑定交换机_spring_02

直连交换机-多个绑定：

spring rabbitmq 创建队列绑定交换机_System_03

注1：什么是路由键
每个消息都有一个称为路由键(routing key)的属性，它其实就是一个简单的字符串
注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将会收到

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)错误

spring rabbitmq 创建队列绑定交换机_分布式_04

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

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

三. 交换机的属性

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

五. 综合案例：交换机的使用

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

0.给子模块添加依赖

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

1.直连交换机(Direct Exchange)

yml:

server.port=8080
## rabbitmq config
spring.rabbitmq.host=192.168.100.133
spring.rabbitmq.port=5672
spring.rabbitmq.username=ljj
spring.rabbitmq.password=123456
 
##与启动容器时虚拟主机名字一致~~~与启动容器时虚拟主机名字一致~~~与启动容器时虚拟主机名字一致~~~
spring.rabbitmq.virtual-host=my_vhost

1.RabbitmqDirectConfig

package com.ljj.rabbitmqconsumer.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 {
//    直连交换机对应的队列
    @Bean
    public Queue directQueue(){
        return new Queue("ljj-direct-Queue");
    }
 
    //直连交换机
    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange("ljj-direct-Exchange");
    }
 
    //直连交换机与队列的绑定关系
    @Bean
    public Binding directBinding(){
        return BindingBuilder.bind(directQueue())
                .to(directExchange())
                .with("direct_routing_key");
    }
}

2.SendMessageController
关键代码：

rabbitTemplate.convertAndSend("testDirectExchange","testDirectRouting", map);
 sendDirectMessage：进行消息推送（也可以改为定时任务，具体看需求）
package com.ljj.rabbitmqconsumer.controller;
 
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;
 

 
@RestController
public class SendMessageController {
    @Autowired
    private RabbitTemplate rabbitTemplate;
 
    @RequestMapping("/sendDirect")
    public Map sendDirect(String routingKey){
        Map msg=new HashMap();
        msg.put("msg","直连交换机 ycx-direct-Exchange 发送的消息");
        msg.put("time", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd hh-mm-ss")));
 
        rabbitTemplate.convertAndSend("ljj-direct-Exchange",
                routingKey,
                msg);
 
        Map res=new HashMap();
        res.put("code",200);
        res.put("msg","成功");
        return res;
 
 
    }
 
 
 
}
运行测试方法

输入地址后回车
多了一行
路由到指定的队列需要指定交换机以及routingkey

指定交换机和routingkey 刷新12次
12条消息

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

4.创建消息接收监听类DirectReceiver
@Component @RabbitListener(queues = {"ljj-direct-Queue"}) public class DirectReceiver { // @RabbitListener(queues = {"direzwc_ct-queue"}) @RabbitHandler public void handler(Map msg){ System.out.println(msg); } }
消费方消费12条消息

注1：新版jdk日期及格式化
LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
注2：rabbitTemplate和amqpTemplate有什么关系
查看源码中会发现rabbitTemplate实现自amqpTemplate接口，两者使用起来并无区别，功能一致
注3：不要@Configuration写成了@Configurable，这两个长得很像
@Configuration该注解是可以用来替代XML文件。
手动new出来的对象，正常情况下，Spring是无法依赖注入的，这个时候可以使用@Configurable注解

2.主题交换机(Topic Exchange)

RabbitTopicConfig

package com.ljj.rabbitmqprovider.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;

/**
 * @authorljj
 * @site www.ljj.com
 * @company
 * @create  2022-12-18 17:17
 */
@Configuration
public class RabbitTopicConfig {
//    队列
    @Bean
    public Queue TopicQueueA(){
        return new Queue("ljj-topic-Queue-a");
    }

    @Bean
    public Queue TopicQueueB(){
        return new Queue("ljj-topic-Queue-b");
    }

    @Bean
    public Queue TopicQueueC(){
        return new Queue("ljj-topic-Queue-c");
    }

//    交换机
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange("ljj-topic-exchange");
    }

//    绑定关系
    @Bean
    public Binding binding1(){
        return BindingBuilder.bind(TopicQueueA())
                .to(topicExchange())
                .with("ljj.person.xx");
    }

    @Bean
    public Binding binding2(){
        return BindingBuilder.bind(TopicQueueB())
                .to(topicExchange())
                .with("ljj.person.yy");
    }

    @Bean
    public Binding binding3(){
        return BindingBuilder.bind(TopicQueueC())
                .to(topicExchange())
                .with("ljj.person.*");
    }
}

可以测试了

spring rabbitmq 创建队列绑定交换机_System_12

spring rabbitmq 创建队列绑定交换机_java_13

当传入参数为xx时 a 与 c队列收到消息 xx 校验

spring rabbitmq 创建队列绑定交换机_分布式_14

spring rabbitmq 创建队列绑定交换机_java_15

当传入参数为yy时 b 与 c队列收到消息 yy校验

spring rabbitmq 创建队列绑定交换机_rabbitmq_16

spring rabbitmq 创建队列绑定交换机_分布式_17

当传入参数为zz时 c队列收到消息 * 校验

spring rabbitmq 创建队列绑定交换机_java_18

spring rabbitmq 创建队列绑定交换机_java_19

TopicReceiver

package com.ljj.rabbitmqconsumer.config;

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 = {"ljj-topic-Queue-a"})
	@RabbitHandler
	public void handler1(Map msg){

		System.out.println("消费者订阅：ljj-topic-Queue-a队列的消息为："+msg);
	}

	@RabbitListener(queues = {"ljj-topic-Queue-b"})
	public void handler2(Map msg){

		System.out.println("消费者订阅：ljj-topic-Queue-b队列的消息为："+msg);
	}

	@RabbitListener(queues = {"ljj-topic-Queue-c"})
	public void handler3(Map msg){

		System.out.println("消费者订阅：ljj-topic-Queue-c队列的消息为："+msg);
	}
	}

spring rabbitmq 创建队列绑定交换机_java_20

3.扇形交换机(Fanout Exchange)

RabbitmqFanoutConfig

package com.ljj.rabbitmqprovider.config;

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

/**
 * @authorljj
 * @site www.ljj.com
 * @company
 * @create  2022-12-18 17:17
 */
@Configuration
public class RabbitFanoutConfig {
//    队列
    @Bean
    public Queue fanoutQueueA(){

        return new Queue("ljj-fanout-Queue-a");
    }

    @Bean
    public Queue fanoutQueueB(){

        return new Queue("ljj-fanout-Queue-b");
    }

    @Bean
    public Queue fanoutQueueC(){

        return new Queue("ljj-fanout-Queue-c");
    }

//    交换机
    @Bean
    public FanoutExchange fanoutExchange(){

        return new FanoutExchange("ljj-fanout-exchange");
    }

//    绑定关系
    @Bean
    public Binding bindingFanout1(){
        return BindingBuilder.bind(fanoutQueueA())
                .to(fanoutExchange());
    }

    @Bean
    public Binding bindingFanout2(){
        return BindingBuilder.bind(fanoutQueueB())
                .to(fanoutExchange());
    }

    @Bean
    public Binding bindingFanout3(){
        return BindingBuilder.bind(fanoutQueueC())
                .to(fanoutExchange());
    }
}

每刷新一次队列消息数都加一不需传参，扇型交换机, 路由键无需配置,配置也不起作用

spring rabbitmq 创建队列绑定交换机_System_21

spring rabbitmq 创建队列绑定交换机_java_22

FanoutReceiver

package com.ljj.rabbitmqconsumer.config;

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 = {"ljj-fanout-Queue-a"})
	@RabbitHandler
	public void handler1(Map msg){

		System.out.println("消费者订阅：ljj-fanout-Queue-a队列的消息为："+msg);
	}

	@RabbitListener(queues = {"ljj-fanout-Queue-b"})
	public void handler2(Map msg){

		System.out.println("消费者订阅：ljj-fanout-Queue-b队列的消息为："+msg);
	}

	@RabbitListener(queues = {"ljj-fanout-Queue-c"})
	public void handler3(Map msg){

		System.out.println("消费者订阅：ljj-fanout-Queue-c队列的消息为："+msg);
	}
	}

spring rabbitmq 创建队列绑定交换机_System_23

spring rabbitmq 创建队列绑定交换机_rabbitmq_24

生产者Controller （直连主题扇形）

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

package com.ljj.rabbitmqprovider.controller;

import com.ljj.rabbitmqprovider.config.RabbitmqDLXConfig;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;

/**
 * @authorljj
 * @site www.ljj.com
 * @company
 * @create  2022-12-14 20:42
 */

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

    @RequestMapping("/sendDirect")
    public Map sendDirect(String routingKey) {
        Map msg = new HashMap();
        msg.put("msg", "直连交换机 ljj-direct-Exchange 发送的消息");
        msg.put("time", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd hh-mm-ss")));

        rabbitTemplate.convertAndSend("ljj-direct-Exchange",
                routingKey,
                msg);

        Map res = new HashMap();
        res.put("code", 200);
        res.put("msg", "成功");
        return res;
    }
//主题交换机
    @RequestMapping("/sendTopic")
    public Map sendTopic(String routingkey){
        Map msg = new HashMap();
        msg.put("msg","主题交换机ljj-topic-Exchange发送的消息");
        msg.put("time", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-ss hh:mm:ss")));
        rabbitTemplate.convertAndSend("ljj-topic-exchange",
                routingkey,msg);

        Map ms = new HashMap();
        ms.put("msg","成功");
        ms.put("code",200);

        return ms;
    }
//扇形交换机
    @RequestMapping("/sendFanout")
    public Map sendFanout(String routingkey){
        Map msg = new HashMap();
        msg.put("msg","扇形交换机ljj-fanout-Exchange发送的消息");
        msg.put("time", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-ss hh:mm:ss")));
        rabbitTemplate.convertAndSend("ljj-fanout-exchange",
                null,msg);

        Map ms = new HashMap();
        ms.put("msg","成功");
        ms.put("code",200);
        return ms;
    }

    
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：智慧物流的系统架构图

下一篇：H5iOS键盘的done事件控制

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯