Springboot 整合 RabbitMQ 消息队列 详情

目录
  • 生产者工程
    • POM依赖
      • application文件
      • 生产者业务代码
  • 测试
  • Direct 模式
    • 业务代码
  • 消费者
    • 消息监听
  • Topic 模式
    • 生产者
    • 消费者

生产者工程

POM依赖

可以在创建工程时直接选择添加依赖。

application文件

因为rabbitmq具有默认地址及用户信息,所以如果是本地rabbitmq可以不需要进行配置。

RabbitMQ配置文件:

在使用相关交换机及队列时,我们需要实现声明交换机及队列,如果没有对应信息,则启动项目会失败。所以在使用springboot整合rabbitmq时,我们可以通过配置文件来进行交换机、队列的声明及二者之间的关系绑定。 由于目前在演示Fanout模式,所以使用FanoutExchange来声明交换机,其他模式则使用相对应的TopicExchange,DirectExchange来声明。

@Configuration
public class RabbitMQConfiguration {

//声明fanout模式的交换机
@Bean
public FanoutExchange fanoutExchange() {
    return new FanoutExchange("fanout_order_exchange", true, false);
}

//声明队列
@Bean
public Queue smsQueue() {
    return new Queue("sms.fanout.queue", true);
}

@Bean
public Queue emailQueue() {
    return new Queue("email.fanout.queue", true);
}

@Bean
public Queue duanxinQueue() {
    return new Queue("duanxin.fanout.queue", true);
}
//绑定

@Bean
public Binding smsBinding() {
    return BindingBuilder.bind(smsQueue()).to(fanoutExchange());
}

@Bean
public Binding emailBinding() {
    return BindingBuilder.bind(emailQueue()).to(fanoutExchange());
}

@Bean
public Binding duanxinBinding() {
    return BindingBuilder.bind(duanxinQueue()).to(fanoutExchange());
}
}

生产者业务代码

这部分代码就简单的通过调用rabbitTemplate来进行消息的分发。@Service public class OrderService {

@Autowired
private RabbitTemplate rabbitTemplate;

public void makeOrder() {
    // 保存订单
    String orderId = UUID.randomUUID().toString();
    System.out.println("下单成功:" + orderId);
    // 通过MQ完成消息的分发
    // 参数1:交换机 ;参数2:路由key/队列名;参数3:消息内容
    String exchangeName = "fanout_order_exchange";
    rabbitTemplate.convertAndSend(exchangeName, "", orderId);
}
}

消费者:

消费者工程和生产者工程类似,我们首先需要引入依赖,然后在application文件中进行相关的配置即可开始编写代码。 在消费者工程中我们也可以编写rabbitmq的配置文件来进行交换机及队列的声明。建议在消费端编写配置文件,因为消费端是先启动的工程,如果交换机和队列未创建会导致工程启动失败。 消息监听

我们通过RabbitListener注解来监听消息队列。需要注意的是我们需要通过Component注解将该监听交给spring管理,否则不能正常接收服务端的消息。 这边只给出一个email的消息监听,上文生产者声明的duanxin,sms队列可以自行创建,只需要修改队列名即可。@Service public class OrderService {

@RabbitListener(queues = {"email.fanout.queue"})
@Component
public class FanoutEmailService {
    @RabbitHandler
    public void receive(String message) {
        System.out.println("email fanout -----》接收到" + message);
    }
}

测试

首先启动消费者工程,然后在生产者工程中创建测试类发送消息即可。

@SpringBootTest class SpringbootOrderRabbitmqProducerApplicationTests {

@Autowired
private OrderService orderService;

@Test
void contextLoads() {
    orderService.makeOrder();
}
}

当发送消息后,我们可以在控制台中发现消费者成功接受消息。

Direct 模式

生产者

建立工程的步骤和上文相同。

配置文件

配置和上文基本相同,由于该部分测试direct模式,所以需要使用DirectExchange创建交换机。需要注意的是该类中的方法名不能和上文rabbitmq的配置文件中的方法名相同,因为我们使用bean注解将其交给spring管理,如果名字相同,则会启动项目失败。

@Configuration
public class DirectRabbitMQConfiguration {

//声明direct模式的交换机
@Bean
public DirectExchange directExchange() {
    return new DirectExchange("direct_order_exchange", true, false);
}

//声明队列
@Bean
public Queue smsDirectQueue() {
    return new Queue("sms.direct.queue", true);
}

@Bean
public Queue emailDirectQueue() {
    return new Queue("email.direct.queue", true);
}

@Bean
public Queue duanxinDirectQueue() {
    return new Queue("duanxin.direct.queue", true);
}
//绑定

@Bean
public Binding smsDirectBinding() {
    return BindingBuilder.bind(smsDirectQueue()).to(directExchange()).with("sms");
}

@Bean
public Binding emailDirectBinding() {
    return BindingBuilder.bind(emailDirectQueue()).to(directExchange()).with("email");
}

@Bean
public Binding duanxinDirectBinding() {
    return BindingBuilder.bind(duanxinDirectQueue()).to(directExchange()).with("duanxin");
}
}

业务代码

@Service
public class OrderService {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void makeOrderDirect() {
        // 保存订单
        String orderId = UUID.randomUUID().toString();
        System.out.println("下单成功:" + orderId);
        String exchangeName = "direct_order_exchange";
        rabbitTemplate.convertAndSend(exchangeName, "sms", orderId);
        rabbitTemplate.convertAndSend(exchangeName, "email", orderId);
    }

}

消费者

消息监听

和上文相同,只需注意队列名即可。

@RabbitListener(queues = {"email.direct.queue"})
@Component
public class DirectEmailService {
    @RabbitHandler
    public void receive(String message) {
        System.out.println("email direct -----》接收到" + message);
    }
}

Topic 模式

上文中个模式都是通过配置文件来声明交换机,队列及绑定二者之间的关系;实际上我们还可以通过注解的方式来声明交换机及注解。

生产者

由于使用注解方式声明,所以我们不需要创建配置文件,直接编写业务代码即可。测试的时候我们只需修改路由名即可,具体如何修改,请前往文章开头链接查看各模式是如何使用的。

@Service
public class OrderService {

@Autowired
private RabbitTemplate rabbitTemplate;

public void makeOrderTopic() {
    // 保存订单
    String orderId = UUID.randomUUID().toString();
    System.out.println("下单成功:" + orderId);
    String exchangeName = "topic_order_exchange";
    String routingKey = "com.email";
    rabbitTemplate.convertAndSend(exchangeName, routingKey, orderId);
}
}

消费者

代码和上文基本相同,区别在于我们直接在RabbitListener注解中将队列和交换机进行绑定。需要注意的是各参数中都是使用字符串。 value对应的是队列,相应的参数分别是队列名、持久化、自动删除。 exchange对应的交换机,相应的参数分别是交换机名以及交换机类型。 key对应的是路由名。

@RabbitListener(bindings = @QueueBinding(
        value = @Queue(value = "email.topic.queue",durable = "true",autoDelete = "false"),
        exchange = @Exchange(value = "topic_order_exchange",type = ExchangeTypes.TOPIC),
        key = "*.email.#"
))
@Component
public class TopicEmailService {
    @RabbitHandler
    public void receive(String message) {
        System.out.println("email topic -----》接收到" + message);
    }
}

以上便是springboot 整合 rabbitmq的两种方式。但是在日常开发中更推荐使用配置文件的形式来实现,因为在配置文件中可以更好的处理过期时间、死信队列等消息队列中的高级特性。

到此这篇关于Springboot 整合 RabbitMQ 消息队列 详情的文章就介绍到这了,更多相关Springboot 整合 RabbitMQ 内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • SpringBoot整合RabbitMQ实现消息确认机制

    前面几篇案例已经将常用的交换器(DirectExchange.TopicExchange.FanoutExchange)的用法介绍完了,现在我们来看一下消息的回调,也就是消息确认. 在rabbitmq-provider项目的application.yml文件上加上一些配置 server: port: 8021 spring: #给项目来个名字 application: name: rabbitmq-provider #配置rabbitMq 服务器 rabbitmq: host: 127.0.0.

  • SpringBoot整合RabbitMQ及生产全场景高级特性实战

    目录 摘要 整合 依赖与配置 生产者配置消息队列规则 生产者发布消息 消费者监听消息 摘要 整合场景含 topic 工作模式(通过 routingKey 可满足简单/工作队列/发布订阅/路由等四种工作模式)和 confirm(消息确认).return(消息返回).basicAck(消息签收).basicNack(拒绝签收).DLX(Dead Letter Exchange死信队列)实现延时/定时任务等. 整合 依赖与配置 以下内容消费者同生产者 <parent> <groupId>

  • SpringBoot整合RabbitMQ实现交换机与队列的绑定

    目录 简介 配置方法概述 法1:配置类(简洁方法)(推荐) 法2:配置类(繁琐方法)(不推荐) 法3:使用方配置(不推荐) 法4:MQ服务端网页(不推荐) 简介 本文用实例介绍SpringBoot中RabbitMQ如何绑定交换机(交换器)与队列. 配置方法概述 交换机 下边两种方式等价. ExchangeBuilder.topicExchange(EXCHANGE_TOPIC_WELCOME).durable(true).build(); new TopicExchange(EXCHANGE_T

  • SpringBoot整合RabbitMQ实现六种工作模式的示例

    目录 前提概念 生产者 队列 消费者 SpringBoot整合RabbitMQ基本配置添加maven依赖 1. 简单(simple)模式 2. 工作模式 生产消息: 3. 发布订阅模式 特点 创建队列.交换机以及绑定: 4. 路由模式 特点 创建队列.交换机以及绑定: 5. 主题模式 特点 创建交换机和队列: 6. RPC模式 特点 消费端添加返回值: 交换机类型 Direct Exchange(直连) Fanout Exchange(扇形) Topic Exchange(主题) 总结 源码示例

  • 详解SpringBoot整合RabbitMQ如何实现消息确认

    目录 简介 生产者消息确认 介绍 流程 配置 ConfirmCallback ReturnCallback 注册ConfirmCallback和ReturnCallback 消费者消息确认 介绍 手动确认三种方式 简介 本文介绍SpringBoot整合RabbitMQ如何进行消息的确认. 生产者消息确认 介绍 发送消息确认:用来确认消息从 producer发送到 broker 然后broker 的 exchange 到 queue过程中,消息是否成功投递. 如果消息和队列是可持久化的,那么确认消

  • SpringBoot整合RabbitMQ的5种模式实战

    目录 一.环境准备 二.简单模式 三.工作队列模式 四.广播模式(Fanout) 五.直连模式(Direct) 六.通配符模式(Topic) 一.环境准备 1.pom依赖 <!-- 父工程依赖 --> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version&g

  • Springboot整合Rabbitmq之Confirm和Return机制

    目录 前言 为什么会有Confirm Springboot整合Mq实现Confirm监听机制 依赖引入 增加配置文件,设定连接信息 配置队列.交换机,以及对其进行绑定 编写mq消息发送服务 编写消息发送接口 启动项目进行测试 正常测试 异常测试 什么是Return? 增加ReturnCallback监听并测试 修改RabbitmqService配置类 测试 总结 相关代码下载 前言 之前专栏中,对Springboot整合Rabbitmq都有一系列的配置和说明,但总缺少一些必要的描述信息.导致很多

  • RabbitMQ 3.9.7 镜像模式集群与Springboot 2.5.5 整合

    目录 1. 概述 2. 场景说明 3. 与Springboot的整合 3.1 引入依赖 3.2 生产服务配置 3.3 生产服务代码 3.4 消费服务配置 3.5 消费服务代码 3.6 Rest 测试代码 4. 综述 1. 概述 老话说的好:做人要懂得变通,善于思考,有时稍微转个弯,也许问题就解决了. 言归正传,之前我们聊了 RabbitMQ 3.9.7 镜像模式集群的搭建,今天我们来聊聊 RabbitMQ 3.9.7 镜像模式集群与Springboot 2.5.5 整合. 2. 场景说明 服务器

  • Springboot 整合 RabbitMQ 消息队列 详情

    目录 生产者工程 POM依赖 application文件 生产者业务代码 测试 Direct 模式 业务代码 消费者 消息监听 Topic 模式 生产者 消费者 生产者工程 POM依赖 可以在创建工程时直接选择添加依赖. application文件 因为rabbitmq具有默认地址及用户信息,所以如果是本地rabbitmq可以不需要进行配置. RabbitMQ配置文件: 在使用相关交换机及队列时,我们需要实现声明交换机及队列,如果没有对应信息,则启动项目会失败.所以在使用springboot整合

  • SpringBoot整合RabbitMQ消息队列的完整步骤

    SpringBoot整合RabbitMQ 主要实现RabbitMQ以下三种消息队列: 简单消息队列(演示direct模式) 基于RabbitMQ特性的延时消息队列 基于RabbitMQ相关插件的延时消息队列 公共资源 1. 引入pom依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId>

  • SpringBoot整合rockerMQ消息队列详解

    目录 Springboot整合RockerMQ 使用总结 消费模式 生产者组和消费者组 生产者投递消息的三种方式 如何保证消息不丢失 顺序消息 分布式事务 Springboot整合RockerMQ 1.maven依赖 <dependencies> <!-- springboot-web组件 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>

  • Springboot整合Active消息队列

    简单理解: Active是Apache公司旗下的一个消息总线,ActiveMQ是一个开源兼容Java Message Service(JMS) 面向消息的中件间. 是一个提供松耦合的应用程序架构. 主要用来在服务与服务之间进行异步通信的. 一.搭建步骤     1.相应jar包 <!-- 整合消息队列ActiveMQ --> <dependency> <groupId>org.springframework.boot</groupId> <artifa

  • SpringBoot整合RabbitMQ处理死信队列和延迟队列

    目录 简介 实例代码 路由配置 控制器 发送器 接收器 application.yml 实例测试 简介 说明 本文用示例介绍SpringBoot整合RabbitMQ时如何处理死信队列/延迟队列. RabbitMQ消息简介 RabbitMQ的消息默认不会超时. 什么是死信队列?什么是延迟队列? 死信队列: DLX,全称为Dead-Letter-Exchange,可以称之为死信交换器,也有人称之为死信邮箱.当消息在一个队列中变成死信(dead message)之后,它能被重新被发送到另一个交换器中,

  • SpringBoot使用RabbitMQ延时队列(小白必备)

    1.什么是MQ MQ,是一种跨进程的通信机制,用于上下游传递消息. 在互联网架构中,MQ是一种非常常见的上下游"逻辑解耦+物理解耦"的消息通信服务. 使用了MQ之后,消息发送上游只需要依赖MQ,不用依赖其他服务. 为什么会产生消息列队? 不同进程(process)之间传递消息时,两个进程之间耦合程度过高,改动一个进程,引发必须修改另一个进程,为了隔离这两个进程,在两进程间抽离出一层(一个模块),所有两进程之间传递的消息,都必须通过消息队列来传递,单独修改某一个进程,不会影响另一个: 不

  • Springboot 整合RabbitMq(用心看完这一篇就够了)

    该篇文章内容较多,包括有rabbitMq相关的一些简单理论介绍,provider消息推送实例,consumer消息消费实例,Direct.Topic.Fanout的使用,消息回调.手动确认等. (但是关于rabbitMq的安装,就不介绍了) 在安装完rabbitMq后,输入http://ip:15672/ ,是可以看到一个简单后台管理界面的. 在这个界面里面我们可以做些什么? 可以手动创建虚拟host,创建用户,分配权限,创建交换机,创建队列等等,还有查看队列消息,消费效率,推送效率等等. 以上

随机推荐