RabbitMQ-Spring整合

最新推荐文章于 2024-04-12 02:12:55 发布
最新推荐文章于 2024-04-12 02:12:55 发布
阅读量262 收藏
点赞数
分类专栏： rabbitMQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lianyuequan/article/details/90703089
版权

目录

Spring-boot中通过注解封装RabbitMQ的使用。

Spring通过XML配置使用rabbitMQ。

通过前面的RabbitMQ的java应用，我们初步了解到MQ的使用。在实际中，我们基本上都不需要这么用，可以直接通过把rabbitMQ整合Spring中，spring帮我们封装了一些消息者、生产者的功能，我们可以直接使用。

 

Spring-boot中通过注解封装RabbitMQ的使用。

1.添加依赖pom.xml

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

2.配置服务器、用户、密码application.properties

spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5673
spring.rabbitmq.username=root
spring.rabbitmq.password=root
spring.rabbitmq.publisher-confirms=true
spring.rabbitmq.publisher-returns=true

3.通过注解定义队列、交换器等。

package mytest.springboot.myRabbitMQTest.common;

import java.util.HashMap;
import java.util.Map;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.amqp.rabbit.core.RabbitMessagingTemplate;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.converter.MappingJackson2MessageConverter;

import mytest.springboot.myRabbitMQTest.common.producer.MyConfirmCallback;
import mytest.springboot.myRabbitMQTest.common.producer.MyReturnCallBack;

/**
 * RabbitMQ 配置
 */
@Configuration
public class RabbitMQConfig {

	@Bean
	RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
		return new RabbitAdmin(connectionFactory);
	}

	@Bean
	Queue queueFooDead(RabbitAdmin rabbitAdmin) {
		Queue queue = new Queue("queue.fooErr", true,true, false);
		rabbitAdmin.declareQueue(queue);
		return queue;
	}

	@Bean
	FanoutExchange deadExchange(RabbitAdmin rabbitAdmin) {
		FanoutExchange deadExchange = new FanoutExchange("deadExchange");
		rabbitAdmin.declareExchange(deadExchange);
		return deadExchange;
	}

	@Bean
	Binding bindingExchangeFooDead(Queue queueFooDead, FanoutExchange deadExchange, RabbitAdmin rabbitAdmin) {
		Binding binding = BindingBuilder.bind(queueFooDead).to(deadExchange);
		rabbitAdmin.declareBinding(binding);
		return binding;
	}

	@Bean
	Queue queueFoo(RabbitAdmin rabbitAdmin) {
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("x-dead-letter-exchange", "deadExchange");// 设置死信交换机
		map.put("x-dead-letter-routing-key", "mail_queue_fail");// 设置死信routingKey
		Queue queue = new Queue("queue.foo", true, false, false, map);
		rabbitAdmin.declareQueue(queue);
		return queue;
	}

	@Bean
	Queue queueBar(RabbitAdmin rabbitAdmin) {
		Queue queue = new Queue("queue.bar", true);
		rabbitAdmin.declareQueue(queue);
		return queue;
	}

	@Bean
	TopicExchange exchange(RabbitAdmin rabbitAdmin) {
		TopicExchange topicExchange = new TopicExchange("exchange");
		rabbitAdmin.declareExchange(topicExchange);
		return topicExchange;
	}

	@Bean
	Binding bindingExchangeFoo(Queue queueFoo, TopicExchange exchange, RabbitAdmin rabbitAdmin) {
		Binding binding = BindingBuilder.bind(queueFoo).to(exchange).with("queue.foo");
		rabbitAdmin.declareBinding(binding);
		return binding;
	}

	@Bean
	Binding bindingExchangeBar(Queue queueBar, TopicExchange exchange, RabbitAdmin rabbitAdmin) {
		Binding binding = BindingBuilder.bind(queueBar).to(exchange).with("queue.bar");
		rabbitAdmin.declareBinding(binding);
		return binding;
	}

	/**
	 * 生产者用
	 * 
	 * @return
	 */
	@Bean
	public RabbitMessagingTemplate rabbitMessagingTemplate(RabbitTemplate rabbitTemplate) {
		RabbitMessagingTemplate rabbitMessagingTemplate = new RabbitMessagingTemplate();
		rabbitMessagingTemplate.setMessageConverter(jackson2Converter());
		rabbitMessagingTemplate.setRabbitTemplate(rabbitTemplate);
		// 消息发送失败返回到队列中, yml需要配置 publisher-returns: true
		rabbitTemplate.setMandatory(true);
		// 消息返回, yml需要配置 publisher-returns: true
		rabbitTemplate.setReturnCallback(new MyReturnCallBack()); // 消息最终没有进行队列时回调
		// 消息确认, yml需要配置 publisher-confirms: true
		rabbitTemplate.setConfirmCallback(new MyConfirmCallback());// 消息保存成功后回调
		return rabbitMessagingTemplate;
	}

	@Bean
	public MappingJackson2MessageConverter jackson2Converter() {
		MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter();
		return converter;
	}

}
package mytest.springboot.myRabbitMQTest.common.consumer;

import java.io.IOException;
import java.util.Random;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import mytest.springboot.myRabbitMQTest.Vo.Bar;
import mytest.springboot.myRabbitMQTest.Vo.Foo;
import com.rabbitmq.client.Channel;

@Component
public class ReceiverService {

    //消费者
	@RabbitListener(queues = "queue.bar")
	public void receiveBarQueue(Bar bar) {
		System.out.println("Received Bar<" + bar.getAge() + ">");
	}

}

生产者

package mytest.springboot.myRabbitMQTest.common.producer;

import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

import org.springframework.amqp.rabbit.core.RabbitMessagingTemplate;
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;

import mytest.springboot.myRabbitMQTest.Vo.Bar;
import mytest.springboot.myRabbitMQTest.Vo.Foo;

@Component
public class SenderService {


	@Autowired
	private RabbitTemplate rabbitTemplate;

	public void sendFoo2RabbitmqByRabbitTemplate(final Foo foo) {

		System.out.println("发送成功开始");
		CorrelationData correlationData = new CorrelationData();
		correlationData.setId("12345678911111111111");
		this.rabbitTemplate.convertAndSend("exchange", "queue.foo", foo ,correlationData);
		System.out.println("发送成功完成1");
		CorrelationData correlationData2 = new CorrelationData();
		correlationData2.setId("12345678911111111112");
		this.rabbitTemplate.convertAndSend("exchange", "queue.foo", foo ,correlationData2);//异步方法
		System.out.println("发送成功完毕");


	}

}

Spring通过XML配置使用rabbitMQ。

  1. 通过Maven加入Spring与RabbitMQ的依赖。 
    <!--rabbitmq依赖 -->  
<dependency>  
    <groupId>org.springframework.amqp</groupId>  
    <artifactId>spring-rabbit</artifactId>  
    <version>1.3.5.RELEASE</version>  
</dependency>
  2. 通过Spring配置rabbit:connection-factory、rabbit:admin、队列、rabbit:template消息模板、交换器（绑定的队列）、消费端、生产端。

      以下是XML方式配置

<!-- 消费端配置 ********************************************** -->
	<!--配置connection-factory，指定连接rabbit server参数 -->
	<rabbit:connection-factory id="connectionFactory" virtual-host="/" username="${rabbitmq.user}" password="${rabbitmq.password}"
		host="${rabbitmq.ip}" port="${rabbitmq.port}" />
	<!-- username="root" password="root" host="127.0.0.1" -->

	<!--通过指定下面的admin信息，当前producer中的exchange和queue会在rabbitmq服务器上自动生成 -->
	<rabbit:admin id="connectAdmin" connection-factory="connectionFactory" />

	<!--定义queue -->
	<rabbit:queue name="queue1" durable="true" auto-delete="false" exclusive="false" declared-by="connectAdmin" />

	<!-- 定义direct exchange，绑定queue1 -->
	<rabbit:direct-exchange name="exchange1"
		durable="true" auto-delete="false" declared-by="connectAdmin">
		<rabbit:bindings>
			<rabbit:binding queue="queue1" key="keys"></rabbit:binding>
		</rabbit:bindings>
	</rabbit:direct-exchange>

	<!--定义rabbit template用于数据的接收和发送 -->
	<rabbit:template id="amqpTemplate" connection-factory="connectionFactory" exchange="exchange1" />

	<!-- 消息接收者 (消费者) ，自动确认-->
	<bean id="messageReceiver" class="test.rabbitmq.MessageConsumer"></bean>
	
	<!-- 消息接收者 (消费者)，需要手功确认 -->
	<bean id="ackMessageReceiver" class="test.rabbitmq.AckMessageConsumer"></bean>

	<!-- queue litener 观察 监听模式 当有消息到达时会通知监听在对应的队列上的监听对象 -->
	<rabbit:listener-container  connection-factory="connectionFactory" > 
		<rabbit:listener queues="queue1" ref="messageReceiver" />
	</rabbit:listener-container> 

    <!--<rabbit:listener-container
		connection-factory="connectionFactory" acknowledge="manual">
		<rabbit:listener queues="queue1" ref="ackMessageReceiver" />
	</rabbit:listener-container> -->
	<!-- 消费端配置 end*************** ******************* -->


<!-- 生产端 , 不需要确认-->
	<rabbit:template id="amqpSendTemplate" connection-factory="connectionSendFactory" exchange="exchange1" />
		
	<bean id="messageProducer" class="test.rabbitmq.MessageProducer">
		<property name="amqpTemplate">
			<ref bean="amqpSendTemplate" />
		</property>
	</bean>
	
	<!-- 生产端 ,带确认-->
	<rabbit:template id="amqpSendTemplateRabbit" connection-factory="connectionSendFactory" exchange="exchange1" 
		confirm-callback="confirmCallBackListener"   return-callback="returnCallBackListener" mandatory="true" />
        
	<bean id="messageProducerAck" class="test.rabbitmq.MessageRabbitProducer">
		<property name="amqpTemplate">
			<ref bean="amqpSendTemplateRabbit" />
		</property>
	</bean>
	
	<bean id="confirmCallBackListener"
		class="test.rabbitmq.ConfirmCallBack">
	</bean>
	<bean id="returnCallBackListener"
		class="test.rabbitmq.ReturnCallBack">
	</bean>
  1. 实现MessageListener接口的MessageConsumer类跟实现ChannelAwareMessageListener（支持手动应答）类 AckMessageConsumer 进行队列消费的消费。 
    package test.rabbitmq;

import java.io.UnsupportedEncodingException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageListener;

public class MessageConsumer implements MessageListener {
	private Logger logger = LoggerFactory.getLogger(MessageConsumer.class);

	@Override
	public void onMessage(Message message) {
		logger.info("consumer receive message------->:{}", message);
		String message1;
		try {
			message1 = new String(message.getBody(), "UTF-8");
			logger.info("consumer receive message------->:{}",message1 );

		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

}
    package com.sinosig.sgis.cls.common.rabbitmq;

import java.io.UnsupportedEncodingException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.core.ChannelAwareMessageListener;

import com.rabbitmq.client.Channel;

public class AckMessageConsumer implements ChannelAwareMessageListener{
	private Logger logger = LoggerFactory.getLogger(MessageConsumer.class);
	
	@Override
	public void onMessage(Message message, Channel arg1) throws Exception {
		
		logger.info("ACK consumer receive message------->:{}", message);
		String message1;
		try {
			message1 = new String(message.getBody(), "UTF-8");
			logger.info("ACK consumer receive message------->:{}",message1 );

		} catch (UnsupportedEncodingException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		Thread.sleep(10000);
		logger.info("ACK END");
		//消费确认
		arg1.basicAck(message.getMessageProperties().getDeliveryTag(), true);
		
		//消费拒绝
//		logger.info("ACK REJECT");
//		arg1.basicReject(message.getMessageProperties().getDeliveryTag(), true); //第二个参数表示放回原消息队列

	}

}

    2.配置rabbit:template模板,配置AmqpTemplate 进行消息的生产,配置实现ConfirmCallback接口进行消息发送的确认。

    package test.rabbitmq;

import java.io.IOException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.AmqpTemplate;


public class MessageProducer {
    private Logger logger = LoggerFactory.getLogger(MessageProducer.class);  

    private AmqpTemplate amqpTemplate;  
    public AmqpTemplate getAmqpTemplate() {
		return amqpTemplate;
    }
	public void setAmqpTemplate(AmqpTemplate amqpTemplate) {
		this.amqpTemplate = amqpTemplate;
	}


	public void sendMessage(Object message) throws IOException {  
        logger.info("to send message:{}", message);  
        
        //u普通生产消息 
        amqpTemplate.convertAndSend("keys", message);
        
    }  
}
    package test.rabbitmq;

import java.io.IOException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.AmqpTemplate;

public class MessageRabbitProducer {

	private Logger logger = LoggerFactory.getLogger(MessageProducer.class);

	private AmqpTemplate amqpTemplate;

	public AmqpTemplate getAmqpTemplate() {
		return amqpTemplate;
	}

	public void setAmqpTemplate(AmqpTemplate amqpTemplate) {
		this.amqpTemplate = amqpTemplate;
	}

	public void sendMessage(Object message) throws IOException {
		logger.info("to send message:{}", message);
		amqpTemplate.convertAndSend("keys", message);
		amqpTemplate.convertAndSend("keys1111", message);

	}
}
    package test.rabbitmq;

import org.springframework.amqp.rabbit.core.RabbitTemplate.ConfirmCallback;
import org.springframework.amqp.rabbit.support.CorrelationData;

public class ConfirmCallBack implements ConfirmCallback {
	
	@Override
	public void confirm(CorrelationData correlationData, boolean ack) {
		System.out.println("confirm--:correlationData:" + correlationData + ",ack:" + ack + ",cause:" );
		
	}
}
    package test.rabbitmq;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.core.RabbitTemplate.ReturnCallback;

public class ReturnCallBack implements ReturnCallback {
	@Override
	public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
		System.out.println("return--message:" + new String(message.getBody()) + ",replyCode:" + replyCode
				+ ",replyText:" + replyText + ",exchange:" + exchange + ",routingKey:" + routingKey);
	}
}

     

 

陌-路
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMq与Spring整合实例
01-28
RabbitMq与Spring整合实例，整个工程采用maven,具体过程看博文： http://blog.csdn.net/evankaka/article/details/50495437
rabbitmq-practice整合springboot的一个小练习demo
07-10
这个是学习完rabbitmq之后，整合springboot的一个小练习demo
Spring环境下获取CorrelationData，msgId的使用方法
futao__的博客
12-12 3410
通常情况下，对于投递到RabbitMQ的消息，我们一般都会指定一个唯一的msgId来标识一条消息，跟踪这条消息的状态。通常情况下，我们的代码都是这样的：生产者端：消费者端：但是这样的代码的...
SpringBoot使用RabbitMQ消息队列
qq_18395585的博客
09-24 263
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/lizc_lizc/article/details/80722090 RabbitMQ简介 AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计...
RabbitMQ讲解与整合(1)
最新发布
2401_84182578的博客
04-12 821
100110)][外链图片转存中…(img-rCFTEj80-1712859100110)]
Springboot 集成 RabbitMq 实现消息确认机制
wxw1997a的博客
08-09 1912
RabbitMq 消息发送确认与消息接收确认
Spring编写实例
weixin_47068446的博客
12-26 271
};}.} };}.} };}.} };}.} };}.} };}.} };}.} };}.} };}.} };}.} };}.} };}.
springboot系类代码：spring-boot-rabbitmq-ack-org.springframework.boot
BLOG域名:programb.blog.csdn.net
05-25 201
什么是消息确认ACK。 答：如果在处理消息的过程中，消费者的服务器在处理消息的时候出现异常，那么可能这条正在处理的消息就没有完成消息消费，数据就会丢失。为了确保数据不会丢失，RabbitMQ支持消息确定-ACK。 ACK的消息确认机制。 ACK机制是消费者从RabbitMQ收到消息并处理完成后，反馈给RabbitMQ，RabbitMQ收到反馈后才将此消息从队列中删除。 如果一个消费者在处理消息出现了网络不稳定、服务器异常等现象，那么就不会有ACK反馈，RabbitMQ会认为这个消息没有正常消费，会将.
springboot-rabbitMQ-websocket:springboot整合rabbitMQ和websocket，实现消息的发布和接收，并通过websocket实时推送数据到页面
05-27
springboot-rabbitMQ-websocketspringboot整合rabbitMQ和websocket，实现消息的发布和接收，并通过websocket实时推送数据到页面
三、在Spring中使用RabbitMQ
qq_36412195的博客
04-17 1272
添加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
Mr_yu_shao的博客
08-31 2831
超简单！入门级SpringBoot整合RabbitMQ，一看就会！
Spring 整合RabbitMQ
zyq13870585230的博客
11-05 2794
目录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"?> <
SpringBoot整合RabbitMQ
K_kzj_K的博客
06-09 4383
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
【RabbitMQ】Spring整合RabbitMQ、Spring实现RabbitMQ五大工作模式（万字长文）
qq_61903414的博客
04-15 2423
订阅模式与前两种不同，订阅模式需要使用到fanout类型的交换机，并且将队列与之绑定，他的生产者在xml文件里需要去创建两个队列与fanout类型的交换机并绑定，在发送消息时指定交换机名称即可，而消费者则与前者相同，只是需要修改指定监听的队列名。此处由于创建的交换机类型是fanout广播类型不需要去配置路由，如果创建的direct交换机不止需要配置队列名属性，还需要配置路由属性，如果是topic交换机则需要配置通配符。同样在消费者创建的xml文件里我们路创建队列监听器容器来将不同队列的消息映射到不同的类。
SpringCloud基础4——RabbitMQ和SpringAMQP
vincewm的博客
09-11 3206
消息队列MQ、RabbitMQ、SpringAMQP高级消息队列协议、发布/订阅模型、fanout、direct、topic模式
RabbitMQ - 基于 SpringAMQP 带你实现五种消息队列模型
CYK_byte的博客
07-13 2089
什么是 AMQP?全称，是用于在应用程序之间传递业务消息的开放标准。该。什么是 SpringAMQP?Spring AMQP是基于AMQP协议定义的一套API规范，提供了模板。包含两部分，其中spring-amqp是基础抽象，spring-rabbit是底层的默认实现。
Spring中使用RabbitMQ
fxtxz2的专栏
07-20 1683
rabbitMQ使用
消息队列 RabbitMQ 与 Spring 整合使用
qq_38745846的博客
05-13 596
一、什么是 RabbitMQ RabbitMQ 是实现 AMQP（高级消息队列协议）的消息中间件的一种，最初起源于金融系统，用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。 RabbitMQ 是由 Erlang 语言开发，安装 RabbitMQ 服务需要先安装 Erlang 语言包
spring整合rabbitmq
08-15
回答: Spring整合RabbitMQ主要包括以下几个步骤。首先，创建一个生产者类，例如ProducerTest，其中使用@Autowired注解注入RabbitTemplate对象，并使用convertAndSend方法发送消息到指定的队列，例如"spring_queue"。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值