SpringBoot整合RabbitMQ

最新推荐文章于 2024-08-13 22:02:45 发布
最新推荐文章于 2024-08-13 22:02:45 发布
阅读量1.2k 收藏 1
点赞数 2
分类专栏： 分布式与微服务 文章标签： rabbitmq spring boot java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44742328/article/details/122448367
版权

导入依赖

 <!--springboot整合rabbitmq的依赖-->
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-amqp</artifactId>
 </dependency>

一、简单整合

我们这里在两个项目中完成一个生产者项目，一个消费者项目

生产者

配置文件

server.port=8080
spring.rabbitmq.host=192.168.195.157
spring.rabbitmq.port=5672
spring.rabbitmq.virtual-host=/
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest

controller（发送端）

/**
 * 生产者模拟请求发送
 * @author acoffee
 * @create 2022-01-12 12:00
 */
@RestController
public class SendController {

    @Autowired
    RabbitTemplate rabbitTemplate;

    @RequestMapping("/sendmail")
    public String sendmail(){
        //发送消息
        rabbitTemplate.convertAndSend("exchangetopic","email","email");
        return "sendmail";
    }

    @RequestMapping("/sendsms")
    public String sendSms(){
        //发送消息
        rabbitTemplate.convertAndSend("exchangetopic","sms","sms");
        return "sendsms";
    }

    @RequestMapping("/sendall")
    public String sendAll(){
        //发送消息
        rabbitTemplate.convertAndSend("exchangetopic","sms.email","sms.email");
        return "sendall";
    }
}

消费者

配置文件

server.port=8081
spring.rabbitmq.host=192.168.195.157
spring.rabbitmq.port=5672
spring.rabbitmq.virtual-host=/
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest

配置类

/**
 * Rabbitmq配置类,定义交换机,队列,绑定
 *
 * @author acoffee
 * @create 2022-01-12 12:12
 */
@Configuration
public class RabbitmqConfiguration {

    //定义交换机
    @Bean
    public TopicExchange exchangeTopic() {
        return new TopicExchange("exchangetopic");
    }

    //定义队列
    @Bean
    public Queue queueMail() {
        return new Queue("queueemail");
    }

    @Bean
    public Queue queueMsg() {
        return new Queue("queuesms");
    }

    @Bean
    public Binding bindingEmail(TopicExchange exchange, Queue queueMail) {
        return BindingBuilder.bind(queueMail).to(exchange).with("#.email.#");
    }

    @Bean
    public Binding bindingMsg(TopicExchange exchange, Queue queueMsg) {
        return BindingBuilder.bind(queueMsg).to(exchange).with("#.sms.#");
    }
}

消费者处理请求

/**
 * 定义一个bean,消费者,监听队列,定义处理消息的方法
 *
 * @author acoffee
 * @create 2022-01-12 13:05
 */
@Component
public class MyConsumer {

    //指定当前方法监听那个队列
    //String msg: 消息体
    //Message: 消息对象
    //Channel: 信道
    @RabbitListener(queues = "queueemail")
    public void receiveEmail(String msg, Message message, Channel channel) {
        System.out.println("处理Email");
        System.out.println("msg:" + msg);
        System.out.println("message:" + message);
        System.out.println("channel:" + channel);
        System.out.println("---------------");
    }

    @RabbitListener(queues = "queuesms")
    public void receiveSms(String msg, Message message, Channel channel) {
        System.out.println("处理Sms");
        System.out.println("msg:" + msg);
        System.out.println("message:" + message);
        System.out.println("channel:" + channel);
        System.out.println("---------------");
    }
}

执行结果：
在这里插入图片描述
在这里插入图片描述

二、生产者消息确认

配置文件

server.port=8080
spring.rabbitmq.host=192.168.195.157
spring.rabbitmq.port=5672
spring.rabbitmq.virtual-host=/
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
#生产者confrim
#spring.rabbitmq.publisher-confirms=true
spring.rabbitmq.publisher-confirm-type=correlated
#生产者return
spring.rabbitmq.publisher-returns=true

添加配置类开启监听

package com.acoffee.configuration;

import org.springframework.amqp.core.ReturnedMessage;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;

/**
 * 实现配置类型，实现接口方法，启动生产者确认
 * @author acoffee
 * @create 2022-01-12 15:09
 */
@Configuration
public class CallbackConfiguration implements RabbitTemplate.ConfirmCallback, RabbitTemplate.ReturnsCallback {

    @Autowired
    RabbitTemplate rabbitTemplate;

    //@PostConstruct @PreDestroy：类似生命周期函数
    @PostConstruct
    public void setUp(){
        rabbitTemplate.setConfirmCallback(this);
        rabbitTemplate.setReturnsCallback(this);
    }

    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        System.out.println("confirm");
        System.out.println("correlationData:"+correlationData);
        System.out.println("ack:"+ack);
        System.out.println("cause:"+cause);
        System.out.println("-----------------");
    }

    @Override
    public void returnedMessage(ReturnedMessage returned) {
        System.out.println("Return");
        System.out.println("message:"+returned.getMessage());
        System.out.println("replyText:"+returned.getReplyText());
        System.out.println("exchange:"+returned.getExchange());
        System.out.println("routingKey"+returned.getRoutingKey());
        System.out.println("-----------------");
    }
}

执行结果：

我们测试了三种

第一种：故意将exchange的名字写错，可以看出返回的 ack 为 false 就是我们说的 nack，并且从cause中就可以看出错误原因，我们原来也说过在基础api中是看不到nack的，在springboot中是可以的。
在这里插入图片描述
第二种：故意写错routingKey，从结果可以看出的ack为true，说明的已经到交换机了，但是由于通过routingKey找不到对应的管道所以给我们返回了消息，在replyText中也可以看到replyText:NO_ROUTE造成的
在这里插入图片描述第三种：正确情况
只返回了confirm中的信息，可以看出ack为true，并且消费者也接收并处理了消息

在这里插入图片描述
在这里插入图片描述

三、消费者消息确认

自动确认

默认就是自动确认，一下全取出来，宕机就会出现问题

在这里插入图片描述

手动确认+限流

消费者配置文件

server.port=8081
spring.rabbitmq.host=192.168.195.157
spring.rabbitmq.port=5672
spring.rabbitmq.virtual-host=/
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
#消费者手动确认
spring.rabbitmq.listener.simple.acknowledge-mode=manual
#限流
spring.rabbitmq.listener.simple.prefetch=1

@RabbitListener(queues = "queueemail")
public void receiveEmail(String msg, Message message, Channel channel) throws Exception {

    System.out.println("处理Email");
    System.out.println("msg:" + msg);
    System.out.println("message:" + message);
    System.out.println("channel:" + channel);
    //手动确认
    channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    System.out.println("---------------");
}

执行结果：
一个一个读取，一个一个确认
在这里插入图片描述

四、消息属性

@RequestMapping("/sendmail")
public String sendmail() {
    	//发送消息
        rabbitTemplate.convertAndSend("exchangetopic", "email", "email1",
                //设置消息属性
                new MessagePostProcessor() {
                    @Override
                    public Message postProcessMessage(Message message) throws AmqpException {
                        message.getMessageProperties().setExpiration("10000");
                        //message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
                        message.getMessageProperties().getHeaders().put("h1", "v1");
                        message.getMessageProperties().getHeaders().put("h2", "v2");
                        return message;
                    }
                });
    return "sendmail";
}

执行结果：
在这里插入图片描述

五、对象存储

配置类中添加JSON消息转化器，底层默认使用的Jackson

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

消费者和生产者都要配置实体类，且包名和类名必须一样

生产者

@RequestMapping("/sendsms")
public String sendSms() {
    //发送消息:传对象
    rabbitTemplate.convertAndSend("exchangetopic", "sms", new Student(1,"tom"));
    return "sendsms";
}

消费者

@RabbitListener(queues = "queuesms")
public void receiveSms(Student msg, Message message, Channel channel) throws IOException {
    System.out.println("处理Sms");
    System.out.println("msg:" + msg);
    System.out.println("message:" + message);
    System.out.println("channel:" + channel);
    //手动确认
    channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    System.out.println("---------------");
}

执行结果：
在这里插入图片描述

六、死信队列

生产者

    @RequestMapping("/sendorder")
    public String sendOrder(){
        //发送消息
        System.out.println("订单产生时间"+new Date());
        rabbitTemplate.convertAndSend("exchangeorder","order","order--info");
        return "sendorder";
    }

消费者

配置模拟队列以及死信队列

@Bean
public TopicExchange exchangeOrder(){
    return new TopicExchange("exchangeorder");
}

@Bean
public Queue queueorder(){
    HashMap<String, Object> args = new HashMap<>();
    //10秒过期，直接进入指定的死信队列
    args.put("x-message-ttl",10000);
    args.put("x-dead-letter-exchange","exchangeorderdlx");
    args.put("x-dead-letter-routing-key","orderdlx");
    Queue queueorder = new Queue("queueorder", true, false, false, args);
    return queueorder;
}

@Bean
public Binding bindingqueueorder(Queue queueorder,TopicExchange exchangeorder){
    return BindingBuilder.bind(queueorder).to(exchangeorder).with("#.order.#");
}

@Bean
public TopicExchange exchangeorderdlx(){
    return new TopicExchange("exchangeorderdlx");
}

@Bean
public Queue queueorderdlx(){
    Queue queueorderdlx = new Queue("queueorderdlx");
    return queueorderdlx;
}

@Bean
public Binding bindingqueueorderdlx(Queue queueorderdlx,TopicExchange exchangeorderdlx){
    return BindingBuilder.bind(queueorderdlx).to(exchangeorderdlx).with("#.orderdlx.#");
}

在死信队列中处理消息

@RabbitListener(queues = "queueorderdlx")
public void receiveOrdereddlx(String msg, Message message, Channel channel) throws IOException {
    System.out.println("处理queueorderdlx");
    System.out.println("msg:" + msg);
    System.out.println("message:" + message);
    System.out.println("channel:" + channel);
    //手动确认
    channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    System.out.println("---------------");
}

七、延迟队列

安装延迟插件

下载地址
在这里插入图片描述
我用的是自己的包，这里需要注意版本兼容问题。

传到linux上去，然后安装解压软件

yum install zip
yum install -y unzip

解压

unzip 要解压的文件 -d 解压的目标位置
unzip rabbitmq_delayed_message_exchange-20171201-3.7.x.zip -d /usr/lib/rabbitmq/lib/rabbitmq_server-3.7.16/plugins/

在这里插入图片描述

查看插件列表

rabbitmq-plugins list

在这里插入图片描述

安装

rabbitmq-plugins enable rabbitmq_delayed_message_exchange

重启

systemctl restart rabbitmq-server

启用延迟队列：发送消息，立即发送到交换机，进入交换以后到了指定延迟时间，才从交换机发送的队列

交换机启用

    @Bean
    public TopicExchange exchangedelay(){
        TopicExchange exchangedelay = new TopicExchange("exchangedelay");
        //交换机启用延迟
        exchangedelay.setDelayed(true);
        return exchangedelay;
    }

    @Bean
    public Queue queuedelay(){
        Queue queuedelay = new Queue("queuedelay");
        return queuedelay;
    }

    @Bean
    public Binding bindingqueuedelay(Queue queuedelay,TopicExchange exchangedelay){
        return BindingBuilder.bind(queuedelay).to(exchangedelay).with("#.delay.#");
    }

消息属性设置

@RequestMapping("/senddelay")
public String sendDelay(){
    //发送消息
    System.out.println("延迟队列发送时间:"+new Date());
    rabbitTemplate.convertAndSend("exchangedelay", "delay", "delay--info",
            new MessagePostProcessor() {
                @Override
                public Message postProcessMessage(Message message) throws AmqpException {
                	//延迟十秒进入队列
                    message.getMessageProperties().setDelay(10000);
                    return message;
                }
            }
    );

    return "senddelay";
}

执行结果：

从结果我们可以看出它先是报没有路由，因为他在转换机中等十秒才会进入队列，而服务器会直接响应回return信息，等十秒就会看到结果，如果不想看，这里我们可以做一些判断，避免这种信息
在这里插入图片描述
在这里插入图片描述

八、完整代码

依赖

   <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--springboot整合rabbitmq的依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
    </dependencies>

生产者

server.port=8080
spring.rabbitmq.host=192.168.195.157
spring.rabbitmq.port=5672
spring.rabbitmq.virtual-host=/
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
#生产者confrim
#spring.rabbitmq.publisher-confirms=true
spring.rabbitmq.publisher-confirm-type=correlated
#生产者return
spring.rabbitmq.publisher-returns=true
#解决循环依赖问题2.6.x可能会出现
spring.main.allow-circular-references=true

实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student implements Serializable {
    int id;
    String name;
}

配置类

@Configuration
public class CallbackConfiguration implements RabbitTemplate.ConfirmCallback, RabbitTemplate.ReturnsCallback {

    @Autowired
    RabbitTemplate rabbitTemplate;

    //@PostConstruct @PreDestroy：类似生命周期函数
    @PostConstruct
    public void setUp(){
        rabbitTemplate.setConfirmCallback(this);
        rabbitTemplate.setReturnsCallback(this);
    }

    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        System.out.println("confirm");
        System.out.println("correlationData:"+correlationData);
        System.out.println("ack:"+ack);
        System.out.println("cause:"+cause);
        System.out.println("-----------------");
    }

    @Override
    public void returnedMessage(ReturnedMessage returned) {
        System.out.println("Return");
        System.out.println("message:"+returned.getMessage());
        System.out.println("replyText:"+returned.getReplyText());
        System.out.println("exchange:"+returned.getExchange());
        System.out.println("routingKey"+returned.getRoutingKey());
        System.out.println("-----------------");
    }

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

controller层(发送请求)

import com.acoffee.entity.Student;
import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;

/**
 * 生产者模拟请求发送
 *
 * @author acoffee
 * @create 2022-01-12 12:00
 */
@RestController
public class SendController {

    @Autowired
    RabbitTemplate rabbitTemplate;

    @RequestMapping("/sendmail")
    public String sendmail() {
        //发送消息
        for (int i = 1; i <= 10; i++) {
            rabbitTemplate.convertAndSend("exchangetopic", "email", "email" + i,
                    //设置消息属性
                    new MessagePostProcessor() {
                        @Override
                        public Message postProcessMessage(Message message) throws AmqpException {
                            //过期时间
                            message.getMessageProperties().setExpiration("10000");
                            //message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
                            message.getMessageProperties().getHeaders().put("h1", "v1");
                            message.getMessageProperties().getHeaders().put("h2", "v2");
                            return message;
                        }
                    });
        }
        return "sendmail";
    }

    @RequestMapping("/sendsms")
    public String sendSms() {
        //发送消息:传对象
        rabbitTemplate.convertAndSend("exchangetopic", "sms", new Student(1,"tom"));
        return "sendsms";
    }

    @RequestMapping("/sendall")
    public String sendAll() {
        //发送消息
        rabbitTemplate.convertAndSend("exchangetopic", "sms.email", "sms.email");
        return "sendall";
    }

    @RequestMapping("/sendorder")
    public String sendOrder(){
        //发送消息
        System.out.println("订单产生时间"+new Date());
        rabbitTemplate.convertAndSend("exchangeorder","order","order--info");
        return "sendorder";
    }

    @RequestMapping("/senddelay")
    public String sendDelay(){
        //发送消息
        System.out.println("延迟队列发送时间:"+new Date());
        rabbitTemplate.convertAndSend("exchangedelay", "delay", "delay--info",
                new MessagePostProcessor() {
                    @Override
                    public Message postProcessMessage(Message message) throws AmqpException {
                        message.getMessageProperties().setDelay(10000);
                        return message;
                    }
                }
        );

        return "senddelay";
    }
}

消费者

实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student implements Serializable {
    int id;
    String name;
}

配置类

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.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;

/**
 * Rabbitmq配置类,定义交换机,队列,绑定
 *
 * @author acoffee
 * @create 2022-01-12 12:12
 */
@Configuration
public class RabbitmqConfiguration {

    //定义交换机
    @Bean
    public TopicExchange exchangeTopic() {
        return new TopicExchange("exchangetopic");
    }

    //定义队列
    @Bean
    public Queue queueMail() {
        return new Queue("queueemail");
    }

    @Bean
    public Queue queueMsg() {
        return new Queue("queuesms");
    }

    @Bean
    public Binding bindingEmail(TopicExchange exchangeTopic, Queue queueMail) {
        return BindingBuilder.bind(queueMail).to(exchangeTopic).with("#.email.#");
    }

    @Bean
    public Binding bindingMsg(TopicExchange exchangeTopic, Queue queueMsg) {
        return BindingBuilder.bind(queueMsg).to(exchangeTopic).with("#.sms.#");
    }

    //对象转json
    @Bean
    public MessageConverter messageConverter(){
        return new Jackson2JsonMessageConverter();
    }


    @Bean
    public TopicExchange exchangeOrder(){
        return new TopicExchange("exchangeorder");
    }

    @Bean
    public Queue queueorder(){
        HashMap<String, Object> args = new HashMap<>();
        args.put("x-message-ttl",10000);
        args.put("x-dead-letter-exchange","exchangeorderdlx");
        args.put("x-dead-letter-routing-key","orderdlx");
        Queue queueorder = new Queue("queueorder", true, false, false, args);
        return queueorder;
    }

    @Bean
    public Binding bindingqueueorder(Queue queueorder,TopicExchange exchangeOrder){
        return BindingBuilder.bind(queueorder).to(exchangeOrder).with("#.order.#");
    }

    @Bean
    public TopicExchange exchangeorderdlx(){
        return new TopicExchange("exchangeorderdlx");
    }

    @Bean
    public Queue queueorderdlx(){
        Queue queueorderdlx = new Queue("queueorderdlx");
        return queueorderdlx;
    }

    @Bean
    public Binding bindingqueueorderdlx(Queue queueorderdlx,TopicExchange exchangeorderdlx){
        return BindingBuilder.bind(queueorderdlx).to(exchangeorderdlx).with("#.orderdlx.#");
    }

    //延迟队列
    @Bean
    public TopicExchange exchangedelay(){
        TopicExchange exchangedelay = new TopicExchange("exchangedelay");
        //交换机启用延迟
        exchangedelay.setDelayed(true);
        return exchangedelay;
    }

    @Bean
    public Queue queuedelay(){
        Queue queuedelay = new Queue("queuedelay");
        return queuedelay;
    }

    @Bean
    public Binding bindingqueuedelay(Queue queuedelay,TopicExchange exchangedelay){
        return BindingBuilder.bind(queuedelay).to(exchangedelay).with("#.delay.#");
    }
}

MyConsumer 类

/**
 * 定义一个bean,消费者,监听队列,定义处理消息的方法
 *
 * @author acoffee
 * @create 2022-01-12 13:05
 */
@Component
public class MyConsumer {
    
    //指定当前方法监听那个队列
    //String msg: 消息体
    //Message: 消息对象
    //Channel: 信道
    @RabbitListener(queues = "queueemail")
    public void receiveEmail(String msg, Message message, Channel channel) throws Exception {

        Thread.sleep(10000);

        System.out.println("处理Email");
        System.out.println("msg:" + msg);
        System.out.println("message:" + message);
        System.out.println("channel:" + channel);
        //手动确认
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        System.out.println("---------------");
    }
    
    @RabbitListener(queues = "queuesms")
    public void receiveSms(Student msg, Message message, Channel channel) throws IOException {
        System.out.println("处理Sms");
        System.out.println("msg:" + msg);
        System.out.println("message:" + message);
        System.out.println("channel:" + channel);
        //手动确认
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        System.out.println("---------------");
    }
}
vid。
关注
专栏目录
spring boot整合RabbitMq
weixin_44105305的博客
03-29 233
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。（但是关于rabbitMq的安装，就不介绍了）在安装完rabbitMq后，输入http://ip:15672/ ，是可以看到一个简单后台管理界面的。可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。
SpringBoot 集成 RabbitMQ
爱笑的boy的博客
03-04 9427
SpringBoot 集成 RabbitMQ
SpringBoot中整合RabbitMQ（测试+部署上线 最完整）
qq_73440769的博客
08-12 2899
包括RabbitMQ在虚拟机本地测试和部署上线通过微信小程序测试，包括Java代码使用示例，也有部署RabbitMQ中的一些困难和解决办法，和最后的解决，配置部署代码一条龙。
spring boot整合RabbitMQ
qq_55648724的博客
03-08 842
无
SpringBoot整合RabbitMQ.zip
06-29
SpringBoot整合RabbitMQ的详细过程 **1.该篇博文首先讲述了交换机和队列之间的绑定关系** ①direct、②fanout、③topic **2.然后讲消息的回调** 四种情况下，确认触发哪个回调函数： ①消息推送到server，但是在...
springBoot整合RabbitMQ案例
04-07
SpringBoot整合RabbitMQ是一个常见的后端开发任务，它涉及到分布式消息传递和Java应用程序的集成。RabbitMQ是一个开源的消息代理和队列服务器，而SpringBoot是基于Spring框架的简化版，提供了快速构建应用程序的方式...
Springboot整合RabbitMQ最简单demo
07-11
Springboot整合RabbitMQ最简单demo,适用于springcloud项目,作为消息总线适用,需要安装RabbitMQ,Mac linux可以使用命令行一键安装,在项目配置文件配置好端口即可(已默认配置),启动项目访问8080端口,参数见controller.
springBoot整合rabbitMQ,包括erlang20.3,rabbitmq-server-3.7.14安装包
07-02
springBoot整合rabbitMQ,包括erlang20.3,rabbitmq-server-3.7.14安装包 整合4种常用模式+高级特性死信队列 暂未整合TTL队列 博客地址:...
springboot整合RabbitMQ
05-04
SpringBoot 整合 RabbitMQ 的过程涉及到多个关键知识点，这些知识点包括了消息中间件的基本概念、SpringBoot 的集成方式、RabbitMQ 的配置与使用，以及相关工具的配合。以下是对这些内容的详细阐述。 首先，...
Spring Boot 集成 RabbitMQ
空明的博客
07-15 1500
Spring Boot 集成 RabbitMQ ,记录一些交换器类型、消息投递及消息确认方式的使用。
springboot整合rabbitmq
m0_52307083的博客
04-14 139
springboot整合rabbitmq其中，Sender 类使用 AmqpTemplate 发送消息，Receiver 类使用 @RabbitListener 注解监听消息队列。其中，spring.rabbitm
Spring Boot集成RabbitMQ
最新发布
这河里吗l的博客
08-13 1371
RabbitMQ是一个由Erlang语言编写的消息中间件，它遵循AMQP协议，提供了稳定可靠的消息传输服务。RabbitMQ通过其独特的架构和丰富的功能，帮助开发者解决分布式系统中的消息传递问题，提高系统的可扩展性、可靠性和响应速度。
SpringBoot集成RabbitMQ
abc_138的博客
07-02 2036
RabbitMQ官方提供的Java 客户端编码相对复杂，一般生产环境下我们更多会结合Spring 来使用。而Spring 的官方刚好基于RabbitMQ 提供了这样一套消息收发的模板工具SpringAMQP。
SpringBoot整合RabbitMQ消息队列-学习笔记
热门推荐
kevinmcy的专栏
08-30 1万+
前言 本篇文章主要用于记录个人学习RabbitMQ的过程，记录下来方便日后查看，如有错误的地方，还望指正。 本篇文章比较详细地记录本人在学习过程中的每一个步骤，比较适合对RabbitMQ不熟的同学学习，跟着本文操作一遍，就可以大概知道RabbitMQ的基础知识了。 准备阶段 首先把RabbitMQ环境安装好，下面再详细介绍RabbitMQ各个知识点和如何使用。 由于是基于Centos7的...
SpringBoot 整合RabbitMQ
weixin_42947972的博客
03-27 96
SpringBoot 整合RabbitMQ 生产者步骤 创建生产者工程(可以直接创建springboot的项目,这里并没有直接创建) 引入依赖 <?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:sche
springboot 整合rabbitmq
09-07
- *1* [SpringBoot整合RabbitMQ](https://blog.csdn.net/K_kzj_K/article/details/106642250)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值