Springboot 集成RabbitMQ 基于AMQP

已于 2022-04-28 17:47:16 修改
阅读量2.9k 收藏 2
点赞数
分类专栏： 技术栈与架构 springboot 文章标签： rabbitmq 中间件
于 2022-03-25 19:18:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50909707/article/details/123737263
版权

目录

一、安装RabbitMQ

二、集成案例

1、为通信的服务添加依赖

2、配置yml

3、rabbitmq简单实现案例

三、直连交换机实现

1、配置类

 2、发送消息的类

3、接收消息的类

4、测试使用sendMessage发送消息，服务器可以看到消息

 四、主题交换机实现

1、匹配规则 

2、主题模式的实现案例

（1）配置类

（2）服务调用

（3）消息接收类

五、工作模式案例解读

1、工作模型实现案例——1对2

2、工作模型实现案例——交换机模型

 (1)交换机广播模式案例

 (2)交换机直连模式案例 

(3)Topic模式下的案例

(4)Object类型数据的接收

一、安装RabbitMQ

见我的博客：windows 安装 RabbitMQ的安装包_编码语者 Dragon Wu的博客-CSDN博客

启动rabbitmq:windows rabbitmq 安装启动 - 张什么锋 - 博客园

一般访问路径： http://localhost:15672

rabbitmqctl status	//查看当前状态
rabbitmq-plugins enable rabbitmq_management	//开启Web插件
rabbitmq-server start	//启动服务
rabbitmq-server stop	//停止服务
rabbitmq-server restart	//重启服务

二、集成案例

1、为通信的服务添加依赖

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

2、配置yml

spring:
  rabbitmq:
    host: localhost
    username: guest
    password: guest
    port: 5672 # rabbitmq对外的服务端口是5672，对外的管理端口是15672
server:
  port: 8080

3、rabbitmq简单实现案例

注意消息队列在控制台默认是需要手动添加的

消息发送者：

package com.wxl;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@SpringBootTest
@RunWith(SpringRunner.class)
public class RabbitMQTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSimpleQueue(){
        String queueName="simple.queue";
        String message="hello, spring amqp!";
        rabbitTemplate.convertAndSend(queueName,message);
    }
}

另起一个springboot服务就行数据监听：

package com.wxl.listener;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class SpringRabbitListener {

    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueue(String msg) {
        System.out.println("消费者接收到simple.queue的消息：【" + msg + "】");
    }
}

启动服务：

可以看到消息已接收到了

 简单使用总结：

三、直连交换机实现

1、配置类

package com.wxl.rabbitmq.direct;

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.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

//直连模式的配置类
@Configuration
public class RabbitConfigDirect {
    @Bean
    public Queue directQueue(){
        //消息队列
        return new Queue("direct_queue");
    }

    @Bean
    public DirectExchange directExchange(){
        //直连交换机
        return new DirectExchange("directExchange");
    }

    @Bean
    public Binding bindingDirect(){
        //将队列和交换机绑定
        return BindingBuilder.bind(directQueue()).to(directExchange()).with("direct");
    }
}

如果你需要将多个队列绑定到一个交互机上还可以这样写

 2、发送消息的类

package com.wxl.rabbitmq.direct;


import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
//rabbitmq里的直连模式
public class MessageServiceRabbitmqDirect {

    @Autowired
    private AmqpTemplate amqpTemplate;

    public void sendMessage(String id){
        amqpTemplate.convertAndSend("directExchange","direct",id);
    }
}

3、接收消息的类

package com.wxl.rabbitmq.direct;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
//消息接收类
public class MessageListener {

    @RabbitListener(queues = "direct_queue")
    public void receive(String id){
        System.out.println("已完成短信发送业务（rabbitmq direct）id:"+id);
    }
}

注意这里添加了@RabbitListener注解

4、测试使用sendMessage发送消息，服务器可以看到消息

 如果设置了多个监听，则会进行轮询的处理，

 四、主题交换机实现

使用主题交互机模式同样可以实现直连交互机模式的效果，主题模式的好处就是即使同样使用一台交换机也能实现不同规则的队列放行。

1、匹配规则 

2、主题模式的实现案例

与直连模式类似

（1）配置类

package com.wxl.rabbitmq.topic;

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.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

//直连模式的配置类
@Configuration
public class RabbitConfigTopic {
    @Bean
    public Queue topicQueue(){
        //消息队列
        return new Queue("topic_queue");
    }

    @Bean
    public Queue topicQueue2(){
        //消息队列
        return new Queue("topic_queue2");
    }

    @Bean
    public DirectExchange directExchange(){
        //直连交换机
        return new DirectExchange("topicExchange");
    }

    @Bean
    public Binding bindingTopic(){
        //将队列和交换机绑定
        return BindingBuilder.bind(topicQueue()).to(directExchange()).with("topic.*.id");//支持模糊匹配，如topic.order.id也能被匹配到
    }

    @Bean
    public Binding bindingTopic2(){
        //将队列和交换机绑定
        return BindingBuilder.bind(topicQueue2()).to(directExchange()).with("topic2");
    }
}

（2）服务调用

package com.wxl.rabbitmq.topic;


import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
//rabbitmq里的主题模式
public class MessageServiceRabbitmqTopic {

    @Autowired
    private AmqpTemplate amqpTemplate;

    public void sendMessage(String id){
        amqpTemplate.convertAndSend("topicExchange","topic.order.id",id);//交换机名，绑定名
    }
}

（3）消息接收类

package com.wxl.rabbitmq.topic;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
//消息接收类
public class MessageListener {

    @RabbitListener(queues = "topic_queue")
    public void receive(String id){
        System.out.println("已完成短信发送业务（rabbitmq topic1）id:"+id);
    }

    @RabbitListener(queues = "topic_queue2")
    public void receive2(String id){
        System.out.println("已完成短信发送业务（rabbitmq top2）id:"+id);
    }
}

五、工作模式案例解读

1、工作模型实现案例——1对2

 对简单案例的生产者进行修改：

package com.wxl;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@SpringBootTest
@RunWith(SpringRunner.class)
public class RabbitMQTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSimpleQueue(){
        String queueName="simple.queue";
        String message="hello, spring amqp!";
        rabbitTemplate.convertAndSend(queueName,message);
    }

    @Test
    //模拟发送50条消息
    public void testSendMessage2Queue() throws Exception{
        String queueName="simple.queue";
        String message="hello, spring amqp!";
        for(int i=1;i<=50;i++){
            rabbitTemplate.convertAndSend(queueName,message);
            Thread.sleep(20);
        }
    }
}

简单案例的消费者进行修改：

package com.wxl.listener;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.time.LocalTime;

@Component
public class SpringRabbitListener {

//    @RabbitListener(queues = "simple.queue")
//    public void listenSimpleQueue(String msg) {
//        System.out.println("消费者接收到simple.queue的消息：【" + msg + "】");
//    }

    @RabbitListener(queues = "simple.queue")
    public void listenWork1Queue(String msg) throws Exception {
        System.out.println("消费者1接收到simple.queue的消息：【" + msg + "】"+ LocalTime.now());
        Thread.sleep(20);
    }

    @RabbitListener(queues = "simple.queue")
    public void listenWork2Queue(String msg) throws Exception {
        System.out.println("消费者2接收到simple.queue的消息：【" + msg + "】"+LocalTime.now());
        Thread.sleep(20);
    }
}

开启消费者的服务。再开启生产者进程。

可以看到两个消费者已接收到消息：

默认是平均分配消息数。

为了更好的分配消息给不同性能的消费者，可以设置preFetch

 我们这里通过睡眠时间的不同模拟消息处理性能不同的消费者。

一般都需要设置prefetch=1来防止消息堆积。

 可以看到配置了prefetch以后，性能好的会处理多一些消息：

2、工作模型实现案例——交换机模型

 (1)交换机广播模式案例

在简单案例的基础配置上做实验，消费者服务里添加配置类：

package com.wxl.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FanoutConfig {
    // itcast.fanout
    //设置交换机
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("itcast.fanout");
    }

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

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

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

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


}

服务运行后，spring会自动将bean类加入容器，再观察rabbitmq控制台：

 添加消息接收监听：

package com.wxl.listener;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.time.LocalTime;

@Component
public class SpringRabbitListener {

//    @RabbitListener(queues = "simple.queue")
//    public void listenSimpleQueue(String msg) {
//        System.out.println("消费者接收到simple.queue的消息：【" + msg + "】");
//    }

//    @RabbitListener(queues = "simple.queue")
//    public void listenWork1Queue(String msg) throws Exception {
//        System.out.println("消费者1接收到simple.queue的消息：【" + msg + "】"+ LocalTime.now());
//        Thread.sleep(20);
//    }
//
//    @RabbitListener(queues = "simple.queue")
//    public void listenWork2Queue(String msg) throws Exception {
//        System.out.println("消费者2接收到simple.queue的消息：【" + msg + "】"+LocalTime.now());
//        Thread.sleep(200);
//    }

    @RabbitListener(queues = "fanout.queue1")
    public void listenFanout2Queue(String msg) throws Exception {
        System.out.println("消费者1接收到fanout.queue的消息：【" + msg + "】"+LocalTime.now());
        Thread.sleep(20);
    }

    @RabbitListener(queues = "fanout.queue2")
    public void listenFanout1Queue(String msg) throws Exception {
        System.out.println("消费者2接收到fanout.queue的消息：【" + msg + "】"+LocalTime.now());
        Thread.sleep(20);
    }
}

重启服务

编辑消息发送者：

    @Test
    public void testSendFanoutExchange(){
        //交换机名称
        String exchangeName="itcast.fanout";
        //消息
        String message="hello, every one!";
        //发送消息
        rabbitTemplate.convertAndSend(exchangeName,"",message);
    }

 小结：

 (2)交换机直连模式案例 

 本次我们采用@RibbitListener来实现配置类的效果

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue1"),//队列
            exchange = @Exchange(name="itcast.direct",type = ExchangeTypes.DIRECT),//交换机
            key = {"red","blue"}//key
    ))
    public void listenDirectQueue(String msg){
        System.out.println("消费者接收到direct.queue1的消息：【" + msg + "】");
    }

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "direct.queue2"),
            exchange = @Exchange(name="itcast.direct",type = ExchangeTypes.DIRECT),
            key = {"red","yellow"}
    ))
    public void listenDirectQueue2(String msg){
        System.out.println("消费者接收到direct.queue2的消息：【" + msg + "】");
    }

 重启服务。

查看rabbitmq控制面板：

 消息发送者：

    @Test
    public void testSendDirectExchange(){
        //交换机名称
        String exchangeName="itcast.direct";
        //消息
        String message="hello, blue!";
        //发送消息
        rabbitTemplate.convertAndSend(exchangeName,"blue",message);
    }

 

也就是说，direct模式下可以通过key值指定发给一个或多个队列。 

小结：

(3)Topic模式下的案例

简单来说就是通过通配符找到对应的队列

 消息监听：

    @RabbitListener(bindings =@QueueBinding(
            value = @Queue(name = "topic.queue1"),
            exchange = @Exchange(name = "itcast.topic",type = ExchangeTypes.TOPIC),
            key="china.#"
    ))
    public void listenTopicQueue1(String msg){
        System.out.println("消费者接收到topic.queue1的消息：【" + msg + "】");
    }

    @RabbitListener(bindings =@QueueBinding(
            value = @Queue(name = "topic.queue2"),
            exchange = @Exchange(name = "itcast.topic",type = ExchangeTypes.TOPIC),
            key="#.news"
    ))
    public void listenTopicQueue2(String msg){
        System.out.println("消费者接收到topic.queue2的消息：【" + msg + "】");
    }

 重启服务

 发送消息：

    @Test
    public void testSendTopicExchange(){
        //交换机名称
        String exchangeName="itcast.topic";
        //消息
        String message="今天是个好日子！";
        //发送消息
        rabbitTemplate.convertAndSend(exchangeName,"china.weather",message);
    }

 

简单的说topic模式类似于模糊查询。 

(4)Object类型数据的接收

由于默认的序列化传输效率低，我们这里需要引入json依赖：

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

在配置类中添加如下：@Bean

package com.wxl;

import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class RabbitMQTestApplication {
    public static void main(String[] args) {
        SpringApplication.run(RabbitMQTestApplication.class, args);
    }
    
    @Bean
    public MessageConverter messageConverter(){
        return new Jackson2JsonMessageConverter();
    }
}

注意这里发送者和接收者都需要引入该Bean。

下面是发送对象信息：

消息消费者：

    @Bean
    public Queue objectQueue(){
        return new Queue("object.queue");
    }

重启服务

    @Test
    public void testSendObjectQueue(){
        Map<String,Object> msg=new HashMap<String, Object>();
        msg.put("name","Jack");
        msg.put("age",12);
        rabbitTemplate.convertAndSend("object.queue",msg);
    }

 测试发送消息

 监听：

    @RabbitListener(queues = "object.queue")
    public void listenObjectQueue(Map<String,Object> msg){
        System.out.println("object对象消息："+msg.toString());
    }

效果已到达。 

小结：

Dragon Wu
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring AMQP整合RabbitMQ
听雪楼
12-31 1568
RabbitAdmin RabbitAdmin类可以很好的操作RabbitMQ, 在Spring中直接进行注入即可 @Bean public RabbitAdmin rabbitAdmin(ConnectionFactory ConnectionFactory) { RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory)...
spring boot整合RabbitMQ（Direct模式）
08-30
springboot集成RabbitMQ非常简单，如果只是简单的使用配置非常少，springboot提供了spring-boot-starter-amqp项目对消息各种支持。下面通过本文给大家介绍下spring boot整合RabbitMQ（Direct模式）,需要的朋友可以参考下
SpringBoot集成RabbitMQ的方法(死信队列)
08-26
主要介绍了SpringBoot集成RabbitMQ的方法(死信队列)，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
springboot-rabbitmq：RabbitMQ的简单介绍，安装及与SpringBoot集成内置高可用的消息传递方案
02-04
1，RabbitMQ简单介绍： RabbitMQ是一个开源的消息代理和服务器，通过常规协议在完全不同的应用之间传递数据，RabbitMQ是使用Erlang语言来编写的，并且RabbitMQ是基于AMQP协议的。 推介文章： 1.1，特点： RabbitMQ灵活使用Erlang语言编写，传递效率高，连续低 开源，性能优秀，稳定性较高 与SpringAMQP完美的整合，API丰富 具有丰富的模式，表达式配置，HA模式，纳入规模模式 保证数据不丢失的情况下，做到高可用 AMQP全称：高级消息队列协议 AMQP翻译：高级消息子系统协议 1.2，AMQP核心概念 服务器：又称代理，接收客户端的连接
RabbitMQ - 基于 SpringAMQP 带你实现五种消息队列模型_spring消息队列
最新发布
2401_84187563的博客
04-17 944
*遇到的问题：**当消息进入 queue 时，消费者1 和 消费者2 都会先做一个操作叫做“消息预取”，也就是先取消息，但不执行操作，等从 queue 中拿完（如果不设置，默认是无限次拿）了以后再执行具体的消费操作，但这样会导致一个问题——当 消费者1 的消费处理速度是 消费者2 处理速度的两倍时，**但是由于“消息预取”，他们两都会取到相等的消息数量，**因此就会导致 消费者1 提前处理完，消费者2 还有很多没有处理的情况，降低了总体处理的效率。实现方式是加入了exchange（交换机）。
demo-spring-boot-mq:使用ActiveMQ，Qpid，RabbitMQ和Spring Boot的消息队列演示项目
05-10
演示弹簧启动MQ 使用Spring Boot的Message Queue演示项目 互通性 请参阅interoperability.xlsx 去做 试用Qpid质子 ） 在WebSockets上尝试Qpid JMS-AMQP 问题 jms-receiver-annotation-@JmsListener不会根据有效负载类型自动选择receiveMessage（）。 参考 了解AMQP和JMS之间的区别。
Springboot-rabbitmq.zip
08-08
SpringBoot集成RabbitMQ 完整版 定义rabbit template用于数据的接收和发送 定制一些处理策略 定制化amqp模板
详解spring boot集成RabbitMQ
08-30
RabbitMQ作为AMQP的代表性产品，在项目中大量使用。结合现在主流的spring boot，极大简化了开发过程中所涉及到的消息通信问题。
RabbitMQ之SpringAMQP
一切总会归于平淡
02-23 2155
​ SpringAMQP是基于RabbitMQ封装的一套模板，并且还利用SpringBoot对其实现了自动装配，使用起来非常方便。 SpringAmqp的官方地址：Spring AMQP ​
RabbitMQ—SpringAMQP
qq_63665506的博客
06-28 306
有别于Fanout模式，不同的消息不会被所有订阅的队列都消费，而是不同的消息被不同的队列消费。存在的问题是，消费者1很快处理完成了它所得到的25条消息，而消费者2以较慢的速度处理它所得到的25条消息，此时消费者1处理空闲状态，没有合理地考虑到它们的消息处理能力，使消息处理过程缓慢。在这个模型中，多了一个exchange（交换机）的角色，生产者在发送消息时，不再是直接发送给Queue，而是先发送到exchange，再由exchange路由转发到绑定了相应规则的队列，消费者监听到消息并对其进行处理。
三分钟实现 Spring Boot 集成 RabbitMQ，实现消息队列服务
Monsterof的博客
10-16 3269
Spring Boot提供了spring-bootstarter-amqp组件对消息队列进行支持，使用非常简单，仅需要非常少的配置即可实现完整的消息队列服务。 消息中间件在互联网公司使用的越来越多，主要用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。消息队列实现系统之间的双向解耦，生产者往消息队列中发送消息，消费者从队列中拿取消息并处理，生产者不用关心是谁来消费，消费者不用关心谁在生产消息，从而达到系统解耦的目的，也大大提高了系统的高可用性和高并发能力。 接下来介绍Spring
SpringBoot - SpringBoot集成RabbitMQ
MinggeQingchun的博客
06-09 269
创建两个模块，一个命名springboot-send，一个命名springboot-receive在两个工程的 pom.xml配置文件中引入AMQP依赖 核心配置文件application.properties文件中 1、direct交换机消息发送方 消息接收方 2、fanout交换机消息发送方 消息接收方 3、topic交换机消息发送方 消息接收方 运行测试Send消息发送，编写Application.java类 运行测试Receive消
SpringBoot集成RabbitMQ延时队列，自定义延时时间Demo
09-16
该示例通过 rabbitmq_delayed_message_exchange 插件实现自定义延时时间的延时队列。 示例是纯净的，只引入了需要的架包 启动示例时，请确保MQ已经安装了延时插件(附件里带有插件及安装说明)以及示例的MQ相关的配置...
Springboot整合RabbitMQ最简单demo
07-11
Springboot整合RabbitMQ最简单demo,适用于springcloud项目,作为消息总线适用,需要安装RabbitMQ,Mac linux可以使用命令行一键安装,在项目配置文件配置好端口即可(已默认配置),启动项目访问8080端口,参数见controller.
springboot-rabbitmq-amqp
03-15
springboot-rabbitmq-amqp
rabbitmq基础+springboot集成rabbitmq
10-14
RabbitMQ基础知识，工作队列、发布订阅、路由模式、通配符模式 都有详细的demo，Springboot整合了RabbitMQ，使用Junit测试，详细的文档说明都有。
Spring集成Rabbitmq收集Logback日志，利用进行Logstash数据整理存储到Elasticsearch中
盲目的拾荒者的博客
08-08 8159
项目中我们常用的是把Logback打印的日志存储到文件中保存到硬盘上，这样不利于日志的收集和分析。 以下演示在SpringBoot中通过rabbitmq收集logback日志存储到Elasticsearch中。 环境准备：安装RabbitMQ，安装Elasticsearch和Elasticsearch-Head(可视化插件)，安装Logstash.====》之前博客已经介绍过了。 pom.x...
SpringAMQP整合RabbitMQ-五种工作模式Demo
Henrik-Yao的博客
11-21 5490
一.MQ基本概念 1.概述 MQ全称 Message Queue（消息队列），是在消息的传输过程中保存消息的容器，是存储消息的中间件 分布式系统通信有两种方式，一种是直接远程调用，一种是借助类似于rabbitmq的第三方中间件完成间接通信 2.MQ的优势 应用解耦：提高系统容错性和可维护性 异步提速：提升用户体验和系统吞吐量 削峰填谷：提高系统稳定性 二.RabbitMQ 1.AMQP AMQP，即Advanced Message Queuing Protocol，一个提供统一消息服务的应用
SpringAMQP和RabbitMQ入门
Keep learing, and stay fast
10-31 1551
Spring AMQP项目将Spring的核心概念应用到基于AMQP的消息传递解决方案的开发中。它提供了一个“模板”作为发送和接收消息的高级抽象。它还通过一个“监听器容器”为消息驱动的POJOs提供支持。这些库方便了AMQP资源的管理，同时促进了依赖注入和声明性配置的使用。
SpringBoot 集成rabbitmq
07-28
SpringBoot集成RabbitMQ可以通过以下步骤实现。首先，在配置文件中添加RabbitMQ的连接信息。例如，在application.yml文件中配置RabbitMQ的主机、端口、用户名和密码等信息。\[1\]然后，引入SpringBoot整合RabbitMQ的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值