RabbitMQ六种模式

最新推荐文章于 2023-05-29 16:18:15 发布
最新推荐文章于 2023-05-29 16:18:15 发布
阅读量304 收藏 1
点赞数
分类专栏： 后端 JAVA RabbitMQ 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smy166153/article/details/117692812
版权
后端 同时被 3 个专栏收录
28 篇文章 0 订阅
订阅专栏
JAVA
22 篇文章 0 订阅
订阅专栏
RabbitMQ
9 篇文章 0 订阅
订阅专栏

文章目录

前言

以下代码在我github里也有https://github.com/Codeouter/Example/tree/test/Project/rabbit-modes

一、配置

xml配置文件

<?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>org.example</groupId>
    <artifactId>rabbit-modes</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <parent>
        <artifactId>spring-boot-starter-parent</artifactId>
        <groupId>org.springframework.boot</groupId>
        <version>2.1.4.RELEASE</version>
    </parent>

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

yml文件如下，每个model的ym配置基本一致所以就写这一个算了。

server:
  port: 8080   #这个端口看自己喜好
spring:
  application:
    name: provider-mode1
  rabbitmq:
    port: 5673       #这个端口看自己的配置，默认是5672
    host: 192.168.136.128  #我这是自己的虚拟机上的，如果不是用虚拟机的就localhost
    username: admin			#账号密码看自己设置
    password: admin

一、Hello World

这种方式是最简单的方式，生产者直接将消息投递到队列里，消费者直接监听队列消费消息
在这里插入图片描述

1.生产者

首先写个配置类，其实就是创建个队列

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

@Configuration
public class Config {

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

然后写个发送的逻辑

mport org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;

@Component
public class Sender {
    @Autowired
    RabbitTemplate rabbitTemplate;

    public void send(){
        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("messageData",messageData);
        map.put("createTime",createTime);
        rabbitTemplate.convertAndSend("myQueue", map);
    }
}

其实这里有个小细节，当我们在IDE里打出rabbitTemplate.convertAndSend的时候，会有如下这些重载的方法
在这里插入图片描述没有哪个方法是说发送到某个队列里的，而是交换器或者是路由键。而我们用的显然是第一个，也就是说在此情况下，队列名字就充当了路由键。

最后是一个Controller

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SendController {
    @Autowired
    Sender sender;
    @GetMapping("/send")
    public String send(){
        sender.send();
        return "ok";
    }
}

启动类就不多说了，自己写吧

2.消费者

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Map;

@Component
@RabbitListener(queues = "myQueue")
public class Consumer {
    @RabbitHandler
    public void receive(Map msg){
        String nowTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        System.out.println("receive: " + msg.toString() + "current time is:" + nowTime);
    }
}

最后会得到如下结果
在这里插入图片描述

二、Work Queues

这种就是一个生产者多个消费者
在这里插入图片描述这个单生产者与多生产者基本相似，我们只展示不太相同的部分。

1.生产者

public class Sender {
    @Autowired
    RabbitTemplate rabbitTemplate;

    public void send(int curId){
        String messageData = "test message, hello!";
        String currentId = "curId";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String,Object> map=new HashMap<>();
        map.put(currentId, curId);
        map.put("messageData",messageData);
        map.put("createTime",createTime);
        rabbitTemplate.convertAndSend("myQueue", map);
    }
}

为了能够更好的观看竞争状况，对send函数修改一下能够加入Id去看哪个消息被哪个消费者接收。
下面就是对controller小小的修改

@RestController
public class SendController {
    @Autowired
    Sender sender;
    @GetMapping("/send")
    public String send(){
        for(int i = 0; i < 50; i++){
            sender.send(i); //每个消息都加入一个id标识一下
        }
        return "ok";

    }
}

2.消费者

@Component
@RabbitListener(queues = "myQueue")
public class Consumer {
    @RabbitHandler
    public void receive(Map msg){
        String nowTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        System.out.println("### Conusumer1 ### receive: " + msg.toString() + "current time is:" + nowTime);
    }
}

@Component
@RabbitListener(queues = "myQueue")
public class Consumer1 {
    @RabbitHandler
    public void receive(Map msg){
        String nowTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        System.out.println("### Conusumer2 ### receive: " + msg.toString() + "current time is:" + nowTime);
    }
}

最终产生的结果大概就是这样。
在这里插入图片描述

三、Publish/Subscribe

在这里插入图片描述这种情况是生产者先发给一个交换器，然后交换器再发送给队列，而消费者则是监听队列获取消息。
这个与上边的work queues非常相似，区别是本模式同一个消息可以被多次消费，而work queues智能消费一次

由于后边要进行路由之类的所以到此时，我们使用yml进行配置队列名以及交换机名

server:
  port: 8084
spring:
  application:
    name: provider-mode-workqueue
  rabbitmq:
    port: 5673
    host: 192.168.136.128
    username: admin
    password: admin
my:
  provider:
    queue1: myQueue1
    exchange: myExchange
    queue2: myQueue2

1.生产者

对于上面publish模式，与上边的不同只是在配置类上面，这次需要创建两个队列，并且还有交换机，以及它们之间的绑定。

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.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;

@Configuration
public class Config {
    @Autowired
    private Environment env;

    @Bean
    public Queue myQueue(){

        return new Queue(env.getProperty("my.provider.queue1"));
    }
    @Bean
    Queue myQueue1(){
        return new Queue(env.getProperty("my.provider.queue2"));
    }

    @Bean
    public FanoutExchange myExchange(){
        return new FanoutExchange(env.getProperty("my.provider.exchange"));
    }

    @Bean
    Binding bindingQueue1(){
        return BindingBuilder.bind(myQueue())
                .to(myExchange());
    }
    @Bean
    Binding bindingQueue2(){
        return BindingBuilder.bind(myQueue1())
                .to(myExchange());
    }
}

发送的逻辑与之前的几乎没有差别，差别局势发送时要指定交换机。

@Component
public class Sender {
    @Autowired
    RabbitTemplate rabbitTemplate;

    @Autowired
    private Environment env;

    public void send(int curId){
        String messageData = "test message, hello!";
        String currentId = "curId";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String,Object> map=new HashMap<>();
        map.put(currentId, curId);
        map.put("messageData",messageData);
        map.put("createTime",createTime);
        rabbitTemplate.convertAndSend(env.getProperty("my.provider.exchange"),"", map);

    }

}

2.消费者

@Component
@RabbitListener(queues = "myQueue1")
public class Consumer {
    @RabbitHandler
    public void receive(Map msg){
        String nowTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        System.out.println("### Conusumer1 ### receive: " + msg.toString() + "current time is:" + nowTime);
    }
}

@Component
@RabbitListener(queues = "myQueue2")
public class Consumer1 {
    @RabbitHandler
    public void receive(Map msg){
        String nowTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        System.out.println("### Conusumer2 ### receive: " + msg.toString() + "current time is:" + nowTime);
    }
}

结果如下
在这里插入图片描述

四、路由模式

需要将一个队列绑定到交换机上，要求该消息与一个特定的路由键完全匹配，
在这里插入图片描述这个代码就不贴了，之前我写的有篇文章就是这样https://blog.csdn.net/smy166153/article/details/117456651?spm=1001.2014.3001.5502，同时下面的主题模式也几乎一致。

五、主题模式

同样是将bindingkey和routingkey绑定，但是规则有些不同。
它约定：

RoutingKey为由"."分割的字符串，如com.rabbitmq.client
BindingKey同样如此
BindingKey可以存在两种不同的字符，“*"和”#“ 其中 * 用于匹配一个单词，#用于匹配多个单词
headers
headers的交换器不依赖于路由键的匹配规则来路由消息，而是根据发送的消息内容中的headers属性来进行匹配

在这里插入图片描述首先是对yml的修改

server:
  port: 8085
spring:
  application:
    name: provider-mode-workqueue
  rabbitmq:
    port: 5673
    host: 192.168.136.128
    username: admin
    password: admin
my:
  provider:
    queue1: myQueue1
    exchange: topicExchange
    queue2: myQueue2
    routing1: first.a.second.b
    routing2: first.b.second.c

然后对发送逻辑进行修改

@Component
public class Sender {
    @Autowired
    RabbitTemplate rabbitTemplate;

    @Autowired
    private Environment env;

    public void send(){
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String,Object> map=new HashMap<>();
        map.put("createTime",createTime);
        rabbitTemplate.convertAndSend(env.getProperty("my.provider.exchange"),
         env.getProperty("my.provider.routing1"), map);
        rabbitTemplate.convertAndSend(env.getProperty("my.provider.exchange"),
         env.getProperty("my.provider.routing2"), map);
    }
}

然后消费者用上边的即可，不用修改。其实也不用启动消费者，看管理工具也是可以的，如下。
在这里插入图片描述同时最后消费的结果如下
在这里插入图片描述

六、RPC模式

在这里插入图片描述Rpc模式是通过客户端发送消息，服务端回复相应的消息，从而实现远程调用。

1.生产者

Config类需要改一下

@Configuration
public class Config {
    @Autowired
    private Environment env;

    @Bean
    public Queue myQueue(){

        return new Queue(env.getProperty("my.provider.queue1"));
    }

    @Bean
    public DirectExchange myExchange(){
        return new DirectExchange(env.getProperty("my.provider.exchange"));
    }

    @Bean
    public Binding binding(){
       return BindingBuilder.bind(myQueue())
                .to(myExchange())
                .with(env.getProperty("my.provider.routing1"));
    }
}

然后是发送的逻辑

@Component
public class Sender {
    @Autowired
    RabbitTemplate rabbitTemplate;

    @Autowired
    private Environment env;

    public void  getPow(int x){
       System.out.println("### send " + x + "###");
       Object rep = rabbitTemplate.convertSendAndReceive(env.getProperty("my.provider.exchange"),
               env.getProperty("my.provider.routing1"), x);

       int res = (int) rep;
      System.out.println("### receive the answer is" + res + "  ###");
    }
}

最后是controller

@RestController
public class SendController {
    @Autowired
    Sender sender;
    @PostMapping("/get/{id}")
    public String send(@PathVariable(value = "id") int id){

        sender.getPow(id);
        return "ok";

    }
}

2.消费者

@Component
@RabbitListener(queues = "${my.consumer.queue1}")
public class Consumer {
    @RabbitHandler
    public int pow(Integer x) throws Exception{
        System.out.println("## receive" + x + "##");
        return  x * x;
    }
}

我们可以的到这样的测试结果
在这里插入图片描述

我在阳澄湖畔吃炸鸡
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ(纯干货,个人学习用)
低调老猿的博客
11-27 728
RabbitMQ 研究 1 RabbitMQ介绍 1.1 应用场景 ​ MQ全称为Message Queue，即消息队列， RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。RabbitMQ官方地址：http://www.rabbitmq...
RabbitMQ五种模式
07-01
异步调用的一种实现方式是引入MQ，A将调用信息发到消息中间件，然后B从消息中间件获取到消息内容执行。此时A不再需要等待B。 这个前提下，**就可以实现异步调用**，**冗余存储**（指可以在MQ中多存一些数据，等待B...
RabbitMQ的六种工作模式以及代码实现
热门推荐
sinJack的博客
08-20 3万+
一、什么是RabbitMQ rabbitmq是基于amqp协议实现一套高效的数据传输组件，MQ（消息队列）。 常见的MQ：ActiveMQ、Kafka、RocketMQ、RabbitMQ 官方文档：https://www.rabbitmq.com/getstarted.html 二、MQ的应用场景 1、消息异步通知(注册时邮箱认证、添加商品生成详情页和将商品添加到搜索库等) 2、消息顺序处理 3、消息延迟处理 4、请求削峰 三、六种工作模式 1.1 simple简单模式 1）消息产生后将消息放入队列 2）
RabbitMQ的五种工作模式超详解
金鳞踏雨
05-31 5092
一、简单模式。二、Work。三、Routing模式。四、Topics模式。五、PubSub模式 1. 创建连接工厂ConnectionFactory2. 设置工厂的参数3.创建连接 Connection4. 创建管道 Channel5. 简单模式中没有交换机exchange，所以不用创建（RabbitMQ会使用默认的交换机！）6. 创建队列queue7. 设置发送内容，使用channal.basicPublish()发送8. 释放资源
RabbitMQ的六种工作模式
小猪快跑
12-21 1526
一.基于erlang语言： 是一种支持高并发的语言 RabbitMQ的六种工作模式： 1.1 simple简单模式 消息产生着§将消息放入队列 消息的消费者(consumer) 监听(while) 消息队列,如果队列中有消息,就消费掉,消息被拿走后,自动从队列中删除(隐患 消息可能没有被消费者正确处理,已经从队列中消失了,造成消息的丢失)应用场景:聊天(中间有一个过度的服务器;p端,c端) ...
RabbitMQ六种工作模式01
qq_60281421的博客
05-29 813
SMS: WorkProducer： 运行： 消费者1：SMSOrder1： 赋值三个 三个消费者 SMSOrder1： SMSOrder2： SMSOrder3分别运行： 让每个消费者 做延迟： 每个消费者会消费不同的消息： Weather.Java： Baidu.java: Sina.java: 手动添加一个交换机 Baidu.java: Sina.java: TopicProducer.java: Baidu.java
基于RabbitMQ几种Exchange 模式详解
08-28
下面小编就为大家带来一篇基于RabbitMQ几种Exchange 模式详解。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
rabbitmq常用三种模式的配置
03-16
rabbitmq包含多种模式，主要是fanout，direct，topic，本代码主要针对这三种模式进行相关的配置，配置文件单独放置在不同的文件夹里，以便学习。
RabbitMQ 五种工作模式C#项目代码
02-08
测试普通队列模式--点对点--消费者 #region 测试工作队列模式-- 一个生产者多个消费者 --生产端 #region 发布/订阅模式 #region 路由模式 #region 主题模式
springboot+RabbitMQ三种模式demo
07-03
springboot+RabbitMQ的direct，topic，fanout三种模式demo
一文搞懂Rabbitmq常用模式
沸羊羊_
07-13 1292
文章目录前言核心组成Rabbitmq模式Hello worldWork queuePublish/subscribe概述应用场景Routing 前言 上一篇文章介绍了消息中间件，本文主要讲解MQ的具体实现 RabbitMQ 消息中间件详解-传送门 核心组成 Rabbitmq模式 Hello world Work queue 一旦 rabbitmq 将消息传递给消费者，就会立即将其标记为删除状态。如果消费者接收任务，但并没有完成处理的情况下，就down了，此时，这种已分派给消费者的但并未完成处理的消息就
rabbitmq五种模式详解（含实现代码）
浅时光|初如梦
08-07 3283
1.简单模式 当生产端发送消息到交换机,交换机根据消息属性发送到队列,消费者监听绑定队列实现消息的接收和消费逻辑编写.简单模式下,强调的一个队列queue只被一个消费者监听消费. 1.1 结构 生产者:生成消息,发送到交换机 交换机:根据消息属性,将消息发送给队列 消费者:监听这个队列,发现消息后,获取消息执行消费逻辑 1.2应用场景 常见的应用场景就是一发,一接的结构 例如: 手机短信,邮件单发 2.争抢模式 强调的也是后端队列与消费者绑定的结构 2.1结构 生产者:.
RabbitMq 6种使用模式
qq_40776768的博客
12-15 2564
RabbitMQ的5种模式与实例 1.1 简单模式Hello World 功能：一个生产者P发送消息到队列Q,一个消费者C接收 生产者实现思路： 创建连接工厂ConnectionFactory，设置服务地址127.0.0.1，端口号5672，设置用户名、密码、virtual host，从连接工厂中获取连接connection，使用连接创建通道channel，使用通道channel创建队列queue，使用通道channel向队列中发送消息，关闭通道和连接。 消费者实现思路 创建连接工厂Connection
RabbitMQ学习记录(九)-六种模式
崔二旦
04-18 1378
RabbitMQ六种模式。
RabbitMQ系列之三 RabbitMQ几种典型模式
程序猿的博客
11-15 2万+
本文详细介绍简单模式Simple、工作模式Work、发布订阅模式Publish/Subscribe、路由模式Routing、通配符模式Topics、远程调用模式RPC(区别于普通的消息队列的范畴了，所以这里暂不对该队列模式进行详解) 模式1：简单模式（Simple / HelloWorld 单生产单消费） 简单的发送与接收，没有特别的处理。 RabbitMQ连接（公共的连接方法，其他模式共用此方...
Python操作rabbitmq 实践笔记
weixin_30765577的博客
10-17 369
发布/订阅系统 1.基本用法 生产者 1 import pika 2 import sys 3 4 username = 'wt' #指定远程rabbitmq的用户名密码 5 pwd = '111111' 6 user_pwd = pika.PlainCredentials(username, pwd) 7 s_conn = pika.Blocking...
RabbitMQ-1入门
~
06-20 1280
JMS规定了两种消息模型；而AMQP的消息模型更加丰富 JMS限定了必须使用Java语言；AMQP只是协议，不规定实现方式，因此是跨语言的。 JMS是定义了统一的接口，来对消息操作进行统一；AMQP是通过规定协议来统一数据交互的格式 activemq是基于JMS，而RabbitMQ基于AMQP 五种消息模型 RabbitMQ提供了6种消息模型，但是第6种其实是RPC，并不是MQ，因...
RabbitMQ的四种转换器模式
caox_nazi的博客
07-25 3932
RabbitMQ的四种转换器模式总结  【参考文献】：（1）、（2） 1. 工作队列： （一）Round-robin 转发机制：一次性全部转发，一个一个的发送信息给下一个消费者(consumer)，而不考虑每个任务的时长等等，且是一次性分配，并非一个一个分配。平均的每个消费者将会获得相等数量的消息。 【发送方（生产者）】： /** * 第一个参数：queue QUEUE_NAME ...
rabbitmq的六种工作模式
最新发布
07-28
1. 简单模式（Simple Mode）：一个生产者向一个消费者发送消息，这是最基本的工作模式。 2. 工作队列模式（Work Queue Mode）：一个生产者向多个消费者发送消息，每个消息只能被一个消费者接收，实现负载均衡。 3....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值