spring boot实战(第十二篇)整合RabbitMQ

最新推荐文章于 2023-08-30 20:17:53 发布
最新推荐文章于 2023-08-30 20:17:53 发布
阅读量202 收藏
点赞数
分类专栏： rabbitmq 文章标签： spring boot rabbit mq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zh_ITRoad/article/details/84809785
版权

前言

本篇主要讲述spring Boot与RabbitMQ的整合，内容非常简单，纯API的调用操作。 操作之间需要加入依赖Jar

 

[html]
  1. <dependency>  
  2. <groupId>org.springframework.boot</groupId>  
  3. <artifactId>spring-boot-starter-amqp</artifactId>  
  4. lt;/dependency>  
			<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-amqp</artifactId>
		</dependency>

 

消息生产者

不论是创建消息消费者或生产者都需要ConnectionFactory
 
 

ConnectionFactory配置

创建AmqpConfig文件AmqpConfig.java(后期的配置都在该文件中)
 
[html]
  1. @Configuration  
  2. public class AmqpConfig {  
  3.   
  4.     public static final String EXCHANGE   = "spring-boot-exchange";  
  5.     public static final String ROUTINGKEY = "spring-boot-routingKey";  
  6.   
  7.     @Bean  
  8.     public ConnectionFactory connectionFactory() {  
  9.         CachingConnectionFactory connectionFactory = new CachingConnectionFactory();  
  10.         connectionFactory.setAddresses("127.0.0.1:5672");  
  11.         connectionFactory.setUsername("guest");  
  12.         connectionFactory.setPassword("guest");  
  13.         connectionFactory.setVirtualHost("/");  
  14.         connectionFactory.setPublisherConfirms(true); //必须要设置  
  15.         return connectionFactory;  
  16.     }  
  17. }  
@Configuration
public class AmqpConfig {

    public static final String EXCHANGE   = "spring-boot-exchange";
    public static final String ROUTINGKEY = "spring-boot-routingKey";

    @Bean
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setAddresses("127.0.0.1:5672");
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        connectionFactory.setVirtualHost("/");
        connectionFactory.setPublisherConfirms(true); //必须要设置
        return connectionFactory;
    }
}

这里需要显示调用
[html]
  1. connectionFactory.setPublisherConfirms(true);  
 connectionFactory.setPublisherConfirms(true);
才能进行消息的回调。
 
 

RabbitTemplate

通过使用RabbitTemplate来对开发者提供API操作
[html]
  1. @Bean  
  2. @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)  
  3. //必须是prototype类型  
  4. public RabbitTemplate rabbitTemplate() {  
  5.     RabbitTemplate template = new RabbitTemplate(connectionFactory());  
  6.     return template;  
  7. }  
    @Bean
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    //必须是prototype类型
    public RabbitTemplate rabbitTemplate() {
        RabbitTemplate template = new RabbitTemplate(connectionFactory());
        return template;
    }
这里设置为原型，具体的原因在后面会讲到
  在发送消息时通过调用RabbitTemplate中的如下方法
[html]
  1. public void convertAndSend(String exchange, String routingKey, final Object object, CorrelationData correlationData)  
public void convertAndSend(String exchange, String routingKey, final Object object, CorrelationData correlationData)
  • exchange:交换机名称

  • routingKey:路由关键字

  • object:发送的消息内容

  • correlationData:消息ID

 
因此生产者代码详单简洁

Send.java

[html]
  1. @Component  
  2. public class Send  {  
  3.   
  4.     private RabbitTemplate rabbitTemplate;  
  5.   
  6.     /**  
  7.      * 构造方法注入  
  8.      */  
  9.     @Autowired  
  10.     public Send(RabbitTemplate rabbitTemplate) {  
  11.         this.rabbitTemplate = rabbitTemplate;  
  12.     }  
  13.   
  14.     public void sendMsg(String content) {  
  15.         CorrelationData correlationId = new CorrelationData(UUID.randomUUID().toString());  
  16.         rabbitTemplate.convertAndSend(AmqpConfig.EXCHANGE, AmqpConfig.ROUTINGKEY, content, correlationId);  
  17.     }  
  18.   
  19.        
  20. }  
@Component
public class Send  {

    private RabbitTemplate rabbitTemplate;

    /**
     * 构造方法注入
     */
    @Autowired
    public Send(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }

    public void sendMsg(String content) {
        CorrelationData correlationId = new CorrelationData(UUID.randomUUID().toString());
        rabbitTemplate.convertAndSend(AmqpConfig.EXCHANGE, AmqpConfig.ROUTINGKEY, content, correlationId);
    }

     
}

 

如果需要在生产者需要消息发送后的回调，需要对rabbitTemplate设置ConfirmCallback对象，由于不同的生产者需要对应不同的ConfirmCallback，如果rabbitTemplate设置为单例bean，则所有的rabbitTemplate

实际的ConfirmCallback为最后一次申明的ConfirmCallback。

下面给出完整的生产者代码：

 

[html]
  1. package com.u51.lkl.springboot.amqp;  
  2.   
  3. import java.util.UUID;  
  4.   
  5. import org.springframework.amqp.rabbit.core.RabbitTemplate;  
  6. import org.springframework.amqp.rabbit.support.CorrelationData;  
  7. import org.springframework.beans.factory.annotation.Autowired;  
  8. import org.springframework.stereotype.Component;  
  9.   
  10. /**  
  11.  * 消息生产者  
  12.  *   
  13.  * @author liaokailin  
  14.  * @version $Id: Send.java, v 0.1 2015年11月01日 下午4:22:25 liaokailin Exp $  
  15.  */  
  16. @Component  
  17. public class Send implements RabbitTemplate.ConfirmCallback {  
  18.   
  19.     private RabbitTemplate rabbitTemplate;  
  20.   
  21.     /**  
  22.      * 构造方法注入  
  23.      */  
  24.     @Autowired  
  25.     public Send(RabbitTemplate rabbitTemplate) {  
  26.         this.rabbitTemplate = rabbitTemplate;  
  27.         rabbitTemplate.setConfirmCallback(this); //rabbitTemplate如果为单例的话，那回调就是最后设置的内容  
  28.     }  
  29.   
  30.     public void sendMsg(String content) {  
  31.         CorrelationData correlationId = new CorrelationData(UUID.randomUUID().toString());  
  32.         rabbitTemplate.convertAndSend(AmqpConfig.EXCHANGE, AmqpConfig.ROUTINGKEY, content, correlationId);  
  33.     }  
  34.   
  35.     /**  
  36.      * 回调  
  37.      */  
  38.     @Override  
  39.     public void confirm(CorrelationData correlationData, boolean ack, String cause) {  
  40.         System.out.println(" 回调id:" + correlationData);  
  41.         if (ack) {  
  42.             System.out.println("消息成功消费");  
  43.         } else {  
  44.             System.out.println("消息消费失败:" + cause);  
  45.         }  
  46.     }  
  47.   
  48. }  
package com.u51.lkl.springboot.amqp;

import java.util.UUID;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.support.CorrelationData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 消息生产者
 * 
 * @author liaokailin
 * @version $Id: Send.java, v 0.1 2015年11月01日 下午4:22:25 liaokailin Exp $
 */
@Component
public class Send implements RabbitTemplate.ConfirmCallback {

    private RabbitTemplate rabbitTemplate;

    /**
     * 构造方法注入
     */
    @Autowired
    public Send(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
        rabbitTemplate.setConfirmCallback(this); //rabbitTemplate如果为单例的话，那回调就是最后设置的内容
    }

    public void sendMsg(String content) {
        CorrelationData correlationId = new CorrelationData(UUID.randomUUID().toString());
        rabbitTemplate.convertAndSend(AmqpConfig.EXCHANGE, AmqpConfig.ROUTINGKEY, content, correlationId);
    }

    /**
     * 回调
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        System.out.println(" 回调id:" + correlationData);
        if (ack) {
            System.out.println("消息成功消费");
        } else {
            System.out.println("消息消费失败:" + cause);
        }
    }

}

 

消息消费者

消费者负责申明交换机(生产者也可以申明)、队列、两者的绑定操作。

交换机

[html]
  1. /**  
  2.      * 针对消费者配置  
  3.         FanoutExchange: 将消息分发到所有的绑定队列，无routingkey的概念  
  4.         HeadersExchange ：通过添加属性key-value匹配  
  5.         DirectExchange:按照routingkey分发到指定队列  
  6.         TopicExchange:多关键字匹配  
  7.      */  
  8.     @Bean  
  9.     public DirectExchange defaultExchange() {  
  10.         return new DirectExchange(EXCHANGE);  
  11.     }  
/**
     * 针对消费者配置
        FanoutExchange: 将消息分发到所有的绑定队列，无routingkey的概念
        HeadersExchange ：通过添加属性key-value匹配
        DirectExchange:按照routingkey分发到指定队列
        TopicExchange:多关键字匹配
     */
    @Bean
    public DirectExchange defaultExchange() {
        return new DirectExchange(EXCHANGE);
    }

在Spring Boot中交换机继承AbstractExchange类
 

 

队列

 
[html] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. @Bean  
  2.     public Queue queue() {  
  3.         return new Queue("spring-boot-queue", true); //队列持久  
  4.   
  5.     }  
@Bean
    public Queue queue() {
        return new Queue("spring-boot-queue", true); //队列持久

    }

绑定

[html] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. @Bean  
  2.   public Binding binding() {  
  3.       return BindingBuilder.bind(queue()).to(defaultExchange()).with(AmqpConfig.ROUTINGKEY);  
  4.   }  
  @Bean
    public Binding binding() {
        return BindingBuilder.bind(queue()).to(defaultExchange()).with(AmqpConfig.ROUTINGKEY);
    }
完成以上工作后，在spring boot中通过消息监听容器实现消息的监听，在消息到来时执行回调操作。
 

消息消费

[html]
  1. @Bean  
  2.   public SimpleMessageListenerContainer messageContainer() {  
  3.       SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory());  
  4.       container.setQueues(queue());  
  5.       container.setExposeListenerChannel(true);  
  6.       container.setMaxConcurrentConsumers(1);  
  7.       container.setConcurrentConsumers(1);  
  8.       container.setAcknowledgeMode(AcknowledgeMode.MANUAL); //设置确认模式手工确认  
  9.       container.setMessageListener(new ChannelAwareMessageListener() {  
  10.   
  11.           @Override  
  12.           public void onMessage(Message message, Channel channel) throws Exception {  
  13.               byte[] body = message.getBody();  
  14.               System.out.println("receive msg : " + new String(body));  
  15.               channel.basicAck(message.getMessageProperties().getDeliveryTag(), false); //确认消息成功消费  
  16.           }  
  17.       });  
  18.       return container;  
  19.   }  
  @Bean
    public SimpleMessageListenerContainer messageContainer() {
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory());
        container.setQueues(queue());
        container.setExposeListenerChannel(true);
        container.setMaxConcurrentConsumers(1);
        container.setConcurrentConsumers(1);
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL); //设置确认模式手工确认
        container.setMessageListener(new ChannelAwareMessageListener() {

            @Override
            public void onMessage(Message message, Channel channel) throws Exception {
                byte[] body = message.getBody();
                System.out.println("receive msg : " + new String(body));
                channel.basicAck(message.getMessageProperties().getDeliveryTag(), false); //确认消息成功消费
            }
        });
        return container;
    }

下面给出完整的配置文件：
 
[html] view plain copy print ? 在CODE上查看代码片 派生到我的代码片
  1. package com.u51.lkl.springboot.amqp;  
  2.   
  3. import org.springframework.amqp.core.AcknowledgeMode;  
  4. import org.springframework.amqp.core.Binding;  
  5. import org.springframework.amqp.core.BindingBuilder;  
  6. import org.springframework.amqp.core.DirectExchange;  
  7. import org.springframework.amqp.core.Message;  
  8. import org.springframework.amqp.core.Queue;  
  9. import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;  
  10. import org.springframework.amqp.rabbit.connection.ConnectionFactory;  
  11. import org.springframework.amqp.rabbit.core.ChannelAwareMessageListener;  
  12. import org.springframework.amqp.rabbit.core.RabbitTemplate;  
  13. import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;  
  14. import org.springframework.beans.factory.config.ConfigurableBeanFactory;  
  15. import org.springframework.context.annotation.Bean;  
  16. import org.springframework.context.annotation.Configuration;  
  17. import org.springframework.context.annotation.Scope;  
  18.   
  19. import com.rabbitmq.client.Channel;  
  20.   
  21. /**  
  22.  * Qmqp Rabbitmq  
  23.  *   
  24.  * http://docs.spring.io/spring-amqp/docs/1.4.5.RELEASE/reference/html/  
  25.  *   
  26.  * @author lkl  
  27.  * @version $Id: AmqpConfig.java, v 0.1 2015年11月01日 下午2:05:37 lkl Exp $  
  28.  */  
  29.   
  30. @Configuration  
  31. public class AmqpConfig {  
  32.   
  33.     public static final String EXCHANGE   = "spring-boot-exchange";  
  34.     public static final String ROUTINGKEY = "spring-boot-routingKey";  
  35.   
  36.     @Bean  
  37.     public ConnectionFactory connectionFactory() {  
  38.         CachingConnectionFactory connectionFactory = new CachingConnectionFactory();  
  39.         connectionFactory.setAddresses("127.0.0.1:5672");  
  40.         connectionFactory.setUsername("guest");  
  41.         connectionFactory.setPassword("guest");  
  42.         connectionFactory.setVirtualHost("/");  
  43.         connectionFactory.setPublisherConfirms(true); //必须要设置  
  44.         return connectionFactory;  
  45.     }  
  46.   
  47.     @Bean  
  48.     @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)  
  49.     //必须是prototype类型  
  50.     public RabbitTemplate rabbitTemplate() {  
  51.         RabbitTemplate template = new RabbitTemplate(connectionFactory());  
  52.         return template;  
  53.     }  
  54.   
  55.     /**  
  56.      * 针对消费者配置  
  57.      * 1. 设置交换机类型  
  58.      * 2. 将队列绑定到交换机  
  59.      *   
  60.      *   
  61.         FanoutExchange: 将消息分发到所有的绑定队列，无routingkey的概念  
  62.         HeadersExchange ：通过添加属性key-value匹配  
  63.         DirectExchange:按照routingkey分发到指定队列  
  64.         TopicExchange:多关键字匹配  
  65.      */  
  66.     @Bean  
  67.     public DirectExchange defaultExchange() {  
  68.         return new DirectExchange(EXCHANGE);  
  69.     }  
  70.   
  71.     @Bean  
  72.     public Queue queue() {  
  73.         return new Queue("spring-boot-queue", true); //队列持久  
  74.   
  75.     }  
  76.   
  77.     @Bean  
  78.     public Binding binding() {  
  79.         return BindingBuilder.bind(queue()).to(defaultExchange()).with(AmqpConfig.ROUTINGKEY);  
  80.     }  
  81.   
  82.     @Bean  
  83.     public SimpleMessageListenerContainer messageContainer() {  
  84.         SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory());  
  85.         container.setQueues(queue());  
  86.         container.setExposeListenerChannel(true);  
  87.         container.setMaxConcurrentConsumers(1);  
  88.         container.setConcurrentConsumers(1);  
  89.         container.setAcknowledgeMode(AcknowledgeMode.MANUAL); //设置确认模式手工确认  
  90.         container.setMessageListener(new ChannelAwareMessageListener() {  
  91.   
  92.             @Override  
  93.             public void onMessage(Message message, Channel channel) throws Exception {  
  94.                 byte[] body = message.getBody();  
  95.                 System.out.println("receive msg : " + new String(body));  
  96.                 channel.basicAck(message.getMessageProperties().getDeliveryTag(), false); //确认消息成功消费  
  97.             }  
  98.         });  
  99.         return container;  
  100.     }  
  101.   
  102. }  
package com.u51.lkl.springboot.amqp;

import org.springframework.amqp.core.AcknowledgeMode;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.ChannelAwareMessageListener;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

import com.rabbitmq.client.Channel;

/**
 * Qmqp Rabbitmq
 * 
 * http://docs.spring.io/spring-amqp/docs/1.4.5.RELEASE/reference/html/
 * 
 * @author lkl
 * @version $Id: AmqpConfig.java, v 0.1 2015年11月01日 下午2:05:37 lkl Exp $
 */

@Configuration
public class AmqpConfig {

    public static final String EXCHANGE   = "spring-boot-exchange";
    public static final String ROUTINGKEY = "spring-boot-routingKey";

    @Bean
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setAddresses("127.0.0.1:5672");
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");
        connectionFactory.setVirtualHost("/");
        connectionFactory.setPublisherConfirms(true); //必须要设置
        return connectionFactory;
    }

    @Bean
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    //必须是prototype类型
    public RabbitTemplate rabbitTemplate() {
        RabbitTemplate template = new RabbitTemplate(connectionFactory());
        return template;
    }

    /**
     * 针对消费者配置
     * 1. 设置交换机类型
     * 2. 将队列绑定到交换机
     * 
     * 
        FanoutExchange: 将消息分发到所有的绑定队列，无routingkey的概念
        HeadersExchange ：通过添加属性key-value匹配
        DirectExchange:按照routingkey分发到指定队列
        TopicExchange:多关键字匹配
     */
    @Bean
    public DirectExchange defaultExchange() {
        return new DirectExchange(EXCHANGE);
    }

    @Bean
    public Queue queue() {
        return new Queue("spring-boot-queue", true); //队列持久

    }

    @Bean
    public Binding binding() {
        return BindingBuilder.bind(queue()).to(defaultExchange()).with(AmqpConfig.ROUTINGKEY);
    }

    @Bean
    public SimpleMessageListenerContainer messageContainer() {
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory());
        container.setQueues(queue());
        container.setExposeListenerChannel(true);
        container.setMaxConcurrentConsumers(1);
        container.setConcurrentConsumers(1);
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL); //设置确认模式手工确认
        container.setMessageListener(new ChannelAwareMessageListener() {

            @Override
            public void onMessage(Message message, Channel channel) throws Exception {
                byte[] body = message.getBody();
                System.out.println("receive msg : " + new String(body));
                channel.basicAck(message.getMessageProperties().getDeliveryTag(), false); //确认消息成功消费
            }
        });
        return container;
    }

}


以上完成 Spring Boot与RabbitMQ的整合 
动配置
在Spring Boot中实现了RabbitMQ的自动配置，在配置文件中添加如下配置信息
[html]
  1. spring.rabbitmq.host=localhost  
  2. spring.rabbitmq.port=5672  
  3. spring.rabbitmq.username=test  
  4. spring.rabbitmq.password=test  
  5. spring.rabbitmq.virtualHost=test  
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=test
spring.rabbitmq.password=test
spring.rabbitmq.virtualHost=test

后会自动创建ConnectionFactory以及RabbitTemplate对应Bean，为什么上面我们还需要手动什么呢?
 
自动创建的ConnectionFactory无法完成事件的回调，即没有设置下面的代码
[html]
  1. connectionFactory.setPublisherConfirms(true);  
connectionFactory.setPublisherConfirms(true);
具体分析见后续文章的源码解读.
转载：http://blog.csdn.net/liaokailin/article/details/49559571
 
zh_ITRoad
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot整合RabbitMQ开发实战详解
08-28
主要介绍了Spring Boot整合RabbitMQ开发实战，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
SpringBoot整合RabbitMQ
K_kzj_K的博客
06-09 4301
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
Springboot整合RabbitMQ
weixin_49076273的博客
06-02 1万+
一、Springboot整合RabbitMQ的代码实现 1.引入Springboot整合RabbitMQ的依赖 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> &l
Springboot 整合RabbitMq
GSON的博客
08-21 3055
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
SpringBoot如何整合RabbitMQ
热门推荐
ShuSheng007的程序人生
07-23 1万+
好久没有写博客了，终日忙于生计，真是人过30不如狗啊，但写点什么好呢？想想当年自己入门时候那痛苦的经历，还是写点优质实用的入门文章吧，既满足了自己好为人师的本性，也能给后辈提供一些帮助。今天咱们就来聊聊springboot整合rabbitmq的那些事吧。SpringBoot的风头之盛不多说了，我是在2016年首次接触springboot的，当时自己要写个APP，后台采用了springboot。当时还真是个新鲜事物，没想到以后几年的发展犹如黄河泛滥，一发不可收拾…rabbitmq官网https。...
SpringBoot整合实现RabbitMQ
weixin_39956506的博客
01-30 4427
RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。创建2个springboot项目，一个 mq-rabbitmq-producer（生产者），一个mq-rabbitmq-consumer（消费者）。rabbitmq配置类：配置Exchange、Queue、以及绑定交换机。rabbitmq配置类：配置Exchange、Queue、以及绑定交换机。
spring boot整合RabbitMQ（Direct模式）
08-30
springboot集成RabbitMQ非常简单，如果只是简单的使用配置非常少，springboot提供了spring-boot-starter-amqp项目对消息各种...下面通过本文给大家介绍下spring boot整合RabbitMQ（Direct模式）,需要的朋友可以参考下
详解Spring Boot 配置多个RabbitMQ
08-30
本篇文章主要介绍了Spring Boot 配置多个RabbitMQ，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring Boot 整合 RabbitMQ 案例.zip
11-02
Spring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例...
springbootj集成canal+mysql+rabbitmq
10-11
mysql需开启binlog 查看是否开启binlog ...3.3 rabbitmq配置 在virtualHost：/ 下新增Exchanges： canal.exchange 新增队列：test.queue, 绑定canal.queue， RoutingKey：canal.routing.key canal下载及配置 ...
【SpringBoot学习11】springboot整合rabbitMQ
一个正在努力学习的iter
04-13 3486
文章目录1. 相关软件安装1.1 Erlang安装1.2 rabbitMQ安装2. 整合rabbitMQ中的direct模型2.1 导入相关坐标2.2 添加核心配置2.3 初始化直连模式系统设置2.4 使用AmqpTemplate操作RabbitMQ2.5 设置消息监听器3. 整合rabbitMQ中的Topic模型3.1 初始化主题模式系统设置3.2 使用AmqpTemplate操作RabbitMQ3.3 设置消息监听器4. 总结 1. 相关软件安装 RabbitMQ是MQ产品中的目前较为流行的产品之一，它
SpringBoot 集成 RabbitMQ
爱笑的boy的博客
03-04 5015
SpringBoot 集成 RabbitMQ
RabbitMQ 发布确认+消息回退
XZB119211的博客
09-23 3029
RabbitMQ 发布确认+消息回退+备份交换机
RabbitTemplate的两段回调确认机制
偶尔写写开发遇到的小知识
07-13 1591
RabbitTemplate 确认机制
Springboot 整合RabbitMQ (完整版)
最新发布
weixin_42113716的博客
08-30 589
Springboot 整合RabbitMQ (完整版)
RabbitMQ与SpringBoot整合实战
tyjlearning的博客
11-01 2692
SpringBoot整合RabbitMQ SpringBoot与RabbitMQ集成非常筒単，不需要做任何的额外设置只需要两步即可： step1：引入相关依赖：spring-boot-starter-amqp step2：対application.properties迸行配置 生产端核心配置 消费端核心配置 SpringBoot整合RabbitMQ实战 1.首先创建一个Spring Boot...
RabbitMQ学习(四）——高级特性
qq_35003730的博客
03-04 1759
RabbitMQ高级特性 1.1 消息的可靠投递 在使用RabbitMQ的时候，作为消息发送方式希望杜绝任何消息丢失或者投递失败的场景。RabbitMQ为我们提供了两种方式用来控制消息的投递可靠性模式 confirm： 确认模式 return： 退回模式 RabbitMQ整个消息投递的路径为： producer ➡rabbimq broker ➡exchange➡queue➡consumer 消息从prodeucer到exchange会返回一个confirmCallback 消息从exchange到q
Spring Boot整合RabbitMQ
Switch的博客
11-11 6898
Spring Boot整合RabbitMQ@(MQ)[rabbitmq,springboot]Spring Boot整合RabbitMQ 写在开头 整合流程 配置文件 RabbitMQ配置 RabbitMQ生产者 RabbitMQ消费者 手动应答简单工具类 参考文档 写在开头最近在搭一套基于SpringBoot的项目，用到了ssm+mysql+rabbitmq+redis。除了rabbitmq之外，
spring boot整合rabbitmq
08-24
Spring Boot与RabbitMQ的整合可以通过使用Spring AMQP实现。下面是一个简单的步骤： 1. 添加依赖：在`pom.xml`文件中添加以下依赖关系： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值