首页 / RABBITMQ / RabbitMQ整合Spring

RabbitMQ整合Spring

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了RabbitMQ整合Spring，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含11310字，纯文字阅读大概需要17分钟。

内容图文

之前我们使用 RabbitMQ 原生的 API 方法来实现MQ的使用，Spring 也提供了 RabbitMQ 的集成，让我们更方便的使用MQ，让我们来学习下吧。

Spring AMQP 是基于 Spring 框架的 AMQP 消息解决方案，提供模板化的发送和接收消息的抽象层，提供基于消息驱动的 POJO 的消息监听等，很大方便我们使用 RabbitMQ 程序的相关开发。

一、RabbitAdmin 管理组件

1.1 准备工作：

添加 Spring AMQP 依赖

        <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
    <version>2.3.1.RELEASE</version>
</dependency>

声明 Bean 对象

        @Configuration
public class RabbitMQConfig {
    /**
     * 注入连接工厂对象
     * @return
     */
    @Bean
    public ConnectionFactory connectionFactory(){
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setHost("111.231.83.100");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        return connectionFactory;
    }
    
    @Bean
    public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
        RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
        // 必须显式设置为 True ，否则 Spring 容器不会加载
        rabbitAdmin.setAutoStartup(true);
        return rabbitAdmin;
    }
}

1.2 Exchange 操作

方法定义	作用
void declareExchange(Exchange exchange)	声明交换机
boolean deleteExchange(String exchange)	删除交换机

1.3 Queue 操作

方法定义	作用
Queue declareQueue()	声明默认队列
String declareQueue(Queue queue)	申明给定的队列
boolean deleteQueue(String queueName)	删除队列
void deleteQueue(String queueName, boolean unused, boolean empty)	删除队列
void purgeQueue(String queueName, boolean noWait)	清除队列信息,noWait = true 时异步执行
int purgeQueue(String queueName)	清除队列信息
Properties getQueueProperties(String queueName)	获取指定队列的属性

声明队列

        @SpringBootTest
public class QueueTest {

    @Autowired
    private RabbitAdmin rabbitAdmin;

    @Test
    public void shouldAddQueueSuccess() {
        // 创建默认队列
        Queue defaultQueue = rabbitAdmin.declareQueue();
        Assert.assertNotNull(defaultQueue);
        Assert.assertEquals(false,defaultQueue.isDurable());

        // 创建指定名称和是否持久化属性的队列
        String  queueName =  rabbitAdmin.declareQueue(new Queue("orderQueue",true));
        Assert.assertNotNull(queueName);
        Assert.assertEquals("orderQueue",queueName);
    }
}

技术分享图片

注：默认的队列因为设置 exclusive = true ,导致在其连接断开的时候自动删除，所以图中看不到。

删除队列

        @SpringBootTest
public class QueueTest {

    @Autowired
    private RabbitAdmin rabbitAdmin;
   
    @Test
    public void shouldDeleteQueueSuccess() {
        boolean result = rabbitAdmin.deleteQueue("orderQueue");
        Assert.assertTrue(result);
    }   
}

技术分享图片

1.4 Binding 绑定

方法定义	作用
void declareBinding(Binding binding)	声明队列与交换机的绑定
void removeBinding(Binding binding)	删除队列与交换机的绑定

声明队列与交换机的绑定

        @SpringBootTest
public class BindingTest {

    @Autowired
    private RabbitAdmin rabbitAdmin;

    @Test
    public void shouldBindingSuccess() {
        // 交换机名称
        String exchange = "admin.topic";
        // 队列名称
        String queueName = "orderQueue";
        // 1.创建绑定关系对象
        Binding binding =
                BindingBuilder
                        // 创建队列
                        .bind(new Queue(queueName, true))
                        // 创建交换机
                        .to(new TopicExchange(exchange, true, false))
                        // 指定路由 Key
                        .with("order#");
        // 2.进行绑定
        rabbitAdmin.declareBinding(binding);
    }

}

技术分享图片

删除队列与交换机的绑定

        @SpringBootTest
public class BindingTest {

    @Autowired
    private RabbitAdmin rabbitAdmin;
	
    @Test
    public void shouldUnBindingSuccess() {
        // 交换机名称
        String exchange = "admin.topic";
        // 队列名称
        String queueName = "orderQueue";
        Binding binding =
                new Binding(queueName, Binding.DestinationType.QUEUE, exchange, "order#", null);
        rabbitAdmin.removeBinding(binding);
    }
}

技术分享图片

1.5 bean 注入

除了上面的通过代码显式申明交换机、队列、路由之外，还可以通过 Bena 注入的形式申明。

        @Configuration
public class RabbitMQConfig {

    /**
     * 注入连接工厂对象
     *
     * @return
     */
    @Bean
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setHost("111.231.83.100");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        return connectionFactory;
    }

    @Bean
    public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
        RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
        // 必须显式设置为 True ，否则 Spring 容器不会加载
        rabbitAdmin.setAutoStartup(true);
        return rabbitAdmin;
    }

    @Bean
    public TopicExchange beanExchange() {
        return new TopicExchange("beanExchange", true, false);
    }

    @Bean
    public Queue beanQueue() {
        return new Queue("beanQueue", true);
    }

    @Bean
    public Binding beanBinding(TopicExchange beanExchange, Queue beanQueue) {
        return BindingBuilder
                // 创建队列
                .bind(beanQueue)
                // 创建交换机
                .to(beanExchange)
                // 指定路由 Key
                .with("bean#");
    }
}

        @SpringBootTest
public class BeanInjectionBindingTest {

    @Autowired
    private RabbitAdmin rabbitAdmin;
    @Autowired
    private Binding beanBinding;

    @Test
    public void shouldBindingSuccess() {
        rabbitAdmin.declareBinding(beanBinding);
    }

}

技术分享图片

二、RabbitTemplate 模板组件

如果你看过 RabbitAdmin 的源码，可以看到里面使用到了一个叫做 RabbitTemplate 的对象，它就是 Spring 提供的消息模板，封装了 RabbitMQ 核心 API 的一系列方法，而 RabbitAdmin 是在它之上的另一层封装。

2.1 常用方法

方法定义	作用
void send(Message message)	发送消息
void convertAndSend(Object object)	将 Java 对象包装成 Message 对象并发送，Java 对象需要实现 Serializable 序列化接口
Message receive(String queueName)	接收消息
receiveAndConvert(String queueName)	接收消息并将 Message 转换成 Java 对

2.2 发送消息

        @SpringBootTest
public class MessageTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void shouldSendMessageSuccess(){
        // 创建消息属性对象
        MessageProperties messageProperties = new MessageProperties();
        messageProperties.getHeaders().put("desc", "信息描述..");
        messageProperties.getHeaders().put("type", "自定义消息类型..");
        // 创建消息对象
        Message message = new Message("Hello RabbitMQ".getBytes(), messageProperties);
        // 发送消息
        rabbitTemplate.send("beanExchange","bean#",message);

        // 发送消息时额外增加属性
        Message newMessage = new Message("newMessage".getBytes(), messageProperties);
        rabbitTemplate.convertAndSend("beanExchange", "bean#", newMessage, new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                message.getMessageProperties().getHeaders().put("desc", "额外修改的信息描述");
                message.getMessageProperties().getHeaders().put("attr", "额外新加的属性");
                return message;
            }
        });
    }
}

技术分享图片

2.3 手动接收消息

        @SpringBootTest
public class MessageTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;  
	
    @Test
    public void shouldConsumeMessageSuccess() {
        Message msg = rabbitTemplate.receive("beanQueue", 2000l);
        System.out.println("消息内容：" + new String(msg.getBody()));
        final Map<String, Object> headers = msg.getMessageProperties().getHeaders();
        System.out.println("=======消息头属性=======");
        for (String key : headers.keySet()) {
            System.out.println("key =" + key + " ; value =" + headers.get(key));
        }
    }
}

执行方法，观察控制台输出：

        消息内容：Hello RabbitMQ
=======消息头属性=======
key =type ; value =自定义消息类型..
key =desc ; value =信息描述..

再次执行方法，观察控制台输出：

        消息内容：newMessage
=======消息头属性=======
key =type ; value =自定义消息类型..
key =attr ; value =额外新加的属性
key =desc ; value =额外修改的信息描述

2.4 消息监听容器

在实际项目中我们不可能采用手动接收消息的形式来消费消息，这个时候 Spring 就为我们提供了一个消息监听容器 SimpleMessageListenerContainer。

它的功能如下：

        * 监听多个队列
* 设置消费者消费数量
* 设置消息确认和自动确认模式
* 是否重回队列
* 异常捕获 handel 函数
* 设置消费者属性
* 设置具体的监听器和消息转换器

SimpleMessageListenerContainer 可以在运行过程中动态修改属性，如修改消费者消费数量大小、接收消息的模式等

        @Configuration
public class RabbitMQConfig {
    ......
	@Bean
    public SimpleMessageListenerContainer messageListenerContainer(ConnectionFactory connectionFactory,Queue beanQueue) {
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory);
        // 设置监听队列，可以有多个
        container.setQueues(beanQueue);
        // 设置并发消费者数量
        container.setConcurrentConsumers(1);
        // 设置最大并发消费者数量
        container.setMaxConcurrentConsumers(5);
        // 设置是否重回队列
        container.setDefaultRequeueRejected(false);
        // 设置签收模式,这里为了演示使用自动签收,实际项目中需要使用手动签收 AcknowledgeMode.MANUAL
        container.setAcknowledgeMode(AcknowledgeMode.AUTO);
        // 设置消费端标签策略
        container.setConsumerTagStrategy(new ConsumerTagStrategy() {
            @Override
            public String createConsumerTag(String queue) {
                return queue + "_" + UUID.randomUUID().toString();
            }
        });
        // 设置消息监听
        container.setMessageListener(new ChannelAwareMessageListener() {
            @Override
            public void onMessage(Message message, Channel channel) throws Exception {
                String msg = new String(message.getBody());
                System.err.println("消费端监听：" + msg);
            }
        });
        return container;
    }
}

启动应用后，执行发送消息测试方法 shouldSendMessageSuccess ,观察控制台输出：

        消费端监听：Hello RabbitMQ

证明消费端监听并消费成功。

2.5 消息监听适配器

除了直接使用 ChannelAwareMessageListener 实现消息事件监听外，还可以通过消息监听适配器(MessageListenerAdapter)，通过反射将消息处理委托给目标监听器的处理方法，并进行灵活的消息类型转换。允许监听器方法对消息内容类型进行操作，完全独立于 Rabbit API。

实际上就是相当于自己实现 ChannelAwareMessageListener 功能。

新建 MessageDelegate

        public class MessageDelegate {
    public void consumeMessage(byte[] messageBody) {
        System.err.println("默认方法, 消息内容:" + new String(messageBody));
    }
}

替换原 ChannelAwareMessageListener 事件

        //   container.setMessageListener(new ChannelAwareMessageListener() {
//       @Override
//       public void onMessage(Message message, Channel channel) throws Exception {
//           String msg = new String(message.getBody());
//           System.err.println("消费端监听：" + msg);
//       }
//   });
// 设置消息监听
MessageListenerAdapter adapter = new MessageListenerAdapter(new MessageDelegate());
// adapter 默认执行方法是 handleMessage,这里我们设置自定义方法名
adapter.setDefaultListenerMethod("consumeMessage");
container.setMessageListener(adapter);

启动应用后，执行发送消息测试方法 shouldSendMessageSuccess ,观察控制台输出：

        默认方法, 消息内容:Hello RabbitMQ

证明消费端监听并消费成功。

我们还可以将队列名和方法做绑定，实现转发功能：

        MessageListenerAdapter adapter = new MessageListenerAdapter(new MessageDelegate());
// adapter 默认执行方法是 handleMessage,这里我们设置自定义方法名
// adapter.setDefaultListenerMethod("consumeMessage");
Map<String, String> queueOrTagToMethodName = new HashMap<>();
queueOrTagToMethodName.put(beanQueue.getName(), "consumeMessage");
adapter.setQueueOrTagToMethodName(queueOrTagToMethodName);
container.setMessageListener(adapter);

2.6 消息转换器

我们现在发送和接受消息的类型都是二进制形式传输，我们可以通过 MessageConverter 进行转换。

新建 TextMessageConverter 类

        public class TextMessageConverter implements MessageConverter {
    @Override
    public Message toMessage(Object object, MessageProperties messageProperties) throws MessageConversionException {
        return new Message(object.toString().getBytes(), messageProperties);
    }

    @Override
    public Object fromMessage(Message message) throws MessageConversionException {
        String contentType = message.getMessageProperties().getContentType();
        if (null != contentType && contentType.contains("text")) {
            return new String(message.getBody());
        }
        return message.getBody();
    }
}

adapter 设置转换类

        adapter.setMessageConverter(new TextMessageConverter());

MessageDelegate 新增字符串参数的方法

        public class MessageDelegate {
	......
    public void consumeMessage(String messageBody){
        System.err.println("字符串类型, 消息内容:" + new String(messageBody));
    }
}

新增发送文本消息测试方法

        @Test
public void shouldSendTextMessageSuccess() {
    // 创建消息属性对象
    MessageProperties messageProperties = new MessageProperties();
    // 通过设置属性，让消费端知道要将消息内容转换成文本类型
    messageProperties.setContentType("text");
    // 创建消息对象
    Message message = new Message("字符串消息".getBytes(), messageProperties);
    // 发送消息
    rabbitTemplate.send("beanExchange", "bean#", message);
}

启动应用后，执行发送消息测试方法，观察控制台输出：

        字符串类型, 消息内容:字符串消息

原文：https://www.cnblogs.com/markLogZhu/p/13273809.html

内容总结

以上是互联网集市为您收集整理的RabbitMQ整合Spring全部内容，希望文章能够帮你解决RabbitMQ整合Spring所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1219479.html

来源：【匿名】

【上一篇】celery-rabbitmq 安装部署【下一篇】rabbitmq常见功能封装（php版本）

更多 ►

【RabbitMQ整合Spring】教程文章相关的互联网学习教程文章

RabbitMQ整合Spring【代码】【图】

之前我们使用 RabbitMQ 原生的 API 方法来实现MQ的使用，Spring 也提供了 RabbitMQ 的集成，让我们更方便的使用MQ，让我们来学习下吧。Spring AMQP 是基于 Spring 框架的 AMQP 消息解决方案，提供模板化的发送和接收消息的抽象层，提供基于消息驱动的 POJO 的消息监听等，很大方便我们使用 RabbitMQ 程序的相关开发。一、RabbitAdmin 管理组件1.1 准备工作：添加 Spring AMQP 依赖<dependency><groupId>org.springframework.boot<...

springboot(八)：RabbitMQ详解【代码】

http://www.cnblogs.com/ityouknow/p/6120544.html******************************************************* RabbitMQ 即一个消息队列，主要是用来实现应用程序的异步和解耦，同时也能起到消息缓冲，消息分发的作用。消息中间件在互联网公司的使用中越来越多，刚才还看到新闻阿里将RocketMQ捐献给了apache，当然了今天的主角还是讲RabbitMQ。消息中间件最主要的作用是解耦，中间件最标准的用法是生产者生产消息传送到队列，消费者...

springboot + rabbitmq 做智能家居，我也没想到会这么简单【代码】【图】

本文收录在个人博客：www.chengxy-nds.top，共享技术资源，共同进步前一段有幸参与到一个智能家居项目的开发，由于之前都没有过这方面的开发经验，所以对智能硬件的开发模式和技术栈都颇为好奇。产品是一款可燃气体报警器，如果家中燃气泄露浓度到达一定阈值，报警器检测到并上传气体浓度值给后台，后台以电话、短信、微信等方式，提醒用户家中可能有气体泄漏。用户还可能向报警器发一些关闭报警、调整音量的指令等。整体功能还是比...

SpringBoot整合RabbitMQ之典型应用场景实战二【代码】【图】

实战前言RabbitMQ 作为目前应用相当广泛的消息中间件，在企业级应用、微服务应用中充当着重要的角色。特别是在一些典型的应用场景以及业务模块中具有重要的作用，比如业务服务模块解耦、异步通信、高并发限流、超时业务、数据延迟处理等。上篇博文我介绍分享了RabbitMQ在业务服务模块异步解耦以及通信的实战业务场景，感兴趣童鞋可以前往观看：http://blog.51cto.com/13877966/2297056这边博文我们继续介绍分享RabbitMQ消息确认机制...

【RabbitMQ消息中间件】10.Spring-Rabbit项目剖析【代码】【图】

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。本文链接：https://blog.csdn.net/u013517797/article/details/79601121之前我们详细介绍了RabbitMQ并且讲解了其5中队列模式，在期间编写了许多小例子。但是在真实的开发阶段，我们很少使用之前编写Demo时的编写方式，一个是不方便，一个是难以维护。所以，在企业级的开发中，一般是结合框架来进行开发的。一、spring-rabbit项目介绍在...

Springboot 1.5.x 集成基于Centos7的RabbitMQ集群安装及配置【代码】【图】

RabbitMQ简介RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ是一套开源（MPL）的消息队列服务软件，是由LShift提供的一个Advanced Message Queuing Protocol（AMQP）的开源实现，由以高性能、健壮以及可伸缩性出名的Erlang写成。选择RabbitMQ市面上有很多MQ可以选择，如：ActiveMQ、ZeroMQ、Apache Qpid及RocketMQ，为什么要选择RabbitMQ呢？1. 除了Qpid，RabbitMQ是唯一一个实现...

带着新人学springboot的应用07（springboot+RabbitMQ 下）【图】

说一两句废话，强烈推荐各位小伙伴空闲时候也可以写写自己的博客！不管水平高低，不管写的怎么样，不要觉得写不好或者水平不够就不写了（咳，我以前就是这样的想法。。。自我反省！）。　　但是开始写博客之后，你会发现很多你以为自己会的东西其实你并不会，然后你会经常在头脑中不断的搜索有关的片段，或者去别的大神博客里到处找有关的资料，最后领悟了属于自己的东西！然后再写出来和别人分享，别人也会给你点意见，你也会慢慢...

SpringBoot(八) Spring和消息队列RabbitMQ【代码】【图】

概述1.大多数应用中，可以通过消息服务中间件来提升系统异步能力和拓展解耦能力。2.消息服务中的两个重要概念：消息代理（Message broker）和目的地（destination）当消息发送者发送消息后，将由消息代理接管，消息代理保证消息传递到指定目的地。3.消息队列主要有两种形式的目的地：队列：点对点方式通信（point-to-point）主题：发布/订阅消息服务点对点式：消息发送者发送消息后，消息代理将其放入一个队列中，消息接受者从队列...

SpringBoot整合RabbitMq【代码】【图】

1. 大多应用中，可通过消息服务中间件来提升系统异步通信、扩展解耦能力2. 消息服务中两个重要概念：消息代理（message broker）和目的地（destination）当消息发送者发送消息以后，将由消息代理接管，消息代理保证消息传递到指定目的地。3. 消息队列主要有两种形式的目的地1. 队列（queue）：点对点消息通信（point-to-point）2. 主题（topic）：发布（publish）/订阅（subscribe）消息通信异步处理：应用解耦：流量削峰 4....

SpringCloud stream连接RabbitMQ收发信息【代码】【图】

1、POM引入spring-cloud-starter-stream-rabbit注意springboot 版本，用1.5.2.RELEASE 就报错 rabbitmqTemple not foundsb版本切换到1.5.14 就好了 <parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>1.5.14.RELEASE</version><relativePath /> </parent><dependency><groupId>org.springframework.cloud</groupId><art...

RabbitMQ整合Spring Booot点对点模式【代码】【图】

pom.xml:<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"><modelVersion>4.0.0</modelVersion><groupId>com.toov5</groupId><artifactId>rabbitmq</artifactId><version>0.0.1-SNAPSHOT</version><dependencies><dependency><groupId>com.rabbitmq</groupId><ar...

springboot集成RabbitMQ方法【代码】【图】

1、简介RabbitMQ 即一个消息队列，主要是用来实现应用程序的异步和解耦，同时也能起到消息缓冲，消息分发的作用。2、创建一个springboot的项目3、添加RabbitMQ依赖<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-amqp</artifactId> </dependency> 4、在application.properties中配置RabbitMQspring.rabbitmq.host=127.0.0.1spring.rabbitmq.port=5672spring.rabbitmq.username=guestspr...

springBoot（24）：集成rabbitmq【代码】【图】

注意：springboot支持的amqp规范的中间件只有rabbitmq第一步：添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency>第二步：配置application.ymlspring: application: name: boot-rabbitmq rabbitmq: host: 192.168.175.13 port: 5672 username: liuy password: 123456第三步：编写amqp队列配置pac...

Springboot接入RabbitMQ详细教程【代码】

本文适用于对 RabbitMQ 有所了解的人，在此不讨论MQ的原理，只讨论如何接入。其实Spring Boot 集成 RabbitMQ 非常简单，本文章使用的是Spring Boot 提供了spring-boot-starter-amqp 项目对消息各种支持。接下来将进入正题，六步轻松教你接入RabbitMQ1.配置pom文件所依赖的主要jar包<dependency><groupId>org.springframework.amqp</groupId><artifactId>spring-rabbit</artifactId><version>2.0.4.RELEASE</version> </dependency>...

spring-amqp整合rabbitmq消费者配置和代码【代码】

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:rabbit="http://www.springframework.org/schema/rabbit" xsi:schemaLocation=" http://www.springframework.org/schema/beans http:...

RABBITMQ - 相关标签

rabbitmq安装 rabbitmq集群

RABBITMQ - 最热教程

rabbitmq连接数量一直增多 RabbitMQ如何避免消息重复投递或重复消...【MQ中间件】RabbitMQ -- RabbitMQ死信...rabbitMQ无法启动解决 Springboot接入RabbitMQ详细教程 linux（debian）系统中安装RabbitMQ Caused by:com.rabbitmq.client.Shutdo...Docker搭建RabbitMQ集群(镜像模式)阿里云linux服务器上部署系统记录（jdk...图文详解：阿里宠儿【小兔】RabbitMQ的...

首页 / RABBITMQ / RabbitMQ整合Spring

RabbitMQ整合Spring

内容导读

内容图文

一、RabbitAdmin 管理组件

1.1 准备工作：

1.2 Exchange 操作

1.3 Queue 操作

1.4 Binding 绑定

1.5 bean 注入

二、RabbitTemplate 模板组件

2.1 常用方法

2.2 发送消息

2.3 手动接收消息

2.4 消息监听容器

2.5 消息监听适配器

2.6 消息转换器

内容总结

内容备注

内容手机端

【RabbitMQ整合Spring】教程文章相关的互联网学习教程文章

RABBITMQ - 相关标签

RABBITMQ - 最新教程

RABBITMQ - 最热教程