RabbitMQ基本使用

最新推荐文章于 2024-04-25 23:01:38 发布
最新推荐文章于 2024-04-25 23:01:38 发布
阅读量1k 收藏 2
点赞数 1
分类专栏： 后端 文章标签： java-rabbitmq rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50769390/article/details/128223240
版权

先会用，知道mq是干嘛的，怎么用RabbitMQ  再去考虑一系列深入东西

 一：什么是MQ

MQ消息队列详解、四大MQ的优缺点分析_从百草园杀到三味书屋&的博客-CSDN博客

理解什么是MQ  MQ在企业/程序中的作用是什么？

 MQ，中文是消息队列（MessageQueue），字面来看就是存放消息的队列。

消息队列中间件（MQ）是分布式系统中重要的组件，主要解决应用耦合，异步消息，流量削锋等问题实现高性能，高可用，可伸缩和最终一致性[架构] 

好处：

        1.吞吐量提升，无需等待订阅者处理完成，给客户端响应更快

        2.耦合度降低，每个服务都可以灵活拔插，可替换

        3.流量晓峰，不管发布事件的流量波动多大，都由Broker接收，订阅者可以按照自己的速度去处理事件

        ...

缺点：

        1.架构复杂了，业务线没有明显的流程线，不好管理

        2.需要依赖于Broker的可靠、安全、性能

比较常见的MQ（ActiveMQ  RabbitMQ  RocketMQ  Kafka ）

几种常见MQ的对比：

RabbitMQActiveMQ（一般不用了）RocketMQKafka
公司/社区RabbitApache阿里Apache
开发语言ErlangJavaJavaScala&Java
协议支持AMQP，XMPP，SMTP，STOMPOpenWire,STOMP，REST,XMPP,AMQP自定义协议自定义协议
可用性高一般高高
单机吞吐量一般差高非常高
消息延迟微秒级毫秒级毫秒级毫秒以内
消息可靠性高一般高一般

二：RabbitMQ

2.1安装RabbitMQ

linux（docker）安装：docker安装RabbitMQ_落后挨打的博客-CSDN博客_docker 安装rabbitmq 

 docker search rabbitmq   搜寻镜像版本

docker pull rabbitmq        拉取镜像到宿主机

将镜像生成容器
docker run -d --hostname my-rabbit --name rabbit -p 15672:15672 -p 5672:5672 rabbitmq

      
docker ps  查看运行的容器 
docker exec -it 镜像ID /bin/bash     进入容器内部
rabbitmq-plugins enable rabbitmq_management  运行
访问地址： http://linuxip地址:15672   （用户guest，密码guest）

 注意:  

        RabbitMQ启动成功后暴露两个端口

        java应用端连接：192.168.136.160:5672

        管理后台地址 ：地址： 15672

        管理员账号/密码 guest/guest

三：RabbitMQ消息模型(队列消息 发布/订阅消息)

 四：Springboot演示RabbitMQ

1.导依赖  amqp

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

   <!--springboot单元测试-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>

  <!--json格式转换-->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
    </dependency>
</dependencies>

2.添加配置文件：

#配置RabbitMQ的基本信息
spring:
  rabbitmq:
    host: 192.168.136.160
    port: 5672
    virtual-host: tjtc
    username: hua
    password: hua

 首先介绍两种：SimpleQueue        WorkQueue  （没有交换机）

 SimpleQueue：一个生产者，一个消费者

 

在上图的模型中，有以下概念：

  • P：生产者，也就是要发送消息的程序

  • C：消费者：消息的接受者，会一直等待消息到来。

  • queue：消息队列，图中红色部分。类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息。

 1.定义发送消息（生产者）

@SpringBootTest
@RunWith(SpringRunner.class)
public class RabbitTemplateTest {

    /**
     * 使用SpringAMQP发送消息：
     *    1、依赖
     *    2、在配置文件中加入rabbitmq的相关配置
     *    3、注入对象RabbitTemplate，调用convertAndSend方法发送消息
     */
    @Autowired
    private RabbitTemplate template;
    
    /**
     * 发送基本（简单）队列消息
     * springamqp发送队列消息，需要在后台系统中手动创建一个队列
     */
    @Test
    public void testSendBaseMessage() {
        String ququeName="simple.queue";
        String message = "hahhah";
        template.convertAndSend(ququeName,message); //队列名称，消息内容
    }
}

 消费者：

import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * 自定义的消息监听器：
 *    1、此类交给容器管理
 *    2、编写方法：监听消息队列（队列中一旦有最新的消息，自动执行方法）
 */
@Component
public class MessageListener {

    /**
     * 消费者的监听器方法：获取消息并消费（完成业务逻辑）
     * 1、方法没有返回值
     * 2、方法有参数（参数=发送的消息内容）
     *      参数类型和发送的消息类型一致
     * 3、在方法上通过@RabbitListener绑定队列
     */
     @RabbitListener(queues = "simple.queue")   //有队列就是用 没队列就报错
    //@RabbitListener(queuesToDeclare ={@Queue("abc")} ) //有对象就使用 没队列就创建一个队列
    public void recBaseMessage(String message) {
        System.out.println("消费者1获取消息："+message);
    }
}

 注意：   

    @RabbitListener(queues = "simple.queue")   //有队列就是用 没队列就报错
    @RabbitListener(queuesToDeclare ={@Queue("abc")} ) //有队列就使用 没队列就创建一个队列

WorkQueue：让多个消费者绑定到一个队列，共同消费队列中的消息。

 

 当消息处理比较耗时的时候，可能生产消息的速度会远远大于消息的消费速度。长此以往，消息就会堆积越来越多，无法及时处理。

此时就可以使用work 模型，多个消费者共同处理消息处理，速度就能大大提高了。

 消息发送：

  /**
     * 发送工作队列消息
     *   发送多次
     */
    @Test
    public void testSendWorkMessage() throws InterruptedException {
        for (int i = 0; i < 50; i++) {
            String message = "凡凡有难，八方点赞,点赞数："+i;
            String queueName = "simple.queue";
            rabbitTemplate.convertAndSend(queueName,message); //队列，消息
            Thread.sleep(10);
        }
    }

 消费者：

    /**
     * 消费者1
     */
    @RabbitListener(queues="simple.queue")
    public void recBaseMessage(String message) throws InterruptedException {
        //性能较高
        System.out.println("1号消费者获取消息："+message);
        Thread.sleep(50);
    }

    /**
     * 消费者2
     */
    @RabbitListener(queues="simple.queue")
    public void recBaseMessage(String message) throws InterruptedException {
        //性能较低
        System.out.println("2号消费者获取消息："+message);
        Thread.sleep(1000);
    }

 注意: RabbitMQ默认的是，平均分配给每个消费者，并没有考虑到消费者的处理能力

那么可以通过配置解决：

spring:
  rabbitmq:
    listener:
      simple:
        prefetch: 1 # 每次只能获取一条消息，处理完成才能获取下一个消息

上边这两种消息队列  

发送者：

        rabbitTemplate.convertAndSend(queueName,message); //队列名称，消息

消费者： （定义一个方法，放一个参数）

         @RabbitListener(queues="simple.queue")

Fanout

可以看到，在订阅模型中，多了一个exchange角色，而且过程略有变化：

  • P：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机）

  • Exchange：交换机，图中的X。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有以下3种类型：

    • Fanout：广播，将消息交给所有绑定到交换机的队列

    • Direct：定向，把消息交给符合指定routing key 的队列

    • Topic：通配符，把消息交给符合routing pattern（路由模式） 的队列

  • C：消费者，与以前一样，订阅队列，没有变化

  • Queue：消息队列也与以前一样，接收消息、缓存消息。

 消息发送：

  /**
     * 测试发送Fanout模式消息（广播模式）
     */
    @Test
    public void testSendFanoutMessage() {
        String exchangeName = "heima165fanout";
        String message = "凡凡有难，八方点赞";
        template.convertAndSend(exchangeName,"",message); //交换机名称，空，消息
    }

 消息消费者：

    /**
     * 监听Fanout模式消息
     *      @RabbitListener:
     *          bindings ：绑定队列和交换机
     *          value：
     *              @Queue ： 指定队列
     *                  value：队列名称
     *          exchange：指定交换机
     *              @Exchange
     *                  value：交换机名称
     *                  type：类型
     */
    /**
     * 获取Fanout模式消息（广播）
     */
package cn.itcast.mq.fanoutqueue;

import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class ConsumerFanOut {

    @RabbitListener(
            bindings = @QueueBinding(
                    value = @Queue(
                            value = "fanout.queue1"
                    ),
                    exchange = @Exchange(
                            value = "fanout",
                            type = ExchangeTypes.FANOUT
                    )
            )
    )
    public void recBaseMessage(String message) {
//        Thread.sleep(1000);
        System.out.println("消费者1获取消息："+message);
    }
}

 2

package cn.itcast.mq.fanoutqueue;

import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class ConsumerFanOut2 {

    @RabbitListener(
            bindings = @QueueBinding(
                    value = @Queue(
                            value = "fanout.queue2"
                    ),
                    exchange = @Exchange(
                            value = "fanout",
                            type = ExchangeTypes.FANOUT
                    )
            )
    )
    public void recBaseMessage(String message) throws InterruptedException {
        Thread.sleep(1000);
        System.out.println("消费者1获取消息："+message);
    }
}

注意：Exchange（交换机）只负责转发消息，不具备存储消息的能力

在Fanout模式中，一条消息，会被所有订阅的队列都消费。但是，在某些场景下，我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange。

Direct

 

在Direct模型下：

  • 队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）

  • 消息的发送方在 向 Exchange发送消息时，也必须指定消息的 RoutingKey。

  • Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的Routingkey与消息的 Routing key完全一致，才会接收到消息

发送者：

   @Test
    public void testSendDirectMessage() {
        for (int i = 0; i < 10; i++) {
            String exchangeName = "Direct";
            String routingKey = "red";
            String message = "今天太冷了" + i;
            rabbitTemplate.convertAndSend(exchangeName,routingKey,message); //交换机，routingkey（类型），消息
        }
    }

消费者：


    @RabbitListener(
            bindings = @QueueBinding(
                    value = @Queue(
                            value = "direct.queue"
                    ),
                    exchange = @Exchange(
                            value = "Direct",
                            type = ExchangeTypes.DIRECT
                    ),
                    key = {"blue"}  // key = {"blue","red","yellow"}
            )
    )
    public void recBaseMessage(String message) throws InterruptedException {
        Thread.sleep(1000);
        System.out.println("消费者1获取消息："+message);
    }
 @RabbitListener(
            bindings = @QueueBinding(
                    value = @Queue(
                            value = "direct.queue2"
                    ),
                    exchange = @Exchange(
                            value = "Direct",
                            type = ExchangeTypes.DIRECT
                    ),
//                    key = { "red"}
                      key = {"blue","red","yellow"}
            )
    )
    public void recBaseMessage(String message) throws InterruptedException {
        Thread.sleep(1000);
        System.out.println("消费者1获取消息："+message);
    }

 Topic  模式

Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符！

Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert

通配符规则：

#：匹配一个或多个词

*：匹配不多不少恰好1个词

 发送者：

    /**
     * 发送topic消息（主题模式）
     */
    @Test
    public void testSendTopicMessage() {
        String exchangeName = "Topic";
        String routingKey = "china.weather";
        String message = "恭喜EDG";
        template.convertAndSend(exchangeName,routingKey,message); //交换机，routingkey（类型），消息
    }

消费者：

    /**
     * 获取主题模式消息
     *   工程，可以支持所有以china开头的消息
     */
    @RabbitListener(
            bindings = @QueueBinding(
                    value = @Queue(
                            value = "topic.queue1"
                    ),
                    exchange = @Exchange(
                            value = "Topic",
                            type = ExchangeTypes.TOPIC
                    ),
                    key = "china.*"
            )
    )
    public void recTopicMessage(String message) {
        System.out.println("消费者1获取topic消息："+message);
    }
  /**
     * 获取主题模式消息
     *   工程，可以支持所有以news结尾的内容
     */
    @RabbitListener(
            bindings = @QueueBinding(
                    value = @Queue(
                            value = "topic.queue2"
                    ),
                    exchange = @Exchange(
                            value = "Topic",
                            type = ExchangeTypes.TOPIC
                    ),
                    key = "*.news"
            )
    )
    public void recTopicMessage(String message) {
        System.out.println("消费者2获取topic消息："+message);
    }

華同学.
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
RabbitMQ简介及简单使用
weixin_46120888的博客
05-02 1906
文章目录1.RabbitMQ基本介绍2.RabbitMQ简单使用案例2.1在RabbitMQ平台上创建一个队列2.2编写生产者代码2.3编写消费者代码3.RabbitMQ如何保证消息不丢失4.RabbitMQ工作队列5.RabbitMQ交换机(exchange)5.1RabbitMQ Fanout 发布订阅5.2 Direct交换机5.3 Topic主题模式6.MQ如何获取消费者消费结果7.rabbitmq死信队列7.1原理7.2演示7.3应用场景8.RabbitMQ重试策略与幂等性问题8.1重试8.2幂等
RabbitMQ基本概念和使用
01-30
RabbitMQ是一个消息代理，核心原理：发送消息，接收消息...首先通过一个非常简单的”helloworld“例子介绍如何使用RabbitMQ，然后再介绍其涉及的基本概念并对交换机和队列多做点介绍。本例非常简单——发送一个消息”h
RabbitMQ最全使用教程-小白也能看懂
最新发布
2401_84557521的博客
04-25 1539
我还通过一些渠道整理了一些大厂真实面试主要有：蚂蚁金服、拼多多、阿里云、百度、唯品会、携程、丰巢科技、乐信、软通动力、OPPO、银盛支付、中国平安等初，中级，高级Java面试题集合，附带超详细答案，希望能帮助到大家。还有专门针对JVM、SPringBoot、SpringCloud、数据库、Linux、缓存、消息中间件、源码等相关面试题。
关于RabbitMQ
art_code的博客
11-10 197
关于RabbitMQ RabbitMQ是一个由erlang开发的AMQP（Advanced Message Queue ）的开源实现。AMQP 的出现其实也是应了广大人民群众的需求，虽然在同步消息通讯的世界里有很多公开标准（如 COBAR的 IIOP ，或者是 SOAP 等），但是在异步消息处理中却不是这样，只有大企业有一些商业实现（如微软的 MSMQ ，IBM 的 Websphere MQ 等...
三十一、RabbitMQ一（1）
u_hcy2000的博客
02-04 529
文章目录学习目标一、消息队列MQ概述1.1 为什么使用MQ1.2. 消息队列产品1.3. AMQP 和 JMS1.3.1. AMQP1.3.2. JMS1.3.3. AMQP 与 JMS 区别1.4. RabbitMQ**应用场景：****1、双十一商品秒杀/抢票功能实现****2、积分兑换(积分可用于多平台)****3、大平台用户注册**1.5 相关定义：二、安装及配置RabbitMQ2.1. docker中安装RabbitMq2.2. 用户以及Virtual Hosts配置2.2.1. 用户角色2.2.
Rabbit MQ的基本使用
qq_62898618的博客
12-24 1777
虚拟主机的概念，它是对Broker的虚拟划分，将消息生产者，消费者，和它们依赖的AMQP相关的结构进行隔离，一般是从安全方面的考虑。AMQP是Advanced Message Queuing Protocol的简称，是面向消息中间件的开放式标准应用协议，这样意味着RabbitMQ可以更容易的构建异构的系统。RabbitMQ是以AMQP协议实现的一种消息中间件产品。消息队列(Message Queue，简称MQ)，从字面意思上看，本质是个队列，FIFO先入先出，只不过队列中存放的内容是message而已。
java使用rabbitMq服务
04-24
在学校简单了解过，从未在生产环境使用过。这一个月任务都是消息队列相关。于是私下里在自己腾讯云轻量级服务器安装了单机兔子先生。现在MQ的基本学习告一段落。感觉这文档还是挺有用的哈，，“应付”我们的日常开发...
RabbitMQ的基本使用
qq_54936371的博客
02-25 1877
RabbitMQ是一个开源的消息代理和队列服务器，用来通过普通协议在完全不同的应用之间共享数据，RabbitMQ是使用Erlang语言来编写的，并且RabbitMQ是基于AMQP协议的。 一、消息队列 1、MQ：Message Queue释义 服务之间最常见的通信方式是直接调用彼此来通信,消息从一端发出后立即就可以达到另一端,称为即时消息通讯(同步通信) 消息从某一端发出后,首先进入一个容器进行临时存储,当达到某种条件后,再由这个容器发送给另一端,称为延迟消息通讯(异步通信) 2、消息队列特点.
简单了解RabbitMQ的基本使用
weixin_44387195的博客
11-16 280
RabbitMQ的基本使用一概述二、RabbitMQ的优势三、RabbitMQ后台管理系统四、消息模型1.基本消息模型2.work消息模型3.订阅模式（三种） 一概述 什么是MQ？ MQ（Message Queue）消息队列，是基础数据结构中“先进先出”的一种数据结构。一般用来解决应用解耦，异步消息，流量削峰等问题，实现高性能，高可用，可伸缩和最终一致性架构。 MQ就是把要传输的数据（消息）放在队列中，用队列机制来实现消息传递–生产者产生消息并把消息放入队列，然后由消费者去处理。消费者可以到指定队列拉取消
rabbitmq 基本操作
一路向前前的专栏
06-28 861
1，basic.consum 订阅消息 2，basic.get 获取单条消息 3，basic.ack 消费者确认收到消息 （可以通过设置auto_ack 参数为true 来自动确认 ） 4，basic.reject 拒绝接受 消息 有个requeue 参数 设置为ture的话，重新放入队列，设置为false的话，从队列中删除 5，queue.declare 创建队列，如果消费者在同一个信道
RabbitMQ的使用
qwq1518346864的博客
06-13 1291
目录 RabbitMQ的使用 一.Java连接RabbitMQ 1.1创建Maven项目 1.2导入依赖 1.3创建工具类连接RabbitMQ 二.通讯方式 1.Hello-World 2.Work 3.Publish/Subscribe 4.Routing 5.Topic RabbitMQ的使用 一.Java连接RabbitMQ 1.1创建Maven项目 pass 。。。。 1.2导入依赖 <dependencies> <dependen.
RabbitMQ使用 详解
lxlsygxs2017的博客
04-06 1444
RabbitMQ单机安装 RabbitMQ消息模型：基本消息队列、工作消息队列、发布订阅（Fanout、Direct、Topic） RabbitMQ集群部署 RabbitMQ生产者消息确认 RabbitMQ消费者消息确认 RabbitMQ消息失败重试机制 RabbitMQ死信交换机 RabbitMQ惰性队列 RabbitMQ消息延迟发送 RabbitMQ镜像集群 RabbitMQ仲裁队列 RabbitMQ集群扩容
rabbitmq如何使用
weixin_42608299的博客
02-11 331
RabbitMQ 是一个开源的消息代理和队列管理系统，支持多种消息协议，可以用来在分布式系统中进行消息传递。 使用 RabbitMQ 的步骤大致如下： 安装 RabbitMQ 服务器：可以在本地安装或使用云服务商提供的 RabbitMQ 服务。 创建交换器：交换器是消息的中转站，接收到消息后决定将消息发送到哪个队列。 创建队列：队列是存储消息的地方，可以有多个消费者同时从队列中消费消息。 ...
RabbitMQ使用(一)
weixin_30332241的博客
07-20 72
1. 安装与使用 1. 激活 RabbitMQ's Management Plugin (前面跟绝对路径) "D:\娱乐\rabbitmq_server-3.6.5\sbin\rabbitmq-plugins.bat" enable rabbitmq_management 2 .用管理员权限启动服务(在\sbin\路径下下操作) net stop RabbitMQ && net ...
RabbitMQ的使用详解
Zero摄氏度的博客
07-12 3134
MQ（message queue），本质是个队列，FIFO先入先出。只不过队列中放的是message，是一种跨进程的通信机制，用于上下游传递消息。在互联网架构中，MQ是一种非常常见的上下游解耦的消息通信服务。使用了MQ之后，消息发送上游只需要依赖MQ，不用依赖其他服务。
RabbitMQ 使用教程（看完就会用了）
Sunshineづ
03-19 2388
本文介绍了 RabbitMQ 的基本概念、安装和配置、使用方法以及应用场景。RabbitMQ 是一个功能强大的消息队列中间件，具有高并发、高可靠、高可扩展等优点，可以应用于多种场景。如果你正在开发一个高并发、分布式的系统，RabbitMQ 绝对是一个值得考虑的选择。
rabbitmq基本介绍
09-04
在开始使用RabbitMQ之前，我们可以通过一个简单的"helloworld"例子来了解它的基本使用方法。我们可以发送一个消息"helloworld"并接收它。同时，这个例子还会涉及到RabbitMQ的基本概念，例如交换机和队列。 这些是...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

華同学.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值