乐购商城项目技术总结 -- RabbitMQ

最新推荐文章于 2024-05-31 10:26:10 发布

KG6666666

最新推荐文章于 2024-05-31 10:26:10 发布

阅读量182

点赞数

分类专栏： Java 文章标签： rabbitmq java

本文链接：https://blog.csdn.net/KG6666666/article/details/120517725

版权

Java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言
一、MQ的优势
二、MQ的劣势
三、相关概念
四、五种工作模式
五、Spring Boot整合RabbitMQ
- 搭建生产者工程
- 搭建消费者工程
六、应用场景
总结

前言

RabbitMQ是一个被广泛使用的开源消息队列。它是轻量级且易于部署的，它能支持多种消息协议。RabbitMQ可以部署在分布式和联合配置中，以满足高规模、高可用性的需求。

一、MQ的优势

MQ全称 Message Queue(消息队列)，是在消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信。

应用之前的远程调用
在这里插入图片描述

加入MQ后应用之间的调用
在这里插入图片描述

1、应用解藕

MQ相当于一个中介，生产方通过MQ与消费方交互，它将应用程序进行解耦合。

系统的耦合性越高，容错性就越低，可维护性就越低。
在这里插入图片描述
使用 MQ 使得应用间解耦，提升容错性和可维护性。

2、任务异步处理

将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方进行异步处理。提高了应用程序的响应时间。

在这里插入图片描述
一个下单操作耗时:20 + 300 + 300 + 300 = 920ms
用户点击完下单按钮后，需要等待920ms才能得到下单响应，太慢!

在这里插入图片描述
用户点击完下单按钮后，只需等待25ms就能得到下单响应 (20 + 5 = 25ms)。
提升用户体验和系统吞吐量(单位时间内处理请求的数目)。

3、削峰填谷

如订单系统，在下单的时候就会往数据库写数据。但是数据库只能支撑每秒1000左右的并发写入，并发量再高就容易宕机。低峰期的时候并发也就100多个，但是在高峰期时候，并发量会突然激增到5000以上，这个时候数据库肯定卡死了。

在这里插入图片描述
消息被MQ保存起来了，然后系统就可以按照自己的消费能力来消费，比如每秒1000个消息，这样慢慢写入数据库，这样就不会卡死数据库了。

但是使用了MQ之后，限制消费消息的速度为1000，但是这样一来，高峰期产生的数据势必会被积压在 MQ中，高峰就被“削”掉了。但是因为消息积压，在高峰期过后的一段时间内，消费消息的速度还是会维持在1000QPS，直到消费完积压的消息,这就叫做“填谷”

在这里插入图片描述

二、MQ的劣势

万物皆是双刃剑，既然有优势，那么必然也有劣势

系统可用性降低

系统引入的外部依赖越多，系统稳定性越差。一旦 MQ 宕机，就会对业务造成影响。如何保证MQ的高可用?

系统复杂度提高

MQ 的加入大大增加了系统的复杂度，以前系统间是同步的远程调用，现在是通过 MQ 进行异步调用。如何保证消息没有被重复消费?怎么处理消息丢失情况?那么保证消息传递的顺序性?

一致性问题

A 系统处理完业务，通过 MQ 给B、C、D三个系统发消息，如果 B 系统、C 系统处理成功，D 系统处理失败。如何保证消息数据处理的一致性?

三、相关概念

2007年，Rabbit 技术公司基于 AMQP 标准开发的 RabbitMQ 1.0 发布。RabbitMQ 采用 Erlang 语言开发。Erlang 语言专门为开发高并发和分布式系统的一种语言，在电信领域使用广泛。

RabbitMQ 基础架构如下图:

在这里插入图片描述

Broker:接收和分发消息的应用，RabbitMQ Server就是 Message Broker
Virtual host:出于多租户和安全因素设计的，把 AMQP 的基本组件划分到一个虚拟的分组中，类似于网络中的 namespace 概念。当多个不同的用户使用同一个 RabbitMQ server 提供的服务时，可以划分出多个vhost，每个用户在自己的 vhost 创建 exchange/queue 等
Connection:publisher/consumer 和 broker 之间的 TCP 连接
Channel:如果每一次访问 RabbitMQ 都建立一个 Connection，在消息量大的时候建立 TCP Connection的开销将是巨大的，效率也较低。Channel 是在 connection 内部建立的逻辑连接，如果应用程序支持多线程，通常每个thread创建单独的 channel 进行通讯，AMQP method 包含了channel id 帮助客户端和message broker 识别 channel，所以 channel 之间是完全隔离的。 Channel 作为轻量级的 Connection 极大减少了操作系统建立 TCP connection 的开销
Exchange:message 到达 broker 的第一站，根据分发规则，匹配查询表中的 routing key，分发消息到queue 中去。常用的类型有:direct (point-to-point), topic (publish-subscribe) and fanout (multicast)
Queue:消息最终被送到这里等待 consumer 取走
Binding:exchange 和 queue 之间的虚拟连接，binding 中可以包含 routing key。Binding 信息被保存到 exchange 中的查询表中，用于 message 的分发依据

RabbitMQ提供了6种模式:简单模式，work模式，Publish/Subscribe发布与订阅模式，Routing路由模式，Topics主题模式，RPC远程调用模式(远程调用，不太算MQ; 暂不作介绍);
在这里插入图片描述

四、五种工作模式

1. 简单模式

在这里插入图片描述
在上图的模型中，有以下概念:

P:生产者，也就是要发送消息的程序
C:消费者:消息的接收者，会一直等待消息到来
queue:消息队列，图中红色部分。类似一个邮箱，可以缓存消息;生产者向其中投递消息，消费者从其中取出消息

来写个简单的案例

先编写一个用于连接的工具类:

public class ConnectionUtil {

	public static Connection getConnection() throws Exception { 
		//创建连接工厂
		ConnectionFactory connectionFactory = new ConnectionFactory(); 
		//主机地址;默认为 localhost 
		connectionFactory.setHost("localhost");
		//连接端口;默认为 5672
		connectionFactory.setPort(5672); 
		//虚拟主机名称;默认为 / 
		connectionFactory.setVirtualHost("/xzk");
		//连接用户名;默认为guest 
		connectionFactory.setUsername("gyh"); 
		//连接密码;默认为guest 
		connectionFactory.setPassword("gyh");
		
		//创建连接
		return connectionFactory.newConnection(); 
	}
}

生产者:

public class Producer {

    static final String QUEUE_NAME = "simple_queue";

	public static void main(String[] args) throws Exception {
		
		//创建连接
		Connection connection = ConnectionUtil.getConnection();
		
		// 创建频道
		Channel channel = connection.createChannel();

		// 声明(创建)队列 
		/**
		* 参数1:队列名称
		* 参数2:是否定义持久化队列
		* 参数3:是否独占本次连接
		* 参数4:是否在不使用的时候自动删除队列 
		* 参数5:队列其它参数
		*/
		channel.queueDeclare(QUEUE_NAME, true, false, false, null);
		
		// 要发送的信息
		String message = "hey, bro!"; 
		
		/**
		* 参数1:交换机名称，如果没有指定则使用默认Default Exchage 
		* 参数2:路由key,简单模式可以传递队列名称
		* 参数3:消息其它属性
		* 参数4:消息内容
		*/
		channel.basicPublish("", QUEUE_NAME, null, message.getBytes()); 			
		System.out.println("已发送消息:" + message);
	}	
    
}

消费者:

public class Consumer {
	
	public static void main(String[] args) throws Exception { 
		Connection connection = ConnectionUtil.getConnection();
		// 创建频道
		Channel channel = connection.createChannel();
		
		// 声明(创建)队列 
		/**
		* 参数1:队列名称
		* 参数2:是否定义持久化队列
		* 参数3:是否独占本次连接
		* 参数4:是否在不使用的时候自动删除队列 
		* 参数5:队列其它参数
		*/
		channel.queueDeclare(Producer.QUEUE_NAME, true, false, false, null);
		//创建消费者;并设置消息处理
		DefaultConsumer consumer = new DefaultConsumer(channel){
		
		
			/**
			* consumerTag 消息者标签，在channel.basicConsume时候可以指定
			* envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重
			传标志(收到消息失败后是否需要重新发送) 
			* properties 属性信息
			* body 消息
			*/
			@Override
			public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
			//路由key
			System.out.println("路由key为:" + envelope.getRoutingKey()); 
			//交换机
			System.out.println("交换机为:" + envelope.getExchange()); 
			//消息id
			System.out.println("消息id为:" + envelope.getDeliveryTag()); 
			//收到的消息
			System.out.println("接收到的消息为:" + new String(body, "utf-8"));
			} 
		};
		
		//监听消息 
		/**
		* 参数1:队列名称
		* 参数2:是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复 会删除消息，设置为false则需要手动确认
		* 参数3:消息接收到后回调
		*/
		channel.basicConsume(Producer.QUEUE_NAME, true, consumer);
		
		//不关闭资源，应该一直监听消息
		//channel.close();
		//connection.close();
	} 
}

2. 工作队列模式

Work Queues 与入门程序的简单模式相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的消息。

在这里插入图片描述
应用场景:对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。

Work Queues 与入门程序的简单模式的代码是几乎一样的;可以完全复制，并复制多一个消费者进行多个消费者同时消费消息的测试。(ConnectionUtil代码同上, 这里就不重复展示了)

生产者:

public class Producer {

    static final String QUEUE_NAME = "work_queue";
    
    public static void main(String[] args) throws Exception {

		//创建连接
		Connection connection = ConnectionUtil.getConnection();
		// 创建频道
		Channel channel = connection.createChannel();

		// 声明(创建)队列 
		/**
		* 参数1:队列名称
		* 参数2:是否定义持久化队列
		* 参数3:是否独占本次连接
		* 参数4:是否在不使用的时候自动删除队列 * 参数5:队列其它参数
		*/
		channel.queueDeclare(QUEUE_NAME, true, false, false, null);
		for (int i = 1; i <= 30; i++) { 
			// 发送信息
			String message = "work模式--" + i; 
			/**
			* 参数1:交换机名称，如果没有指定则使用默认Default Exchage 
			* 参数2:路由key,简单模式可以传递队列名称
			* 参数3:消息其它属性
			* 参数4:消息内容
			*/
			channel.basicPublish("", QUEUE_NAME, null,message.getBytes());
			System.out.println("已发送消息:" + message); 
		}
		// 关闭资源 
		channel.close(); 
		connection.close();
	}
}

消费者1:

public class Consumer1 {

	public static void main(String[] args) throws Exception { 
	
		Connection connection = ConnectionUtil.getConnection();
		
		// 创建频道
		Channel channel = connection.createChannel();
		
		// 声明(创建)队列 
		/**
		* 参数1:队列名称
		* 参数2:是否定义持久化队列
		* 参数3:是否独占本次连接
		* 参数4:是否在不使用的时候自动删除队列 * 参数5:队列其它参数
		*/
		channel.queueDeclare(Producer.QUEUE_NAME, true, false, false, null); 	
		//一次只能接收并处理一个消息
		channel.basicQos(1);
		
		//创建消费者;并设置消息处理
		DefaultConsumer consumer = new DefaultConsumer(channel){
			@Override
			/**
			* consumerTag 消息者标签，在channel.basicConsume时候可以指定
			* envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
			* properties 属性信息
			* body 消息
			*/
			public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
				try { //路由key
					System.out.println("路由key为:" + envelope.getRoutingKey());
					//交换机
					System.out.println("交换机为:" + envelope.getExchange()); 
					//消息id
					System.out.println("消息id为:" + envelope.getDeliveryTag()); 
					//收到的消息
					System.out.println("消费者1-接收到的消息为:" + new String(body,"utf-8"));
					Thread.sleep(1000);
					//确认消息
					channel.basicAck(envelope.getDeliveryTag(), false); 
				} catch (InterruptedException e) {
					e.printStackTrace(); 
				}
			}
		};
		//监听消息 
		/**
		* 参数1:队列名称
		* 参数2:是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复 会删除消息，设置为false则需要手动确认
		* 参数3:消息接收到后回调
		*/
		channel.basicConsume(Producer.QUEUE_NAME, false, consumer);
	}
}

消费者2:

public class Consumer2 {

	public static void main(String[] args) throws Exception { 
	
		Connection connection = ConnectionUtil.getConnection();
		
		// 创建频道
		Channel channel = connection.createChannel();
		
		// 声明(创建)队列 
		/**
		* 参数1:队列名称
		* 参数2:是否定义持久化队列
		* 参数3:是否独占本次连接
		* 参数4:是否在不使用的时候自动删除队列 * 参数5:队列其它参数
		*/
		channel.queueDeclare(Producer.QUEUE_NAME, true, false, false, null); 	
		//一次只能接收并处理一个消息
		channel.basicQos(1);
		
		//创建消费者;并设置消息处理
		DefaultConsumer consumer = new DefaultConsumer(channel){
			@Override
			/**
			* consumerTag 消息者标签，在channel.basicConsume时候可以指定
			* envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
			* properties 属性信息
			* body 消息
			*/
			public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
				try { //路由key
					System.out.println("路由key为:" + envelope.getRoutingKey());
					//交换机
					System.out.println("交换机为:" + envelope.getExchange()); 
					//消息id
					System.out.println("消息id为:" + envelope.getDeliveryTag()); 
					//收到的消息
					System.out.println("消费者1-接收到的消息为:" + new String(body,"utf-8"));
					Thread.sleep(1000);
					//确认消息
					channel.basicAck(envelope.getDeliveryTag(), false); 
				} catch (InterruptedException e) {
					e.printStackTrace(); 
				}
			}
		};
		//监听消息 
		/**
		* 参数1:队列名称
		* 参数2:是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复 会删除消息，设置为false则需要手动确认
		* 参数3:消息接收到后回调
		*/
		channel.basicConsume(Producer.QUEUE_NAME, false, consumer);
	}
}

小结:

在一个队列中如果有多个消费者，那么消费者之间对于同一个消息的关系是竞争的关系。

3. 订阅者模式(Fanout)

相较于前面两个模式(只有三个角色), 订阅者模式中多了一个exchange角色, 而且过程略有变化:

在这里插入图片描述

P:生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X(交换机)
C:消费者，消息的接受者，会一直等待消息到来。
Queue:消息队列，接收消息、缓存消息。
Exchange:交换机，图中的X。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于 Exchange的类型。Exchange有常见以下3种类型:

  Fanout:广播，将消息交给所有绑定到交换机的队列 
  Direct:定向，把消息交给符合指定routing key 的队列 
  Topic:通配符，把消息交给符合routing pattern(路由模式) 的队列

Exchange(交换机)只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失!

发布订阅模式: 1、每个消费者监听自己的队列。 2、生产者将消息发给broker，由交换机将消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接收到消息

生产者:


/**
* 发布与订阅使用的交换机类型为:fanout 
*/
public class Producer {
	//交换机名称
	static final String FANOUT_EXCHAGE = "fanout_exchange"; 
	
	//队列名称
	static final String FANOUT_QUEUE_1 = "fanout_queue_1"; 
	
	//队列名称
	static final String FANOUT_QUEUE_2 = "fanout_queue_2";
	public static void main(String[] args) throws Exception { 
		//创建连接
		Connection connection = ConnectionUtil.getConnection(); 
	
		// 创建频道
		Channel channel = connection.createChannel();
	
		/**
		* 声明交换机
		* 参数1:交换机名称
		* 参数2:交换机类型，fanout、topic、direct、headers 
		*/
		channel.exchangeDeclare(FANOUT_EXCHAGE, BuiltinExchangeType.FANOUT);

		// 声明(创建)队列 
		/**
		* 参数1:队列名称
		* 参数2:是否定义持久化队列
		* 参数3:是否独占本次连接
		* 参数4:是否在不使用的时候自动删除队列 
		* 参数5:队列其它参数
		*/
		//队列1
		channel.queueDeclare(FANOUT_QUEUE_1, true, false, false, null); 
		//队列2		
		channel.queueDeclare(FANOUT_QUEUE_2, true, false, false, null);
		
		//队列绑定交换机
		channel.queueBind(FANOUT_QUEUE_1, FANOUT_EXCHAGE, ""); 
		channel.queueBind(FANOUT_QUEUE_2, FANOUT_EXCHAGE, "");
		
		
		for (int i = 1; i <= 10; i++) {
 			// 发送信息
			String message = "你好;小兔子!发布订阅模式--" + i;
			/**
			* 参数1:交换机名称，如果没有指定则使用默认Default Exchage 
			* 参数2:路由key,简单模式可以传递队列名称
			* 参数3:消息其它属性
			* 参数4:消息内容
			*/
			channel.basicPublish(FANOUT_EXCHAGE, "", null, message.getBytes());
			
			System.out.println("已发送消息:" + message); 
		}
		
		// 关闭资源 
		channel.close(); 
		connection.close();
	}
}

消费者1:

public class Consumer1 {

	public static void main(String[] args) throws Exception { 
	
		Connection connection = ConnectionUtil.getConnection();
		
		// 创建频道
		Channel channel = connection.createChannel();

		//声明交换机
		channel.exchangeDeclare(Producer.FANOUT_EXCHAGE, BuiltinExchangeType.FANOUT);
		
		// 声明(创建)队列 
		/**
		* 参数1:队列名称
		* 参数2:是否定义持久化队列
		* 参数3:是否独占本次连接
		* 参数4:是否在不使用的时候自动删除队列 * 参数5:队列其它参数
		*/
		channel.queueDeclare(Producer.FANOUT_QUEUE_1, true, false, false, null); 	
		//队列绑定交换机
		channel.queueBind(Producer.FANOUT_QUEUE_1, Producer.FANOUT_EXCHAGE, "");
				
		//创建消费者;并设置消息处理
		DefaultConsumer consumer = new DefaultConsumer(channel){
			@Override
			/**
			* consumerTag 消息者标签，在channel.basicConsume时候可以指定
			* envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
			* properties 属性信息
			* body 消息
			*/
			public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
				    //路由key
					System.out.println("路由key为:" + envelope.getRoutingKey());
					//交换机
					System.out.println("交换机为:" + envelope.getExchange()); 
					//消息id
					System.out.println("消息id为:" + envelope.getDeliveryTag()); 
					//收到的消息
					System.out.println("消费者1-接收到的消息为:" + new String(body,"utf-8"));
					
			}
		};
		//监听消息 
		/**
		* 参数1:队列名称
		* 参数2:是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复 会删除消息，设置为false则需要手动确认
		* 参数3:消息接收到后回调
		*/
		channel.basicConsume(Producer.FANOUT_QUEUE_1, true, consumer);
	}
}

消费者2:

public class Consumer2 {

	public static void main(String[] args) throws Exception { 
	
		Connection connection = ConnectionUtil.getConnection();
		
		// 创建频道
		Channel channel = connection.createChannel();

		//声明交换机
		channel.exchangeDeclare(Producer.FANOUT_EXCHAGE, BuiltinExchangeType.FANOUT);
		
		// 声明(创建)队列 
		/**
		* 参数1:队列名称
		* 参数2:是否定义持久化队列
		* 参数3:是否独占本次连接
		* 参数4:是否在不使用的时候自动删除队列 * 参数5:队列其它参数
		*/
		channel.queueDeclare(Producer.FANOUT_QUEUE_2, true, false, false, null); 	
		//队列绑定交换机
		channel.queueBind(Producer.FANOUT_QUEUE_2, Producer.FANOUT_EXCHAGE, "");
				
		//创建消费者;并设置消息处理
		DefaultConsumer consumer = new DefaultConsumer(channel){
			@Override
			/**
			* consumerTag 消息者标签，在channel.basicConsume时候可以指定
			* envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
			* properties 属性信息
			* body 消息
			*/
			public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
				    //路由key
					System.out.println("路由key为:" + envelope.getRoutingKey());
					//交换机
					System.out.println("交换机为:" + envelope.getExchange()); 
					//消息id
					System.out.println("消息id为:" + envelope.getDeliveryTag()); 
					//收到的消息
					System.out.println("消费者2-接收到的消息为:" + new String(body,"utf-8"));
					
			}
		};
		//监听消息 
		/**
		* 参数1:队列名称
		* 参数2:是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复 会删除消息，设置为false则需要手动确认
		* 参数3:消息接收到后回调
		*/
		channel.basicConsume(Producer.FANOUT_QUEUE_2, true, consumer);
	}
}

4. Routing路由模式

路由模式特点:

队列与交换机的绑定，不能是任意绑定了，而是要指定一个 RoutingKey (路由key)
消息的发送方在向 Exchange发送消息时，也必须指定消息的 RoutingKey 。
Exchange不再把消息交给每一个绑定的队列，而是根据消息的 Routing Key 进行判断，只有队列的 Routingkey 与消息的 Routing key 完全一致，才会接收到消息

在这里插入图片描述

图解:

P:生产者，向Exchange发送消息，发送消息时，会指定一个routing key。 -
X:Exchange(交换机)，接收生产者的消息，然后把消息递交给与routing key完全匹配的队列
C1:消费者，其所在队列指定了需要routing key 为 error 的消息
C2:消费者，其所在队列指定了需要routing key 为 info、error、warning 的消息

生产者:

/**
* 路由模式的交换机类型为:direct 
*/
public class Producer {
	
	//交换机名称
	static final String DIRECT_EXCHAGE = "direct_exchange"; 
	
	//队列名称
	static final String DIRECT_QUEUE_INSERT = "direct_queue_insert"; 
	
	//队列名称
	static final String DIRECT_QUEUE_UPDATE = "direct_queue_update";

	public static void main(String[] args) throws Exception { 
		//创建连接
		Connection connection = ConnectionUtil.getConnection(); 
	
		// 创建频道
		Channel channel = connection.createChannel();
	
		/**
		* 声明交换机
		* 参数1:交换机名称
		* 参数2:交换机类型，fanout、topic、direct、headers 
		*/
		channel.exchangeDeclare(DIRECT_EXCHAGE, BuiltinExchangeType.DIRECT);

		// 声明(创建)队列 
		/**
		* 参数1:队列名称
		* 参数2:是否定义持久化队列
		* 参数3:是否独占本次连接
		* 参数4:是否在不使用的时候自动删除队列 
		* 参数5:队列其它参数
		*/
		//队列1
		channel.queueDeclare(DIRECT_QUEUE_INSERT, true, false, false, null); 
		//队列2	
		channel.queueDeclare(DIRECT_QUEUE_UPDATE, true, false, false, null);
					
		//队列绑定交换机
		channel.queueBind(DIRECT_QUEUE_INSERT, DIRECT_EXCHAGE, "insert"); 		
		channel.queueBind(DIRECT_QUEUE_UPDATE, DIRECT_EXCHAGE, "update");
		
		// 发送信息
		String message = "新增了商品。路由模式;routing key 为 insert ";
		/**
		* 参数1:交换机名称，如果没有指定则使用默认Default Exchage 
		* 参数2:路由key,简单模式可以传递队列名称
		* 参数3:消息其它属性
		* 参数4:消息内容
		*/
		channel.basicPublish(DIRECT_EXCHAGE, "insert", null, message.getBytes());
		System.out.println("已发送消息:" + message); 
		
		// 发送信息
		message = "修改了商品。路由模式;routing key 为 update"; 
		/**
		* 参数1:交换机名称，如果没有指定则使用默认Default Exchage 
		* 参数2:路由key,简单模式可以传递队列名称
		* 参数3:消息其它属性
		* 参数4:消息内容
		*/
		channel.basicPublish(DIRECT_EXCHAGE, "update", null, message.getBytes());
		System.out.println("已发送消息:" + message);
		
		// 关闭资源 
		channel.close(); 
		connection.close();
	}
}

消费者1:

public class Consumer1 {

	public static void main(String[] args) throws Exception { 
	
		Connection connection = ConnectionUtil.getConnection();
		
		// 创建频道
		Channel channel = connection.createChannel();

		//声明交换机
		channel.exchangeDeclare(Producer.DIRECT_EXCHAGE, BuiltinExchangeType.DIRECT);
		
		// 声明(创建)队列 
		/**
		* 参数1:队列名称
		* 参数2:是否定义持久化队列
		* 参数3:是否独占本次连接
		* 参数4:是否在不使用的时候自动删除队列 * 参数5:队列其它参数
		*/
		channel.queueDeclare(Producer.DIRECT_QUEUE_INSERT, true, false, false, null); 	
		//队列绑定交换机
		channel.queueBind(Producer.DIRECT_QUEUE_INSERT, Producer.DIRECT_EXCHAGE, "insert");
				
		//创建消费者;并设置消息处理
		DefaultConsumer consumer = new DefaultConsumer(channel){
			@Override
			/**
			* consumerTag 消息者标签，在channel.basicConsume时候可以指定
			* envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
			* properties 属性信息
			* body 消息
			*/
			public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
				    //路由key
					System.out.println("路由key为:" + envelope.getRoutingKey());
					//交换机
					System.out.println("交换机为:" + envelope.getExchange()); 
					//消息id
					System.out.println("消息id为:" + envelope.getDeliveryTag()); 
					//收到的消息
					System.out.println("消费者1-接收到的消息为:" + new String(body,"utf-8"));
					
			}
		};
		//监听消息 
		/**
		* 参数1:队列名称
		* 参数2:是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复 会删除消息，设置为false则需要手动确认
		* 参数3:消息接收到后回调
		*/
		channel.basicConsume(Producer.DIRECT_QUEUE_INSERT, true, consumer);
	}
}

消费者2:

public class Consumer2 {

	public static void main(String[] args) throws Exception { 
	
		Connection connection = ConnectionUtil.getConnection();
		
		// 创建频道
		Channel channel = connection.createChannel();

		//声明交换机
		channel.exchangeDeclare(Producer.DIRECT_EXCHAGE, BuiltinExchangeType.DIRECT);
		
		// 声明(创建)队列 
		/**
		* 参数1:队列名称
		* 参数2:是否定义持久化队列
		* 参数3:是否独占本次连接
		* 参数4:是否在不使用的时候自动删除队列 * 参数5:队列其它参数
		*/
		channel.queueDeclare(Producer.DIRECT_QUEUE_UPDATE, true, false, false, null); 	
		//队列绑定交换机
		channel.queueBind(Producer.DIRECT_QUEUE_UPDATE, Producer.DIRECT_EXCHAGE, "UPDATE");
				
		//创建消费者;并设置消息处理
		DefaultConsumer consumer = new DefaultConsumer(channel){
			@Override
			/**
			* consumerTag 消息者标签，在channel.basicConsume时候可以指定
			* envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
			* properties 属性信息
			* body 消息
			*/
			public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
				    //路由key
					System.out.println("路由key为:" + envelope.getRoutingKey());
					//交换机
					System.out.println("交换机为:" + envelope.getExchange()); 
					//消息id
					System.out.println("消息id为:" + envelope.getDeliveryTag()); 
					//收到的消息
					System.out.println("消费者2-接收到的消息为:" + new String(body,"utf-8"));
					
			}
		};
		//监听消息 
		/**
		* 参数1:队列名称
		* 参数2:是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复 会删除消息，设置为false则需要手动确认
		* 参数3:消息接收到后回调
		*/
		channel.basicConsume(Producer.DIRECT_QUEUE_UPDATE, true, consumer);
	}
}

5. Topics通配符模式

Topic 类型与 Direct 相比，都是可以根据 RoutingKey 把消息路由到不同的队列。只不过 Topic 类型 Exchange 可以让队列在绑定 Routing key 的时候使用通配符!

Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如: item.insert

通配符规则:
#: 匹配一个或多个词
*: 匹配不多不少恰好1个词

举个栗子:
item.# : 能够匹配 item.insert.abc 或者 item.insert
item.* : 只能匹配 item.insert
在这里插入图片描述

生产者:
使用topic类型的Exchange，发送消息的routing key有3种: item.insert 、 item.update 、 item.delete :

/**
* 通配符Topic的交换机类型为:topic 
*/
public class Producer {
	
	//交换机名称
	static final String TOPIC_EXCHAGE = "topic_exchange"; 
	
	//队列名称
	static final String TOPIC_QUEUE_1 = "topic_queue_1"; 
	
	//队列名称
	static final String TOPIC_QUEUE_2 = "topic_queue_2";

	public static void main(String[] args) throws Exception { 
		//创建连接
		Connection connection = ConnectionUtil.getConnection(); 
	
		// 创建频道
		Channel channel = connection.createChannel();
	
		/**
		* 声明交换机
		* 参数1:交换机名称
		* 参数2:交换机类型，fanout、topic、direct、headers 
		*/
		channel.exchangeDeclare(TOPIC_EXCHAGE, BuiltinExchangeType.TOPIC);
		
		// 发送信息
		String message = "新增了商品。Topic模式;routing key 为 item.insert ";		
		channel.basicPublish(TOPIC_EXCHAGE, "item.insert", null, message.getBytes());
		System.out.println("已发送消息:" + message); 
		
		// 发送信息
		message = "修改了商品。Topic模式;routing key 为 item.update"; 		
		channel.basicPublish(TOPIC_EXCHAGE, "item.update", null, message.getBytes());
		System.out.println("已发送消息:" + message);

		// 发送信息
		message = "删除了商品。Topic模式;routing key 为 item.delete"; 
		channel.basicPublish(TOPIC_EXCHAGE, "item.delete", null, message.getBytes()); 
		System.out.println("已发送消息:" + message);
		
		// 关闭资源 
		channel.close(); 
		connection.close();
	}
}

消费者1

接收两种类型的消息:更新商品和删除商品

public class Consumer1 {

	public static void main(String[] args) throws Exception { 
	
		Connection connection = ConnectionUtil.getConnection();
		
		// 创建频道
		Channel channel = connection.createChannel();

		//声明交换机
		channel.exchangeDeclare(Producer.TOPIC_EXCHAGE, BuiltinExchangeType.TOPIC);
		
		// 声明(创建)队列 
		/**
		* 参数1:队列名称
		* 参数2:是否定义持久化队列
		* 参数3:是否独占本次连接
		* 参数4:是否在不使用的时候自动删除队列 * 参数5:队列其它参数
		*/
		channel.queueDeclare(Producer.TOPIC_QUEUE_1, true, false, false, null);
		
		//队列绑定交换机
		channel.queueBind(Producer.TOPIC_QUEUE_1, Producer.TOPIC_EXCHAGE, "item.update");		
		channel.queueBind(Producer.TOPIC_QUEUE_1, Producer.TOPIC_EXCHAGE, "item.delete");
				
		//创建消费者;并设置消息处理
		DefaultConsumer consumer = new DefaultConsumer(channel){
			@Override
			/**
			* consumerTag 消息者标签，在channel.basicConsume时候可以指定
			* envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
			* properties 属性信息
			* body 消息
			*/
			public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
				    //路由key
					System.out.println("路由key为:" + envelope.getRoutingKey());
					//交换机
					System.out.println("交换机为:" + envelope.getExchange()); 
					//消息id
					System.out.println("消息id为:" + envelope.getDeliveryTag()); 
					//收到的消息
					System.out.println("消费者1-接收到的消息为:" + new String(body,"utf-8"));
					
			}
		};
		//监听消息 
		/**
		* 参数1:队列名称
		* 参数2:是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复 会删除消息，设置为false则需要手动确认
		* 参数3:消息接收到后回调
		*/
		channel.basicConsume(Producer.TOPIC_QUEUE_1, true, consumer);
	}
}

消费者2

接收所有类型的消息:新增商品，更新商品和删除商品。

public class Consumer2 {

	public static void main(String[] args) throws Exception { 
	
		Connection connection = ConnectionUtil.getConnection();
		
		// 创建频道
		Channel channel = connection.createChannel();

		//声明交换机
		channel.exchangeDeclare(Producer.TOPIC_EXCHAGE, BuiltinExchangeType.TOPIC);
		
		// 声明(创建)队列 
		/**
		* 参数1:队列名称
		* 参数2:是否定义持久化队列
		* 参数3:是否独占本次连接
		* 参数4:是否在不使用的时候自动删除队列 * 参数5:队列其它参数
		*/
		channel.queueDeclare(Producer.TOPIC_QUEUE_2, true, false, false, null);
		
		//队列绑定交换机
		channel.queueBind(Producer.TOPIC_QUEUE_2, Producer.TOPIC_EXCHAGE, "item.*");		
		
				
		//创建消费者;并设置消息处理
		DefaultConsumer consumer = new DefaultConsumer(channel){
			@Override
			/**
			* consumerTag 消息者标签，在channel.basicConsume时候可以指定
			* envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志(收到消息失败后是否需要重新发送)
			* properties 属性信息
			* body 消息
			*/
			public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
				    //路由key
					System.out.println("路由key为:" + envelope.getRoutingKey());
					//交换机
					System.out.println("交换机为:" + envelope.getExchange()); 
					//消息id
					System.out.println("消息id为:" + envelope.getDeliveryTag()); 
					//收到的消息
					System.out.println("消费者2-接收到的消息为:" + new String(body,"utf-8"));	
			}
		};
		//监听消息 
		/**
		* 参数1:队列名称
		* 参数2:是否自动确认，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复 会删除消息，设置为false则需要手动确认
		* 参数3:消息接收到后回调
		*/
		channel.basicConsume(Producer.TOPIC_QUEUE_2, true, consumer);
	}
}

Topic主题模式可以实现 Publish/Subscribe发布与订阅模式和 Routing路由模式的功能;只是Topic在配置routing key 的时候可以使用通配符，显得更加灵活。

6. 模式总结

RabbitMQ工作模式:

1、简单模式 HelloWorld 一个生产者、一个消费者，不需要设置交换机(使用默认的交换机)
2、工作队列模式 Work Queue 一个生产者、多个消费者(竞争关系)，不需要设置交换机(使用默认的交换机)
3、发布订阅模式 Publish/subscribe 需要设置类型为fanout的交换机，并且交换机和队列进行绑定，当发送消息到交换机后，交换机会将消息发送到绑定的队列
4、路由模式 Routing 需要设置类型为direct的交换机，交换机和队列进行绑定，并且指定routing key，当发送消息到交换机后，交换机会根据routing key将消息发送到对应的队列
5、通配符模式 Topic 需要设置类型为topic的交换机，交换机和队列进行绑定，并且指定通配符方式的 routing key，当发送消息到交换机后，交换机会根据routing key将消息发送到对应的队列

五、Spring Boot整合RabbitMQ

在spring boot项目中只需要引入对应的amqp启动器依赖即可，方便的使用RabbitTemplate发送消息，使用注解接收消息。

生产者工程:

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

消费者工程:

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

搭建生产者工程

pom文件:

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

配置文件:

spring:
  rabbitmq:
	host: 110.42.216.234 
	port: 5672 
	virtual-host: /xzk 
	username: guest
	password: guest

绑定交换机和队列

@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("itemTopicExchange") 
	public Exchange topicExchange(){
		return ExchangeBuilder.topicExchange(ITEM_TOPIC_EXCHANGE).durable(true).build(); 
	//声明队列 
	@Bean("itemQueue")
	public Queue itemQueue(){
		return QueueBuilder.durable(ITEM_QUEUE).build(); 
	}
	
	//绑定队列和交换机
	@Bean
	public Binding itemQueueExchange(@Qualifier("itemQueue") Queue queue, @Qualifier("itemTopicExchange")Exchange exchange){ 
		return BindingBuilder.bind(queue).to(exchange).with("item.#").noargs();
	 
	 }
}

在测试类中发送消息:

@RunWith(SpringRunner.class) 
@SpringBootTest
public class RabbitMQTest {
	
	@Autowired
    private RabbitTemplate rabbitTemplate;
	
	@Test
	public void test(){ 	
		rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE, "item.insert", "商品新增，routing key 为item.insert"); 	
		rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE, "item.update", "商品修改，routing key 为item.update"); 	
		rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE, "item.delete", "商品删除，routing key 为item.delete"); }

搭建消费者工程

添加依赖:

<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>

配置文件:

spring:
  rabbitmq:
	host: 110.42.216.234 
	port: 5672 
	virtual-host: /xzk 
	username: guest 
	password: guest

消息监听处理类:

@Component
public class MyListener {
	/**
	* 监听某个队列的消息
	* @param message 接收到的消息 
	*/
    @RabbitListener(queues = "springboot_item_queue")
    public void myListener1(String message){
		System.out.println("消费者接收到的消息为:" + message); 
	}

六、应用场景

在本次项目中MQ用于解决用户下单以后，订单超时如何取消订单的问题。

用户进行下单操作（会有锁定商品库存、使用优惠券、积分一系列的操作）；
生成订单，获取订单的id；
获取到设置的订单超时时间（假设设置的为60分钟不支付取消订单）；
按订单超时时间发送一个延迟消息给RabbitMQ，让它在订单超时后触发取消订单的操作；
如果用户没有及时支付，进行取消订单操作（释放锁定商品库存、返还优惠券、返回积分一系列操作）。

配置文件 order-service.yml

server:
  port: 9009
  
中间无关部分省略...

mq:
  pay:
    exchange:
      order: exchange.pay.order
    queue:
      order: queue.pay.order
    routing:
      key: routing.pay.order
  order:
    exchange:
      ttl: exchange.order.ttl
      dlx: exchange.order.dlx
    queue:
      ttl: queue.order.ttl
      dlx: queue.order.dlx
    routing:
      ttl: routing.order.ttl
      dlx: routing.order.dlx

mq配置类 MqConfig.class

package com.kkb.legou.order.config;

@Configuration
public class MqConfig {


    @Autowired
    private Environment env;


    /**
     * 正常交换机
     * @return
     */
    @Bean
    public Exchange ttlExchange() {
        return ExchangeBuilder.directExchange(env.getProperty("mq.order.exchange.ttl")).durable(true).build();
    }


    /**
     * 死信交换机
     * @return
     */
    @Bean
    public Exchange dlxExchange() {
        return ExchangeBuilder.directExchange(env.getProperty("mq.order.exchange.dlx")).durable(true).build();
    }


    /**
     * 正常队列
     * @return
     */
    @Bean
    public Queue ttlQueue() {
        return QueueBuilder
                .durable(env.getProperty("mq.order.queue.ttl"))
                //死信交换机名称
                .withArgument("x-dead-letter-exchange", env.getProperty("mq.order.exchange.dlx"))
                //发送给死信交换机的routingkey
                .withArgument("x-dead-letter-routing-key", env.getProperty("mq.order.routing.dlx"))
                //队列过期时间，30秒过期
                .withArgument("x-message-ttl", 30000).build();
    }

    /**
     * 死信队列
     * @return
     */
    @Bean
    public Queue dlxQueue() {
        return QueueBuilder.durable(env.getProperty("mq.order.queue.dlx")).build();
    }

    /**
     * 正常交换机，队列绑定 
     * @param queue
     * @param exchange 
     * @return
     */
    @Bean
    public Binding ttlBinding(@Qualifier("ttlQueue") Queue queue, @Qualifier("ttlExchange") Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(env.getProperty("mq.order.routing.ttl")).noargs();
    }

    /**
     * 死信交换机，队列绑定
     * @param queue
     * @param exchange
     * @return
     */
    @Bean
    public Binding dlxBinding(@Qualifier("dlxQueue") Queue queue, @Qualifier("dlxExchange") Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with(env.getProperty("mq.order.routing.dlx")).noargs();
    }

}

订单Service的添加方法(处理完业务后, 向ttl队列放送消息, 设置过期时间30秒)

package com.kkb.legou.order.service.impl;

@Service
public class OrderServiceImpl extends CrudServiceImpl<Order> implements IOrderService {

	@Autowired
    private RabbitTemplate rabbitTemplate;

    @Override
    public void add(Order order) {
    
    // 此处业务相关的代码省略...

	// 发送延迟30分钟取消订单消息     			
	rabbitTemplate.convertAndSend(env.getProperty("mq.order.exchange.ttl"), env.getProperty("mq.order.routing.ttl"), order.getId().toString());
	
	}
}

OrderLazyStatusListener类监听死信队列(ttl队列中过期的消息会通过死信交换机发送到死信队列中)

package com.kkb.legou.order.listener;

@Component
@RabbitListener(queues = "${mq.order.queue.dlx}")
public class OrderLazyStatusListener {

    @Autowired
    private IOrderService orderService;

    @Autowired
    private SkuClient skuClient;

    @RabbitHandler
    public void handlerData(String msg) {
        System.out.println(msg);
        if (StringUtils.isNotEmpty(msg)) {
            Long id = Long.parseLong(msg);
            Order order = orderService.getById(id);
            order.setOrderStatus("3");
            orderService.updateById(order);//修改订单装填
            //回滚库存
            List<OrderItem> list = orderService.getOrderItemByOrderId(id);
            for(OrderItem orderItem : list){
                int num = orderItem.getNum();
                skuClient.rollBackCount(num, orderItem.getSkuId());
            }

        }
    }

}

总结

一般稍微大点的系统都会用到消息队列，项目中常用的的主要有RocketMQ、RabbitMQ和kafka。使用消息队列的最终目的是通讯，本质是解耦生产者消费者依赖，一般用在异步处理、解耦、错峰、流量控制等场景。

KG6666666

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
乐购商城项目技术总结 -- RabbitMQ

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、MQ的优势1、应用解藕2、任务异步处理3、削峰填谷二、MQ的劣势三、相关概念前言RabbitMQ是一个被广泛使用的开源消息队列。它是轻量级且易于部署的，它能支持多种消息协议。RabbitMQ可以部署在分布式和联合配置中，以满足高规模、高可用性的需求。一、MQ的优势MQ全称 Message Queue(消息队列)，是在消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信。应用之前的远程调用加入MQ后
复制链接

扫一扫