RabbitMQ

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

1.MQ基础
2.常见消息模型
3.消息的可靠性
4.消息持久化
5.消费者确认机制ACK
6.死信交换机
7.延时交换机
8.消息堆积
9.MQ集群

基础

同步通讯：
在这里插入图片描述

  • 优点
    • 时效性更强，可以立刻获得结果
  • 问题
    • 耦合度高
    • 性能吞吐能力下降
    • 有额外的资源消耗
    • 有级联失败问题

异步通信
在这里插入图片描述

  • 优点
    • 耦合度低
    • 吞吐量提升
    • 故障隔离
    • 流量削峰
  • 缺点
    • 依赖于Broker的可靠性、安全性、吞吐能力
    • 架构复杂，没有明显流程线，不好追踪问题

安装

  • systemctl start docker # 启动docker服务

  • docker load -i mq.tar # 上传mq，并且安装

  • 运行MQ
    docker run
    -e RABBITMQ_DEFAULT_USER=xiaowang
    -e RABBITMQ_DEFAULT_PASS=123321
    -v mq-plugins:/plugins
    –name mq
    –hostname mq
    -p 15672:15672
    -p 5672:5672
    -d
    rabbitmq:3.8-management

  • 通过ip地址 + 端口访问 http://ip:15672/

简介

消息发送者将消息发送交换机，交换机将消息路由交给队列，队列存储消息，消费者从队列获取消息，处理消息
在这里插入图片描述

常见消息模型

在这里插入图片描述

基本消息队列

发送者将信息发出，接收者创建队列查看是否存在当前队列，定义回调函数，将函数与队列做绑定，一般队列有消息，就会调用回调函数
在这里插入图片描述
发送者

public void testSendMessage() throws IOException, TimeoutException {
        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("192.168.150.101");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("itcast");
        factory.setPassword("123321");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

        // 2.创建通道Channel
        Channel channel = connection.createChannel();

        // 3.创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        // 4.发送消息
        String message = "hello, rabbitmq!";
        channel.basicPublish("", queueName, null, message.getBytes());
        System.out.println("发送消息成功：【" + message + "】");

        // 5.关闭通道和连接
        channel.close();
        connection.close();

    }

接收者

  public static void main(String[] args) throws IOException, TimeoutException {
        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("192.168.150.101");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("itcast");
        factory.setPassword("123321");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

        // 2.创建通道Channel
        Channel channel = connection.createChannel();

        // 3.创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        // 4.订阅消息
        channel.basicConsume(queueName, true, new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 5.处理消息
                String message = new String(body);
                System.out.println("接收到消息：【" + message + "】");
            }
        });
        System.out.println("等待接收消息。。。。");
    }

SpringAMQP

引入依赖

        <!--AMQP依赖，包含RabbitMQ-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

配置AMQP地址

spring:
  rabbitmq:
    host:  # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: xiaowang # 用户名
    password: 123321 # 密码

发送者使用RabbitTemplate 发送队列消息
只能发送在已存在的队列
在这里插入图片描述

public class SpringAmpqpTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSendMessage2SimpleQueue(){
        String queueName = "simple.queue";
        String message = "Hello,Spring amqp ！！！！！";
        rabbitTemplate.convertAndSend(queueName,message);
    }

}

监听队列的消息
一旦接收到队列，该队列就会被删除

    @RabbitListener(queues = "simple.queue")
    public void ListenterSimpleQuery(String message){
        System.out.println("消费者接收到发送者的消息:"+message);
    }

工作队列 WorkQueue

两个消费者同时处理请求，
在这里插入图片描述

spring:
  rabbitmq:
    host: 192.168.13.133 # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: xiaowang # 用户名
    password: 123321 # 密码
    listener:
      simple:
        prefetch: 1  # 每次只能获取到一条消息，处理完才能获取第二条消息

交换机 ->发布/订阅模型

发布者发布消息到队列中，消费者获取到这条队列，队列种的数据就会删除.如果不想让队列删除，增加交换机，绑定队列，发布者发送至交换机，由交换机发布到每一个队列中
在这里插入图片描述

  • 交换机绑定队列
@Configuration
public class FanoutConfig {

    /**
     * 声明交换机
     * @return Fanout类型交换机
     */
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("itcast.fanout");
    }

    /**
     * 第1个队列
     */
    @Bean
    public Queue fanoutQueue1(){
        return new Queue("fanout.queue1");
    }

    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue1(Queue fanoutQueue1, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
    }

    /**
     * 第2个队列
     */
    @Bean
    public Queue fanoutQueue2(){
        return new Queue("fanout.queue2");
    }

    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue2(Queue fanoutQueue2, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
    }


}
  • 消费者
    @RabbitListener(queues = "fanout.queue1")
    public void ListenterSimpleQuery1(String message) throws InterruptedException {
        Thread.sleep(20);
        System.out.println("消费者接收到发送者的消息1:"+message+"------"+LocalTime.now());
    }

    @RabbitListener(queues = "fanout.queue2")
    public void ListenterSimpleQuerytwo2(String message) throws InterruptedException {
        Thread.sleep(200);
        System.out.println("消费者接收到发送者的消息2:"+message+"-------"+LocalTime.now());
    }
  • 发布者
    // 发送到交换机
    @Test
    public void testSend(){
        String switchName = "itcast.fanout" ;
        String message = "hello.every one !!!!" ;
        rabbitTemplate.convertAndSend(switchName , "",message);
    }

路由模式 Direct交换机

发布者指定交换机，以及发送的key，对应的消费者key，就可以接收到
消费者

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue1") ,   //队列
            exchange = @Exchange(name = "itcast.direct"),
            key = {"red","blue"}
    ))
    public void ListeDirectQueue1(String msg){
        System.out.println("消费者1发送的消息是"+msg);
    }
    
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue2") ,   //队列
            exchange = @Exchange(name = "itcast.direct"),//交换机
            key = {"red","yellow"} //指定key 访问哪个key就可以发送到哪一个队列
    ))
    public void ListeDirectQueue2(String msg){
        System.out.println("消费者2发送的消息是"+msg);
    }

发布者

    // 发送到交换机
    @Test
    public void testSend2(){
        String switchName = "itcast.direct" ;
        String message = "hello.every red !!!!" ;
        rabbitTemplate.convertAndSend(switchName , "red",message);
    }

Topic交换机 支持通配符

生产者发送的消息，消费者通过通配符的形式查看是否符合

消费者

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue1") ,   //队列
            exchange = @Exchange(name = "itcast.topic",type = ExchangeTypes.TOPIC),//交换机
            key = {"china.#"} //指定key 访问哪个key就可以发送到哪一个队列
    ))
    public void ListeTopQueue1(String msg){
        System.out.println("消费者china1发送的消息是"+msg);
    }

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "topic.queue2") ,   //队列
            exchange = @Exchange(name = "itcast.topic",type = ExchangeTypes.TOPIC),//交换机
            key = {"#.news"} //指定key 访问哪个key就可以发送到哪一个队列
    ))
    public void ListeTopQueue2(String msg){
        System.out.println("消费者china2发送的消息是"+msg);
    }

生产者

    // 发送到交换机
    @Test
    public void testTop1(){
        String switchName = "itcast.topic" ;
        String message = "hello.every China !!!!" ;
        rabbitTemplate.convertAndSend(switchName , "china.news",message);
    }

    @Test
    public void testTop2(){
        String switchName = "itcast.topic" ;
        String message = "hello.天气 GOOd" ;
        rabbitTemplate.convertAndSend(switchName , "china.weather",message);
    }

消息转换器

引入jackson依赖

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.9.10</version>
</dependency>

声明转化json的bean

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.9.10</version>
</dependency>

发送定义转化json

    @Bean
    public MessageConverter messageConverter(){
        return new Jackson2JsonMessageConverter();//转json
    }

可以显示中文

    @Test
    public void testTop3(){
        Map<String,Object> map =new HashMap<>();
        map.put("你好",123);
        map.put("hello123",123);
        rabbitTemplate.convertAndSend( "object.queue",map);
    }

消费者监听消息转化为中文

@Bean
public MessageConverter jsonMessageConverter(){
    return new Jackson2JsonMessageConverter();
}

消费者监听消息

    @RabbitListener(queues = "object.queue")
    public void Test(Map<String,Object> map) {
        System.out.println("接收到object消息"+map);
    }

mq消息的可靠性

消息丢失

  • mq生产者将消息发送的时候，可能造成数据的丢失
  • 消息在mq存储的时候，可能会造成数据的丢失
  • 消费者在消费消息时，可能会造成数据的丢失

生产者确认机制，会发送是否发送到交换机的通知

1.生产者设置文件
在这里插入图片描述2.设置交换机/队列/并绑定
在这里插入图片描述
3.判断消息是否发送到交换机
在这里插入图片描述

消息没有发送都队列中

在这里插入图片描述

  • 实现步骤：
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Slf4j
@Configuration  // 生产者确认机制，确认是否发送到交换机
public class CommonConfig implements ApplicationContextAware {


    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        // 从IOC容器中，获取template对象
        RabbitTemplate rabbitTemplate = applicationContext.getBean(RabbitTemplate.class);
        // 执行发送者的回调函数
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            /**
             * @param correlationData  // 自定义的数据 消息UUID
             * @param ack // 确认是否发送到交换机中  true是发送到交换机中
             * @param cause // 原因 ， 没有发送到交换机中的原因
             */
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {

                log.info("发送确认回调触发，当前消息的id{}",correlationData.getId());

                if (ack){
                    log.info("消息已成功发入交换机中----------------");
                }else {
                    log.error("消息没有发送到交换机中！！！！！！！！！  原因未{}" ,  cause);
                    //  这边进行业务重新发送
                }
            }
        });
        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            /**
             *  这个方法触发，代表消息没能正确的路由到队列，被mq返回回来了
             * @param message  返回的消息对象
             * @param replyCode   // 回复的状态编码
             * @param replyTest // 回复的内容
             * @param exchange // 交换机
             * @param routingKey // 路由key
             */
            @Override
            public void returnedMessage(Message message, int replyCode, String replyTest, String exchange, String routingKey) {
                log.info("消息发送失败,应答码{},原因{},交换机{},路由键{},消息{}",
                        replyCode,replyTest,exchange,routingKey,message.toString());
                //  这边进行业务重新发送
            }
        });
    }


    /**
     * 声明交换机
     * @return Fanout类型交换机
     */
    @Bean
    public DirectExchange simpleExchange(){
        return new DirectExchange("simple.direct",false ,false);
    }

    /**
     * 第1个队列
     */
    @Bean
    public Queue simpleQueue(){
        return new Queue("fanout.queue" ,false);
    }

    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding binding(){
        return BindingBuilder.bind(simpleQueue()).to(simpleExchange()).with("simple");
    }
}

消息持久化

  • 交换机与队列是否持久化
    在这里插入图片描述
  • 发送的消息是否持久化
    在这里插入图片描述

消费者确认机制

  • 只有消费者确认了，这条消息才会从rabbit MQ中删除
  • 有三种模式
    在这里插入图片描述

在这里插入图片描述

自动ack的重试策略 -> 根据设定的最大次数重置后，如果还没有读取到这条消息，这条消息就会丢失

在这里插入图片描述

消费者重复失败策略，重试耗尽后，将消息投递到指定交换机->修复问题： 根据设定的最大次数重置后，如果还没有读取到这条消息，这条消息就会丢失在这里插入图片描述


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.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.retry.MessageRecoverer;
import org.springframework.amqp.rabbit.retry.RepublishMessageRecoverer;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class CommonConfig {

    // 设置交换机并绑定队列
    @Bean
    public DirectExchange errorMessageExchange(){
        return new DirectExchange("error.direct");
    }
    @Bean
    public Queue errorQueue(){
        return new Queue("error.queue", true);
    }
    @Bean
    public Binding errorBinding(Queue errorQueue, DirectExchange errorMessageExchange){
        return BindingBuilder.bind(errorQueue).to(errorMessageExchange).with("error");
    }

    // 失败策略
    @Bean
    public MessageRecoverer republishMessageRecoverer(RabbitTemplate rabbitTemplate){
        return new RepublishMessageRecoverer(rabbitTemplate, "error.direct", "error");
    }

}

死信交换机

延时交换机

  • 下载插件
    在这里插入图片描述
    声明方式 1
    在这里插入图片描述
    声明方式 2
    在这里插入图片描述
    在这里插入图片描述

消息堆积

处理消息堆积的方法
在这里插入图片描述

惰性队列存储更大量的数据，普通消息队列存储在内存上，向硬盘缓存同步，惰性队列直接存储在硬盘上

特点在这里插入图片描述

实战

在这里插入图片描述

集群

在这里插入图片描述

QvQ要乐观点
关注
rabbitmq监听器
10-16
rabbitmq监听器测试程序，包括建立通道，测试舰艇通道等功能。
Rabbitmq - rabbitmq Listener监听
程序员路同学
11-13 5531
rabbitmq 监听配置以及listener参数讲解
Spring Boot 实现 RabbitMQ 监听消息的几种方式
最新发布
ttyy1112的专栏
05-20 1241
通过在方法上标记注解来监听指定的队列，当消息到达时，被注解的方法将被调用。：实现 Spring AMQP 提供的接口，编写自定义的消息监听器，然后使用设置消息监听器。：通过类，可以将普通的 Java 方法转换为消息监听器，从而简化消息处理逻辑。：结合和注解，可以实现多个不同类型消息的处理方法，根据消息内容的不同调用对应的处理方法。这些方式都可以在 Spring Boot 项目中方便地实现 RabbitMQ 的消息监听功能。
Springboot RabbitMq源码解析之RabbitListener注解 (四)
959
12-04 5735
RabbitListener注解源码解析
RabbitMQ使用场景练习：监听器Listener(九)
热门推荐
azhegps的博客
12-22 1万+
监听器      RabbitMQ中监听器有ReturnListener、ConfirmListener、ShutdownListener，本练习中使用ReturnListener，在发布消息时设置mandatory等于true，监听消息是否有相匹配的队列，没有时ReturnListener将执行handleReturn方法，消息将返给发送者       设置mandatory=true，当路
RabbitMQ：@RabbitListener注解简化消息监听
kaven
02-17 5006
pom.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 https://maven.apache.org/xsd/ma
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，使得开发人员能够轻松地实现消息的发送和接收。在...
rabbitmq
StudingStudent的博客
08-19 263
rabbitmq 1、AMQP AMQP，即Advanced Message Queuing Protocol,一个提供统一消息服务的应用层标准高级消息队列协议,是应用层协议的一个开放标准,为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同的开发语言等条件的限制。 2、RabbitMQ的使用 1、核心概念 Message 消息，消息是不具名的，它由消息头和消息体组成。消息体是不透明的，而消息头则由一系列的可选属性组成，这些属性包括routing-key（路由
Springboot RabbitMq源码解析之RabbitListener注解
翻身已碰头的博客
02-19 1万+
Springboot RabbitMq源码解析之配置类 Springboot RabbitMq源码解析之消息发送 Springboot RabbitMq源码解析之消费者容器SimpleMessageListenerContainer Springboot RabbitMq源码解析之consumer管理和AmqpEvent ...
rabbitmq动态创建监听
面朝大海，春暖花开
11-02 2547
【代码】rabbitmq动态创建监听。
分布式高级篇3 —— RabbitMQ
YZG ' BLOG
02-09 775
RabbitMQ 是一个消息中间件：它接受并转发消息。你可以把它当做一个快递站点，当你要发送一个包裹时，你把你的包裹放到快递站，快递员最终会把你的快递送到收件人那里，按照这种逻辑 RabbitMQ 是一个快递站，一个快递员帮你传递快件。RabbitMQ 与快递站的主要区别在于，它不处理快件而是接收，存储和转发消息数据。RabbitMQ 的三大特点该场景一般在秒杀或者团购活动中使用广泛。
RabbitMQ消费端自定义监听器【3-7】
Coding Earth Engine
10-28 4762
代码展示 生产者 package com.mq.rabbit.customizelistener; import com.rabbitmq.client.*; import java.io.IOException; /** * @author Mqs * @date 2018/10/27 23:53 * @desc */ public class Producer { ...
rabbitmq消费者使用@RabbitListener完整快速跑demo教程
hfwangyl的博客
11-30 455
网上对于使用rabbitmq发送消息的文章还是很多的，对于生产者这里就不做过多的介绍了，本文详细的介绍一下再使用消费者消费消息的时候，常用的步骤及遇到的坑~有不对的地方欢迎指出。 首先，先缓一缓有些迷茫的大脑，梳理一下你现在完成到哪一步了，接下来需要做哪一步。 `前提条件：生产者已经搭建好了，rabbitmq已经启起来了，消息也发到了rabbitmq上`
rabbitmq to rabbitmq
03-27
RabbitMQ是一个开源的消息中间件，它实现了高级消息队列协议（AMQP）并提供可靠的消息传递机制。它允许应用程序之间进行异步通信，并支持多种消息模式，如点对点、发布/订阅和工作队列。 当我们提到"RabbitMQ to RabbitMQ"时，通常是指在不同的RabbitMQ实例之间进行消息传递。这种情况下，可以使用RabbitMQ的一些特性来实现消息的可靠传递和路由。 一种常见的方式是使用Exchange和Queue来进行消息的路由和传递。在发送端，消息会被发送到一个Exchange，然后Exchange会根据预定义的规则将消息路由到一个或多个Queue中。接收端可以监听这些Queue，并从中获取消息进行处理。 另一种方式是使用RabbitMQ的集群功能。通过将多个RabbitMQ实例组成一个集群，可以实现消息的高可用性和负载均衡。当一个节点出现故障时，其他节点可以接管其工作，确保消息的可靠传递。 总结起来，RabbitMQ to RabbitMQ是指在不同的RabbitMQ实例之间进行消息传递和路由。可以使用Exchange和Queue来定义消息的路由规则，也可以通过集群来实现高可用性和负载均衡。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值