【学相伴】狂神说 RabbitMQ快速入门笔记（简单使用RabbitMQ）SpringBoot整和RabbitMQ

最新推荐文章于 2023-01-11 18:45:38 发布
最新推荐文章于 2023-01-11 18:45:38 发布
阅读量967 收藏
点赞数
分类专栏： RabbitMQ 文章标签： java-rabbitmq rabbitmq spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59823583/article/details/126772783
版权

文章目录

SpringBoot整合RabbitMQ

由于我们做项目基于Springboot开发，因此我们这里主要进行Springboot配置开发

在这里插入图片描述

YML配置

server:
  port: 8081
spring:
  rabbitmq:
    username: sakura
    password: 123456
    virtual-host: /
    host: 192.168.117.129
    port: 5672

Config配置类

我们需要一个配置类，声明我们的交换机和队列，需要注册进容器里面

  • 1.声明一个注册交换机FanoutExchange交换机
  • 2.声明一个队列EmailQueue
  • 3.进行队列和交换机进行
@Configuration
public class RabbitMqConfiguration {
    //1. 声明注册fanout模式的交换机
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange("fanout-order-exchange", true, false);
    }
    //2. 声明队列duanxinqueue smsqueue emailqueue
    @Bean
    public Queue emailQueue() {
        return new Queue("email.fanout.queue", true);
    }
    @Bean
    public Queue smsQueue() {
        return new Queue("sms.fanout.queue", true);
    }
    @Bean
    public Queue weixinQueue() {
        return new Queue("weixin.fanout.queue", true);
    }
    //3. 绑定关系
    @Bean
    public Binding emailBinding() {
        return BindingBuilder.bind(emailQueue()).to(fanoutExchange());
    }
    @Bean
    public Binding smsBinding() {
        return BindingBuilder.bind(smsQueue()).to(fanoutExchange());
    }
    @Bean
    public Binding weixinBinding() {
        return BindingBuilder.bind(weixinQueue()).to(fanoutExchange());
    }
}

上述的队列名，交换机名，我们可以定义一个类，声明为常量或者就在RabbitMQ里面创建的exchange或者queue

2.service类

@Service
public class OrderService {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    public void makeOrder(String userId, String productId, int num) {
        String orderId = UUID.randomUUID().toString();
        System.out.println("订单创建成功：" + orderId);
        String exchangeName = "fanout-order-exchange";
        String routingKey = "";
        /*
         * @params1 交换机
         * @params2 routingKey/队列名称
         * @params3 消息内容
         * */
        rabbitTemplate.convertAndSend(exchangeName, routingKey, orderId);
    }
}

3.测试类

@SpringBootTest
class SpringbootOrderRabbitmqProducerApplicationTests {
    @Autowired
    private OrderService orderService;
    @Test
    void contextLoads() throws InterruptedException{
        orderService.makeOrder("1","1",12);
    }
}

二、进行消费者接受信息

2.1yml文件

server:
  port: 8082
spring:
  rabbitmq:
    username: sakura
    password: 123456
    virtual-host: /
    host: 192.168.117.129
    port: 5672

2.2 配置类

@Configuration
public class DirectRabbitMqConfiguration {
    //1. 声明注册fanout模式的交换机
    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange("direct-order-exchange", true, false);
    }
    //2. 声明队列
    @Bean
    public Queue emailQueueDirect() {
        return new Queue("email.direct.queue", true);
    }
    @Bean
    public Queue smsQueueDirect() {
        return new Queue("sms.direct.queue", true);
    }
    @Bean
    public Queue weixinQueueDirect() {
        return new Queue("weixin.direct.queue", true);
    }
    //3. 绑定关系
    @Bean
    public Binding emailBindingDirect() {
        return BindingBuilder.bind(emailQueueDirect()).to(directExchange()).with("email");
    }
    @Bean
    public Binding smsBindingDirect() {
        return BindingBuilder.bind(smsQueueDirect()).to(directExchange()).with("sms");
    }
    @Bean
    public Binding weixinBindingDirect() {
        return BindingBuilder.bind(weixinQueueDirect()).to(directExchange()).with("weixin");
    }
}

3.FanoutConsumer…多个消费者

@Component
@RabbitListener(queues = {"email.fanout.queue"})
public class FanoutEmailConsumer {
    @RabbitHandler
    public void receiveMessage(String message) {
        System.out.println("email.queue--接收到了消息是：" + message);
    }
}

FanoutSMSConsumer：

@Component
@RabbitListener(queues = {"sms.fanout.queue"})
public class FanoutSMSConsumer {
    @RabbitHandler
    public void receiveMessage(String message) {
        System.out.println("sms.queue--接收到了消息是：" + message);
    }
}

FanoutSMSConsumer：

@Component
@RabbitListener(queues = {"sms.fanout.queue"})
public class FanoutSMSConsumer {
    @RabbitHandler
    public void receiveMessage(String message) {
        System.out.println("sms.queue--接收到了消息是：" + message);
    }
}

FanoutWeiXinConsumer：

@Component
@RabbitListener(queues = {"weixin.fanout.queue"})
public class WeiXinConsumer {
    @RabbitHandler
    public void receiveMessage(String message) {
        System.out.println("weixin.queue--接收到了消息是：" + message);
    }
}

这样每个消费者类都监听了对应的队列，都可以同步收到信息

DIRECT模式

3.1配置类

@Configuration
public class DirectRabbitMqConfiguration {
    //1. 声明注册fanout模式的交换机
    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange("direct-order-exchange", true, false);
    }
    //2. 声明队列
    @Bean
    public Queue emailQueueDirect() {
        return new Queue("email.direct.queue", true);
    }
    @Bean
    public Queue smsQueueDirect() {
        return new Queue("sms.direct.queue", true);
    }
    @Bean
    public Queue weixinQueueDirect() {
        return new Queue("weixin.direct.queue", true);
    }
    //3. 绑定关系
    @Bean
    public Binding emailBindingDirect() {
        return BindingBuilder.bind(emailQueueDirect()).to(directExchange()).with("email");
    }
    @Bean
    public Binding smsBindingDirect() {
        return BindingBuilder.bind(smsQueueDirect()).to(directExchange()).with("sms");
    }
    @Bean
    public Binding weixinBindingDirect() {
        return BindingBuilder.bind(weixinQueueDirect()).to(directExchange()).with("weixin");
    }
}

3.2service:

   public void makeOrderDirect(String userId, String productId, int num) {
        String orderId = UUID.randomUUID().toString();
        System.out.println("订单创建成功：" + orderId);
        String exchangeName = "direct-order-exchange";
        /*
         * @params1 交换机
         * @params2 routingKey/队列名称
         * @params3 消息内容
         * */
        rabbitTemplate.convertAndSend(exchangeName, "email", orderId);
        rabbitTemplate.convertAndSend(exchangeName, "weixin", orderId);
    }

3.3test类

    @Test
    void contextLoadsDirect() throws InterruptedException{
        orderService.makeOrderDirect("1","1",12);
    }

消费者：
DirectEmailConsumer

@Component
@RabbitListener(queues = {"email.direct.queue"})
public class DirectEmailConsumer {
    @RabbitHandler
    public void receiveMessage(String message) {
        System.out.println("email.queue--接收到了消息是：" + message);
    }
}

DirectSMSConsumer

@Component
@RabbitListener(queues = {"sms.direct.queue"})
public class DirectSMSConsumer {
    @RabbitHandler
    public void receiveMessage(String message) {
        System.out.println("sms.queue--接收到了消息是：" + message);
    }
}

ES中使用MQ来进行消息查询转发的情况

1）引入依赖

在hotel-admin、hotel-demo中引入rabbitmq的依赖：

<!--amqp-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
2）声明队列交换机名称

在hotel-admin和hotel-demo中的cn.itcast.hotel.constatnts包下新建一个类MqConstants：

package cn.itcast.hotel.constatnts;

    public class MqConstants {
    /**
     * 交换机
     */
    public final static String HOTEL_EXCHANGE = "hotel.topic";
    /**
     * 监听新增和修改的队列
     */
    public final static String HOTEL_INSERT_QUEUE = "hotel.insert.queue";
    /**
     * 监听删除的队列
     */
    public final static String HOTEL_DELETE_QUEUE = "hotel.delete.queue";
    /**
     * 新增或修改的RoutingKey
     */
    public final static String HOTEL_INSERT_KEY = "hotel.insert";
    /**
     * 删除的RoutingKey
     */
    public final static String HOTEL_DELETE_KEY = "hotel.delete";
}
3.声明队列交换机（配置类）

在hotel-demo中，定义配置类，声明队列、交换机：

package cn.itcast.hotel.config;

import cn.itcast.hotel.constants.MqConstants;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MqConfig {
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange(MqConstants.HOTEL_EXCHANGE, true, false);
    }

    @Bean
    public Queue insertQueue(){
        return new Queue(MqConstants.HOTEL_INSERT_QUEUE, true);
    }

    @Bean
    public Queue deleteQueue(){
        return new Queue(MqConstants.HOTEL_DELETE_QUEUE, true);
    }

    @Bean
    public Binding insertQueueBinding(){
        return BindingBuilder.bind(insertQueue()).to(topicExchange()).with(MqConstants.HOTEL_INSERT_KEY);
    }

    @Bean
    public Binding deleteQueueBinding(){
        return BindingBuilder.bind(deleteQueue()).to(topicExchange()).with(MqConstants.HOTEL_DELETE_KEY);
    }
}

发送MQ
在这里插入图片描述

3.2.5.接收MQ消息

hotel-demo接收到MQ消息要做的事情包括：

  • 新增消息：根据传递的hotel的id查询hotel信息，然后新增一条数据到索引库
  • 删除消息：根据传递的hotel的id删除索引库中的一条数据

1）给hotel-demo中的cn.itcast.hotel.service.impl包下的HotelService中实现业务：

@Override
public void deleteById(Long id) {
    try {
        // 1.准备Request
        DeleteRequest request = new DeleteRequest("hotel", id.toString());
        // 2.发送请求
        client.delete(request, RequestOptions.DEFAULT);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

@Override
public void insertById(Long id) {
    try {
        // 0.根据id查询酒店数据
        Hotel hotel = getById(id);
        // 转换为文档类型
        HotelDoc hotelDoc = new HotelDoc(hotel);

        // 1.准备Request对象
        IndexRequest request = new IndexRequest("hotel").id(hotel.getId().toString());
        // 2.准备Json文档
        request.source(JSON.toJSONString(hotelDoc), XContentType.JSON);
        // 3.发送请求
        client.index(request, RequestOptions.DEFAULT);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

3）编写监听器

在hotel-demo中的cn.itcast.hotel.mq包新增一个类：

package cn.itcast.hotel.mq;

import cn.itcast.hotel.constants.MqConstants;
import cn.itcast.hotel.service.IHotelService;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class HotelListener {

    @Autowired
    private IHotelService hotelService;

    /**
     * 监听酒店新增或修改的业务
     * @param id 酒店id
     */
    @RabbitListener(queues = MqConstants.HOTEL_INSERT_QUEUE)
    public void listenHotelInsertOrUpdate(Long id){
        hotelService.insertById(id);
    }

    /**
     * 监听酒店删除的业务
     * @param id 酒店id
     */
    @RabbitListener(queues = MqConstants.HOTEL_DELETE_QUEUE)
    public void listenHotelDelete(Long id){
        hotelService.deleteById(id);
    }
}
李知恩真爱粉
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【学相伴】狂神说 RabbitMQ笔记（简单使用RabbitMQ）
m0_67393295的博客
07-31 299
*RabbitMQ是一个由erlang开发的AMQP（AdvancedMessageQueue高级消息队列协议）的开源实现，能够实现异步消息处理RabbitMQ是一个消息代理它接受和转发消息。你可以把它想象成一个邮局当你把你想要发布的邮件放在邮箱中时，你可以确定邮差先生最终将邮件发送给你的收件人。在这个比喻中，RabbitMQ是邮政信箱，邮局和邮递员。RabbitMQ和邮局的主要区别在于它不处理纸张，而是接受，存储和转发二进制数据块优点异步消息处理业务解耦（下订单操作。...
RabbitMQ笔记.pdf
09-15
RabbitMQ的学习笔记，记录了消息中间件的相关知识点和RabbitMQ基础操作
RabbitMQ 学习笔记
weixin_45312373的博客
03-10 3088
RabbitMQ (狂神说学习笔记) 1、消息队列预科（了解一下） 消息队列协议 所谓协议是指 计算机底层操作系统和应用程序通讯时共同遵守的一组约定，只有遵循共同的约定和规范，系统和底层操作系统之间才能相互交流 和一般的网络应用程序的不同它主要负责数据的接受和传递，所以性能比较的高 协议对数据格式和计算机之间交换数据都必须严格遵守规范 网络协议的三要素 语法：语法是用户数据与控制信息的结构与格式，以及数据出现的顺序 语义：语义是解释控制信息每个部分的意义，它规定了需要发出何种控制信息，以及完成
RabbitMQ狂神说笔记（RabbitMQ B站狂神说笔记、KuangStudy、学相伴飞哥）
qq_29294165的博客
07-14 1868
rabbitmq文档
RabbitMQ笔记.md
04-20
结合狂神RabbitMQ笔记，外加自己查阅资料
rabbitmq学习资料
01-30
【RabbitMQ 学习资料】这篇文档是针对初学者准备的，主要涵盖了...对于初学者来说，理解其基本概念和操作流程，结合Spring Boot等框架进行实践，能快速掌握RabbitMQ的使用，提高系统间的解耦能力和异步处理能力。
RabbitMQ.md
09-02
RabbitMQ学习笔记 RabbitMQ学习笔记 RabbitMQ学习笔记 RabbitMQ学习笔记 RabbitMQ学习笔记 RabbitMQ学习笔记
Rabbitmq笔记+入门教程+示例
02-23
RabbitMQ环境搭建，介绍队列类型，spring-rabbit示例， 使用RabbitMQ完成商品数据的同步
RabbitMQ实战视频课程
06-12
MQ全称为Message Queue,?MQ是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息（针对应用程序的数据）来通信，而无需专用连接来链接它们。消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是用于诸如远程过程调用的技术。排队指的是应用程序通过 队列来通信。队列的使用除去了接收和发送应用程序同时执行的要求。其中较为成熟的MQ产品有IBM WEBSPHERE MQ等等
RabbitMQ资料RabbitMQ资料
07-25
RabbitMQ资料RabbitMQ资料RabbitMQ资料RabbitMQ资料
quotient_quotient_java_remainder_
10-03
to find quotient and remainder
狂神说笔记-全系列狂神说笔记-全系列
04-11
狂神说笔记_全系列狂神说笔记_全系列
Rabbitmq相关配置
不想混日子的程序员的博客
07-29 2355
springboot整合rabbitmq
rabbitmq
weixin_47414034的博客
01-11 382
topic模式：其实也是路由key，只不过为了方便管理路由key（也就是说不再是一个route key对应一个队列，而是一组route key对应一个队列），用了通配符*和#，*是匹配一个词（一个单词而不是一个字母），#是匹配0个或多个。当一个消息携带的路由keyroute key 是lazy.orange.elephant时，那这个消息既符合1也符合3，所以也会被发送给两个队列。fanout模式：发布订阅模式，也就是广播模式，消息可以被多个队列接收，多个队列接收的是同一个消费者发送的同一个消息。
狂神说rabbitmq笔记
最新发布
08-17
- *3* [【学相伴】狂神说 RabbitMQ笔记（简单使用RabbitMQ）](https://blog.csdn.net/qq_44716544/article/details/120100456)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

李知恩真爱粉

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

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

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

打赏作者

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

抵扣说明：

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

余额充值