Spring集成消息队列RabbitMQ

最新推荐文章于 2023-09-20 23:18:55 发布
最新推荐文章于 2023-09-20 23:18:55 发布
阅读量456 收藏
点赞数
分类专栏： jms 文章标签： rabbitmq spring

1. RabbitMQ简介

1.1. RabbitMQ

RabbitMQ是由Erlang(爱立信公司)语言开发，实现Advanced Message Queuing Protocol (AMQP高级消息队列协议)的消息中间件。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。

1.2. 结构图

这里写图片描述
• Broker：消息队列服务器实体，例如RabbitMQ服务
• Vhost：虚拟主机，默认为“/”，一个broker里可以有多个vhost，区分不同用户权限，类似Java的命令空间
• Connection：应用程序与broker连接，可有多个连接
• Channel：消息通道，connection中可建立多个channel，每个channel代表一个会话任务，所有操作都在channel中进行。
• Exchange：消息交换机，channel中可有多个，用于投递消息。应用程序发送消息时先把消息给交换机，由交换机投递给队列，不是直接给队列。
类型有三种：fanout(广播)、Direct（处理路由键，轮播实现）、Topic（支持消息模糊匹配）
• Queue：队列，用于存放消息
• Message：消息，应用程序需要发送的数据
• Bind：根据routingKey绑定exchange与queue规则，决定消息发送的方向

1.3. 对象间关系

这里写图片描述

2. rabbitMQ与spring集成

使用spring封装的rabbitmq的https://github.com/spring-projects/spring-amqp 做集成。

2.1. 发送消息Producer

发送接口

public interface SimpleMQProducer {

    /**
     * 发送消息至MQ
     */
    public void sendDataToMQ(Object message); 

    /**
     * 发送消息至MQ
     */
    public void sendDataToMQ(Object message, String msgid); 

}
  
  
  • 1
  • 2
  • 3

发送接口实现

public class SmartMQProducer implements InitializingBean,SimpleMQProducer{

    protected final Loggerx logger = Loggerx.getLogger("dao");

    protected RabbitTemplate rabbitTemplate = new RabbitTemplate();

    protected String queue;

    protected String exchange;

    protected String routingKey;

    protected ConnectionFactory connectionFactory;

    protected MessageConverter messageConverter;

    protected RetryTemplate retryTemplate;

    protected ConfirmCallback confirmCallback;

    protected ReturnCallback failedCallback;

    public RabbitTemplate getRabbitTemplate() {
        return rabbitTemplate;
    }

    public void setRabbitTemplate(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }

    public void setQueue(String queue) {
        this.queue = queue;
    }

    public void setExchange(String exchange) {
        this.exchange = exchange;
    }

    public void setRoutingKey(String routingKey) {
        this.routingKey = routingKey;
    }

    public void setConnectionFactory(ConnectionFactory connectionFactory) {
        this.connectionFactory = connectionFactory;
    }

    public void setMessageConverter(MessageConverter messageConverter) {
        this.messageConverter = messageConverter;
    }

    public void setRetryTemplate(RetryTemplate retryTemplate) {
        this.retryTemplate = retryTemplate;
    }

    public void setConfirmCallback(ConfirmCallback confirmCallback) {
        this.confirmCallback = confirmCallback;
    }

    public void setFailedCallback(ReturnCallback failedCallback) {
        this.failedCallback = failedCallback;
    }

    @Override
    public void sendDataToMQ(Object message) {
        CorrelationData correlationId = null;
        try {
            correlationId = new CorrelationData(GUID.genTxNo(25));
        } catch (Exception e) {
            logger.error(LogType.EX, "产生消息id失败",e);
            correlationId = new CorrelationData(UUID.randomUUID().toString());
        }
        this.rabbitTemplate.convertAndSend(this.routingKey, message, correlationId);
        logger.info(LogType.EX, "发送到MQ的消息内容["+JsonUtil.toJSONString(message)+"],消息ID["+correlationId.getId()+"]");
    }

    @Override
    public void sendDataToMQ(Object message, String msgid) {
        CorrelationData correlationId = new CorrelationData(msgid);
        this.rabbitTemplate.convertAndSend(this.routingKey, message, correlationId);
        logger.info(LogType.EX, "发送到MQ的消息内容["+JsonUtil.toJSONString(message)+"],消息ID["+correlationId.getId()+"]");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        this.rabbitTemplate.setQueue(this.queue);
        this.rabbitTemplate.setExchange(this.exchange);
        this.rabbitTemplate.setRoutingKey(this.routingKey);
        this.rabbitTemplate.setConnectionFactory(this.connectionFactory);
        this.rabbitTemplate.setMessageConverter(this.messageConverter);
        this.rabbitTemplate.setMandatory(true);
        if (null == this.failedCallback) {
            // 确认消息是否到达broker服务器，也就是只确认是否正确到达exchange中即可，只要正确的到达exchange中，broker即可确认该消息返回给客户端ack。
            this.rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
                @Override
                public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                    //记录本地日志
                    Object object = StringUtil.ByteToObject(message.getBody());
                    logger.error(LogType.EX, "消息发送到MQ失败,内容["+object+"]");
                }
            });
        }else {
            this.rabbitTemplate.setReturnCallback(this.failedCallback);
        }
        //设置回调
        this.rabbitTemplate.setConfirmCallback(this.confirmCallback);
    }

}
  
  
  • 1
  • 2
  • 3
  • 4

发送到MQ失败回调处理

public abstract class SmartMQFailedCallBack implements ReturnCallback {

    protected final Loggerx logger = Loggerx.getLogger("bo");
    /**
     * 确认消息是否到达broker服务器，也就是只确认是否正确到达queue中即可，只要正确的到达queue中，broker即可确认该消息返回给客户端ack。
     */
    public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
        if (null != message) {
            Object object = StringUtil.ByteToObject(message.getBody());
            logger.error(LogType.EX, "消息发送到MQ失败,内容["+object+"]");
            executeFailedMessage(object);
        }else {
            logger.error(LogType.EX, "消息发送到MQ失败,消息内容为null"); 
        }
    }

    public abstract void executeFailedMessage(Object message);
}
  
  
  • 1
  • 2
  • 3
  • 4

发送到MQ后回调处理（不分成功或失败）

public abstract class SmartMQConfirmCallBack implements ConfirmCallback{
    protected final Logger logger = Logger.getLogger("bo");

    /**
     * 确认消息是否到达broker服务器，也就是只确认是否正确到达exchange中即可，只要正确的到达exchange中，broker即可确认该消息返回给客户端ack。
     * 
     */
    public void confirm(CorrelationData correlationData, boolean ack) {
        if (ack) {
            logger.info(LogType.INFO, "消息成功消费，消息ID["+correlationData.getId()+"]");
        } else {
            logger.error(LogType.EX, "消息失败消费，消息ID["+correlationData.getId()+"]");
        }
        executeCallBack(correlationData.getId(),ack);
    }

    public abstract void executeCallBack(String msgID,boolean ack);
}
  
  
  • 1
  • 2
  • 3
  • 4

发送端spring

<?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-1.0.xsd">

    <!-- 连接服务配置 -->
    <bean id="mqConnectionFactory" class="org.springframework.amqp.rabbit.connection.CachingConnectionFactory">
        <constructor-arg value="xxx.xxx.xx.xx"/>
        <property name="username" value="guest"/>
        <property name="password" value="guest"/>
        <property name="virtualHost" value="/"/>
        <property name="channelCacheSize" value="50"/>
        <property name="publisherConfirms" value="true"/>
        <property name="publisherReturns" value="true"/>
    </bean>

    <rabbit:admin connection-factory="mqConnectionFactory" />
    <!-- 声明消息转换器为SimpleMessageConverter -->
    <bean id="msgConverter" class="org.springframework.amqp.support.converter.SimpleMessageConverter" />
    <!-- 消息发送重试 ,可选项-->
    <bean id="retryTemplate" class="org.springframework.retry.support.RetryTemplate">
        <property name="backOffPolicy">
            <bean class="org.springframework.retry.backoff.ExponentialBackOffPolicy">
                <property name="initialInterval" value="500" />
                <property name="multiplier" value="10.0" />
                <property name="maxInterval" value="10000" />
            </bean>
        </property>
    </bean>
    <!-- queue 队列声明 -->
    <!-- durable=true,交换机持久化,rabbitmq服务重启交换机依然存在,保证不丢失; durable=false,相反 -->
    <!-- auto-delete=true:无消费者时，队列自动删除; auto-delete=false：无消费者时，队列不会自动删除 -->
    <!-- 排他性，exclusive=true:首次申明的connection连接下可见; exclusive=false：所有connection连接下都可见-->
    <rabbit:queue id="test" durable="true" auto-delete="false" exclusive="false" name="test" />

    <!-- exchange queue binging key 绑定 -->
    <!-- durable=true,交换机持久化,rabbitmq服务重启交换机依然存在,保证不丢失; durable=false,相反 -->
    <!-- auto-delete=true:无消费者时，队列自动删除; auto-delete=false：无消费者时，队列不会自动删除 -->
    <rabbit:direct-exchange name="test" durable="true" auto-delete="false" id="test">
        <rabbit:bindings>
            <rabbit:binding queue="test" key="test_key" />
        </rabbit:bindings>
    </rabbit:direct-exchange>

    <!-- 消息发送到mq回调处理，需要处理错误消息,可选项 -->
    <bean id="testfailedCallback" class="xxx.TestMsgFailedCallBack"></bean>
    <!-- 消息发送到mq回调处理，接着业务处理 ,可选项-->
    <bean id="testconfirmCallback" class="xxx.TestconfirmCallback"></bean>
    <bean id="testProducer" class="XXXX.SmartMQProducer">
        <property name="connectionFactory" ref="mqConnectionFactory" />
        <property name="messageConverter" ref="msgConverter" />
        <property name="retryTemplate" ref="retryTemplate" />
        <property name="confirmCallback" ref="testconfirmCallback" />
        <property name="failedCallback" ref="testfailedCallback" />
        <property name="exchange" value="test" />
        <property name="queue" value="test" />
        <property name="routingKey" value="test" />
    </bean> 

</beans>
  
  
  • 1
  • 2
  • 3
  • 4

2.2. 消费端Consumer

接收端spring配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:aop="http://www.springframework.org/schema/aop"  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-3.1.xsd
    http://www.springframework.org/schema/rabbit
    http://www.springframework.org/schema/rabbit/spring-rabbit-1.0.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-3.1.xsd">

    <!-- 连接服务配置 -->
    <bean id="mqConnectionFactory"
        class="org.springframework.amqp.rabbit.connection.CachingConnectionFactory">
        <constructor-arg value="xxx.xxx.xxx.xxx" />
        <property name="username" value="guest" />
        <property name="password" value="guest" />
        <property name="virtualHost" value="/" />
        <property name="channelCacheSize" value="50" />
    </bean>
    <!-- 创建rabbitAdmin 代理类 -->
    <rabbit:admin connection-factory="mqConnectionFactory" />

    <!-- 声明消息转换器为SimpleMessageConverter -->
    <bean id="msgConverter"
        class="org.springframework.amqp.support.converter.SimpleMessageConverter" />

    <!-- queue 队列声明 -->
    <rabbit:queue id="test" name="test" durable="true" auto-delete="false" exclusive="false" />

    <!-- exchange queue binging key 绑定 -->
    <!-- durable=true,交换机持久化,rabbitmq服务重启交换机依然存在,保证不丢失; durable=false,相反 -->
    <!-- auto-delete=true:无消费者时，队列自动删除; auto-delete=false：无消费者时，队列不会自动删除 -->
    <!-- 通过Binding来判定Queue、Exchange、routingKey -->
    <rabbit:direct-exchange id="test" name="test"
        durable="true" auto-delete="false">
        <rabbit:bindings>
            <rabbit:binding queue="test" key="test_key" />
        </rabbit:bindings>
    </rabbit:direct-exchange>

    <bean id="testMsgHandler" class="xxxx.testMsgHandler" />
    <bean id="testMsgAdapter" class="org.springframework.amqp.rabbit.listener.adapter.MessageListenerAdapter">
        <constructor-arg ref="testHandler" />
        <property name="defaultListenerMethod" value="handleTxMsg"></property>
        <property name="messageConverter" ref="msgConverter"></property>
    </bean>
    <bean id="testlistenerContainer" class="org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer">
        <property name="queueNames" value="test"></property>
        <property name="connectionFactory" ref="mqConnectionFactory"></property>
        <property name="messageListener" ref="testAdapter"></property>
        <property name="maxConcurrentConsumers" value="100" />
        <property name="concurrentConsumers" value="20" /
    </bean>

</beans>
  
  
  • 1
  • 2
  • 3

接收端封装

public abstract class ConsumerHandler{

    protected static Logger logger = Logger.getLogger("bo");

    public void handleTxMsg(Object message) {
        try {
             //基类的业务处理
            }
            logger.info(LogType.MQ, "消息内容["+JsonUtil.toJSONString(message)+"]");
            handler(message);
        } catch (Exception e) {
            logger.error(LogType.EX, e, e);
        } finally {
            LogContextHolder.getInstance().removeLogContext();
        }
    }
    //实际的业务处理
    public abstract void handler(Object message);
}

  
  
  • 1
  • 2
  • 3

3. 效果

这里写图片描述

zjqbobo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springbootj集成canal+mysql+rabbitmq
10-11
mysql需开启binlog 查看是否开启binlog ... 新增队列：test.queue, 绑定canal.queue， RoutingKey：canal.routing.key canal下载及配置 https://github.com/alibaba/canal/releases/tag/canal-1.1.5 配置文件见附件
RbbitMq不推荐使用匿名队列
牧竹子
12-10 994
405, reply-text=RESOURCE_LOCKED排它队列导致的异常
SpringAMQP消息队列（SpringBoot集成RabbitMQ）
JackMa的博客
02-18 5997
但是此时有一个问题就是消息预取，比如队列有10条消息，两个消费者各自直接先预取5个消息，如果一个消费者接受消息的速度慢，一个快，就会导致一个消费者已经完成工作，另一个还在慢慢处理，会造成消息堆积消费者身上，要解决这个问题需要在yml文件配置相关配置。exchange是交换机，负责消息路由，但不存储消息，路由失败则消息丢失。控制台结果如下（共发送20条，每个队列10条）六、发布订阅模式之路由模式（Direct）三、工作消息队列（Work Queue）可以提高消息处理速度，避免队列消息堆积。
三、在Spring中使用RabbitMQ
qq_36412195的博客
04-17 1257
添加RabbitMQ到Spring中 1.添加RabbitMQ依赖 在使用Spring发送和接收RabbitMQ消息之前，我们需要将Spring Boot的AMQPstarter依赖添加到构建文件中 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency&g
Spring项目整合 RabbitMQ消息队列，动态创建队列与交换机
Carroll的博客
07-17 6823
RabbitMQ是一个被广泛使用的开源消息队列。它是轻量级且易于部署的，它能支持多种消息协议。RabbitMQ可以部署在分布式和联合配置中，以满足高规模、高可用性的需求。，初始默认用户名/密码guest/guest。至此，RabbitMQ的安装和配置完成。......
Spring整合RabbitMQ
Mr_yu_shao的博客
08-31 1939
超简单！入门级SpringBoot整合RabbitMQ，一看就会！
spring集成rabbitmq 通俗易懂的demo
12-12
spring集成rabbitmq 通俗易懂的demo，保证可以使用，具体的配置，可以参考我的文章
SpringBoot集成RabbitMQ延时队列，自定义延时时间Demo
09-16
该示例通过 rabbitmq_delayed_message_exchange 插件实现自定义延时时间的延时队列。 示例是纯净的，只引入了需要的架包 启动示例时，请确保MQ已经安装了延时插件(附件里带有插件及安装说明)以及示例的MQ相关的配置...
贝岭的matlab的代码-belling-spring-rabbitmq:Spring项目集成了消息队列-RabbitMQ，实现了普通消息订阅
06-16
百灵Spring集成RabbitMQ封装 简介 Spring项目集成了消息队列-RabbitMQ，考虑到数据安全和稳定性，选择了RabbitMQ.当前开发环境在Win10下测试 内置功能 基于普通消息订阅-发布模式的消息队列实现。 基于延迟消息队列...
springboot集成消息队列实现发送与接收demo
01-18
springboot集成消息队列实现发送与接收demo; 包含activemq rocketmq kafka等
spring data rabbitmq 源码
10-29
RabbitMQ是一个由erlang开发的AMQP（Advanced Message Queue ）的开源实现，AMQP就是一个协议，是一个高级抽象层消息通信协议。 虽然在同步消息通讯的世界里有很多公开标准（如 COBAR的 IIOP ，或者是 SOAP 等），但是在异步消息处理中却不是这样，只有大企业有一些商业实现（如微软的 MSMQ ，IBM 的 Websphere MQ 等），因此，在 2006 年的 6 月，Cisco 、Redhat、iMatix 等联合制定了 AMQP 的公开标准。也就是说AMQP是异步通讯的一个协议。
SpringBoot整合RabbitMQ
K_kzj_K的博客
06-09 4279
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
消息队列 RabbitMQ 与 Spring 整合使用
qq_38745846的博客
05-13 562
一、什么是 RabbitMQ RabbitMQ 是实现 AMQP（高级消息队列协议）的消息中间件的一种，最初起源于金融系统，用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。 RabbitMQ 是由 Erlang 语言开发，安装 RabbitMQ 服务需要先安装 Erlang 语言包
SpringBoot使用RabbitMQ消息队列
qq_18395585的博客
09-24 256
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/lizc_lizc/article/details/80722090 RabbitMQ简介 AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计...
RabbitMQ介绍，搭建及spring集成
q3198215426的博客
02-08 1442
RabbitMQ是什么？ RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。 常见的消息中间件，及应用场景？ Kafka、ActiveMQ、RabbitMQ、RocketMQ
springboot对接rabbitmq并且实现动态创建队列和消费
最新发布
weixin_43317111的博客
09-20 2355
/ 死信： 队列 交换机 绑定consumer 绑定队列。//设置延迟队列的 TTL 消息存活时间。// 延迟: 队列 交换机 绑定队列。// 绑定consumer 绑定队列。//设置延迟队列绑定的死信交换机。//设置延迟队列绑定的死信路由键。
SpringBoot 集成 RabbitMQ
爱笑的boy的博客
03-04 4907
SpringBoot 集成 RabbitMQ
【RabbitMQ】Spring整合RabbitMQ、Spring实现RabbitMQ五大工作模式（万字长文）
qq_61903414的博客
04-15 2246
订阅模式与前两种不同，订阅模式需要使用到fanout类型的交换机，并且将队列与之绑定，他的生产者在xml文件里需要去创建两个队列与fanout类型的交换机并绑定，在发送消息时指定交换机名称即可，而消费者则与前者相同，只是需要修改指定监听的队列名。此处由于创建的交换机类型是fanout广播类型不需要去配置路由，如果创建的direct交换机不止需要配置队列名属性，还需要配置路由属性，如果是topic交换机则需要配置通配符。同样在消费者创建的xml文件里我们路创建队列监听器容器来将不同队列的消息映射到不同的类。
Spring Boot 整合Spring Data以及rabbitmq，thymeleaf，向qq邮箱发送信息
欢迎来到我的博客，一起学习Java！
12-05 1275
首先得将自己的qq开启qq邮箱的POP3/SMTP服务 说明： p,e为路由key。 用户系统完成登录的时候，将{手机号-时间-IP}保存到队列Phone-queue中，msg-sys系统获得消息打印到控制台（完成用户登录过程短信服务的异步调用,完成用户系统和短信系统的解耦合） 用户系统完成注册的时候，将{email-时间-IP-账户激活url }保存到队列email-sys中，...
spring boot 集成 rabbitmq
04-26
可以使用Spring Boot提供的AMQP Starter依赖来集成RabbitMQ。具体步骤如下： 1.添加依赖 在pom.xml文件中添加以下依赖： ``` <groupId>org.springframework.boot <artifactId>spring-boot-starter-amqp ``` ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值