黑马商城（六）RabbitMQ

最新推荐文章于 2025-04-25 11:12:59 发布
最新推荐文章于 2025-04-25 11:12:59 发布
阅读量337 收藏 5
点赞数 7
文章标签： rabbitmq 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DDDiccc/article/details/147379995
版权

一、同步调用

二、异步调用

三、MQ技术选型

快速Docker部署：

docker run \
 -e RABBITMQ_DEFAULT_USER=itheima \
 -e RABBITMQ_DEFAULT_PASS=123321 \
 -v mq-plugins:/plugins \
 --name mq \
 --hostname mq \
 -p 15672:15672 \
 -p 5672:5672 \
 --network hmall\
 -d \
 rabbitmq:3.8-management

RabbitMQ：

数据隔离： 

案例：

 快速入门（实现基于MQ收发消息）：

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

spring:
  rabbitmq:
    host: 192.168.50.129 # 你的虚拟机IP
    port: 5672 # 端口
    virtual-host: /hmall # 虚拟主机
    username: hmall # 用户名
    password: 123 # 密码

Work Queues:

案例：

构造了两个方法模拟两个消费者

package com.itheima.consumer.mq;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

@Slf4j
@Component
public class SpringRabbitListener {

    @RabbitListener(queues = "work.queue")
    public void listenWorkQueue1(String message){
        System.out.println("消费者1接收到消息： "+message+ ","+ LocalDateTime.now());
    }

    @RabbitListener(queues = "work.queue")
    public void listenWorkQueue2(String message){
        System.err.println("消费者2......接收到消息： "+message+ ","+ LocalDateTime.now());
    }


}

package com.itheima.publisher;

import org.junit.jupiter.api.Test;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class SpringAmqpTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testWorkQueue(){
        //1.队列名
        String queueName="work.queue";
        //2.消息
        for (int i=1;i<=50;i++){
            String message="hello.spring amqp_"+i;
            //3.发送消息
            rabbitTemplate.convertAndSend(queueName,message);
        }
    }
}

    @RabbitListener(queues = "work.queue")
    public void listenWorkQueue1(String message) throws InterruptedException {
        System.out.println("消费者1接收到消息： "+message+ ","+ LocalDateTime.now());
        Thread.sleep(25);
    }

    @RabbitListener(queues = "work.queue")
    public void listenWorkQueue2(String message) throws InterruptedException {
        System.err.println("消费者2......接收到消息： "+message+ ","+ LocalDateTime.now());
        Thread.sleep(200);
    }

默认性能不影响分配规则

交换机：

Fanout交换机：

 案例：

    @Test
    public void testFanoutQueue(){
        //1.交换机名
        String exName="hmall.fanout";
        //2.消息
        String message="hello.everyone!";
        //3.发送消息
        rabbitTemplate.convertAndSend(exName,null,message);
    }
    @RabbitListener(queues = "fanout.queue1")
    public void listenFanoutQueue1(String message){
        log.info("消费者1监听到fanout.queue1的消息：{}",message);
    }

    @RabbitListener(queues = "fanout.queue2")
    public void listenFanoutQueue2(String message){
        log.info("消费者2监听到fanout.queue2的消息：{}",message);
    }

Direct交换机：

案例：

    @RabbitListener(queues = "direct.queue1")
    public void listenDirectQueue1(String message){
        log.info("消费者1监听到direct.queue1的消息：{}",message);
    }

    @RabbitListener(queues = "direct.queue2")
    public void listenDirectQueue2(String message){
        log.info("消费者2监听到 direct.queue2的消息：{}",message);
    }
    @Test
    public void testDirectQueue(){
        //1.交换机名
        String exName="hmall.direct";
        //2.消息
        String message="hello.yellow!";
        //3.发送消息
        rabbitTemplate.convertAndSend(exName,"yellow",message);
    }

Topic交换机：

案例：
    @Test
    public void testTopicQueue(){
        //1.交换机名
        String exName="hmall.topic";
        //2.消息
        String message="天气不错";
        //3.发送消息
        rabbitTemplate.convertAndSend(exName,"china.weather",message);
    }

声明队列交换机： 

package com.itheima.consumer.Config;

import com.rabbitmq.client.AMQP;
import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FanoutConfiguration {
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("hmall.fanout");
       /* return ExchangeBuilder.fanoutExchange("hamll.fanout").build();*/
    }
    @Bean
    public Queue fanoutQueue1(){
        return QueueBuilder.durable("fanout.queue1").build();
        /*return new Queue("fanout.queue1");*/
    }

    @Bean
    public Binding fanoutQueue1Binding(Queue fanoutQueue1,FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
    }

    @Bean
    public Queue fanoutQueue2(){
        return QueueBuilder.durable("fanout.queue2").build();
    }

    @Bean
    public Binding fanoutQueue2Binding(Queue fanoutQueue2,FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
    }

}
案例：

法一：
package com.itheima.consumer.Config;

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

@Configuration
public class DirectConfiguration {
    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange("hmall.direct");
       /* return ExchangeBuilder.fanoutExchange("hamll.direct").build();*/
    }
    @Bean
    public Queue directQueue1(){
        return QueueBuilder.durable("direct.queue1").build();
        /*return new Queue("direct.queue1");*/
    }

    //Direct交换机的Key每次只能绑定一个Key
    @Bean
    public Binding directQueue1BindingRed(Queue directQueue1,DirectExchange directExchange){
        return BindingBuilder.bind(directQueue1).to(directExchange).with("red");
    }
    @Bean
    public Binding directQueue1BindingBlue(Queue directQueue1,DirectExchange directExchange){
        return BindingBuilder.bind(directQueue1).to(directExchange).with("blue");
    }

    @Bean
    public Queue directQueue2(){
        return QueueBuilder.durable("direct.queue2").build();
        /*return new Queue("direct.queue1");*/
    }

    //Direct交换机的Key每次只能绑定一个Key
    @Bean
    public Binding directQueue2BindingRed(Queue directQueue2,DirectExchange directExchange){
        return BindingBuilder.bind(directQueue2).to(directExchange).with("red");
    }
    @Bean
    public Binding directQueue2BindingYellow(Queue directQueue2,DirectExchange directExchange){
        return BindingBuilder.bind(directQueue2).to(directExchange).with("yellow");
    }
}
法二（基于注解）：

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue1",durable = "true"),
            exchange = @Exchange(name = "hmall.direct",type = ExchangeTypes.DIRECT),
            key = {"red","blue"}
    ))
    /*@RabbitListener(queues = "direct.queue1")*/
    public void listenDirectQueue1(String message){
        log.info("消费者1监听到direct.queue1的消息：{}",message);
    }

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue2",durable = "true"),
            exchange = @Exchange(name = "hmall.direct",type = ExchangeTypes.DIRECT),
            key = {"red","yellow"}
    ))
    /*@RabbitListener(queues = "direct.queue2")*/
    public void listenDirectQueue2(String message){
        log.info("消费者2监听到 direct.queue2的消息：{}",message);
    }

消息转换器：

案例：

package com.itheima.publisher.config;

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 MessageConverterConfiguration {

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


    @RabbitListener(queues = "object.queue")
    public void listenObjectQueue(Map<String,Object> message){
        log.info("消费者2监听到 direct.queue2的消息：{}",message);
    }

四、业务改造

配置依赖：

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

配置yaml文件：

spring:
  rabbitmq:
    host: 192.168.50.129 # 你的虚拟机IP
    port: 5672 # 端口
    virtual-host: /hmall # 虚拟主机
    username: hmall # 用户名
    password: 123 # 密码

在Common中配置一个Json消息转换器：

package com.hmall.common.config;

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 MqConfig {
    @Bean
    public MessageConverter messageConverter(){
        return new Jackson2JsonMessageConverter();
    }
}

交易微服务中置消费者 Consumer--Listener（监听）：

package com.hmall.trade.listener;

import com.hmall.trade.service.IOrderService;
import lombok.RequiredArgsConstructor;
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
@RequiredArgsConstructor
public class PayStatusListener {

    private final IOrderService orderService;
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "trade.pay.success.queue",durable = "true"),
            exchange = @Exchange(name = "pay.direct",type = ExchangeTypes.DIRECT),
            key = {"pay.success"}
    ))
    public void listenPaySuccess(Long orderId){
        orderService.markOrderPaySuccess(orderId);
    }

}

 支付微服务中设置Publisher--基于MQ发送消息：

注入 RabbitTemplate  来实现

    private final RabbitTemplate rabbitTemplate;   

    @Override
    @Transactional
    public void tryPayOrderByBalance(PayOrderFormDTO payOrderFormDTO) {
        // 1.查询支付单
        PayOrder po = getById(payOrderFormDTO.getId());
        // 2.判断状态
        if(!PayStatus.WAIT_BUYER_PAY.equalsValue(po.getStatus())){
            // 订单不是未支付，状态异常
            throw new BizIllegalException("交易已支付或关闭！");
        }
        // 3.尝试扣减余额
        /*userService.deductMoney(payOrderFormDTO.getPw(), po.getAmount());*/
        userClient.deductMoney(payOrderFormDTO.getPw(), po.getAmount());
        // 4.修改支付单状态
        boolean success = markPayOrderSuccess(payOrderFormDTO.getId(), LocalDateTime.now());
        if (!success) {
            throw new BizIllegalException("交易已支付或关闭！");
        }
        //5.修改订单状态

        //异步通知
        try {
            rabbitTemplate.convertAndSend("pay.direct","pay.success",po.getBizOrderNo());
        } catch (Exception e) {
            log.error("发送支付状态通知失败，订单id：{}",po.getBizOrderNo(),e);
            //兜底方案
        }
    }

DDDiccc
关注
【黑马点评】 使用RabbitMQ实现消息队列——2.使用RabbitMQ监听秒杀下单
m0_52031708的博客
10-06 3304
黑马点评之使用RabbitMQ实现消息队列
【黑马点评优化】 使用RabbitMQ实现消息队列——1.Docker与RabbitMQ环境安装
m0_52031708的博客
10-06 2682
黑马点评中使用RabbitMQ实现消息队列
黑马商城：RabbitMQ基础
weixin_49007640的博客
12-30 1593
黑马商城：RabbitMQ基础
RabbitMQ笔记-黑马
小赵的博客
04-29 997
建立connection创建channel利用channel声明队列利用channel向队列发送消息建立connection创建channel利用channel声明队列定义consumer的消费行为handleDelivery()利用channel将消费者与队列绑定多个消费者绑定到一个队列，同一条消息只会被一个消费者处理通过设置prefetch来控制消费者预取的消息数量交换机的作用是什么？接收publisher发送的消息将消息按照规则路由到与之绑定的队列。
黑马点评day4：使用RabbitMQ实现消息队列
2302_80981029的博客
03-04 2166
使用RabbitMQ实现黑马点评中的消息队列
RabbitMQ 高级篇 | 黑马
weixin_54232666的博客
04-12 902
RabbitMQ高级篇，包括消息可靠性投递和确认、限流、TTL、死信队列、延迟队列、优先级队列、惰性队列，这一篇就够了！
【黑马RabbitMQ】MQ基础
thorandloki的博客
12-05 1871
MQ提供接受消息、存储消息、发送消息的功能。
黑马 RabbitMQ 学习笔记
Marain123的博客
05-21 1378
MQ 概述： MQ 全称 message queue (消息队列) ，是在消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信。 MQ 消息队列，存储消息的中间件 分布式系统的通信两种方式：直接远程调用和借助第三方完成间接通信 发送方称为生产者，接收放称为消费者 MQ 优势和劣势 优势： 应用解耦 异步提速 削峰填谷 劣势： 系统可用性降低：系统引入的外部系统越多，系统稳定性越差。一旦MQ 宕机，就会对业务造...
RabbitMQ 基础篇 | 黑马
weixin_54232666的博客
04-10 1176
黑马课程学习笔记，一篇彻底入门RabbitMQ，MQ的基本概念和工作模式和springboot整合rabbitMQ的用法。这一篇就够了！
黑马商城docker镜像rabbitmq资源
08-09
黑马商城docker镜像rabbitmq资源
SpringCloud黑马商城后端代码
05-16
《SpringCloud黑马商城后端代码详解》 在现代互联网应用开发中，微服务架构成为了一种主流设计模式，Spring Cloud作为Java领域的微服务治理框架，因其强大的功能和易用性，受到了广大开发者们的青睐。本篇文章将...
RabbitMQ-黑马
06-17
### RabbitMQ 黑马教程知识点总结 #### 一、引言 在分布式系统设计中，服务间的通信方式至关重要。传统的同步通信方式虽然直观且易于理解，但存在诸多限制，如扩展性不足、性能瓶颈以及级联失败等问题。本文将详细...
黑马商城项目—最新SpringCloud开发实战—功能实现详细学习笔记（RabbitMQ篇）
weixin_43982558的博客
09-01 2155
2024黑马商城项目RabbitMQ篇
处理任务“无需等待”：集成RabbitMQ实现异步通信与系统解耦
pjx987的博客
04-24 795
虽然RabbitTemplate和@RabbitListener在某些配置下可以自动创建队列，但在生产环境中，推荐显式地声明所需的队列、交换机和绑定。这能确保基础设施的存在，避免因自动创建的不可靠性导致问题，并且使配置更清晰。// 导入核心类// --- 声明欢迎邮件队列 ---@Bean// durable(true) 持久化队列 (RabbitMQ重启后依然存在)// --- (可选) 如果不使用默认交换机, 可以声明一个交换机 ---
RabbitMQ和Seata冲突吗？Seata与Spring中的事务管理冲突吗
m0_73889530的博客
04-20 1283
答：不冲突，它们可以协同工作，但作用域不同。如何协同？ Seata AT 模式下的分支事务实际上是基于本地事务的。当 存在时，Seata 会拦截 管理的本地事务的提交/回滚。结论：同时使用两者是常见且必要的。 保证本地操作的原子性，而 则将这种原子性扩展到分布式环境下的多个参与者。答：冲突！在期望跨服务数据库原子性的场景下，同步调用 Seata AT 模式和异步发送 RabbitMQ 消息是矛盾的。Seata AT 模式的局限性: Seata AT 模式主要设计用于同步调用场景下的数据库操作。它无法管
【MQ篇】RabbitMQ初体验！
qq_56158663的博客
04-22 1051
想象一下，你有很多信件（数据），需要寄给不同的朋友（应用程序）。如果让你一只一只地跑去送，那可真是累死个人！😩 这时候，RabbitMQ这只神奇的兔子就出现了。✨你可以把所有的信件都交给这只兔子，它会根据你事先设定的规则（路由），把信件准确无误地送到对应的朋友手中。这只兔子非常勤劳，不知疲倦，而且效率极高，能同时处理大量的信件。💨所以，简单来说，RabbitMQ就是一个消息队列中间件。它就像一个邮局或者一个快递公司，负责接收、存储和转发消息（数据）。
RabbitMQ 基础概念（队列、交换机、路由键、绑定键、信道、连接、虚拟主机、多租户）介绍
青灯文案的博客
04-23 656
本文是博主在梳理 RabbitMQ 知识的过程中，将所遇到和可能会遇到的基础知识记录下来，用作梳理 RabbitMQ 的整体架构和功能的线索文章，通过查找对应的知识能够快速的了解对应的知识而解决相应的问题。
【MQ篇】RabbitMQ之消息持久化！
最新发布
qq_56158663的博客
04-25 616
你想想，咱们电脑里的数据，要么放在内存里（速度快，但关机就没），要么存在硬盘上（速度慢点，但断电还在）。但如果 RabbitMQ 服务器突然“打个盹”😴 或者“哎呀，摔了一跤”💥（宕机或重启），内存里的东西就“唰”地一下都没了！，你就给这个队列上了把“锁” 🔒，告诉 RabbitMQ：“这个信箱要钉死在这儿，重启了也得给我留着！通过这个实验，你就能亲眼看到“持久化”的神奇力量：它让你的重要消息熬过了服务器的重启！
黑马springboot整合rabbitmq看不见队列
08-04
根据提供的引用内容，黑马springboot整合rabbitmq看不见队列的问题可能是由于以下原因导致的： 1. 配置错误：在引用[2]和引用[3]中，可以看到配置了rabbitmq的相关信息，包括主机、端口、用户名和密码等。请确保这些配置与实际的rabbitmq服务器信息一致。 2. 依赖缺失：根据引用[2]和引用[3]中的代码片段，可以看到项目中使用了spring-boot-starter-amqp依赖来集成rabbitmq。请确保该依赖已正确添加到项目的依赖管理文件中。 3. 队列未声明：在rabbitmq中，队列需要先进行声明才能被使用。请确保在代码中正确声明了需要使用的队列，并且声明的队列与实际需要使用的队列名称一致。 4. 权限问题：请确保在rabbitmq服务器上配置了正确的权限，以允许项目使用指定的用户名和密码进行连接和操作。 综上所述，如果黑马springboot整合rabbitmq看不见队列，可以检查配置是否正确、依赖是否添加、队列是否正确声明以及权限是否设置正确。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值