RabbitMQ - 整合Spring

最新推荐文章于 2022-02-15 23:51:35 发布
最新推荐文章于 2022-02-15 23:51:35 发布
阅读量90 收藏
点赞数 1
分类专栏： Java RabbitMQ 文章标签： rabbitmq spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chrismurphy/article/details/120320608
版权

RabbitMQ - 整合Spring

目录

1. Spring 整合 RabbitMQ

注意：RabbitMQ相关配置在 安装配置 中已涉及。

1.1 搭建生产者工程

1.1.1 创建工程

在这里插入图片描述

1.1.2 添加依赖

修改pom.xml文件内容为如下：

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.13.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework.amqp</groupId>
        <artifactId>spring-rabbit</artifactId>
        <version>2.1.8.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.2.13.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>
1.1.3 配置整合
  1. 创建spring-rabbitmq-producer\src\main\resources\properties\rabbitmq.properties连接参数等配置文件；
rabbitmq.host=192.168.2.190 # 虚拟机地址
rabbitmq.port=5672
rabbitmq.username=murphy
rabbitmq.password=xmf123123
rabbitmq.virtual-host=/mq
  1. 创建spring-rabbitmq-producer\src\main\resources\spring\spring-rabbitmq.xml整合配置文件；
<?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://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit.xsd ">

    <!-- 加载配置文件 -->
    <context:property-placeholder location="classpath:properties/rabbitmq.properties"/>
    <!-- 定义 rabbitmq connectionFactory -->
    <rabbit:connection-factory id="connectionFactory"
                               host="${rabbitmq.host}"
                               port="${rabbitmq.port}"
                               username="${rabbitmq.username}"
                               password="${rabbitmq.password}"
                               virtual-host="${rabbitmq.virtual-host}"/>
    <!-- 定义管理交换机、队列 -->
    <rabbit:admin connection-factory="connectionFactory"/>
    <!-- 定义持久化队列，不存在则自动创建，不绑定到交换机则绑定到默认交换机 - 默认交换机类型为direct，名字为：""，路由键为队列的名称 -->
    <rabbit:queue id="spring_queue" name="spring_queue" auto-declare="true"/>

    <!-- 广播：所有队列均能接收到消息 -->
    <!-- 定义广播交换机中的持久化队列，不存在则自动创建 - auto-declare: 自动声明 -->
    <rabbit:queue id="spring_fanout_queue_1" name="spring_fanout_queue_1" auto-declare="true"/>
    <rabbit:queue id="spring_fanout_queue_2" name="spring_fanout_queue_2" auto-declare="true"/>
    <!-- 定义广播类型交换机：并绑定上述两个队列 -->
    <rabbit:fanout-exchange id="spring_fanout_exchange" name="spring_fanout_exchange" auto-declare="true">
        <rabbit:bindings>
            <rabbit:binding queue="spring_fanout_queue_1"/>
            <rabbit:binding queue="spring_fanout_queue_2"/>
        </rabbit:bindings>
    </rabbit:fanout-exchange>

    <!-- 通配符：* - 匹配一个单词 / # - 匹配多个单词 -->
    <!-- 定义广播交换机中的持久化队列，不存在则自动创建 -->
    <rabbit:queue id="spring_topic_queue_star" name="spring_topic_queue_star" auto-declare="true"/>
    <rabbit:queue id="spring_topic_queue_well1" name="spring_topic_queue_well1" auto-declare="true"/>
    <rabbit:queue id="spring_topic_queue_well2" name="spring_topic_queue_well2" auto-declare="true"/>

    <!-- 定义Topic类型交换机：并绑定上述队列 -->
    <rabbit:topic-exchange id="spring_topic_exchange" name="spring_topic_exchange" auto-declare="true">
        <rabbit:bindings>
            <rabbit:binding pattern="murphy.*" queue="spring_topic_queue_star"/>
            <rabbit:binding pattern="murphy.#" queue="spring_topic_queue_well1"/>
            <rabbit:binding pattern="chris.#" queue="spring_topic_queue_well2"/>
        </rabbit:bindings>
    </rabbit:topic-exchange> 

    <!-- 定义 rabbitTemplate 对象操作可以在代码中方便发送消息 -->
    <rabbit:template id="rabbitTemplate" connection-factory="connectionFactory"/>
</beans>
1.1.4 发送消息

创建测试文件spring-rabbitmq-producer\src\test\java\com\murphy\rabbitmq\ProducerTest.java

/**
 * 生产者
 *
 * @author murphy
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:/spring/spring-rabbitmq.xml")
public class ProducerTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 只发队列消息
     * 默认交换机类型：direct
     * 交换机的名字为空，路由键为队列的名称
     */
    @Test
    public void testQueue() {
        // 路由键与队列同名
        rabbitTemplate.convertAndSend("spring_queue","Send Messages - spring_queue");
    }

    /**
     * 发送广播
     * 交换机类型：Fanout
     * 绑定到该交换机的所有队列均能接收消息
     */
    @Test
    public void fanoutTest() {
        /**
         * 参数1：交换机名称
         * 参数2：路由键名(广播设置为空)
         * 参数3：发送的消息名称
         */
        rabbitTemplate.convertAndSend("spring_fanout_exchange","",
                "Send Messages - spring_fanout_exchange");
    }

    /**
     * 通配符
     * 交换机类型：Topic
     * 匹配路由键的通配符，*表示一个单词，#表示多个单词
     * 绑定到该交换机的匹配队列能够收到对应消息
     */
    @Test
    public void topicTest() {
        /**
         * 参数1：交换机名称
         * 参数2：路由键名
         * 参数3：发送的消息内容
         */
        rabbitTemplate.convertAndSend("spring_topic_exchange","murphy.test",
                "Send Messages - spring_topic_exchange - Murphy.Test");
        rabbitTemplate.convertAndSend("spring_topic_exchange","murphy.test.1",
                "Send Messages - spring_topic_exchange - Murphy.Test.1");
        rabbitTemplate.convertAndSend("spring_topic_exchange","murphy.test.2",
                "Send Messages - spring_topic_exchange - Murphy.Test.2");
        rabbitTemplate.convertAndSend("spring_topic_exchange","chris.#",
                "Send Messages - spring_topic_exchange - chris.com");
    }
}

测试运行效果

在这里插入图片描述

在这里插入图片描述

1.2 搭建消费者工程

1.2.1 创建工程

在这里插入图片描述

1.2.2 添加依赖

修改pom.xml文件内容为如下：

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.13.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework.amqp</groupId>
        <artifactId>spring-rabbit</artifactId>
        <version>2.1.8.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.2.13.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>
1.2.3 配置整合
  1. 创建spring-rabbitmq-consumer\src\main\resources\properties\rabbitmq.properties连接参数等配置文件;
rabbitmq.host=192.168.2.190
rabbitmq.port=5672
rabbitmq.username=murphy
rabbitmq.password=xmf123123
rabbitmq.virtual-host=/mq
  1. 创建spring-rabbitmq-consumer\src\main\resources\spring\spring-rabbitmq.xml整合配置文件;
<?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://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit.xsd ">

    <!-- 加载配置文件 -->
    <context:property-placeholder location="classpath:properties/rabbitmq.properties"/>

    <!-- 定义 rabbitmq connectionFactory -->
    <rabbit:connection-factory id="connectionFactory"
                               host="${rabbitmq.host}"
                               port="${rabbitmq.port}"
                               username="${rabbitmq.username}"
                               password="${rabbitmq.password}"
                               virtual-host="${rabbitmq.virtual-host}"/>
    <!-- 监听器 - 注册 -->
    <bean id="springQueueListener" class="com.murphy.rabbitmq.listener.SpringQueueListener"/>
    <bean id="fanoutListener1" class="com.murphy.rabbitmq.listener.FanoutListener1"/>
    <bean id="fanoutListener2" class="com.murphy.rabbitmq.listener.FanoutListener2"/>
    <bean id="topicListenerStar" class="com.murphy.rabbitmq.listener.TopicListenerStar"/>
    <bean id="topicListenerWell1" class="com.murphy.rabbitmq.listener.TopicListenerWell1"/>
    <bean id="topicListenerWell2" class="com.murphy.rabbitmq.listener.TopicListenerWell2"/>
    <!-- 监听器 - 监听与消费 -->
    <rabbit:listener-container connection-factory="connectionFactory" auto-declare="true">
        <rabbit:listener ref="springQueueListener" queue-names="spring_queue"/>
        <rabbit:listener ref="fanoutListener1" queue-names="spring_fanout_queue_1"/>
        <rabbit:listener ref="fanoutListener2" queue-names="spring_fanout_queue_2"/>
        <rabbit:listener ref="topicListenerStar" queue-names="spring_topic_queue_star"/>
        <rabbit:listener ref="topicListenerWell1" queue-names="spring_topic_queue_well1"/>
        <rabbit:listener ref="topicListenerWell2" queue-names="spring_topic_queue_well2"/>
    </rabbit:listener-container>
</beans>
1.2.4 消息监听器
  1. 队列监听器
  • 创建spring-rabbitmq-consumer\src\main\java\com\murphy\rabbitmq\listener\SpringQueueListener.java
/**
 * 消息队列
 *
 * @author murphy
 */
public class SpringQueueListener implements MessageListener {

    public void onMessage(Message message) {
        try {
            String msg = new String(message.getBody(),"UTF-8");
            System.out.printf("Receiving —— 路由名称：%s，路由键：%s，队列名：%s，消息内容：%s \n",
                    message.getMessageProperties().getReceivedExchange(),
                    message.getMessageProperties().getReceivedRoutingKey(),
                    message.getMessageProperties().getConsumerQueue(),
                    msg);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  1. 广播监听器 1
  • 创建spring-rabbitmq-consumer\src\main\java\com\murphy\rabbitmq\listener\FanoutListener1.java
/**
 * 消息队列
 *
 * @author murphy
 */
public class FanoutListener1 implements MessageListener {

    public void onMessage(Message message) {
        try {
            String msg = new String(message.getBody(),"UTF-8");
            System.out.printf("Receiving —— 路由名称：%s，路由键：%s，队列名：%s，消息内容：%s \n",
                    message.getMessageProperties().getReceivedExchange(),
                    message.getMessageProperties().getReceivedRoutingKey(),
                    message.getMessageProperties().getConsumerQueue(),
                    msg);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  1. 广播监听器 2
  • 创建spring-rabbitmq-consumer\src\main\java\com\murphy\rabbitmq\listener\FanoutListener2.java
/**
 * 消息队列
 *
 * @author murphy
 */
public class FanoutListener2 implements MessageListener {

    public void onMessage(Message message) {
        try {
            String msg = new String(message.getBody(),"UTF-8");
            System.out.printf("Receiving —— 路由名称：%s，路由键：%s，队列名：%s，消息内容：%s \n",
                    message.getMessageProperties().getReceivedExchange(),
                    message.getMessageProperties().getReceivedRoutingKey(),
                    message.getMessageProperties().getConsumerQueue(),
                    msg);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  1. *号通配符监听器
  • 创建spring-rabbitmq-consumer\src\main\java\com\murphy\rabbitmq\listener\TopicListenerStar.java
/**
 * 消息队列
 *
 * @author murphy
 */
public class TopicListenerStar implements MessageListener {

    public void onMessage(Message message) {
        try {
            String msg = new String(message.getBody(),"UTF-8");
            System.out.printf("Receiving —— 路由名称：%s，路由键：%s，队列名：%s，消息内容：%s \n",
                    message.getMessageProperties().getReceivedExchange(),
                    message.getMessageProperties().getReceivedRoutingKey(),
                    message.getMessageProperties().getConsumerQueue(),
                    msg);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  1. #号通配符监听器 1
  • 创建spring-rabbitmq-consumer\src\main\java\com\murphy\rabbitmq\listener\TopicListenerWell1.java
/**
 * 消息队列
 *
 * @author murphy
 * @since 2021/9/12 12:12 下午
 */
public class TopicListenerWell1 implements MessageListener {

    public void onMessage(Message message) {
        try {
            String msg = new String(message.getBody(),"UTF-8");
            System.out.printf("Receiving —— 路由名称：%s，路由键：%s，队列名：%s，消息内容：%s \n",
                    message.getMessageProperties().getReceivedExchange(),
                    message.getMessageProperties().getReceivedRoutingKey(),
                    message.getMessageProperties().getConsumerQueue(),
                    msg);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
  1. #号通配符监听器 2
  • 创建spring-rabbitmq-consumer\src\main\java\com\murphy\rabbitmq\listener\TopicListenerWell2.java
/**
 * 消息队列
 *
 * @author murphy
 */
public class TopicListenerWell2 implements MessageListener {

    public void onMessage(Message message) {
        try {
            String msg = new String(message.getBody(),"UTF-8");
            System.out.printf("Receiving —— 路由名称：%s，路由键：%s，队列名：%s，消息内容：%s \n",
                    message.getMessageProperties().getReceivedExchange(),
                    message.getMessageProperties().getReceivedRoutingKey(),
                    message.getMessageProperties().getConsumerQueue(),
                    msg);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
1.2.5 接收信息

创建测试类

/**
 * 消费者
 *
 * @author murphy
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:/spring/spring-rabbitmq.xml")
public class ConsumerTest {

    @Test
    public void test() {
        while (true) {

        }
    }
}

测试结果

在这里插入图片描述

在这里插入图片描述

2. SpringBoot 整合 RabbitMQ

2.1 简介

在Spring项目中，可以使用Spring-Rabbit去操作RabbitMQ ，而在SpringBoot项目中只需要引入对应的amqp启动器依赖即可，方便的使用RabbitTemplate发送消息，使用注解接收消息。

一般在开发过程中：

  • 生产者工程：

    1. application.yml文件配置RabbitMQ相关信息;
    2. 在生产者工程中编写配置类，用于创建交换机和队列，并进行绑定
    3. 注入RabbitTemplate对象，通过RabbitTemplate对象发送消息到交换机

  • 消费者工程:

    1. application.yml文件配置RabbitMQ相关信息
    2. 创建消息处理类，用于接收队列中的消息并进行处理

2.2 搭建生产者工程

2.2.1 创建工程

在这里插入图片描述

2.2.2 添加依赖
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.0.RELEASE</version>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
</dependencies>
2.2.3 配置整合

创建启动类 - com.murphy.rabbitmq.ProducerApplication

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

创建配置文件 - resources/application.yml

spring:
  rabbitmq:
    host: 192.168.2.190
    port: 5672
    username: murphy
    password: xmf123123
    virtual-host: /mq

创建配置文件 - com.murphy.rabbitmq.config.RabbitMQConfig - 进行RabbitMQ的相关配置

/**
 * RabbitMQ配置
 *
 * @author murphy
 */
@Configuration
public class RabbitMQConfig {
    // 交换机名称
    public static final String ITEM_TOPIC_EXCHANGE = "springboot_item_topic_exchange";
    // 队列名称
    public static final String ITEM_QUEUE = "springboot_item_queue";

    // 声明交换机
    @Bean
    public Exchange itemTopicExchange() {
        return ExchangeBuilder.topicExchange(ITEM_TOPIC_EXCHANGE).durable(true).build();
    }

    // 声明队列
    @Bean
    public Queue itemQueue() {
        return QueueBuilder.durable(ITEM_QUEUE).build();
    }

    // 绑定队列和交换机 - noargs:不传参数
    @Bean
    public Binding itemQueueExchange(@Qualifier("itemQueue") Queue queue,
                                     @Qualifier("itemTopicExchange") Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("item.*").noargs();
    }
}
2.2.4 发送消息

创建测试类

/**
 * 生产者
 *
 * @author murphy
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringBootProducerTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void test() {
        rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE,"item.insert",
                "INSERT - Routing Key：item.insert");
        rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE,"item.update",
                "UPDATE - Routing Key：item.update");
        rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE,"item.delete",
                "DELETE - Routing Key：item.delete");
    }
}

先运行上述测试程序(交换机和队列才能先被声明和绑定)，然后启动消费者；在消费者工程springboot-rabbitmq-consumer中控制台查看是否接收到对应消息。

运行结果 - 交换机与队列的绑定

在这里插入图片描述

在这里插入图片描述

2.3 搭建消费者工程

2.3.1 创建工程

在这里插入图片描述

2.3.2 添加依赖
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.0.RELEASE</version>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
</dependencies>
2.3.3 配置整合

启动类 - com.murphy.rabbitmq.ConsumerApplication

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

配置类 application.yml - resources/application.yml

spring:
  rabbitmq:
    host: 192.168.2.190
    port: 5672
    username: murphy
    password: xmf123123
    virtual-host: /mq
2.3.4 消息监听

消息监听器 - com.murphy.rabbitmq.listener.MyListener

/**
 * 监听器
 *
 * @author murphy
 */
@Component
public class MyListener {

    /**
     * 监听某个队列的消息
     * @param message 消息内容
     */
    @RabbitListener(queues = "springboot_item_queue")
    public void myListener1(String message) {
        System.out.println("Receiving：" + message);
    }
}
2.3.5 接收消息

测试类

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

    @Test
    public void test() {
        while (true) {

        }
    }
}

运行结果

在这里插入图片描述

在这里插入图片描述

xmurphymurphy
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
RabbitMq与Spring整合实例
01-28
RabbitMq与Spring整合实例，整个工程采用maven,具体过程看博文： http://blog.csdn.net/evankaka/article/details/50495437
rabbitmq整合spring
liyanlei的专栏
11-29 649
这两天闲着没事玩了下RabbitMQ. MQ全称为Message Queue, （MQ）是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息（针对应用程序的数据）来通信，而无需专用连接来链接它们。消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是用于诸如的技术。排队指的是应用程序通过 队列来通信。队列的使用除去了接收和发送应用程序同
RabbitMQ 整合 Spring
mrathena
12-02 324
博文目录 文章目录Spring Baseproducerconsumer Spring Base 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="http://
springboot 整合rabbitMQ
weixin_30902675的博客
09-03 108
RabbitMQ RabbitMQ是一个被广泛使用的开源消息队列。它是轻量级且易于部署的，它能支持多种消息协议。RabbitMQ可以部署在分布式和联合配置中，以满足高规模、高可用性的需求。 在pom.xml中添加相关依赖 <!--消息队列相关依赖--> <dependency> <groupId>org.spr...
RabbitMQ：整合Spring Boot
kaven
02-15 1356
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="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/ma
SpringMVC和rabbitmq集成使用
jmdonghao的博客
09-02 1万+
1.添加maven依赖 <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>3.5.1</version> </dependency> <dependency> <groupId>org.springframework.amqp</groupId>
springboot-rabbitMQ-websocket:springboot整合rabbitMQ和websocket，实现消息的发布和接收，并通过websocket实时推送数据到页面
05-27
springboot-rabbitMQ-websocketspringboot整合rabbitMQ和websocket，实现消息的发布和接收，并通过websocket实时推送数据到页面
spring-boot-rabbitmq-demo.zip
03-09
spring boot和rabbitMQ最佳实践 1、JSON序列化与反序列化 要实现消息跨平台，需要配置消息JSON序列化（配置见代码实现），就可以实现不同语言之间互相发送/接收消息，还可以直接用RabbitMQ控制台发送消息。 2、...
rabbitmq-practice整合springboot的一个小练习demo
07-10
这个是学习完rabbitmq之后，整合springboot的一个小练习demo
1 SpringBoot整合RabbitMQ-整合配置篇-源码数据库
09-04
1 SpringBoot整合RabbitMQ实战系列教程-整合配置篇-源码数据库
RabbitMQ整合Spring AMQP实战！（全）
java专栏的博客
08-12 8213
前言 1. AMQP 核心组件 RabbitAdmin SpringAMQP声明 RabbitTemplate SimpleMessageListenerContainer MessageListenerAdapter MessageConverter 2. RabbitAdmin RabbitAdmin类可以很好的才注意RabbitMQ,在Spring中直接进行诸如即可。 ...
Spring 整合RabbitMQ
zyq13870585230的博客
11-05 2797
目录1. 搭建生产者工程1.1. 创建工程1.2. 添加依赖1.3. 配置整合1.4. 发送消息2. 搭建消费者工程2.1. 创建工程2.2. 添加依赖5.2.3. 配置整合5.2.4. 消息监听器1）队列监听器2）广播监听器13）广播监听器24）星号通配符监听器5）井号通配符监听器6）井号通配符监听器2 1. 搭建生产者工程 1.1. 创建工程 1.2. 添加依赖 两个工程的pom.xml文件内容为如下： <?xml version="1.0" encoding="UTF-8"?> <
Spring整合rabbitmq实践（一）：基础使用配置
热门推荐
JinchaoLv的博客
11-19 1万+
1. Rabbitmq基本概念 1.1. Rabbitmq中的各个角色 producer：消息生产者； consumer：消息消费者； queue：消息队列； exchange：接收producer发送的消息按照binding规则转发给相应的queue； binding：exchange与queue之间的关系； virtualHost：每个virtualHost持有自己的exchange、que...
spring整合rabbitmq的实现
飞翔的鸡肉
04-27 8540
RabbittMq的五种队列：简单队列 ：P：消息的生产者C：消息的消费者红色：队列生产者将消息发送到队列，消费者从队列中获取消息。WORK模式：一个生产者、2个消费者。一个消息只能被一个消费者获取。订阅模式：解读：1、1个生产者，多个消费者2、每一个消费者都有自己的一个队列3、生产者没有将消息直接发送到队列，而是发送到了交换机4、每个队列都要绑定到交换机5、生产者发送的消息，经过交换机，到达队列...
RabbitMQ学习（三）：Spring整合RabbitMQ
雷小涛的专栏
01-02 6194
1、maven依赖 org.springframework.amqp spring-rabbit 1.4.6.RELEASE 2、spring-rabbit配置 2.1、配置rabbitMQ连接 （1）采用方式配置连接 <rabbit:connection-factory id="connectionFactory" host="${rabbitmq.h
关于RabbitMQ以及RabbitMQ和Spring的整合
weixin_30640291的博客
02-17 158
基本概念 RabbitMQ是流行的开源消息队列系统，用erlang语言开发。RabbitMQ是AMQP（高级消息队列协议）的标准实现。如果不熟悉AMQP，直接看RabbitMQ的文档会比较困难。不过它也只有几个关键概念，这里简单介绍。 RabbitMQ的结构图如下： 几个概念说明： Broker：简单来说就是消息队列服务器实体。　　Exchange：消息交...
航班信息管理系统（JDBC）
chrismurphy的博客
04-27 1981
现在有一家航空公司为了提高用户体验，希望做一个航班信息系统，用户 可以根据需求去对航班信息进行操作。组长把这个任务安排给了程序员赵丹， 赵丹发现这里需要通过 java 代码操作数据库，并且用户是可以在控制台做对 应的操作，JDBC 可以帮她解决这个问题。学习起来，试着把这个系统实现出来。
SSM整合 - 动态角色权限管理
chrismurphy的博客
08-17 795
SSM实现：已登录的用户根据其角色信息及其角色权限，实现菜单列表的动态展示。
spring整合rabbitmq
最新发布
08-15
最后，在spring-rabbitmq-producer.xml文件中配置队列、交换机和绑定，例如使用配置队列，使用<rabbit:direct-exchange>配置Direct类型的交换机，以及使用进行绑定操作。这样就完成了Spring与RabbitMQ的整合配置。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

xmurphymurphy

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值