rabbitmq

最新推荐文章于 2024-05-20 18:48:59 发布
最新推荐文章于 2024-05-20 18:48:59 发布
阅读量263 收藏 2
点赞数 2
分类专栏： rabbitmq 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/StudingStudent/article/details/119804511
版权

rabbitmq

1、AMQP

AMQP，即Advanced Message Queuing Protocol,一个提供统一消息服务的应用层标准高级消息队列协议,是应用层协议的一个开放标准,为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同的开发语言等条件的限制。

2、RabbitMQ的使用

1、核心概念

Message

消息，消息是不具名的，它由消息头和消息体组成。消息体是不透明的，而消息头则由一系列的可选属性组成，这些属性包括routing-key（路由键）、 priority（相对于其他消息的优先权）、 delivery-mode（指出该消息可能需要持久性存储）等。

Publisher

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

Exchange

交换器，用来接收生产者发送的消息并将这些消息路由给服务器中的队列。Exchange有4种类型： direct(默认)， fanout, topic, 和headers，不同类型的Exchange转发消息的策略有所区别

Queue

消息队列，用来保存消息直到发送给消费者。它是消息的容器，也是消息的终点。一个消息可投入一个或多个队列。消息一直在队列里面，等待消费者连接到这个队列将其取走。

Binding

绑定，用于消息队列和交换器之间的关联。一个绑定就是基于路由键将交换器和消息队列连
接起来的路由规则，所以可以将交换器理解成一个由绑定构成的路由表。Exchange 和Queue的绑定可以是多对多的关系。
Connection：网络连接，比如一个TCP连接。
Channel：信道，多路复用连接中的一条独立的双向数据流通道。信道是建立在真实的TCP连接内的虚拟连接， AMQP 命令都是通过信道发出去的，不管是发布消息、订阅队列还是接收消息，这些动作都是通过信道完成。因为对于操作系统来说建立和销毁 TCP 都是非常昂贵的开销，所以引入了信道的概念，以复用一条 TCP 连接。
Consumer：消息的消费者，表示一个从消息队列中取得消息的客户端应用程序。
Virtual Host：虚拟主机，表示一批交换器、消息队列和相关对象。虚拟主机是共享相同的身份认证和加密环境的独立服务器域。每个 vhost 本质上就是一个 mini 版的 RabbitMQ 服务器，拥有自己的队列、交换器、绑定和权限机制。 vhost 是 AMQP 概念的基础，必须在连接时指定，RabbitMQ 默认的 vhost 是 / 。

2、几种消息模型

  • 简单模式

一对一

概述：一个生产者一个消费者

应用场景：一发一接的结构

例如: 手机短信,邮件单发

//发送者
private static String QUEUE_NAME = "test-simple";

    //创建队列发送消息
    public  void sendMessage() throws Exception{
        //获取连接
        Connection connection = getConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //创建队列
        //队列名称 是否持久化 是否独占队列 是否消费完成后删除队列 额外附加参数
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //消息内容
        String message = "hello tom!";
        //交换机名称 队列名称 传递消息额外设置 消息的具体内容
        channel.basicPublish("",QUEUE_NAME,null,message.getBytes(StandardCharsets.UTF_8));
        System.out.println("发送消息："+message);
        //关闭通道、连接
        channel.close();
        connection.close();
    }
//接收者
 private static String QUEUE_NAME = "test-simple";

    public void getMessage() throws Exception {
        //获取连接
        Connection connection = getConnection();
        //创建通道
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        channel.basicConsume(QUEUE_NAME, true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("收到消息：" + new String(body));
            }
        });
        channel.close();
        connection.close();
    }
  • 工作模式(资源争抢)

一对多

概述：一个生产者多个消费者

应用场景：一发多收结构

例如：抢红包、资源调度


//生产者
private static String QUEUE_NAME = "test-work";

    public static void main(String[] args) throws Exception {
        //获取连接
        Connection connection = getConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //创建队列
        //队列名称 是否持久化 是否独占队列 是否消费完成后删除队列 额外附加参数
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
        //消息内容
        for (int i = 0; i < 20; i++) {
            //交换机名称 队列名称 传递消息额外设置 消息的具体内容
            channel.basicPublish("", QUEUE_NAME, null, ("hello tom!"+i).getBytes(StandardCharsets.UTF_8));
            System.out.println("发送+"+i);
        }
        System.out.println("发送消息: success");
        //关闭通道、连接
        channel.close();
        connection.close();
    }

//消费者
 private static String QUEUE_NAME = "test-work";

    public static void main(String[] args) throws Exception {
        //获取连接
        Connection connection = getConnection();
        //创建通道
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, true, false, false, null);

        channel.basicConsume(QUEUE_NAME, true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1-收到消息：" + new String(body));
                channel.basicAck(1,false);
            }
        });
    }
  • 发布订阅模式

发布订阅模式图

概述：发送消息到交换机 交换机根据绑定队列发送给生产者

应用场景：服务推送

例如：订阅公众号接收文档

//发布者
  private static String EXCHANGE_NAME = "fanout-exchange";
    
    public static void main(String[] args) throws Exception {
        //获取连接
        Connection connection = getConnection();
        Channel channel = connection.createChannel();
        //交换机名称 交换机类型 fanout广播类型
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
        channel.basicPublish(EXCHANGE_NAME,"",null,"fanout type message".getBytes(StandardCharsets.UTF_8));
        //
        channel.close();
        connection.close();
    }
//订阅者
private static String EXCHANGE_NAME = "fanout-exchange";

    public static void main(String[] args) throws Exception {
        //获取连接
        Connection connection = getConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
        //临时队列
        String queue = channel.queueDeclare().getQueue();
        //绑定交换机和队列
        channel.queueBind(queue,EXCHANGE_NAME,"");
        //消费消息
        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者2："+new String(body));
            }
        });
    }
  • 路由模式

路由模式图

概述：根据routKey不同，交换机发送到不同队列中。

//生产者

    private static String DIRECT_NAME = "direct_exchange";

    public static void main(String[] args) throws Exception {
        //获取连接
        Connection connection = getConnection();
        Channel channel = connection.createChannel();
        //交换机名称 交换机类型 direct路由模式
        channel.exchangeDeclare(DIRECT_NAME,"direct");
        //发送消息
        String routingKey = "warning";
        channel.basicPublish(DIRECT_NAME,routingKey,null,("这是direct模式发布routKey:["+routingKey+"],发送新增消息").getBytes(StandardCharsets.UTF_8));
        channel.close();
        connection.close();
    }
//消费者
private static String DIRECT_NAME = "direct_exchange";

    public static void main(String[] args) throws Exception {
        //获取连接
        Connection connection = getConnection();
        Channel channel = connection.createChannel();
        //交换机名称 交换机类型 direct路由模式
        channel.exchangeDeclare(DIRECT_NAME,"direct");
        String queue = channel.queueDeclare().getQueue();
        //临时队列和交换机绑定
        channel.queueBind(queue,DIRECT_NAME,"info");
        channel.queueBind(queue,DIRECT_NAME,"error");
        channel.queueBind(queue,DIRECT_NAME,"warning");
        //消费消息
        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者2："+new String(body));
            }
        });
    }
  • 统配符匹配模式

统配符匹配模式

//生产者
  private static String TOPIC_NAME = "topic_exchange";

    public static void main(String[] args) throws Exception {
        //获取连接
        Connection connection = getConnection();
        Channel channel = connection.createChannel();
        //交换机名称 交换机类型 topic
        channel.exchangeDeclare(TOPIC_NAME,"topic");
        //发布消息
        String routingKey = "user.service";
        channel.basicPublish(TOPIC_NAME,routingKey,null,("这是topic动态路由模型,routKey["+routingKey).getBytes(StandardCharsets.UTF_8));
        channel.close();
        connection.close();
    }
//消费者
 private static String TOPIC_NAME = "topic_exchange";

    public static void main(String[] args) throws Exception {
        //获取连接
        Connection connection = getConnection();
        Channel channel = connection.createChannel();
        //交换机名称 交换机类型 topic
        channel.exchangeDeclare(TOPIC_NAME,"topic");
        //创建一个临时队列
        String queue = channel.queueDeclare().getQueue();
        //绑定队列和交换机 动态通配符形式
        channel.queueBind(queue,TOPIC_NAME,"user.*");
        //消费消息
        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者2："+new String(body));
            }
        });
    }

springboot与rabbitmq整合

  • 导入依赖
 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
 </dependency>
  • 配置连接信息
spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: test
    password: 123456
    virtual-host: /test

生产者

 @Autowired
    private RabbitTemplate rabbitTemplate;
    @Test
    void testHello() {
        for (int i = 0; i < 10; i++) {
            rabbitTemplate.convertAndSend("work","hello world："+i);
        }

    }

消费者

@Component
public class HelloConsumer {

    @RabbitListener(queuesToDeclare = @Queue("work"))
    public void receive(String message){
        System.out.println("message1："+message);
    }

    @RabbitListener(queuesToDeclare = @Queue("work"))
    public void receive2(String message){
        System.out.println("message2："+message);
    }
}
  • 发布订阅模式

发送端


    //发布订阅模式
    @Test
    public void testFanout(){
        rabbitTemplate.convertAndSend("logs","","Fanout的模型发送消息");
    }

接收端

@Component
public class FanoutConsumer {
    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,//创建临时队列
                    exchange = @Exchange(value = "logs",type = "fanout") //绑定的交换机
            )
    })
    public void receive(String message){
        System.out.println("message1 = " +message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,//创建临时队列
                    exchange = @Exchange(value = "logs",type = "fanout") //绑定的交换机
            )
    })
    public void receive2(String message){
        System.out.println("message2 = " +message);
    }
}
  • 路由模式

发送端

 //路由模式
    @Test
    public void testDirect(){
        rabbitTemplate.convertAndSend("directs","error","Direct的模式发送信息");
    }

接收端

@Component
public class DirectConsumer {

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,//创建临时队列
                    exchange = @Exchange(value = "directs", type = "direct"),//自定义交换机名称和类型
                    key = {"info", "error", "warn"}
            )
    })
    public void receive1(String message) {
        System.out.println("message1 = " + message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,//创建临时队列
                    exchange = @Exchange(value = "directs", type = "direct"),//自定义交换机名称和类型
                    key = {"error"}
            )
    })
    public void receive2(String message) {
        System.out.println("message2 = " + message);
    }
}
  • 统配符模式

发送端

    //统配符模式
    @Test
    void testTopic(){
        rabbitTemplate.convertAndSend("topics","user.ll","这是topic模式发送信息");
    }

接收端

@Component
public class TopicConsumer {

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,//临时队列
                    exchange = @Exchange(name = "topics",type = "topic"),
                    key = {"user.save","user.*"}
            )
    })
    public void receive1(String message){
        System.out.println("message1 = "+message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,//临时队列
                    exchange = @Exchange(name = "topics",type = "topic"),
                    key = {"user.get"}
            )
    })
    public void receive2(String message){
        System.out.println("message2 = "+message);
    }
}

  )
})
public void receive1(String message){
    System.out.println("message1 = "+message);
}

@RabbitListener(bindings = {
        @QueueBinding(
                value = @Queue,//临时队列
                exchange = @Exchange(name = "topics",type = "topic"),
                key = {"user.get"}
        )
})
public void receive2(String message){
    System.out.println("message2 = "+message);
}

}


---
Studing小菜鸟
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMq使用方法
thebinso的博客
05-23 843
1.RabbitMq运行机制 2.交换机(Exchange) 类型 direct（直接）：消息精确发送，而且只能到达一个队列 fanout（扇出）：消息会分发到所有绑定的队列上。 topic（主题）：与fanout类似，但是多了个属性路由key绑定，消息会发送到路由key对应的队列上 3.spring整合rabbitmq 3.1 导入amqp依赖 <dependency> <groupId>org.springframework.boot&l.
【SpringBoot MQ 系列】RabbitListener 消费基本使用姿势介绍
程序员高级码农的博客
01-08 2111
【MQ 系列】RabbitListener 消费基本使用姿势介绍之前介绍了 rabbitmq 的消息发送姿势，既然有发送，当然就得有消费者，在 SpringBoot 环境下，消费可以说比较简单了，借助注解，基本上可以满足你 90%以上的业务开发需求下面我们来看一下的最最常用使用姿势。
Spring Boot 实现 RabbitMQ 监听消息的几种方式
最新发布
ttyy1112的专栏
05-20 1199
通过在方法上标记注解来监听指定的队列，当消息到达时，被注解的方法将被调用。：实现 Spring AMQP 提供的接口，编写自定义的消息监听器，然后使用设置消息监听器。：通过类，可以将普通的 Java 方法转换为消息监听器，从而简化消息处理逻辑。：结合和注解，可以实现多个不同类型消息的处理方法，根据消息内容的不同调用对应的处理方法。这些方式都可以在 Spring Boot 项目中方便地实现 RabbitMQ 的消息监听功能。
rabbitmq消费者使用@RabbitListener完整快速跑demo教程
hfwangyl的博客
11-30 445
网上对于使用rabbitmq发送消息的文章还是很多的，对于生产者这里就不做过多的介绍了，本文详细的介绍一下再使用消费者消费消息的时候，常用的步骤及遇到的坑~有不对的地方欢迎指出。 首先，先缓一缓有些迷茫的大脑，梳理一下你现在完成到哪一步了，接下来需要做哪一步。 `前提条件：生产者已经搭建好了，rabbitmq已经启起来了，消息也发到了rabbitmq上`
rabbitmq动态创建监听
面朝大海，春暖花开
11-02 2532
【代码】rabbitmq动态创建监听。
RabbitMQ：@RabbitListener 与 @RabbitHandler 及 消息序列化
weixin_43343423的博客
12-04 3万+
添加 @RabbitListener 注解来指定某方法作为消息消费的方法，例如监听某 Queue 里面的消息 MessageConvert 涉及网络传输的应用序列化不可避免，发送端以某种规则将消息转成 byte 数组进行发送，接收端则以约定的规则进行 byte[] 数组的解析 RabbitMQ 的序列化是指 Message 的 body 属性，即我们真正需要传输的内容，RabbitMQ 抽象出一个...
RabbitMQ
02-24
应用解耦、异步、流量削锋、数据分发、错峰流控、日志收集等等...MQ衡量标准服务性能、数据存储、集群架构主流竞品分析当前市面上mq的产品很多，比如RabbitMQ、Kafka、ActiveMQ、ZeroMQ和阿里巴巴捐献给Apache的...
RabbitMQ Server3.13.0
04-02
**RabbitMQ Server 3.13.0** RabbitMQ 是一个开源的消息代理和队列服务器，它基于AMQP（Advanced Message Queuing Protocol）协议，用于在分布式系统中高效地路由和传递消息。RabbitMQ 3.13.0 版本是其稳定版本之一...
rabbitmqadmin
07-08
RabbitMQ命令行手动创建队列rabbitmqadmin用法 手动创建队列方法：登录http://ip:15672/cli下载 将下载的rabbitmqadmin放到/usr/sbin目录下，并赋予权限：chmod 755 rabbitmqadmin 查看命令帮助信息： python ...
rabbitmq开发规范
07-04
**RabbitMQ开发规范详解** 在使用RabbitMQ进行分布式消息传输时，遵循一定的开发规范至关重要，这不仅可以提高系统的可维护性，也有助于保证数据的一致性和稳定性。本篇文章将详细阐述RabbitMQ的命名规范、消息传输...
rabbitmq3.10.4
06-07
RabbitMQ是一个开源的消息代理和队列服务器，广泛应用于分布式系统中的消息传递。它基于AMQP（Advanced Message Queuing Protocol）协议，为多种编程语言提供API，使得开发人员能够轻松地实现消息的发送和接收。在...
@RabbitListener起作用的原理
yygr的博客
05-11 3851
https://blog.csdn.net/zidongxiangxi/article/details/100623548 一、前言 在spring中，定义rabbitMq的消费者可以相当方便，只需要在消息处理类或者类方法加上@RabbitListener注解，指定队列名称即可。如下代码： @Component public class RabbitMqListener1 { @RabbitListener(queues = "queue1") public void consu..
RabbitMQ @RabbitListener注解和使用
华棋皓
07-30 3万+
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rabbit="http://www.springframework.org/schema/rabbit" xsi:schemaLocation="ht...
Spring Boot 中的 @RabbitListener 注解是什么，原理，如何使用
u013749113的博客
07-01 8921
RabbitListener 注解是 Spring AMQP 框架中的一个关键组件，它可以将一个方法标记为 RabbitMQ 的消息监听器。在 Spring Boot 应用程序中，可以使用 @RabbitListener 注解来监听队列，并在接收到消息时执行指定的方法。在本文中，我们介绍了 @RabbitListener 注解的原理、使用方法和常见应用场景。通过使用 @RabbitListener 注解，可以方便地实现异步任务处理、发布订阅模式等功能。
SpringBoot整合RabbitMQ高级特性
weixin_45962477的博客
02-16 857
持久化exchange要持久化queue要持久化message要持久化生产方确认Confirm消费方确认AckBroker高可用RabbitMQ默认日志存放路径： /var/log/rabbitmq/没有权限在命令前面加上sudo日志包含了RabbitMQ的版本号、Erlang的版本号、RabbitMQ服务节点名称、cookie的hash值、RabbitMQ配置文件地址、内存限制、磁盘限制、默认账户guest的创建以及权限配置等等。
@RabbitListener注解
热门推荐
Va1mZzz的博客
10-18 3万+
I. 配置 首先创建一个 SpringBoot 项目，用于后续的演示 springboot 版本为2.2.1.RELEASE rabbitmq 版本为3.7.5 依赖配置文件 pom.xml <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <ve..
Rabbitmq使用@RabbitListener动态生成队列进行监听
wxz980927155的博客
08-17 5987
private static final String QUEUE_NAME="cre_in_out."+ getIp(); @Bean public org.springframework.amqp.core.Queue queue(){ return new org.springframework.amqp.core.Queue(QUEUE_NAME,true); } @RabbitListener(bindings = @QueueBinding(.
RabbitMQ实战运用(五)——SpringBoot整合RabbitMQ
qq_43553923的博客
03-25 172
SpringBoot整合RabbitMQ 介绍 SpringBoot主要通过RabbitTemplate类来操作RabbitMQ。 加入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 配置 spring: rabb
rabbitmq to rabbitmq
03-27
RabbitMQ是一个开源的消息中间件，它实现了高级消息队列协议（AMQP）并提供可靠的消息传递机制。它允许应用程序之间进行异步通信，并支持多种消息模式，如点对点、发布/订阅和工作队列。 当我们提到"RabbitMQ to ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值