RabbitMQ（二）Spring boot集成

最新推荐文章于 2019-05-20 09:09:00 发布
最新推荐文章于 2019-05-20 09:09:00 发布
阅读量316 收藏 2
点赞数
分类专栏： MQ中间件 文章标签： RabbitMQ 消息队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sadlay/article/details/86650659
版权

RabbitMQ（二）Spring Boot集成

Spring Boot集成RabbitMQ非常简单，如果只是简单的使用配置非常少，Spring Boot提供了spring-boot-starter-amqp项目对消息各种支持。

简单使用

1、配置pom包

主要是添加spring-boot-starter-amqp的支持

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

2、配置文件

配置rabbitmq的安装地址、端口以及账户信息

spring.application.name=rabbitmq
server.port=8080

spring.rabbitmq.host=192.168.3.253
spring.rabbitmq.port=5672
spring.rabbitmq.username=admin
spring.rabbitmq.password=123456

3、队列配置

package com.lay.rabbitmq.queue.config;

/**
 * @Description:
 * @Author: lay
 * @Date: Created in 18:36 2018/12/18
 * @Modified By:IntelliJ IDEA
 */
@Configuration
public class RabbitConfig {
    @Bean
    public Queue queue(){
        return new Queue("hello");
    }

}

4、发送者

AmqpTemplate是springboot提供的默认实现，RabbitTemplate是对AmqpTemplate的又一次封装（两者都可以实现发送的基本功能，这里使用前者）。

package com.lay.rabbitmq.queue.sender;

/**
 * @Description:
 * @Author: lay
 * @Date: Created in 18:50 2018/12/18
 * @Modified By:IntelliJ IDEA
 */
@Component
public class HelloSender {
    @Autowired
    private AmqpTemplate rabbitTemplate;

    public void send(){
        String context="hello"+new Date();
        System.out.println("Sender:"+context);
        rabbitTemplate.convertAndSend("hello",context);
    }
	
    public void send(int i){
        String context="Spring boot queue *****"+i;
        //System.out.println("Sender:"+context);
        rabbitTemplate.convertAndSend("hello",context);
    }
}

5、接收者

package com.lay.rabbitmq.queue.receiver;

/**
 * @Description:
 * @Author: lay
 * @Date: Created in 18:54 2018/12/18
 * @Modified By:IntelliJ IDEA
 */
@Component
@RabbitListener(queues = "hello")
public class HelloReceiver {

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

}

6、测试

package com.lay.rabbitmq;

/**
 * @Description:
 * @Author: lay
 * @Date: Created in 18:57 2018/12/18
 * @Modified By:IntelliJ IDEA
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class RabbitMqHelloTest {
    @Autowired
    private HelloSender helloSender;

    @Test
    public void hello() throws Exception{
        helloSender.send();
    }

}

注意，发送者和接收者的queue name必须一致，不然不能接收

多对多使用

一个发送者，N个接收者或者N个发送者和N个接收者会出现什么情况呢？

一对多发送

对上面的代码进行了小改造,接收端注册了两个Receiver,Receiver1和Receiver2，发送端加入参数计数，接收端打印接收到的参数，下面是测试代码，发送一百条消息，来观察两个接收端的执行效果

    @Test
    public void oneToMany() throws Exception {
        for (int i=0;i<100;i++){
            helloSender.send(i);
        }
    }

结果如下：

Receiver 1: Spring boot neo queue ****** 11
Receiver 2: Spring boot neo queue ****** 12
Receiver 2: Spring boot neo queue ****** 14
Receiver 1: Spring boot neo queue ****** 13
Receiver 2: Spring boot neo queue ****** 15
Receiver 1: Spring boot neo queue ****** 16
Receiver 1: Spring boot neo queue ****** 18
Receiver 2: Spring boot neo queue ****** 17
Receiver 2: Spring boot neo queue ****** 19
Receiver 1: Spring boot neo queue ****** 20

根据返回结果得到以下结论

一个发送者，N个接受者,经过测试会均匀的将消息发送到N个接收者中

多对多发送

复制了一份发送者，加入标记，在一百个循环中相互交替发送

@Test
	public void manyToMany() throws Exception {
		for (int i=0;i<100;i++){
			helloSender.send(i);
			helloSender2.send(i);
		}
}

结果如下：

Receiver 1: Spring boot neo queue ****** 20
Receiver 2: Spring boot neo queue ****** 20
Receiver 1: Spring boot neo queue ****** 21
Receiver 2: Spring boot neo queue ****** 21
Receiver 1: Spring boot neo queue ****** 22
Receiver 2: Spring boot neo queue ****** 22
Receiver 1: Spring boot neo queue ****** 23
Receiver 2: Spring boot neo queue ****** 23
Receiver 1: Spring boot neo queue ****** 24
Receiver 2: Spring boot neo queue ****** 24
Receiver 1: Spring boot neo queue ****** 25
Receiver 2: Spring boot neo queue ****** 25

结论：和一对多一样，接收端仍然会均匀接收到消息

高级使用

对象的支持

springboot以及完美的支持对象的发送和接收，不需要格外的配置。

先定义一个用户对象User

package com.lay.rabbitmq.object.entity;

/**
 * @Description:
 * @Author: lay
 * @Date: Created in 19:17 2018/12/18
 * @Modified By:IntelliJ IDEA
 */
public class User implements Serializable {
    private static final long serialVersionUID = 426370694438321946L;
    private Long id;
    private String userName;
    private String sex;
    private Integer age;

    public static long getSerialVersionUID() {
        return serialVersionUID;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", sex='" + sex + '\'' +
                ", age=" + age +
                '}';
    }
}

配置队列：

package com.lay.rabbitmq.object.config;

/**
 * @Description:
 * @Author: lay
 * @Date: Created in 18:36 2018/12/18
 * @Modified By:IntelliJ IDEA
 */
@Configuration
public class RabbitObjectConfig {

    @Bean
    public Queue userQueue(){
        return new Queue("user");
    }
}

发送者：

package com.lay.rabbitmq.object.sender;

/**
 * @Description:
 * @Author: lay
 * @Date: Created in 19:23 2018/12/18
 * @Modified By:IntelliJ IDEA
 */
@Component
public class UserSender {

    @Autowired
    private AmqpTemplate rabbitTemplate;

    public void send(User user){
        System.out.println("Sender User: "+user.toString());
        rabbitTemplate.convertAndSend("user",user);
        try {
            Thread.sleep(2000L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

接收者：

package com.lay.rabbitmq.object.receiver;

/**
 * @Description:
 * @Author: lay
 * @Date: Created in 19:25 2018/12/18
 * @Modified By:IntelliJ IDEA
 */
@Component
@RabbitListener(queues = "user")
public class UserReceiver {
    @RabbitHandler
    public void process(User user) {
        System.out.println("UserReceiver  : " + user.toString());
    }

}

Topic Exchange

topic 是RabbitMQ中最灵活的一种方式，可以根据routing_key自由的绑定不同的队列

首先对topic规则配置，这里使用两个队列来测试

队列和交换机配置

package com.lay.rabbitmq.topic.config;

/**
 * @Description:
 * @Author: lay
 * @Date: Created in 18:36 2018/12/18
 * @Modified By:IntelliJ IDEA
 */
@Configuration
public class TopicRabbitConfig {
    public final static String message = "topic.message";
    public final static String messages = "topic.messages";
    @Bean
    public Queue queueMessage(){
        return new Queue(TopicRabbitConfig.message);
    }

    @Bean
    public Queue queueMessages(){
        return new Queue(TopicRabbitConfig.messages);
    }

    @Bean
    public TopicExchange exchange(){
        return new TopicExchange("topicExchange");
    }
    @Bean
    public Binding bindExchangeMessage(Queue queueMessage,TopicExchange exchange){
        return BindingBuilder.bind(queueMessage).to(exchange).with("topic.message");
    }
    @Bean
    public Binding bindExchangeMessages(Queue queueMessages,TopicExchange exchange){
        return BindingBuilder.bind(queueMessages).to(exchange).with("topic.#");
    }

}

使用queueMessages同时匹配两个队列，queueMessage只匹配”topic.message”队列

生产者：

package com.lay.rabbitmq.topic.sender;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @Description:
 * @Author: lay
 * @Date: Created in 19:46 2018/12/18
 * @Modified By:IntelliJ IDEA
 */
@Component
public class TopicSender {
    @Autowired
    private AmqpTemplate rabbitTemplate;

    public void send1(){
        String conText="this is message 1";
        System.out.println("Sender: "+conText);
        rabbitTemplate.convertAndSend("topicExchange","topic.message",conText);
    }

    public void send2(){
        String conText="this is messages 2";
        System.out.println("Sender: "+conText);
        rabbitTemplate.convertAndSend("topicExchange","topic.messages",conText);
    }
}

发送send1会匹配到topic.#和topic.message 两个Receiver都可以收到消息，发送send2只有topic.#可以匹配所有只有Receiver2监听到消息

消费者1:

package com.lay.rabbitmq.topic.receiver;

/**
 * @Description:
 * @Author: lay
 * @Date: Created in 19:49 2018/12/18
 * @Modified By:IntelliJ IDEA
 */
@Component
@RabbitListener(queues = TopicRabbitConfig.message)
public class TopicReceiver1 {
    @RabbitHandler
    public void process(String context){
        System.out.println("TopicReceiver 1: "+context);
    }
}

消费者2：

package com.lay.rabbitmq.topic.receiver;

/**
 * @Description:
 * @Author: lay
 * @Date: Created in 19:49 2018/12/18
 * @Modified By:IntelliJ IDEA
 */
@Component
@RabbitListener(queues = TopicRabbitConfig.messages)
public class TopicReceiver2 {
    @RabbitHandler
    public void process(String context){
        System.out.println("TopicReceiver 2: "+context);
    }
}

Fanout Exchange

Fanout 就是我们熟悉的广播模式或者订阅模式，给Fanout交换机发送消息，绑定了这个交换机的所有队列都收到这个消息。

Fanout 相关配置

package com.lay.rabbitmq.fanout.config;

/**
 * @Description:
 * @Author: lay
 * @Date: Created in 10:13 2018/12/20
 * @Modified By:IntelliJ IDEA
 */
@Configuration
public class FanoutRabbitConfig {
    public static final String QUEUE_A = "fanout.A";
    public static final String QUEUE_B = "fanout.B";
    public static final String QUEUE_C = "fanout.C";
    public static final String FANOUT_EXCHANGE = "fanoutExchange";

    @Bean
    public Queue AMessage() {
        return new Queue(QUEUE_A);
    }

    @Bean
    public Queue BMessage() {
        return new Queue(QUEUE_B);
    }

    @Bean
    public Queue CMessage() {
        return new Queue(QUEUE_C);
    }

    @Bean
    FanoutExchange fanoutExchange() {
        return new FanoutExchange(FANOUT_EXCHANGE);
    }

    @Bean
    Binding bindingExchangeA(Queue AMessage, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(AMessage).to(fanoutExchange);
    }

    @Bean
    Binding bindingExchangeB(Queue BMessage, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(BMessage).to(fanoutExchange);
    }

    @Bean
    Binding bindingExchangeC(Queue CMessage, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(CMessage).to(fanoutExchange);
    }
}

这里使用了A、B、C三个队列绑定到Fanout交换机上面，发送端的routing_key写任何字符都会被忽略：

生产者：

package com.lay.rabbitmq.fanout.sender;

/**
 * @Description:
 * @Author: lay
 * @Date: Created in 13:42 2018/12/19
 * @Modified By:IntelliJ IDEA
 */
@Component
public class FanoutSender {

    @Autowired
    @Lazy
    RabbitTemplate rabbitTemplate;

    public void send(){
        String context="this is a fanout message";
        System.out.println("Sender"+context);
        rabbitTemplate.convertAndSend(FanoutRabbitConfig.FANOUT_EXCHANGE,"",context);
    }
}

消费者A:

package com.lay.rabbitmq.fanout.receiver;

import com.lay.rabbitmq.fanout.config.FanoutRabbitConfig;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @Description:
 * @Author: lay
 * @Date: Created in 13:44 2018/12/19
 * @Modified By:IntelliJ IDEA
 */
@Component
public class FanoutReceiverA {


    @RabbitListener(queues = FanoutRabbitConfig.QUEUE_A)
    public void process(String context){
        System.out.println("ReceiverA: "+context);
    }

    @RabbitListener(queues = FanoutRabbitConfig.QUEUE_A)
    public void process2(String context){
        System.out.println("ReceiverD: "+context);
    }
}

消费者B：

package com.lay.rabbitmq.fanout.receiver;

import com.lay.rabbitmq.fanout.config.FanoutRabbitConfig;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @Description:
 * @Author: lay
 * @Date: Created in 13:49 2018/12/19
 * @Modified By:IntelliJ IDEA
 */
@Component
@RabbitListener(queues = FanoutRabbitConfig.QUEUE_B)
public class FanoutReceiverB {

    @RabbitHandler
    public void process(String context){
        //System.out.println("ReceiverB: "+context);
    }
}

消费者C：

package com.lay.rabbitmq.fanout.receiver;

import com.lay.rabbitmq.fanout.config.FanoutRabbitConfig;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @Description:
 * @Author: lay
 * @Date: Created in 13:50 2018/12/19
 * @Modified By:IntelliJ IDEA
 */
@Component
@RabbitListener(queues = FanoutRabbitConfig.QUEUE_C)
public class FanoutReceiverC {

    @RabbitHandler
    public void process(String context){
        //System.out.println("ReceiverC: "+context);
    }
}

结果绑定到fanout交换机上面的队列都收到了消息

示例代码-github

Sadlay
关注
专栏目录
详解Spring Boot 配置多个RabbitMQ
08-30
Spring Boot 配置多个 RabbitMQ Spring Boot 是一个流行的 Java 框架，用于快速构建生产级别的应用程序。RabbitMQ 是一个消息队列中间件，用于实现异步消息处理和队列管理。配置多个 RabbitMQ 实例是为了提高系统的...
SpringBoot+RabbitMQ
一名系统架构师的征途
08-08 3703
RabbitMQ 即一个消息队列，主要是用来实现应用程序的异步和解耦，同时也能起到消息缓冲，消息分发的作用。消息中间件在互联网公司的使用中越来越多，刚才还看到新闻阿里将RocketMQ捐献给了apache，当然了今天的主角还是讲RabbitMQ。消息中间件最主要的作用是解耦，中间件最标准的用法是生产者生产消息传送到队列，消费者从队列中拿取消息并处理，生产者不用关心是谁来消费，消费者不用关心谁在生产...
Spring Boot(八)：RabbitMQ 详解
纯洁的微笑
05-20 403
RabbitMQ 即一个消息队列，主要是用来实现应用程序的异步和解耦，同时也能起到消息缓冲，消息分发的作用。消息中间件在互联网公司的使用中越来越多，刚才还看到新闻阿里将 ...
Spring boot集成RabbitMQ的示例代码
08-27
Spring Boot 集成 RabbitMQ 的示例代码 Spring Boot 集成 RabbitMQ 是一种常见的消息队列集成方式，下面将详细介绍 Spring Boot 集成 RabbitMQ 的示例代码。 首先，我们需要了解什么是 RabbitMQ。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下载及配置 ...
spring boot集成rabbitmq的实例教程
08-28
【Spring Boot集成RabbitMQ】 在Spring Boot应用中集成RabbitMQ，可以让我们的系统实现高效、异步的消息通信。RabbitMQ是一个开源的消息代理，它作为消息中间件，允许不同服务之间通过消息进行通信，提高了系统的...
RabbitMQ（四）消息Ack确认机制
热门推荐
Sadlay的博客
02-07 1万+
RabbitMQ（四）消息Ack确认机制 确认种类 RabbitMQ的消息确认有两种。 消息发送确认：这种是用来确认生产者将消息发送给交换器，交换器传递给队列的过程中，消息是否成功投递。发送确认分为两步，一是确认是否到达交换器，二是确认是否到达队列。 消费接收确认。这种是确认消费者是否成功消费了队列中的消息。 环境配置 为了测试，我们先配置rabbit环境 引入Maven依赖 ...
RabbitMQ（三）消息序列化
Sadlay的博客
01-31 1万+
RabbitMQ（三）消息序列化 MessageConvert 涉及网络传输的应用序列化不可避免，发送端以某种规则将消息转成 byte 数组进行发送，接收端则以约定的规则进行 byte[] 数组的解析 RabbitMQ 的序列化是指 Message 的 body 属性，即我们真正需要传输的内容，RabbitMQ 抽象出一个 MessageConvert 接口处理消息的序列化，其实现有 Simpl...
RabbitMQ（五）延时任务
Sadlay的博客
02-13 4249
RabbitMQ（五）延时任务 延时队列 顾名思义，延迟队列就是进入该队列的消息会被延迟消费的队列。而一般的队列，消息一旦入队了之后就会被消费者马上消费。 场景一：在订单系统中，一个用户下单之后通常有30分钟的时间进行支付，如果30分钟之内没有支付成功，那么这个订单将进行一场处理。这是就可以使用延时队列将订单信息发送到延时队列。 场景二：用户希望通过手机远程遥控家里的智能设备在指定的时间进行工作。...
RabbitMQ 在生产环境下运用和出现的问题
Sadlay的博客
02-15 3165
RabbitMQ 在生产环境下运用和出现的问题 在生产环境中，由于 Spring 对 RabbitMQ 提供了一些方便的注解，所以首先可以使用这些注解。例如： @EnableRabbit：@EnableRabbit 和 @configuration 注解在一个类中结合使用，如果该类能够返回一个 RabbitListenerContainerFactory 类型的 bean，那么就相当于能够把该终...
RabbitMQ（一）RabbitMQ消息队列基础知识详解
Sadlay的博客
01-24 1162
RabbitMQ消息队列基础知识详解 RabbitMQ 即一个消息队列，主要是用来实现应用程序的异步和解耦，同时也能起到消息缓冲，消息分发的作用。 消息中间件在互联网公司的使用中越来越多，刚才还看到新闻阿里将RocketMQ捐献给了apache，当然了今天的主角还是讲RabbitMQ。消息中间件最主要的作用是解耦，中间件最标准的用法是生产者生产消息传送到队列，消费者从队列中拿取消息并处理，生产者不...
RabbitMQ安装
Sadlay的博客
02-21 223
RabbitMQ安装 CentOS7版本安装 依赖环境 C++环境 yum -y install make gcc gcc-c++ kernel-devel m4 ncurses-devel openssl-devel unixODBC unixODBC-devel httpd python-simplejson ErLang环境 #安装文件获取 wget http://erlang.org/d...
知识图谱-基于Neo4j+Python+Cypher+KG实现的小型金融知识图谱构建项目-附项目源码+流程教程-优质项目实战
10-20
知识图谱_基于Neo4j+Python+Cypher+KG实现的小型金融知识图谱构建项目_附项目源码+流程教程_优质项目实战
资产管理系统-使用Python+CSS开发的资产配置管理系统-附完整流程教程-优质项目.zip
10-20
资产管理系统_使用Python+CSS开发的资产配置管理系统_附完整流程教程_优质项目
基于SpringMVC+Spring+MyBatis的博客网站系统源码+数据库+使用说明（毕业设计）
10-20
基于SpringMVC+Spring+MyBatis的博客网站系统源码+数据库（毕业设计），本项目是一套个人98分毕业设计系统，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者，也可作为课程设计、期末大作业，包含：项目源码、项目说明等。该项目可以直接作为毕设使用，项目都经过严格调试，确保可以运行！ 基于SpringMVC+Spring+MyBatis的博客网站系统源码+数据库+使用说明（毕业设计）基于SpringMVC+Spring+MyBatis的博客网站系统源码+数据库+使用说明（毕业设计）基于SpringMVC+Spring+MyBatis的博客网站系统源码+数据库+使用说明（毕业设计） 基于SpringMVC+Spring+MyBatis的博客网站系统源码+数据库+使用说明（毕业设计）基于SpringMVC+Spring+MyBatis的博客网站系统源码+数据库+使用说明（毕业设计）基于SpringMVC+Spring+MyBatis的博客网站系统源码+数据库+使用说明（毕业设计）基于SpringMVC+Spring+MyBatis的博客网站系统源码+数据
614075276467436开心叠一叠.apk
最新发布
10-20
614075276467436开心叠一叠.apk
优秀毕业设计-基于海思Hi3516开发板的RTP流媒体服务器系统-项目实战.zip
10-20
优秀毕业设计_基于海思Hi3516开发板的RTP流媒体服务器系统_项目实战
rabbitmq集成spring boot
09-20
rabbitmq与Spring Boot的集成可以通过添加相应的依赖来实现。你需要在项目的pom.xml文件中添加以下依赖： ```xml <!-- rabbitmq --> <groupId>org.springframework.boot <artifactId>spring-boot-starter-amqp ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值