八、消息中间件RabbitMQ与SpringBoot集成

最新推荐文章于 2023-06-02 14:21:15 发布
最新推荐文章于 2023-06-02 14:21:15 发布
阅读量231 收藏
点赞数
分类专栏： 消息中间件之RabbitMQ 文章标签： RabbitMQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lcc2ztt/article/details/101446237
版权

RabbitMQ与SpirngBoot2.1.2的集成

准备工作：idea/eclipse（我使用Idea开发工具），JDK1.8，Maven

创建MAVEN工程

1、创建生产者的一个简单的Maven工程，创建方式这里就不描述了，创建后的目录结构如下
在这里插入图片描述
在这里我只使用了其中一个工程，把消费者和生产者写到一起，节约自己的时间，后期有时间把消费者和生产者拆开。

pom文件添加依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>rabbitmq-springboot</artifactId>
        <groupId>kevin</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>mq-product</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
            <version>2.1.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.1.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>2.1.2.RELEASE</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

创建yml配置文件

spring:
  application:
    name: rabbitmq-product
  rabbitmq:
    host: 192.168.244.101
    username: kevin
    password: 123456
    port: 5672
    virtual-host: myhost
    publisher-confirms: true

定义常量

package com.kevin.consts;

/**
 * 描述：常量定义<br/>
 * 创建人： Kevin Lea <br/>
 * 创建时间： 2019-10-8 11:19<br/>
 * 版本：1.0
 */
public class RabbitMQConst {
	//默认direct hello队列名称
    public final static String QUEUE_HELLO = "q.hello";
    //默认direct user队列名称
    public final static String QUEUE_USER = "q.user";

	//topic eamil队列名称
    public final static String QUEUE_TOPIC_EMAIL = "q.info.email";
    //topic user队列名称
    public final static String QUEUE_TOPIC_USER = "q.info.user";
    //fanout 队列名称
    public final static String QUEUE_FANOUT = "q.fanout";
    //topic email 路由键
    public final static String RK_EMAIL = "q.info.email";
    //topic user路由键
    public final static String RK_USER = "q.info.user";

	//topic交换器
    public final static String EXCHANGE_TOPIC = "exchange.topic";
    //fanout交换器
    public final static String EXCHANGE_FANOUT = "exchange.fanout";

}

创建Configuration配置类

在这里主要申明bean，加载组件什么的。

package com.kevin.config;

import com.kevin.consts.RabbitMQConst;
import com.kevin.sender.UserReceiver;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.lang.Nullable;

/**
 * 描述：配置类<br/>
 * 创建人： Kevin Lea <br/>
 * 创建时间： 2019-10-8 11:01<br/>
 * 版本：1.0
 */
@Configuration
public class RabbitMQConfig {

    @Value("${spring.rabbitmq.host}")
    private String host;

    @Value("${spring.rabbitmq.port}")
    private int port;

    @Value("${spring.rabbitmq.username}")
    private String username;

    @Value("${spring.rabbitmq.password}")
    private String password;

    @Value("${spring.rabbitmq.virtual-host}")
    private String virtualHost;

    @Value("${spring.rabbitmq.publisher-confirms}")
    private boolean publisherConfirms;

    @Autowired
    private UserReceiver userReceiver;


    /**
     * 连接工厂
     * @return
     */
    @Bean
    public ConnectionFactory connectionFactory(){
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setHost(host);
        connectionFactory.setPort(port);
        connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
        connectionFactory.setVirtualHost(virtualHost);
        connectionFactory.setPublisherConfirms(publisherConfirms);
        return connectionFactory;
    }

    /**
     * rabbitAdmin分装了对RabbitMQ的管理操作
     * @param connectionFactory
     * @return
     */
    @Bean
    public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory){
        return new RabbitAdmin(connectionFactory);
    }

    /**
     * 使用template
     * @param connectionFactory
     * @return
     */
    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory){
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        //设置失败通知
        rabbitTemplate.setMandatory(true);
        //发送方确认
        rabbitTemplate.setConfirmCallback(confirmCallback());
        //失败回调
        rabbitTemplate.setReturnCallback(returnCallback());
        return rabbitTemplate;
    }

    ///消费者确认//
    @Bean
    public SimpleMessageListenerContainer messageListenerContainer(){
        SimpleMessageListenerContainer simpleMessageListenerContainer
                = new SimpleMessageListenerContainer(connectionFactory());
        simpleMessageListenerContainer.setQueues(userQueue());
        simpleMessageListenerContainer.setAcknowledgeMode(AcknowledgeMode.MANUAL);
        simpleMessageListenerContainer.setMessageListener(userReceiver);
        return simpleMessageListenerContainer;
    }



    ///发送方确认//
    @Bean
    public RabbitTemplate.ConfirmCallback confirmCallback(){
        return (@Nullable CorrelationData correlationData, boolean ack, @Nullable String cause) ->{
            if(ack){
                System.out.println("发送者确认发送给了MQ成功。");
            }else{
                System.out.println("发送者发送给MQ失败，考虑重发：" + cause);
            }
        };
    }
    ///失败通知//
    @Bean
    public RabbitTemplate.ReturnCallback returnCallback(){
        return  (Message message, int replyCode, String replyText, String exchange, String routingKey) -> {
            System.out.println("无法路由消息，需要考虑另外处理。");
            System.out.println("Returned replyText:" + replyText);
            System.out.println("Returned exchange:" + exchange);
            System.out.println("Returned routingKey:" + routingKey);
            String messageJson = new String(message.getBody());
            System.out.println("Returned message:" + messageJson);
        };
    }

    ///使用RabbitMQ系统缺省的交换器（direct交换器）//
    @Bean
    public Queue helloQueue(){
        return new Queue(RabbitMQConst.QUEUE_HELLO);
    }
    @Bean
    public Queue userQueue(){
        return new Queue(RabbitMQConst.QUEUE_USER);
    }

    ///Topic交换器//
    @Bean
    public Queue topicEmailQueue(){
        return new Queue(RabbitMQConst.QUEUE_TOPIC_EMAIL);
    }
    @Bean
    public Queue topicUserQueue(){
        return new Queue(RabbitMQConst.QUEUE_TOPIC_USER);
    }

    /**
     * 申明交换器
     * @return
     */
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange(RabbitMQConst.EXCHANGE_TOPIC);
    }

    /**
     * 绑定路由键
     * @return
     */
    @Bean
    public Binding bindingTopicEmailExchangeMessage(){
        return BindingBuilder.bind(topicEmailQueue())
                .to(topicExchange())
                .with("q.*.email");
    }
    /**
     * 绑定路由键
     * @return
     */
    @Bean
    public Binding bindingTopicUserExchangeMessage(){
        return BindingBuilder.bind(topicUserQueue())
                .to(topicExchange())
                .with("q.*.user");
    }

    ///Fanout交换器//
    /**
     * 申明交换器
     * @return
     */
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange(RabbitMQConst.EXCHANGE_FANOUT);
    }

    @Bean
    public Queue fanoutQueue(){
        return  new Queue(RabbitMQConst.QUEUE_FANOUT);
    }

    @Bean
    public Binding bindingFanoutExchange(){
        return BindingBuilder.bind(fanoutQueue())
                .to(fanoutExchange());
    }
}

默认direct的生产者

package com.kevin.sender;

import com.kevin.consts.RabbitMQConst;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 描述：默认direct的生产者组件定义<br/>
 * 创建人： Kevin Lea <br/>
 * 创建时间： 2019-10-8 16:40<br/>
 * 版本：1.0
 */
@Component
public class DefaultSender {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void send(String message){
        String sendMessage = message + "---" + System.currentTimeMillis();
        System.out.println("Sender:" + sendMessage);
        this.rabbitTemplate.convertAndSend(RabbitMQConst.QUEUE_HELLO,sendMessage);
    }
}

direct通过RabbitListener监听消费者

package com.kevin.sender;

import com.kevin.consts.RabbitMQConst;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * 描述：通过监听队列来处理消息<br/>
 * 创建人： Kevin Lea <br/>
 * 创建时间： 2019-10-8 16:52<br/>
 * 版本：1.0
 */
@Component
@RabbitListener(queues = RabbitMQConst.QUEUE_HELLO)
public class HelloReceiver {

    @RabbitHandler
    public void process(String hello){
        System.out.println("HelloReceiver>>>>>>>>>" + hello);
    }

}

direct实现ChannelAwareMessageListener接口手动应答模式

package com.kevin.sender;

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.stereotype.Component;

/**
 * 描述：实现ChannelAwareMessageListener 接口，手动应答<br/>
 * 如果配置里配置了手动应答，那么消费者必须实现ChannelAwareMessageListener 来处理<br/>
 * 创建人： Kevin Lea <br/>
 * 创建时间： 2019-10-8 16:46<br/>
 * 版本：1.0
 */
@Component
public class UserReceiver implements ChannelAwareMessageListener {
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        try {
            String msg = new String(message.getBody());
            System.out.println("UserReceiver>>>>>>>接收到消息：" + msg);
            try {
                channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
                System.out.println("UserReceiver>>>>>>>消息已消费");
            }catch (Exception e){
                channel.basicNack(message.getMessageProperties().getDeliveryTag(),false,true);
                System.out.println("UserReceiver>>>>>>>拒绝消息，要求MQ重新派发");
                throw e;
            }
        }catch (Exception ex){
            System.out.println(ex.getMessage());
        }
    }
}

fanout生产者

package com.kevin.sender;

import com.kevin.consts.RabbitMQConst;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 描述：Fanout生产者<br/>
 * 创建人： Kevin Lea <br/>
 * 创建时间： 2019-10-8 17:00<br/>
 * 版本：1.0
 */
@Component
public class FanoutSender {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void send(String message){
        String sendMessage = message + "---" + System.currentTimeMillis();
        System.out.println("Sender:" + sendMessage);
        this.rabbitTemplate.convertAndSend(RabbitMQConst.EXCHANGE_FANOUT,"",sendMessage);
    }
}

fanout消费者

package com.kevin.sender;

import com.kevin.consts.RabbitMQConst;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * 描述：Fanout消费者<br/>
 * 创建人： Kevin Lea <br/>
 * 创建时间： 2019-10-8 17:02<br/>
 * 版本：1.0
 */
@Component
@RabbitListener(queues = RabbitMQConst.QUEUE_FANOUT)
public class FanoutReceiver {

    @RabbitHandler
    public void process(String message){
        System.out.println("FanoutReceiver >>>>>>>>>" + message);
    }
}

topic生产者

package com.kevin.sender;

import com.kevin.consts.RabbitMQConst;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 描述：Topic生产者<br/>
 * 这里模拟发送了3条消息<br/>
 * 分别发送到eamil队列，user队列和一个error队列<br/>
 * 其中消费者eamil，user正常接收消息，error无法路由，回到发送失败通知回调里<br/>
 * 创建人： Trouble Li <br/>
 * 创建时间： 2019-10-8 17:05<br/>
 * 版本：1.0
 */
@Component
public class TopicSender {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void send(){
        String message1 = "I am email message....";
        System.out.println("TopicSender send the 1st>>>>>>>>>>>" + message1);
        this.rabbitTemplate.convertAndSend(RabbitMQConst.EXCHANGE_TOPIC,RabbitMQConst.RK_EMAIL,message1);
        String message2 = "I am user message....";
        System.out.println("TopicSender send the 2nd>>>>>>>>>>>" + message2);
        this.rabbitTemplate.convertAndSend(RabbitMQConst.EXCHANGE_TOPIC,RabbitMQConst.RK_USER,message2);
        String message3 = "I am error message....";
        System.out.println("TopicSender send the 3rd>>>>>>>>>>>" + message3);
        this.rabbitTemplate.convertAndSend(RabbitMQConst.EXCHANGE_TOPIC,"errorKey",message3);
    }
}

topic email消费者

package com.kevin.sender;

import com.kevin.consts.RabbitMQConst;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * 描述：Topic eamil消费者，只消费自己监听的队列<br/>
 * 创建人： Kevin Lea <br/>
 * 创建时间： 2019-10-8 17:09<br/>
 * 版本：1.0
 */
@Component
@RabbitListener(queues = RabbitMQConst.QUEUE_TOPIC_EMAIL)
public class TopicEmailReceiver {

    @RabbitHandler
    public void process(String message){
        System.out.println("TopicEmailReceiver <<<<<<<<" + message);
    }
}

topic user消费者

package com.kevin.sender;

import com.kevin.consts.RabbitMQConst;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * 描述：Topic user消费者，只消费自己监听的队列<br/>
 * 创建人： Kevin Lea <br/>
 * 创建时间： 2019-10-8 17:09<br/>
 * 版本：1.0
 */
@Component
@RabbitListener(queues = RabbitMQConst.QUEUE_TOPIC_USER)
public class TopicUserReceiver {

    @RabbitHandler
    public void process(String message){
        System.out.println("TopicUserReceiver <<<<<<<<" + message);
    }
}

定义一个简单controller做测试

package com.kevin.controller;

import com.kevin.sender.DefaultSender;
import com.kevin.sender.FanoutSender;
import com.kevin.sender.TopicSender;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 描述：测试的controller，测试rabbitmq与springboot集成<br/>
 * 创建人： Kevin Lea <br/>
 * 创建时间： 2019-10-8 16:25<br/>
 * 版本：1.0
 */
@RestController
@RequestMapping("/rabbit")
public class RabbitController {

    @Autowired
    private DefaultSender defaultSender;
    @Autowired
    private TopicSender topicSender;
    @Autowired
    private FanoutSender fanoutSender;

    @RequestMapping("/hello")
    public void hello(){
        defaultSender.send("hello");
    }

    @RequestMapping("/topic")
    public void topic(){
        topicSender.send();
    }

    @RequestMapping("/fanout")
    public void fanout(){
        fanoutSender.send("fanout hello");
    }
}

最后定义一个springboot入口

package com.kevin;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * 描述：sprigboot启动入口<br/>
 * 创建人： Kevin Lea <br/>
 * 创建时间： 2019-10-8 10:59<br/>
 * 版本：1.0
 */
@SpringBootApplication
public class RabbitMQProductApplication {

    public static void main(String[] args) {
        SpringApplication.run(RabbitMQProductApplication.class,args);
    }

}

到这里RabbitMQ与SpringBoot集成就集成完成了。
我们简单的看下topic的测试结果：
在浏览器中输入http://localhost:8080/rabbit/topic
后台日志会输出对应结果

TopicSender send the 1st>>>>>>>>>>>I am email message....
TopicSender send the 2nd>>>>>>>>>>>I am user message....
TopicEmailReceiver <<<<<<<<I am email message....
TopicSender send the 3rd>>>>>>>>>>>I am user message....
发送者确认发送给了MQ成功。
TopicUserReceiver <<<<<<<<I am user message....
发送者确认发送给了MQ成功。
无法路由消息，需要考虑另外处理。
Returned replyText:NO_ROUTE
Returned exchange:exchange.topic
Returned routingKey:errorKey
Returned message:I am user message....
发送者确认发送给了MQ成功。

从结果上看email和user都能够正常的消费，但是error无法路由，进入了失败者通知

Kevin Lea
关注
专栏目录
RabbitMQ 生产者消费者例子和执行流程
weixin_43246116的博客
12-12 941
依赖 <dependencies> <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>4.0.3...
如何在idea中配置Rabbitmq的生产者和消费者
cyberpunk_Isme的博客
10-21 739
从生产者角度： 首先在项目的pom文件当中导入amqp坐标，然后在application.yml文件中加入rabbitmq的相关ip，port，账户和密码，然后是标记队列交换机，队列和路由键。然后在启动类中创建@Bean将前面的交换机，队列和路由键进行创建并绑定。 @Autowired private Environment env; @Bean public DirectExchange basicExchange(){ return new DirectExch
springboot项目中使用rabbitMQ
qq_46112170的博客
10-14 823
springboot+rabbitmq使用demo
java rabbitmq消费者,RabbitMQ与spring集成,配置完整的生产者和消费者
weixin_29204749的博客
03-13 209
RabbitMQ与AMQP协议详解可以看看这个 http://www.cnblogs.com/frankyou/p/5283539.html下面是rabbitMQ和spring集成的配置,我配置了二种ExCahange: topicExchange和directExChangexmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:c...
rocketmq整合springboot关于启动报空指针/使用configuration注解注入容器
weixin_42642782的博客
07-07 1781
rocketmq整合springboot关于启动报空指针/使用configuration注解注入容器 整合rocketmq整合springboot时，发现启动报错 @Configuration @RocketMQMessageListener(topic = "topicTest",consumerGroup = "please_rename_unique_group_name") public class RocketmqListener implements RocketMQListener<St
SpringBoot集成消息中间件RabbitMQ（八）
Noneplus
08-02 2167
一.初识RabbitMQ 二.RabbitMQ常见三种分发策略 三. 搭建RabbitMQ环境 四.SpringBoot集成RabbitMQ 一.初识RabbitMQ 什么是RabbitMQ？ 使用Erlang语言编写的一种消息中间件。 什么是消息中间件？ 一种数据传送的消息传递机制，换句话说，是一种软件应用之间的通讯方式。 举个栗子： 消息中间件的作用之一是应用解耦。 拿取快递为例，前几年的...
Rabbitmq消息中间件初步学习——第二节SpringBoot集成Rabbitmq
Burnup_110的博客
02-14 465
前言 本节主要涉及到Rabbitmq在SpringBoot的API使用，基本是上一节的一个扩展，也会简单的介绍一下七种模型和Header Exchange的使用，不过使用场景从原生变成了SpringBoot封装。 对于七种模型和Header Exchange的介绍会很简单提及，如果想详细了解，可以看一下上一节内容。 一 Hello Word Hello Word 模型采用默认Exchange，以Queue Name作为RoutingKey的方式进行消息发布。 ...
简单的RabbitMQ集成Springboot实现订单异步发送功能示例以及RabbitMQ的相关问题
captian_900331的博客
06-02 1569
【代码】简单的RabbitMQ集成Springboot实现订单异步发送功能示例。
SpringBoot集成RabbitMQ消息中间件.zip
09-02
SpringBoot集成RabbitMQ消息中间件
RabbitMQ整合SpringBoot综合应用
06-19
在IT行业中，消息队列（Message Queue）是解决系统间异步通信和解耦的关键工具，而RabbitMQ作为一款广泛使用的开源消息中间件，它提供了高效、可靠的消息传递功能。本篇主要讨论如何将RabbitMQ与SpringBoot进行整合...
RabbitMQ与SpringBoot整合.docx
06-19
### RabbitMQ与SpringBoot整合详解 #### 一、RabbitMQ简介 RabbitMQ作为一款高效、可靠的消息中间件，在分布式系统中扮演着至关重要的角色。消息中间件是一类基础软件，其主要职责是在分布式系统中实现消息的发送...
springboot-integrate-rabbitmq:springboot-集成-rabbitmq
03-16
本项目"springboot-integrate-rabbitmq"正是关于如何将Spring Boot与RabbitMQ集成的实践示例。 首先，我们要理解Spring Boot集成RabbitMQ的基本步骤。这通常包括以下部分： 1. **依赖添加**：在Spring Boot项目中...
springboot与常用消息中间件的简单使用
weixin_44416026的博客
01-18 621
springboot与常用消息中间件的简单使用
Spring-amqp 1.6.1消费者手工对消息进行确认
Revivedsun的专栏
11-19 3255
在使用Spring amqp创建消费者并接收消息时，通常会用到下面两个接口。public interface MessageListener { void onMessage(Message message);}public interface ChannelAwareMessageListener { void onMessage(Message message, Channel c
springboot 2.x整合rabbitmq之使用自定义Listener
adminit的博客
03-30 2304
1、在pom.xml中引入相关依赖 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation...
SpringBoot使用RabbitMQ做消息中间件
芸灵fly的博客
03-25 5232
说明MQ全称为Message Queue, 消息队列（MQ）是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息（针对应用程序的数据）来通信，而无需专用连接来链接它们。消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是用于诸如远程过程调用的技术。排队指的是应用程序通过 队列来通信。队列的使用除去了接收和发送应用程序同时执行的要求。MQ是消...
rabbitMq集成Spring后，消费者设置手动ack，并且在业务上控制是否ack
热门推荐
Java程序员的进阶之路
08-19 4万+
rabbitMq集成Spring后，消费者设置手动ack，并且在业务上控制是否ack
“人力资源+大数据+薪酬报告+涨薪调薪”
09-18
人力资源+大数据+薪酬报告+涨薪调薪，在学习、工作生活中，越来越多的事务都会使用到报告，通常情况下，报告的内容含量大、篇幅较长。那么什么样的薪酬报告才是有效的呢？以下是小编精心整理的调薪申请报告，欢迎大家分享。相信老板看到这样的报告，一定会考虑涨薪的哦。
java-ssm+vue高校课程评价系统实现源码(项目源码-说明文档)
最新发布
09-18
管理员登陆系统后，可以查看首页，个人中心，指标信息管理，课程管理，院系管理，专业管理，班级管理，教师管理，专家管理，学生管理，课程信息管理，等功能，还能对每个功能逐一进行相应操作 项目关键技术 开发工具：IDEA 、Eclipse 编程语言: Java 数据库: MySQL5.7+ 后端技术：ssm 前端技术：Vue 关键技术：springboot、SSM、vue、MYSQL、MAVEN 数据库工具：Navicat、SQLyog
RabbitMQ与SpringBoot整合教程：消息中间件深度解析
"RabbitMQ是一种广泛使用的消息中间件，用于实现应用间的解耦和异步通信。本文档将深入探讨RabbitMQ的介绍、由来，以及如何与SpringBoot进行整合。同时，也会涉及AMQP协议的基本概念，包括Broker、Virtualhost和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值