rabbitMq的3种Exchange代码示例

最新推荐文章于 2023-09-14 22:31:24 发布

曾令胜

最新推荐文章于 2023-09-14 22:31:24 发布

阅读量603

点赞数 1

本文链接：https://blog.csdn.net/qq_21190847/article/details/105755324

版权

一、rabbitMq的Exchange的几种工作模式

1、Direct Exchange-路由模式

直连型交换机，根据消息携带的路由键将消息投递给对应队列。点对点消息发送。

大致流程，有一个队列绑定到一个直连交换机上，同时赋予一个路由键 routing key 。
然后当一个消息携带着路由值为X，这个消息通过生产者发送给交换机时，交换机就会根据这个路由值X去寻找绑定值也是X的队列。

2、Fanout Exchange-–发布/订阅模式

扇型交换机，这个交换机没有路由键概念，就算你绑了路由键也是无视的。这个交换机在接收到消息后，会直接转发到绑定到它上面的所有队列。

3、Topic Exchange-匹配订阅模式

主题交换机，这个交换机其实跟直连交换机流程差不多，但是它的特点就是在它的路由键和绑定键之间是有规则的。
简单地介绍下规则：

*  (星号) 用来表示一个单词 (必须出现的)


# (井号) 用来表示任意数量（零个或多个）单词

通配的绑定键是跟队列进行绑定的，举个小例子
队列Q1 绑定键为 .TT. 队列Q2绑定键为 TT.#
如果一条消息携带的路由键为 A.TT.B，那么队列Q1将会收到；
如果一条消息携带的路由键为TT.AA.BB，那么队列Q2将会收到；

二、代码示例

本次实例教程需要创建2个springboot项目，一个 provider （生产者），一个consumer（消费者）。
首先定义生产者:
pom.xml添加依赖

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

application.xml添加rabbitmq配置，如果用户名没有修改默认guest，如果密码修改默认guest,如果端口没有修改默认5672.这三项都没有修改过可以不配置，使用默认配置。
主启动类上添加@EnableRabbit注解

spring.rabbitmq.host=rabbitmq服务地址
spring.rabbitmq.username=登录账户
spring.rabbitmq.password=密码
spring.rabbitmq.port=端口

1、direct exchange(直连型交换机),创建DirectRabbitConfig.java

@Configuration
public class DirectRabbitConfig {
    //创建队列 起名：TestDirectQueue
    @Bean
    public Queue TestDirecQueue(){
        return new Queue("TestDirectQueue",true);
    }
    //Direct交换机 起名：TestDirectExchange
    @Bean
    public DirectExchange TestDirctExchange(){
        return new DirectExchange("TestDirectExchange");
    }
    //绑定 将队列和交换机绑定，并设置用于匹配键：TestDirectRouting
    @Bean
    public Binding bindingDirect(){
        return BindingBuilder.bind(TestDirecQueue()).to(TestDirctExchange()).with("TestDirectRouting");
    }
}

创建测试类，添加发送DirectMessage

@RunWith(SpringRunner.class)
@SpringBootTest
public class TestMessage {
    @Autowired
    RabbitTemplate rabbitTemplate;  //使用RabbitTemplate,这提供了接收/发送等等方法

    @Test
    public void  sendDirectMessage() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "test message, hello!";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String,Object> map=new HashMap<>();
        map.put("messageId",messageId);
        map.put("messageData",messageData);
        map.put("createTime",createTime);
        //将消息携带绑定键值：TestDirectRouting 发送到交换机TestDirectExchange
        rabbitTemplate.convertAndSend("TestDirectExchange", "TestDirectRouting", map);
    }
    }

登录rabbitmq管理界面查看消息发送情况在这里插入图片描述
接收到消息内容
consumer消费端中加入rabbitmq的pom依赖，application.xml和消费端配置一下。主启动类上添加@EnableRabbit注解，然后创建接收消息类。

@Component
@RabbitListener(queues = "TestDirectQueue")//监听的队列名称 TestDirectQueue
public class DirectReceiver {
    @RabbitHandler
    public void process(Object testMessage) {
        System.out.println("DirectReceiver消费者收到消息---1  : " + testMessage.toString());
    }
}

输出消息获取结果

DirectReceiver消费者收到消息---1  : (Body:'{createTime=2020-04-25 18:47:32, messageId=77eb8c30-0dd0-446c-b92a-ca98d81aa173, messageData=test message, hello!}'

2、接下来是使用Fanout Exchang 扇型交换机。

同样地，先在provIder项目上创建FanoutRabbitConfig.java，创建三个队列：fanout.A fanout.B fanout.C 将三个队列都绑定在交换机 fanoutExchange 上


@Configuration
public class FanoutRabbitConfig {
    /**
     *  创建三个队列 ：fanout.A   fanout.B  fanout.C
     *  将三个队列都绑定在交换机 fanoutExchange 上
     *  因为是扇型交换机, 路由键无需配置,配置也不起作用
     */


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

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

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

    @Bean
    FanoutExchange fanoutExchange() {
        return new FanoutExchange("fanoutExchange");
    }

    @Bean
    Binding bindingExchangeA() {
        return BindingBuilder.bind(queueA()).to(fanoutExchange());
    }

    @Bean
    Binding bindingExchangeB() {
        return BindingBuilder.bind(queueB()).to(fanoutExchange());
    }

    @Bean
    Binding bindingExchangeC() {
        return BindingBuilder.bind(queueC()).to(fanoutExchange());
    }

}

provider生产者测试类中添加发送Fanout消息的测试方法

 @Test
    public void  sendFanoutMessage() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "message: testFanoutMessage ";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String, Object> map = new HashMap<>();
        map.put("messageId", messageId);
        map.put("messageData", messageData);
        map.put("createTime", createTime);
        rabbitTemplate.convertAndSend("fanoutExchange", null, map);
    }

查看管理中心
在这里插入图片描述
消费端创建三个接收类

@Component
@RabbitListener(queues = "fanout.A")
public class FanoutReceiverA {
    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("FanoutReceiverA消费者收到消息  : " +testMessage.toString());
    }

}

@Component
@RabbitListener(queues = "fanout.B")
public class FanoutReceiverB {
    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("FanoutReceiverB消费者收到消息  : " +testMessage.toString());
    }

}

@Component
@RabbitListener(queues = "fanout.C")
public class FanoutReceiverC {
    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("FanoutReceiverC消费者收到消息  : " +testMessage.toString());
    }

}

运行消费端测试消息接收
输出结果

FanoutReceiverB消费者收到消息  : {createTime=2020-04-25 19:07:44, messageId=786b4b00-96c7-403f-829f-cb99507c6844, messageData=message: testFanoutMessage }
FanoutReceiverC消费者收到消息  : {createTime=2020-04-25 19:07:44, messageId=786b4b00-96c7-403f-829f-cb99507c6844, messageData=message: testFanoutMessage }
FanoutReceiverA消费者收到消息  : {createTime=2020-04-25 19:07:44, messageId=786b4b00-96c7-403f-829f-cb99507c6844, messageData=message: testFanoutMessage }

3、接着，我们使用Topic Exchange 主题交换机。
在rabbitmq-provider项目里面创建TopicRabbitConfig.java

@Configuration
public class TopicRabbitConfig {
    //绑定键
    public final static String man = "topic.man";
    public final static String woman = "topic.woman";

    @Bean
    public Queue firstQueue() {
        return new Queue(TopicRabbitConfig.man);
    }

    @Bean
    public Queue secondQueue() {
        return new Queue(TopicRabbitConfig.woman);
    }

    @Bean
    TopicExchange exchange() {
        return new TopicExchange("topicExchange");
    }


    //将firstQueue和topicExchange绑定,而且绑定的键值为topic.man
    //这样只要是消息携带的路由键是topic.man,才会分发到该队列
    @Bean
    Binding bindingExchangeMessage() {
        return BindingBuilder.bind(firstQueue()).to(exchange()).with(man);
    }

    //将secondQueue和topicExchange绑定,而且绑定的键值为用上通配路由键规则topic.#
    // 这样只要是消息携带的路由键是以topic.开头,都会分发到该队列
    @Bean
    Binding bindingExchangeMessage2() {
        return BindingBuilder.bind(secondQueue()).to(exchange()).with("topic.#");
    }
}

消息生产端添加消息发送测试方法

 @Test
    public void sendTopicMessage1() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "message: M A N ";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String, Object> manMap = new HashMap<>();
        manMap.put("messageId", messageId);
        manMap.put("messageData", messageData);
        manMap.put("createTime", createTime);
        rabbitTemplate.convertAndSend("topicExchange", "topic.man", manMap);
    }

查看管理界面，
在这里插入图片描述
因为topic.woman 路由键是topic.#所以可以能接收到消息

消费端创建两个接收类

@Component
@RabbitListener(queues = "topic.man")
public class TopicManReceiver {
    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("TopicManReceiver消费者收到消息  : " + testMessage.toString());
    }

}

@Component
@RabbitListener(queues = "topic.woman")
public class TopicTotalReceiver {

    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("TopicTotalReceiver消费者收到消息  : " + testMessage.toString());
    }

}

运行消费端测试
控制台打印如下

TopicManReceiver消费者收到消息  : {createTime=2020-04-25 19:29:16, messageId=3b5a0919-169e-489a-9645-b23105724265, messageData=message: M A N }
TopicTotalReceiver消费者收到消息  : {createTime=2020-04-25 19:29:16, messageId=3b5a0919-169e-489a-9645-b23105724265, messageData=message: M A N }

继续执行测试方法

 @Test
    public void sendTopicMessage2() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "message: woman is all ";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String, Object> womanMap = new HashMap<>();
        womanMap.put("messageId", messageId);
        womanMap.put("messageData", messageData);
        womanMap.put("createTime", createTime);
        rabbitTemplate.convertAndSend("topicExchange", "topic.woman", womanMap);
    }

消费端控制台输出

TopicTotalReceiver消费者收到消息  : {createTime=2020-04-25 19:44:55, messageId=7d21d79a-5ba9-43d9-9f21-c2835f479d68, messageData=message: woman is all }

证明只有topic.woman队列绑定了topic.#路由键能匹配到消息。

曾令胜

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
rabbitMq的3种Exchange代码示例

一、rabbitMq的Exchange的几种工作模式1、Direct Exchange-路由模式直连型交换机，根据消息携带的路由键将消息投递给对应队列。点对点消息发送。大致流程，有一个队列绑定到一个直连交换机上，同时赋予一个路由键 routing key 。然后当一个消息携带着路由值为X，这个消息通过生产者发送给交换机时，交换机就会根据这个路由值X去寻找绑定值也是X的队列。2、Fanou...
复制链接

扫一扫