Rabbitmq高级整合应用

RabbitMq整合Spring AMQP实战

RabbitAdmin
- 使用RabbitTemplate的execute方法执行对应操作
- rabbitAdmin.declareExchange()//声明
- rabbitAdmin.declareQueue()
- rabbitAdmin.declareBinding()
- rabbitAdmin.declareBinding(BindingBuilder.bind(new Queue("test.topic.queue",false)).//直接创建队列
  
  to(new FanoutExchange("test.topic",false,false)).//直接创建交换机，建立关联关系
  
  with("user.#"));//指定路由Key
- rabbitAdmin.declareBinding(BindingBuilder.bind(new Queue("test.fanout.queue",false)).to(new FanoutExchange("test.fanout",false,false)));
- rabbitAdmin.purgeQueue("test.topic.queue",false);//清空队列数据
- autoStartup必须设置为true，否则Spring容器不会加载RabbitAdmin类
- RabbitAdmin底层实现就是从Spring容器中获取Exchange、Binding、RoutingKey以及Queue的@Bean声明
消息模板-RabbitTemplate
- 发送消息的关键类
- 提供了丰富的发送消息方法，包括可靠性投递消息方法、回调监听消息接口ConfirmCallback、返回值确认接口ReturnCallback等等。同样我们需要进行注入到Spring容器中，然后直接使用
SimpleMessageListenerContainer
- 简单消息监听器，可以监听队列（多个队列），自动启动、自动声明功能
- 设置事务特性、事务管理器、事务属性、事务容量（并发）、是否开启事务、回滚消息等
- 设置消费者数量、最小最大数量、批量消费
- 设置消息确认和自动确认模式、是否重回队列、异常捕获handler函数
- 设置消费者标签生成策略、是否独占模式、消费者属性等
- 设置具体的监听器、消息转换器等等
- 注意：SimpleMessageListenerContainer可以进行动态设置，比如在运行中的应用可以动态的修改其消费者数量的大小、接收消息的模式等
- 很多基于RabbitMQ的自动化后端管控台在进行动态设置的时候，也是根据这一特性去实现的。
MessageListenerAdapter
- 消息监听适配器
- 可以自定义类来接收处理消息
- 队列和方法名称一一匹配
  - adapter.setQueueOrTagToMethodName(Map)
MessageConverter
- 可以用来转换消息，比如把byte[] 转成String之类
- 要用Map接，用json格式的转换器，Jackson2JsonMessageConverter
- 支持java对象转换，用DefaultJackson2JavaTypeMapper，识别header中__TypeId__，值为类的全路径
- 支持java对象多映射关系
- ext convert 全局转换器ContentTypeDelegatingMessageConverter
文件操作
- byte[] body = Files.readAllBytes(Paths.get("d:/002_books","picture.png"));

4-12

RabbitMQ整合SpringBoot实战

publish-confirms,实现一个监听器用于监听Broker端给我们返回的确认请求RabbitTemplate.ConfirmCallback
注意一点，在发送消息的时候对template进行配置mandatory=true保证监听有效
生产端还可以配置其他属性，比如发送重试，超时时间，次数，间隔等
代码，服务端

package com.bfxy.springboot.conusmer;

import java.util.Map;

import org.springframework.amqp.rabbit.annotation.Exchange;

import org.springframework.amqp.rabbit.annotation.Queue;

import org.springframework.amqp.rabbit.annotation.QueueBinding;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;

import org.springframework.amqp.rabbit.annotation.RabbitListener;

import org.springframework.amqp.support.AmqpHeaders;

import org.springframework.messaging.Message;

import org.springframework.messaging.handler.annotation.Headers;

import org.springframework.messaging.handler.annotation.Payload;

import org.springframework.stereotype.Component;

import com.rabbitmq.client.Channel;

@Component

public class RabbitReceiver {

	@RabbitListener(bindings = @QueueBinding(

			value = @Queue(value = "queue-1",

			durable="true"),

			exchange = @Exchange(value = "exchange-1",

			durable="true",

			type= "topic",

			ignoreDeclarationExceptions = "true"),

			key = "springboot.*"

			)

	)

	@RabbitHandler

	public void onMessage(Message message, Channel channel) throws Exception {

		System.err.println("--------------------------------------");

		System.err.println("消费端Payload: " + message.getPayload());

		Long deliveryTag = (Long)message.getHeaders().get(AmqpHeaders.DELIVERY_TAG);

		//手工ACK

		channel.basicAck(deliveryTag, false);

	}

	/**

	 *

	 * 	spring.rabbitmq.listener.order.queue.name=queue-2

		spring.rabbitmq.listener.order.queue.durable=true

		spring.rabbitmq.listener.order.exchange.name=exchange-1

		spring.rabbitmq.listener.order.exchange.durable=true

		spring.rabbitmq.listener.order.exchange.type=topic

		spring.rabbitmq.listener.order.exchange.ignoreDeclarationExceptions=true

		spring.rabbitmq.listener.order.key=springboot.*

	 * @param order

	 * @param channel

	 * @param headers

	 * @throws Exception

	 */

	@RabbitListener(bindings = @QueueBinding(

			value = @Queue(value = "${spring.rabbitmq.listener.order.queue.name}",

			durable="${spring.rabbitmq.listener.order.queue.durable}"),

			exchange = @Exchange(value = "${spring.rabbitmq.listener.order.exchange.name}",

			durable="${spring.rabbitmq.listener.order.exchange.durable}",

			type= "${spring.rabbitmq.listener.order.exchange.type}",

			ignoreDeclarationExceptions = "${spring.rabbitmq.listener.order.exchange.ignoreDeclarationExceptions}"),

			key = "${spring.rabbitmq.listener.order.key}"

			)

	)

	@RabbitHandler

	public void onOrderMessage(@Payload com.bfxy.springboot.entity.Order order,

			Channel channel,

			@Headers Map<String, Object> headers) throws Exception {

		System.err.println("--------------------------------------");

		System.err.println("消费端order: " + order.getId());

		Long deliveryTag = (Long)headers.get(AmqpHeaders.DELIVERY_TAG);

		//手工ACK

		channel.basicAck(deliveryTag, false);

	}

}

- 配置

spring.rabbitmq.addresses=i.tzxylao.com:5672,i.tzxylao.com:5673,i.tzxylao.com:5674

spring.rabbitmq.username=dev

spring.rabbitmq.password=xxxx

spring.rabbitmq.virtual-host=hospital

spring.rabbitmq.connection-timeout=15000

spring.rabbitmq.listener.simple.acknowledge-mode=manual

spring.rabbitmq.listener.simple.concurrency=5

spring.rabbitmq.listener.simple.max-concurrency=10

spring.rabbitmq.listener.order.queue.name=queue-2

spring.rabbitmq.listener.order.queue.durable=true

spring.rabbitmq.listener.order.exchange.name=exchange-2

spring.rabbitmq.listener.order.exchange.durable=true

spring.rabbitmq.listener.order.exchange.type=topic

spring.rabbitmq.listener.order.exchange.ignoreDeclarationExceptions=true

spring.rabbitmq.listener.order.key=springboot.*

代码，生产端

package com.bfxy.springboot.producer;

import java.util.Map;

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

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

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

import org.springframework.amqp.rabbit.support.CorrelationData;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.messaging.Message;

import org.springframework.messaging.MessageHeaders;

import org.springframework.messaging.support.MessageBuilder;

import org.springframework.stereotype.Component;

import com.bfxy.springboot.entity.Order;

@Component

public class RabbitSender {

	//自动注入RabbitTemplate模板类

	@Autowired

	private RabbitTemplate rabbitTemplate;  

	//回调函数: confirm确认

	final ConfirmCallback confirmCallback = new RabbitTemplate.ConfirmCallback() {

		@Override

		public void confirm(CorrelationData correlationData, boolean ack, String cause) {

			System.err.println("correlationData: " + correlationData);

			System.err.println("ack: " + ack);

			if(!ack){

				System.err.println("异常处理....");

			}

		}

	};

	//回调函数: return返回

	final ReturnCallback returnCallback = new RabbitTemplate.ReturnCallback() {

		@Override

		public void returnedMessage(org.springframework.amqp.core.Message message, int replyCode, String replyText,

				String exchange, String routingKey) {

			System.err.println("return exchange: " + exchange + ", routingKey: "

				+ routingKey + ", replyCode: " + replyCode + ", replyText: " + replyText);

		}

	};

	//发送消息方法调用: 构建Message消息

	public void send(Object message, Map<String, Object> properties) throws Exception {

		MessageHeaders mhs = new MessageHeaders(properties);

		Message msg = MessageBuilder.createMessage(message, mhs);

		rabbitTemplate.setConfirmCallback(confirmCallback);

		rabbitTemplate.setReturnCallback(returnCallback);

		//id + 时间戳 全局唯一

		CorrelationData correlationData = new CorrelationData("1234567890");

		rabbitTemplate.convertAndSend("exchange-1", "springboot.abc", msg, correlationData);

	}

	//发送消息方法调用: 构建自定义对象消息

	public void sendOrder(Order order) throws Exception {

		rabbitTemplate.setConfirmCallback(confirmCallback);

		rabbitTemplate.setReturnCallback(returnCallback);

		//id + 时间戳 全局唯一

		CorrelationData correlationData = new CorrelationData("0987654321");

		rabbitTemplate.convertAndSend("exchange-2", "springboot.def", order, correlationData);

	}

}

- 配置

spring.rabbitmq.addresses=192.168.11.76:5672

spring.rabbitmq.username=dev

spring.rabbitmq.password=123

spring.rabbitmq.virtual-host=hospital

spring.rabbitmq.connection-timeout=15000

spring.rabbitmq.publisher-confirms=true

spring.rabbitmq.publisher-returns=true

spring.rabbitmq.template.mandatory=true

RabbitMQ整合Spring Cloud实战

Spring Cloud Stream整合

Barista接口：Barista接口是定义来作为后面类的参数，这一接口定义来通道类型和通道名称，通道名称是作为配置用，通道类型则决定了app会使用这一通道进行发送消息还是从中接收消息
@Output：输出注解，用于定义发送消息接口
@Input：输入注解，用于定义消息的消费者接口
@StreamListener：用于定义监听方法的注解
添加代理层，用于快速的替换mq
代码

生产者

package com.bfxy.rabbitmq.stream;

import org.springframework.cloud.stream.annotation.Output;

import org.springframework.messaging.MessageChannel;

/**

 * <B>中文类名：</B><BR>

 * <B>概要说明：</B><BR>

 * 这里的Barista接口是定义来作为后面类的参数，这一接口定义来通道类型和通道名称。

 * 通道名称是作为配置用，通道类型则决定了app会使用这一通道进行发送消息还是从中接收消息。

 */

public interface Barista {

    //String INPUT_CHANNEL = "input_channel";

    String OUTPUT_CHANNEL = "output_channel";  

    //注解@Input声明了它是一个输入类型的通道，名字是Barista.INPUT_CHANNEL，也就是position3的input_channel。这一名字与上述配置app2的配置文件中position1应该一致，表明注入了一个名字叫做input_channel的通道，它的类型是input，订阅的主题是position2处声明的mydest这个主题

//    @Input(Barista.INPUT_CHANNEL)

//    SubscribableChannel loginput();

    //注解@Output声明了它是一个输出类型的通道，名字是output_channel。这一名字与app1中通道名一致，表明注入了一个名字为output_channel的通道，类型是output，发布的主题名为mydest。

    @Output(Barista.OUTPUT_CHANNEL)

    MessageChannel logoutput();  

//	String INPUT_BASE = "queue-1";

//	String OUTPUT_BASE = "queue-1";

//	@Input(Barista.INPUT_BASE)

//	SubscribableChannel input1();

//	MessageChannel output1();  

}

package com.bfxy.rabbitmq.stream;

import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.cloud.stream.annotation.EnableBinding;

import org.springframework.messaging.Message;

import org.springframework.messaging.MessageHeaders;

import org.springframework.messaging.support.MessageBuilder;

import org.springframework.stereotype.Service;

@EnableBinding(Barista.class)

@Service

public class RabbitmqSender {  

    @Autowired

    private Barista barista;  

    // 发送消息

    public String sendMessage(Object message, Map<String, Object> properties) throws Exception {

        try{

        	MessageHeaders mhs = new MessageHeaders(properties);

        	Message msg = MessageBuilder.createMessage(message, mhs);

            boolean sendStatus = barista.logoutput().send(msg);

            System.err.println("--------------sending -------------------");

            System.out.println("发送数据：" + message + ",sendStatus: " + sendStatus);

        }catch (Exception e){

        	System.err.println("-------------error-------------");

        	e.printStackTrace();

            throw new RuntimeException(e.getMessage());

        }

        return null;

    }  

}

配置文件

server.port=8001

server.servlet.context-path=/producer

spring.application.name=producer

spring.cloud.stream.bindings.output_channel.destination=exchange-3

spring.cloud.stream.bindings.output_channel.group=queue-3

spring.cloud.stream.bindings.output_channel.binder=rabbit_cluster

spring.cloud.stream.binders.rabbit_cluster.type=rabbit

spring.cloud.stream.binders.rabbit_cluster.environment.spring.rabbitmq.addresses=192.168.11.76:5672

spring.cloud.stream.binders.rabbit_cluster.environment.spring.rabbitmq.username=guest

spring.cloud.stream.binders.rabbit_cluster.environment.spring.rabbitmq.password=guest

spring.cloud.stream.binders.rabbit_cluster.environment.spring.rabbitmq.virtual-host=/

消费者

package com.bfxy.rabbitmq.stream;

import org.springframework.cloud.stream.annotation.Input;

import org.springframework.messaging.SubscribableChannel;

/**

 * <B>中文类名：</B><BR>

 * <B>概要说明：</B><BR>

 * 这里的Barista接口是定义来作为后面类的参数，这一接口定义来通道类型和通道名称。

 * 通道名称是作为配置用，通道类型则决定了app会使用这一通道进行发送消息还是从中接收消息。

 * @author ashen（Alienware）

 * @since 2016年7月22日

 */

public interface Barista {

    String INPUT_CHANNEL = "input_channel";  

    //注解@Input声明了它是一个输入类型的通道，名字是Barista.INPUT_CHANNEL，也就是position3的input_channel。这一名字与上述配置app2的配置文件中position1应该一致，表明注入了一个名字叫做input_channel的通道，它的类型是input，订阅的主题是position2处声明的mydest这个主题

    @Input(Barista.INPUT_CHANNEL)

    SubscribableChannel loginput();  

}

package com.bfxy.rabbitmq.stream;

import org.springframework.amqp.support.AmqpHeaders;

import org.springframework.cloud.stream.annotation.EnableBinding;

import org.springframework.cloud.stream.annotation.StreamListener;

import org.springframework.messaging.Message;

import org.springframework.stereotype.Service;

import com.rabbitmq.client.Channel;

@EnableBinding(Barista.class)

@Service

public class RabbitmqReceiver {  

    @StreamListener(Barista.INPUT_CHANNEL)

    public void receiver(Message message) throws Exception {

		Channel channel = (com.rabbitmq.client.Channel) message.getHeaders().get(AmqpHeaders.CHANNEL);

		Long deliveryTag = (Long) message.getHeaders().get(AmqpHeaders.DELIVERY_TAG);

    	System.out.println("Input Stream 1 接受数据：" + message);

    	System.out.println("消费完毕------------");

    	channel.basicAck(deliveryTag, false);

    }

}

配置文件

server.port=8002

server.context-path=/consumer

spring.application.name=consumer

spring.cloud.stream.bindings.input_channel.destination=exchange-3

spring.cloud.stream.bindings.input_channel.group=queue-3

spring.cloud.stream.bindings.input_channel.binder=rabbit_cluster

spring.cloud.stream.bindings.input_channel.consumer.concurrency=1

spring.cloud.stream.rabbit.bindings.input_channel.consumer.requeue-rejected=false

spring.cloud.stream.rabbit.bindings.input_channel.consumer.acknowledge-mode=MANUAL

spring.cloud.stream.rabbit.bindings.input_channel.consumer.recovery-interval=3000

spring.cloud.stream.rabbit.bindings.input_channel.consumer.durable-subscription=true

spring.cloud.stream.rabbit.bindings.input_channel.consumer.max-concurrency=5

spring.cloud.stream.binders.rabbit_cluster.type=rabbit

spring.cloud.stream.binders.rabbit_cluster.environment.spring.rabbitmq.addresses=192.168.11.76:5672

spring.cloud.stream.binders.rabbit_cluster.environment.spring.rabbitmq.username=guest

spring.cloud.stream.binders.rabbit_cluster.environment.spring.rabbitmq.password=guest

spring.cloud.stream.binders.rabbit_cluster.environment.spring.rabbitmq.virtual-host=/

rabbitmq系统学习（二）的更多相关文章

Redis系统学习二、数据结构
一.字符串 1.在Redis里,字符串是最基本的数据结构.当你在思索着关键字-值对时,你就是在死锁着字符串数据结构.不要被名字给搞混了. 常见实例: set users:leto " ...
rabbitmq系统学习（三）集群架构
RabbitMQ集群架构模式主备模式实现RabbitMQ的高可用集群,一般在并发和数据量不高的情况下,这种模型非常的好用且简单.主备模式也称为Warren模式 HaProxy配置 listen r ...
rabbitmq系统学习（一）
各种mq activemq,kafka使用zookeeper做管理 rocketmq自己实现nameserver broke管理 AMQP核心概念高级消息队列协议 publisher applica ...
Linux系统学习二、测评-身份鉴别1
身份鉴别 1)对登陆操作系统和数据库系统的用户进行身份表示和鉴别 1.密码文件中的口令字段是否不为空 2.检查各个用户主目录下的.rhosts文件 3.查看/etc/hosts.equiv 学习: 1 ...
Linux系统学习(二)一Linux基本操作
一.Linux的目录结构 1.1 Linux的目录结构图 1.2 目录内容 /:这就是根目录.对你的电脑来说,有且只有一个根目录.所有的东西,我是说所有的东西都是从这里开始.举个例子:当你在终端里输入 ...
Scala系统学习(二)：Scala开发环境安装配置
Scala可以安装在任何基于UNIX/Linux或基于Windows的系统上.在您的机器上开始安装Scala之前,必须在计算机上安装Java 1.8或更高版本. 下面请按照以下步骤安装Scala. 步 ...
Linux系统学习二十一、SAMBA服务—相关文件、配置文件详解
3.相关文件常用文件: /etc/samba/smb.conf #配置文件 /etc/samba/lmhosts #对应NetBIOS名与主机的IP的文件,一般Samba会自 ...
Linux系统学习二十二、SAMBA服务—Samba基本使用—share权限访问、客户端的使用
share权限访问配置文件修改 [global]全局设置 workgroup=MYGROUP server string=Samba Server Lamp log file=/var/log/sa ...
Linux系统学习二十、SAMBA服务—介绍、安装、端口
1.简介网络数据文件共享服务器可以和Windows中的网上邻居通用数据共享的方法: Windows中最常用的是“网上邻居”.网上邻居使用的文件系统是CIFS(通用互联网文件系统)协议进行数据共享 ...

随机推荐

[转]tomcat启动报错too low setting for -Xss
tomcat启动报错too low setting for -Xss 网上给的答案都是调整Xss参数,其实不是正确的做法, -Xss:每个线程的Stack大小,“-Xss 15120” 这使得tomc ...
《笨方法学Python》加分题33
while-leep 和我们接触过的 for-loop 类似,它们都会判断一个布尔表达式的真伪.也和 for 循环一样我们需要注意缩进,后续的练习会偏重这方面的练习.不同点在于 while 循环在执行 ...
laravel和lumen数据库链接错误_FatalErrorException Call to a member function connection
FatalErrorException in Model.php line 3339: Call to a member function connection() on null 挺简单的一个lum ...
python3 第三十章 - 内置函数之Dictionary相关
Python字典包含了以下内置函数: 序号函数及描述实例 1 len(dict)计算字典元素个数,即键的总数. >>> dict = {'Name': 'cnblogs', 'A ...
python基础入门之对文件的操作
**python**文件的操作1.打开文件打开文件:open(file,mode='r') file:操作文件的路径加文件名 #绝对路径:从根目录开始的 #相对路径:从某个路径开始 mode:操作文 ...
c语言基础课第一次作业
1)大学和高中最大的不同是没有人天天看着你,请看大学理想的师生关系是?有何感想? 通过阅读邹欣老师的博客,了解到了老师心中理想的师生关系是(健身教练与健身学员).在初中,高中我们一直都是填鸭式教育,像 ...
根据缺少的so，安装相关的软件
http://blog.csdn.net/dianyueneo/article/details/8161350. ubuntu缺少libGL.so sudo apt-get install apt-f ...
地磁应用中的低功耗无线数传模块xbee PRO S2C
地球上每一个地理坐标点,在一段时间内磁场强度是恒定的,当车辆这种铁磁物质经过这个点时,对这个点的磁场强度产生一个连续的扰动,通过磁传感器采样数据与初始采样数据(该点的地球磁场值)进行对比,其差值为车辆 ...
[转]etcd 启用 https
1, 生成 TLS 秘钥对 2,拷贝密钥对到所有节点 3,配置 etcd 使用证书 4,测试 etcd 是否正常 5,配置 kube-apiserver 使用 CA 连接 etcd 6,测试 kube ...
学习Acegi应用到实际项目中（8）- 扩展UserDetailsService接口
一个能为DaoAuthenticationProvider提供存取认证库的的类,它必须要实现UserDetailsService接口: public UserDetails loadUserByUse ...

rabbitmq系统学习（二）

Rabbitmq高级整合应用

RabbitMq整合Spring AMQP实战

RabbitMQ整合SpringBoot实战

RabbitMQ整合Spring Cloud实战

Spring Cloud Stream整合

rabbitmq系统学习（二）的更多相关文章

随机推荐

热门专题