消息队列 RabbitMq 的学习和应用

最新推荐文章于 2023-08-02 09:39:43 发布
最新推荐文章于 2023-08-02 09:39:43 发布
阅读量247 收藏 1
点赞数
分类专栏： 学习笔记 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/real_rookie/article/details/119143512
版权

消息队列 RabbitMq 的学习和应用

MQ简介

队列类似一种List结构，专门来存储数据的一个队列

使用场景

在这里插入图片描述
在这里插入图片描述

RabbitMq简介

在这里插入图片描述
在这里插入图片描述
JMS和AMQP的区别
在这里插入图片描述
在这里插入图片描述

RabbitMQ的概念

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
生产者和消费者都是建立在长链接上
在这里插入图片描述

docker 安装

在这里插入图片描述
下载并启动这个容器
docker run -d --name rabbitmq -p 5671:5671 -p 5672:5672 -p 4369:4369 -p 25672:25672 -p 15671:15671 -p 15672:15672 rabbitmq:management
容器自启
docker update rabbitmq --restart=always

测试使用 Exchange类型

一个交换机可以绑定很多队列，队列可以被多个交换机绑定
在这里插入图片描述
有4种类型的交换机，只学习前三种
在这里插入图片描述
直接交换机，将消息直接交给一个指定的队列，消息最终只能到达一个队列

在这里插入图片描述

广播模式交换机，不分路由键，直接把消息交给所有绑定了的队列
在这里插入图片描述
主题模式交换机，部分广播，匹配式

在这里插入图片描述
创建测试交换机
在这里插入图片描述
type：选择交换机类型
Durability：持久化和临时的，默认持久，重启虚拟机交换机不被删除
Auto delete: 是否自动删除，如果没绑定队列会自动删除
Internal：是否是内部交换机，只供内部使用的

创建一个队列

在这里插入图片描述
点进刚才创建的交换机，进行绑定

在这里插入图片描述

Direct-Exchange 测试

根据这个图创建几个交换机和队列来测试
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
发送一个测试消息
在这里插入图片描述
路由建和队列名同名
在这里插入图片描述
点进队列获取消息
在这里插入图片描述
重点：Ack Mode 消息的获取模式，Nack 获取消息后又放回了队列，可重复获取，
在这里插入图片描述
ack 自动删除，获取后消息就删除了，不会再回到队列中

Fanout-Exchange 测试

在这里插入图片描述
同样点进创建好的交换机，绑定好刚创建的4个队列

在这里插入图片描述
测试一个发送
在这里插入图片描述
发现有绑定的队列都有收到消息，这是fanout扇出交换机，不写路由建也能发给全部绑定的队列
在这里插入图片描述

Topic-Exchange 测试

创建一个测试 Topic 交换机在这里插入图片描述
区别绑定 ，atguigu开头的 绑定路由建为 atguigu.#

在这里插入图片描述
以路由建 atguigu.news发送消息
在这里插入图片描述
发现都能接受到，因为经过这个路由建匹配，所有队列都匹配上了
在这里插入图片描述
再测试，以hello.news为路由建发送消息
在这里插入图片描述
发现只有绑定关系为 *.news 的 队列收到
在这里插入图片描述

SpringBoot整合RabbitMQ

在这里插入图片描述

1、 引入springboot已经准备好的场景启动器

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

查看 RabbitAutoConfiguration 发现已经给容器中通过 @Bean自动 配置了 RabbitTemplate AmqpAdmin CachingConnectionFactory RabbitMessagingTemplate

2、 配置文件配置信息
在这里插入图片描述
3、启动类 @EnableRabbit注解开启

AmqpAdmin使用

1、如何创建 Exchange、Queue、Binding

@Autowired
AmqpAdmin amqpAdmin;

@Test
public void createExchange() {
    //String name, boolean durable, boolean autoDelete, Map<String, Object> arguments
    // durable 是否持久化
    DirectExchange directExchange = new DirectExchange("hello-java-exchange", true, false);
    amqpAdmin.declareExchange(directExchange);
    System.out.println("Exchange[hello-java-exchange]创建成功");
}

@Test
public void createQueue() {
    //String name, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
    //exclusive 排他，一条链接连上后 别人就连不上
    Queue queue = new Queue("hello-java-queue", true, false, false);
    amqpAdmin.declareQueue(queue);
    System.out.println("Queue[hello-java-queue]创建成功");
}

@Test
public void createBinding() {
    // String destination【目的地】,
    // Binding.DestinationType destinationType【目的地类型】可以指定是交换机还是队列,
    // String exchange【交换机】,
    // String routingKey【路由键】,
    // Map<String, Object> arguments【自定义参数】
    // 将exchange指定的交换机和destination目的地进行绑定，使用routeingKey作为指定的路由键
    Binding binding = new Binding("hello-java-queue",
            Binding.DestinationType.QUEUE,
            "hello-java-exchange",
            "hello.java",
            null);
    amqpAdmin.declareBinding(binding);
    System.out.println("Binding[hello-Binding]创建成功");
}

如何收发消息 RabbitTemplate使用

@Autowired
RabbitTemplate rabbitTemplate;

@Test
public void sendMessageTest() {
    MsgTest res = new MsgTest();
    res.setCreateTime(new Date());
    res.setName("哈哈");
    //1、发送消息
    rabbitTemplate.convertAndSend("hello-java-exchange", "hello.java", res);

}

对发出的对象消息，要实现序列化接口

如何让发出的对象消息是一个json
在容器放一个消息类型转换器

@Configuration
public class MyRabbitConfig {

    @Autowired
    RabbitTemplate rabbitTemplate;

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

RabbitListener&RabbitHandler接收消息

RabbitListener

在任意服务的实现中测试，监听"hello-java-queue"队列

@RabbitListener(queues = {"hello-java-queue"})
public void receiveMessage(Object message){
    System.out.println("接收到消息。。。内容："+message+"类型"+message);
}

启动服务，会自动接收到之前发送到还未消费的消息
类型为 类型class org.springframework.amqp.core.Message

也可以直接将发送出的消息的对象写在方法参数中，直接获取

    @RabbitListener(queues = {"hello-java-queue"})
    public void receiveMessages(Message message,
                               OrderEntity orderEntity) {
        byte[] body = message.getBody();
        MessageProperties properties = message.getMessageProperties();
        System.out.println("接收到消息。。。内容：" + orderEntity + "类型" + message.getClass());
    }

Queue：可以很多人都来监听。只要收到消息，队列删除消息，而且只能有一个收到此消息

场景：订单服务启动多个

复制服务，模拟启动多个相同的服务
在这里插入图片描述

//发送多条消息
@Test
public void sendMessageTest() {
    for (int i = 0; i < 10; i++) {
        OrderReturnReasonEntity reasonEntity = new OrderReturnReasonEntity();
        reasonEntity.setId(1L);
        reasonEntity.setCreateTime(new Date());
        reasonEntity.setName("哈哈"+i);
        //1、发送消息
        rabbitTemplate.convertAndSend("hello-java-exchange", "hello.java", reasonEntity);
    }
}

发现只有一个消息完全处理完，方法运行结束，我们就可以接收到下一个消息

RabbitHandler

RabbitListener ：标在类 + 方法上
RabbitHandler ：表在方法上

就可以发送不同对象，接收时就可以通过方法参数重载

@Test
public void sendMessageTest() {

    for (int i = 0; i < 10; i++) {
        if (i%2 == 0){
            OrderReturnReasonEntity reasonEntity = new OrderReturnReasonEntity();
            reasonEntity.setId(1L);
            reasonEntity.setCreateTime(new Date());
            reasonEntity.setName("哈哈"+i);
            rabbitTemplate.convertAndSend("hello-java-exchange", "hello.java", reasonEntity);
        }else {
            OrderEntity orderEntity = new OrderEntity();
            orderEntity.setOrderSn(UUID.randomUUID().toString());
            rabbitTemplate.convertAndSend("hello-java-exchange", "hello.java", orderEntity);
        }
    }

}

重载


@RabbitHandler
public void receiveMessage(Message message, OrderEntity order, Channel channel) {}

@RabbitHandler
public void receiveMessage(Message message, OrderReturnReasonEntity order, Channel channel) {}

消息确认机制

可靠投递-发送端确认

在这里插入图片描述
RabbitMq有三段确认机制
1、publisher confirmCallback
触发时机，生产者发送消息到服务器，服务器接收到消息了，如果是集群模式，需要所有broker收到

在这里插入图片描述
要使用confirmCallback ，需要定制 rabbitTemplate，在配置类中

2、publisher returnCallback

在这里插入图片描述
测试 消息抵达队列失败，最简单的错误就是 routeKing 写错了

发送时可以指定一个唯一id

//1、发送消息
rabbitTemplate.convertAndSend("hello-java-exchange", "hello22.java", orderEntity, new CorrelationData(UUID.randomUUID().toString()));

两个回调的打印

Fail message[(Body:'{"id":null,"memberId":null,"orderSn":null,"couponId":null,"createTime":null,"memberUsername":null,"totalAmount":null,"payAmount":null,"freightAmount":null,"promotionAmount":null,"integrationAmount":null,"couponAmount":null,"discountAmount":null,"payType":null,"sourceType":null,"status":null,"deliveryCompany":null,"deliverySn":null,"autoConfirmDay":null,"integration":null,"growth":null,"billType":null,"billHeader":null,"billContent":null,"billReceiverPhone":null,"billReceiverEmail":null,"receiverName":"嘿嘿","receiverPhone":null,"receiverPostCode":null,"receiverProvince":null,"receiverCity":null,"receiverRegion":null,"receiverDetailAddress":null,"note":null,"confirmStatus":null,"deleteStatus":null,"useIntegration":null,"paymentTime":null,"deliveryTime":null,"receiveTime":null,"commentTime":null,"modifyTime":null}' MessageProperties [headers={spring_returned_message_correlation=000d3613-d316-4483-abfa-6a4e611555e5, __TypeId__=com.atguigu.gulimall.order.entity.OrderEntity}, contentType=application/json, contentEncoding=UTF-8, contentLength=0, receivedDeliveryMode=PERSISTENT, priority=0, deliveryTag=0])] replyCode[312] replyText[NO_ROUTE] exchange[hello-java-exchange] routingKey[hello22.java]
confirm...correlationData[CorrelationData [id=000d3613-d316-4483-abfa-6a4e611555e5]],=>b[true],=>s[null]

两个回调的设置源码

@Configuration
public class MyRabbitConfig {
    @Autowired
    RabbitTemplate rabbitTemplate;
    /**
     * 定制 RabbitTemplate
     * 1、服务器收到消息就回调
     *      1、spring.rabbitmq.publisher-confirms=true
     *      2、设置确认回调 ConfirmCallback
     * 2、消息正确抵达队列
     *      1、spring.rabbitmq.publisher-returns=true
     *      spring.rabbitmq.template.mandatory=true
     *      2、设置确认回调 ReturnCallback
     * 3、消费端确认（保证每个消息被正确消费，此时broker才可以删除这个消息）
     *      1、默认是自动确认的，只要消息被接收到，客户端会自动确认，服务端就会移除这个消息
     *
     * @PostConstruct MyRabbitConfig对象创建完成后执行这个方法
     */
    @PostConstruct
    public void initRabbitTemplate() {
        //设置消息抵达Broker的确认回调
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            /**
             * 1、只要消息抵达Broker ack就为true 不管是否有消费者都会回调
             * @param correlationData 当前消息的唯一关联数据（这个是消息的唯一id）
             * @param ack 消息是否成功收到
             * @param cause 失败的原因
             */
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                System.out.println("confirm...correlationData[" + correlationData + "],=>b[" + ack + "],=>s[" + cause + "]");

            }
        });
        //设置消息抵达队列的确认回调
        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            /**
             * 只有消息没有投递给指定的队列，才会触发这个失败回调
             * @param message    投递失败的消息详细信息
             * @param replyCode  恢复的状态码
             * @param replyText  恢复的文本内容
             * @param exchange   当时发给哪个交换机
             * @param routingKey 当时用的路由键
             */
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                System.out.println("Fail message[" + message + "] replyCode[" + replyCode + "] replyText[" + replyText + "] exchange[" + exchange + "] routingKey[" + routingKey + "]");
            }
        });
    }
}

可靠投递-消费端确认

消费端确认（保证每个消息被正确消费，此时才可以broker删除这个消息）

测试：
发送了5个消息，队列中有5个消息待消费，debug模拟消息接收，在接收第一个消息时就将服务停止，模拟宕机，发现5个消息全部消失了。原因就是自动 ACK机制。

所以，默认是自动确认的，只要接收到消息，客户端会自动确认，服务端就会移除这个消息

为了保证消息不丢失，手动确认。
配置文件中设置为手动模式

spring.rabbitmq.listener.simple.acknowledge-mode=manual

手动确认模式下，只要我们没有明确告诉MQ，货物被签收，消息就一直是unacked状态，即使Consumer宕机，消息也不会丢失，会重新变为Ready，下次有新的Consumer链接进来就发给他

如何签收：

//这个标识 是 channel 内自增的，不会重复
long deliveryTag = message.getMessageProperties().getDeliveryTag();
// false 非批量签收
channel.basicAck(deliveryTag, false);

拒绝签收：两个方法

// long deliveryTag, 
// boolean requeue 是否批量拒收
channel.basicReject(deliveryTag, false);

//long deliveryTag, boolean multiple, 
// boolean requeue 是否重新入队
channel.basicNack(deliveryTag, false, false);

RabbitMQ 的应用

RabbitMQ延时队列

在这里插入图片描述

消息TTL就是消息的存活时间
在这里插入图片描述
TTL消息到一定时间会被服务器丢弃，也就死亡了，可以单独处理
在这里插入图片描述
死了的消息可以进入一个 路由，我们称这个路由为死信路由，是一个普通的交换机
在这里插入图片描述
流程为

一个延迟队列，该队列不能被任何人监听，待该队列消息过期后经死信路由交换机，进入到一个专门处理过期信息的队列，监听该队列的服务就可以进行处理了
在这里插入图片描述

延时队列定时关单模拟

在这里插入图片描述
创建这样一个构造关系的交换机 order-event-exchange ，该交换机绑定两个队列，连个绑定关系分别是 order.create.order 和 order.release.order ，对应的两个队列 order.delay.queue 和 order.release.order.queue 其中 order.delay.queue为延迟队列，
设置的死信交换机为 x-dead-letter-exchange:order-event-exchange 死信路由为 x-dead-letter-routing-key:order.release.order 存活时间 x-message-ttl:60000

消息的一个周期分析：

消费者下单后 产生一个延时关单信息，到 交换机 order-event-exchange 路由为order.create.order，所以消息路由到 order.delay.queue 这个延时队列，存活时间到期后，这个延时队列根据设置的 死信交换机order-event-exchange 和死信路由 order.release.order 将到期消息发送到 order.release.order.queue 队列，这个队列就有服务监听，处理这个关单信息。

在spring中可以通过往容器放@Bean的方式创建 队列和交换机，

@Configuration
public class MyMQConfig {

    @RabbitListener(queues = "order.release.order.queue")
    public void listener(OrderEntity entity, Channel channel, Message message) throws IOException {
        System.out.println("收到过期订单信息，准备关闭订单"+entity.getOrderSn());
        channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
    }


    //容器中的组建Queue Exchange Binding 都会自动创建（前提是RabbitMQ没有）
    @Bean
    public Queue orderDelayQueue() {
        // 延时队列
        // String name, boolean durable, boolean exclusive, boolean autoDelete,
        //			@Nullable Map<String, Object> arguments :
        Map<String, Object> arguments = new HashMap<>();
        arguments.put("x-dead-letter-exchange", "order-event-exchange");//死信交换机
        arguments.put("x-dead-letter-routing-key", "order.release.order");//死信路由键
        arguments.put("x-message-ttl", 60000);//消息过期时间 ms 1分钟
        return new Queue("order.delay.queue", true, false, false, arguments);
    }

    @Bean
    public Queue orderReleaseOrderQueue() {
        //普通队列，接收已经到期的延时消息
        return new Queue("order.release.order.queue", true, false, false);
    }

    @Bean
    public Exchange orderEventExchange() {

        // String name, boolean durable, boolean autoDelete, Map<String, Object> arguments
        // 普通交换机
        return new TopicExchange("order-event-exchange", true, false);
    }

    @Bean
    public Binding orderCreateOrderBinding() {

        //和延时队列绑定
        return new Binding("order.delay.queue",
                Binding.DestinationType.QUEUE,
                "order-event-exchange",
                "order.create.order",
                null);
    }

    @Bean
    public Binding orderReleaseOrderBinding() {

        //和普通队列绑定
        return new Binding("order.release.order.queue",
                Binding.DestinationType.QUEUE,
                "order-event-exchange",
                "order.release.order",
                null);
    }


}

随便写一个生产消息的方法

@Controller
public class HelloController {

    @Autowired
    RabbitTemplate rabbitTemplate;

    @ResponseBody
    @GetMapping("/test/creatPOrder")
    public String creatPOrderTest() {
        OrderEntity entity = new OrderEntity();
        entity.setOrderSn("10010");
        entity.setModifyTime(new Date());

        //给MQ发消息
        rabbitTemplate.convertAndSend("order-event-exchange", "order.create.order", entity);
        return "ok";
    }
}

创建业务交换机&队列

为锁库存业务加上延时设计
在这里插入图片描述
创建各个队列交换机绑定关系

@Configuration
public class MyRabbitConfig {

    @Autowired
    RabbitTemplate rabbitTemplate;

    @RabbitListener(queues = "stock.release.stock.queue")
    public void handle(Message message) {

    }

    /**
     * 使用JSON序列化机制，进行消息转换
     */
    @Bean
    public MessageConverter messageConverter() {
        return new Jackson2JsonMessageConverter();
    }

    @Bean
    public Exchange stockEventExchange() {
        return new TopicExchange("stock-event-exchange", true, false);
    }

    @Bean
    public Queue stockReleaseStockQueue() {
        return new Queue("stock.release.stock.queue", true, false, false);
    }

    @Bean
    public Queue stockDelayQueue() {
        //延迟队列
        Map<String, Object> arguments = new HashMap<>();
        arguments.put("x-dead-letter-exchange", "stock-event-exchange");//死信交换机
        arguments.put("x-dead-letter-routing-key", "stock.release");//死信路由
        arguments.put("x-message-ttl", 120000);//消息过期时间 ms 1分钟
        return new Queue("stock.delay.queue", true, false, false, arguments);
    }


    @Bean
    public Binding stockReleaseBinding() {

        //和延时队列绑定
        return new Binding("stock.release.stock.queue",
                Binding.DestinationType.QUEUE,
                "stock-event-exchange",
                "stock.release.#",
                null);
    }

    @Bean
    public Binding stockLockedBinding() {

        //和普通队列绑定
        return new Binding("stock.delay.queue",
                Binding.DestinationType.QUEUE,
                "stock-event-exchange",
                "stock.locked",
                null);
    }

}

监听库存解锁

库存解锁的场景
1、下单成功，订单过期没有支付系统被系统自动取消和被用户手动取消。需要解锁库存/

2、下订单成功，库存锁定成功接下来的业务调用失败，导致订单回滚，之前锁定的库存就要自动解锁。

库存服务中，确认商品库存成功后，锁定这个商品的库存，发送延时队列的消息，同时在mysql中保存这次锁单的详情，wms_ware_order_task表保存这次锁单的详情，对应此表的子表wms_ware_order_task_detail 保存此次锁单中的各个商品

库存解锁逻辑

监听释放了的消息，结合存入mysql的锁单详情。

记录一个报错

Caused by: org.springframework.web.client.RestClientException: Could not extract response: no suitable HttpMessageConverter found for response type [class com.atguigu.common.utils.R] and content type [text/html;charset=UTF-8]

无法返回一个页面，因为远程调用订单服务的请求，被订单服务的拦截器拦截，跳转至了登陆页面，所以R对象无法返回一个页面
解决办法，在订单服务的拦截器中，获取一个匹配路径，放行指定匹配路径的请求，不做拦截

String uri = request.getRequestURI();
boolean match = new AntPathMatcher().match("/order/order/status/**", uri);

if (match){
    return true;
}

定时关单完成

消息丢失、积压、重复解决方案

在这里插入图片描述

try {
    //TODO 保证消息一定发送出去，每一个消息都可以做一个日志记录（给数据库保存每一个消息的详细信息）
    //定期扫描数据库将失败的信息再发一次
    rabbitTemplate.convertAndSend("order-event-exchange","order.release.other",orderEntity);
}catch (Exception e){
    //TODO 将没发送成功的消息进行重试发送
}

1、做好消息确认机制（publisher、consumer【手动ack】）
2、每一个发送的消息都在数据库做好记录。定期将失败的消息再发送一遍

在这里插入图片描述
在这里插入图片描述

end

朱阿朱
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
利用Python学习RabbitMQ消息队列
12-23
RabbitMQ可以当做一个消息代理，它的核心原理非常简单：即接收和发送消息，可以把它想象成一个邮局：我们把信件放入邮箱，邮递员就会把信件投递到你的收件人处，RabbitMQ就是一个邮箱、邮局、投递员功能综合体，整个...
Spring学习笔记3之消息队列(rabbitmq)发送邮件功能
09-01
RabbitMQ是一个开源的消息代理和队列服务器，它基于AMQP（Advanced Message Queuing Protocol）协议工作，提供了可靠且可扩展的消息传递能力。 首先，我们了解RabbitMQ的基本概念： 1. **MQ全称Message Queue**，...
RabbitMQ学习(五)-RabbitMQ的应用
qq_44128703的博客
06-14 100
title: RabbitMQ学习(五)-RabbitMQ的应用 date: 2021-1-13 tags:将之前的 spring boot 整合 ElasticSearch 的项目再整合上 RabbitMQ。 1.2 编写配置文件 1.3 编写配置类 1.4 修改 Service 层 从之前通过 RestTemplate 传递信息，变为 通过 RabbitMQ 传递消息。 二、修改 search 模块 2.1 导入相关依赖 同上。同上。同上。添加一个将 json 转为对象的静态方法。.........
消息队列MQ
weixin_43051445的博客
03-31 245
1.RabbitMQ 1.2.消息队列（MQ） 1.2.1.什么是消息队列 消息队列，即MQ，Message Queue。 消息队列是典型的：生产者、消费者模型。生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入，这样就实现了生产者和消费者的解耦。 结合前面所说的问题： 商品服务对商品增删改以后，无需去操...
消息队列RabbitMQ入门与使用
skLit8的博客
10-26 698
队列的主要作用是消除高并发访问高峰，加快网站的响应速度。在不使用消息队列的情况下，用户的请求数据直接写入数据库，在高并发的情况下，会对数据库造成巨大的压力，同时也使得系统响应延迟加剧。
学习笔记：分布式消息队列RabbitMQ
最新发布
qq_45867699的博客
08-02 354
简单模式 HelloWorld：一个生产者、一个消费者，不需要设置交换机（使用默认的交换机）。工作队列模式 Work Queue：一个生产者、多个消费者（竞争关系），不需要设置交换机（使用默认的交换机）。发布订阅模式 Publish/Subscribe：需要设置类型为 fanout 的交换机，并且交换机和队列进行绑定，当发送消息到交换机后，交换机会将消息发送到绑定的队列。
干货！消息队列RabbitMQ入门教程
luostudent的博客
11-01 2036
​写在前面：全文12000多字，从为什么需要用消息队列，到rabbitMQ安装使用，如何使用JavaAPI生产消费消息，以及使用消息队列带来的一些常见问题。绝对很适合新手入门学习。 为什么需要消息队列 异步处理 削峰限流 秒杀活动，一般会因为流量过大，导致应用挂掉。加入消息队列可控制活动人数，缓解短时间的高流量。 应用解耦 双十一购物节，订单系统需要通知库存系统，传统做法是订单系统直接调用库存系统的接口，库存系统出现故障时订单就会失败。可在订单系统和库存系统中间加一个..
Windows 10 - Python 消息队列 RabbitMQ 学习总结 1
Muxiu
03-11 519
目录消息队列的基本知识概述什么是消息队列？为何要使用消息队列的原因？理解消息队列服务器和 Web 服务器的关系题外：关于服务端和客户端的企业级理解了解 Web 服务器了解 Web 框架和 Web 服务的区别对于框架和服务器B/S架构消息队列的个人理解：浏览器 B/S 架构的业务逻辑个人理解： 消息队列的基本知识概述 什么是消息队列？ 消息（Message）是指在应用间传送的数据。消息可以非常简单，比如只包含文本字符串，也可以更复杂，可能包含嵌入对象。 消息队列（Message Queue —— MQ）是一
消息队列(RabbitMQ&&Kafka)
Abner's Technology Blog
02-25 1860
主流的消息中间件】RabbitMQ、Kafka、ActiveMQ、RocketMQ RabbitMQ中的生产者和消费者】Producer：生产者，就是投递消息的一方，生产者创建消息，然后发布到 RabbitMQ 中。Consumer：消费者，就是接收消息的一方。消费者连接到 RabbitMQ 服务器，并订阅到队列上。当消费者消费一条消息时，只是消费消息的消息体（payload）。在消息路由的过程中，消息的标签会丢弃，存入到队列中的消息只有消息体，消费者也只会消费到消息体，也就不知道消息的生产者是谁，当然消费
消息队列 RabbitMQ学习
qq_40180411的博客
07-23 161
什么叫消息队列 消息（Message）是指在应用间传送的数据。消息可以非常简单，比如只包含文本字符串，也可以更复杂，可能包含嵌入对象。 消息队列（Message Queue）是一种应用间的通信方式，消息发送后可以立即返回，由消息系统来确保消息的可靠传递。消息发布者只管把消息发布到 MQ 中而不用管谁来取，消息使用者只管从 MQ 中取消息而不管是谁发布的。这样发布者和使用者都不用知道对方的存在。 为何用消息队列 从上面的描述中可以看出消息队列是一种应用间的异步协作机制，那什么时候需要使用 MQ 呢？
RabbitMQ消息队列__学习报告
weixin_70228478的博客
10-26 3523
（1）（开发者）查看所有的队列：rabbitmqctl list_queues（2）（开发者）清除所有的队列：rabbitmqctl reset（3）添加用户：rabbitmqctl add_user username password（4）分配角色：rabbitmqctl set_user_tags username administrator（5）新增虚拟主机：rabbitmqctl add_vhost vhost_name。
消息队列 rabbitmq 学习
hj1993的博客
03-04 529
RabbitMQ是一个在AMQP基础上完整的，可复用的企业消息系统。他遵循Mozilla Public License开源协议。MQ全称为Message Queue, 消息队列（MQ）是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息（针对应用程序的数据）来通信，而无需专用连接来链接它们。消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是用于诸如远程过程调用的技术。排队指的是应用程序通过队列来通信。
Spring boot整合消息队列RabbitMQ实现四种消息模式（适合新手或者开发人员了解学习RabbitMQ机制）
06-27
在业务逻辑的异步处理，系统解耦，分布式通信以及控制高并发的场景下，消息队列有着广泛的应用。本项目基于Spring的AMQP模块，整合流行的开源消息...AMQP作为比JMS更加高级的消息协议，支持更多的消息路由和消息模式。
Rabbitmq企业级消息队列课程MP4
12-06
Rabbitmq企业级的消息服务系统,可以在应用间收发消息,本课程主要学习了 Rabbitmq 环境搭建以及常见几种方式的消息的发送接收。 ( o) E% U' d/ h7 x2 r 『课程目录』: 1、Rabbitmq介绍 2、Rabbitmq安装' U5 x- p7 M...
rabbitmq学习资料
01-30
【RabbitMQ 学习资料】这篇文档是针对初学者准备的，主要涵盖了RabbitMQ的基本概念、消息队列的工作原理、AMQP和JMS的区别、常见消息中间件的对比，以及RabbitMQ的安装与配置，还有其提供的Web管理界面和基本功能。...
云原生Java架构实战 K8s+Docker+KubeSphere+DevOps（上）
real_rookie的博客
10-26 4017
云原生Java架构 K8s+Docker+KubeSphere+DevOps云平台私有网络VPCVPC的子网计算VPC的交换机重要概念容器化docker概念青云服务器centos安装dockerdocker实战docker进阶部署redis创建Java应用Kubernetes基础概念简介集群的方式end 简介：摘自 尚硅谷雷锋阳老师的语雀文档 云平台 学会使用按量付费的云服务器，开发测试性价比高 私有网络VPC 和网络有关的概念，如何在云服务器开通一个集群 一个云服务器有两个IP：公网IP和私网IP 公网I
云原生Java架构实战 K8s+Docker+KubeSphere+DevOps（中）
real_rookie的博客
10-29 1941
云原生Java架构实战 K8s+Docker+KubeSphere+DevOps（下）KubeSphere平台安装简介Kubernetes上安装KubeSphereend KubeSphere 平台安装 简介 Kubernetes上安装KubeSphere 安装步骤 选择4核8G（master）、8核16G（node1）、8核16G（node2） 三台机器，按量付费进行实验，CentOS7.9 安装Docker 安装Kubernetes 安装KubeSphere前置环境 安装KubeSphere 1、
谷粒商城分布式基础篇
real_rookie的博客
07-29 1504
文章目录简介环境使用vagrant快速创建linux虚拟机虚拟机网络设置linux安装docker配置docker阿里云镜像加速docker安装MySQLdocker安装redis开发工具&环境安装配置配置git-ssh项目结构创建&提交到码云数据库初始化快速开发人人开源搭建后台管理系统 简介 环境 使用vagrant快速创建linux虚拟机 使用virtualbox 6.0 使用vagrant 2.2.5 cmd窗口 vagrant 初始化 centos vagrant ini
云原生Java架构实战 K8s+Docker+KubeSphere+DevOps（下）
real_rookie的博客
11-04 1376
云原生Java架构实战 K8s+Docker+KubeSphere+DevOps（下）应用部署实战ruo-yi-cloud本地环境nacos启动导入ruoyi数据库ruo-yi-cloud上云end 应用部署实战 ruo-yi-cloud 1、项目 https://gitee.com/y_project/RuoYi-Cloud 2、架构 下载项目 本地环境nacos启动 单机模式mysql启动nacos，nacos conf/application.properties配置文件添加如下配置，并运行目录下的
rabbitmq实战 高效部署分布式消息队列 pdf
08-01
《RabbitMQ实战：高效部署分布式消息队列》是一本介绍RabbitMQ的实用指南，旨在帮助读者了解如何高效地部署和使用分布式消息队列。 本书详细介绍了RabbitMQ的基本概念和架构，从安装和配置开始，一步步引导读者了解各种高效的部署和使用方法。书中重点介绍了如何构建高可用的消息队列集群，如何实现消息的可靠传递和消费者的动态扩展。同时，还涵盖了消息队列的监控和性能优化的内容。 本书不仅提供了丰富的理论知识，而且通过实际案例和示例代码，帮助读者深入了解如何在实践中应用RabbitMQ。读者可以学习如何使用RabbitMQ处理不同类型的消息，如何使用RabbitMQ实现异步通信和发布订阅模式，以及如何与其他技术栈进行集成。 《RabbitMQ实战：高效部署分布式消息队列》还介绍了RabbitMQ的实际应用场景，如电商订单系统和日志处理系统等。读者可以通过这些实例了解如何在真实项目中应用RabbitMQ解决实际问题。 总之，这本书是一本针对RabbitMQ的实用指南，适合想要学习和应用分布式消息队列的读者。通过阅读本书，读者可以深入了解RabbitMQ的各种特性和用法，掌握如何高效地部署和使用分布式消息队列。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值