Java基础之《RabbitMQ（2）—交换器》

csj50

已于 2022-05-22 13:59:38 修改

阅读量637

点赞数

分类专栏： JAVA基础文章标签： java

于 2022-05-20 18:21:50 首次发布

本文链接：https://blog.csdn.net/csj50/article/details/124888515

版权

JAVA基础专栏收录该内容

173 篇文章 14 订阅

订阅专栏

本文详细介绍了RabbitMQ中的信道、交换器、队列、路由键等核心概念，并通过具体场景展示了direct、topic和fanout三种交换器的工作流程。信道作为TCP连接上的虚拟通道，有效减少了TCP创建和销毁的开销，提高了系统性能。同时，交换器根据路由键将消息路由到相应的队列，实现灵活的消息分发。

摘要由CSDN通过智能技术生成

一、RabbitMQ为什么需要信道，为什么不是TCP直接通信

1、什么是信道
信道就是控制台上的Channels

项目启动后，Queues是出来了，但是Channels是空的，只有发送数据后，信道就会有了

2、连接、信道、交换器、队列的关联关系

Pubilsher：生产者
Consumer：消费者
Broker：rabbitmq服务器
Virtual Host：rabbitmq的虚拟机
Exchange Binding Queue：交换器和队列绑定在一起

具体讲解：
（1）Message
消息，消息是不具名的，它由消息头和消息体组成。消息体是不透明的，而消息头则由一系列的可选属性组成，这些属性包括routing-key（路由键）、priority（相对于其他消息的优先权）、delivery-mode（指出该消息可能需要持久性存储）等。
（2）Publisher
消息的生产者，也是一个向交换器发布消息的客户端应用程序。
（3）Consumer
消息的消费者，表示一个从消息队列中取得消息的客户端应用程序。
（4）Exchange
交换器，用来接收生产者发送的消息并将这些消息路由给服务器中的队列。
3种常用的交换器类型：
1.direct（发布与订阅、完全匹配）
2.fanout（广播）
3.topic（主题、规则匹配）
（5）Binding
绑定，用于消息队列和交换器之间的关联。一个绑定就是基于路由键将交换器和消息队列连接起来的路由规则，所以可以将交换器理解成一个由绑定构成的路由表。
（6）Queue
消息队列，用来保存消息直到发送给消费者。它是消息的容器，也是消息的终点。一个消息可以投入一个或多个队列。消息一直在队列里面，等待消费者连接到这个队列将其取走。
（7）routing key
路由键：RabbitMQ决定消息该投递到哪个队列的规则。
队列通过路由键绑定到交换器。
消息发送到代理服务器时，消息将拥有一个路由键，即便是空的，RabbitMQ也会将其和绑定使用的路由键进行匹配。
如果相匹配，消息将会投递到该队列，如果不匹配，消息将会进入黑洞。
（8）Connection
指RabbitMQ服务器和服务端建立的TCP连接。
（9）Channel
1.channel中文叫信道，是TCP里面的虚拟连接。例如：电缆相当于TCP，信道是一条独立光纤束，一条TCP连接上创建多条信道是没有限制的。
2.TCP一旦打开，就会创建AMQP信道。
3.无论是发布消息、接收消息、订阅队列，这些动作都是通过信道完成的。
（10）Virtual Host
虚拟主机，表示一批交换器、消息队列和相关对象。虚拟主机是共享相同的身份认证和加密环境的独立服务器域。每个vhost本质上就是一个mini版的RabbitMQ服务器，拥有自己的队列、交换器、绑定和权限机制。vhost是AMQP概念的基础，必须在连接时指定，RabbitMQ默认的vhost是/。
（11）Broker
表示消息队列服务器实体。

3、交换器和队列的关系
交换器是通过路由键和队列绑定在一起的，如果消息拥有的路由键跟队列和交换器的路由键匹配，那么消息就会被路由到该绑定的队列当中去。
也就是说，消息到队列的过程中，消息首先会经过交换器，接下来交换器再通过路由键匹配分发消息到具体的队列中去。
路由键可以理解为匹配规则。

4、rabbitmq为什么要用信道？为什么不是TCP直接通信？
（1）TCP的创建和销毁，开销大，创建要3次握手，销毁要4次分手。
（2）如果不用信道，那应用程序就会tcp连接到rabbit，高峰时每秒成千上万条连接会造成资源的巨大浪费，而且操作系统每秒处理tcp连接数也是有限制的，必定造成性能瓶颈。
（3）信道的原理是一条线程一条信道，多条线程多条信道同用一条TCP连接。一条TCP连接可以容纳无限的信道，即使每秒成千上万的请求也不会成为性能瓶颈。

二、direct交换器消息流

1、业务场景：系统日志处理
微服务产生的日志，交给日志服务器来处理
日志处理服务器有4个服务，分别为DEBUG、INFO、WARN、ERROR等
服务直接的通信采用direct（发布订阅）

2、配置文件添加

#yml不允许有value的key下面一层及有value，要间隔一个空的层级
#设置交换器
mq:
  config:
    exchange: log-direct
    queue:
      info: log.info
      error: log.error
      routing:
        key:
          info: log.info.routing.key
          error: log.error.routing.key

3、修改消息发送类

package com.example.web;

import java.util.Date;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;

@Api(description = "rabbitmq测试接口")
@RestController
@RequestMapping("/rabbit")
public class RabbitController {

	@Autowired
	RabbitTemplate rabbitTemplate;
	
	@Value("${mq.config.exchange}")
	private String exchange;
	
	@ApiOperation("发送一条记录")
	@GetMapping("/send")
	public void send() {
		String msg = "hello" + new Date();
		//第一个参数是queue名称，第二个参数是msg
		rabbitTemplate.convertAndSend("testQueue", msg);
	}
	
	@ApiOperation("direct交换器测试")
	@GetMapping("/direct")
	public void direct() {
		String msg = "hello" + new Date();
		//第一个参数是交换器，第二个参数是路由键，第三个参数是msg
		rabbitTemplate.convertAndSend(exchange, "log.info.routing.key", msg);
		rabbitTemplate.convertAndSend(exchange, "log.error.routing.key", msg);
	}
}

4、添加消息接收类
RabbitDirectInfoService.java

package com.example.rabbit;

import org.springframework.amqp.core.ExchangeTypes;
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.stereotype.Component;

@Component
@RabbitListener(bindings = @QueueBinding(
		//绑定一个队列
		value = @Queue(value = "${mq.config.queue.info}", autoDelete = "true"),
		//绑定一个交换器
		exchange = @Exchange(value = "${mq.config.exchange}", type = ExchangeTypes.DIRECT),
		//配置路由键
		key = "${mq.config.queue.routing.key.info}"
		)
		)
public class RabbitDirectInfoService {

	@RabbitHandler
	public void process(String msg) {
		System.out.println("接收到INFO日志:" + msg);
	}
}

RabbitDirectErrorService.java

package com.example.rabbit;

import org.springframework.amqp.core.ExchangeTypes;
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.stereotype.Component;

@Component
@RabbitListener(bindings = @QueueBinding(
		//绑定一个队列
		value = @Queue(value = "${mq.config.queue.error}", autoDelete = "true"),
		//绑定一个交换器
		exchange = @Exchange(value = "${mq.config.exchange}", type = ExchangeTypes.DIRECT),
		//配置路由键
		key = "${mq.config.queue.routing.key.error}"
		)
		)
public class RabbitDirectErrorService {
	
	@RabbitHandler
	public void process(String msg) {
		System.out.println("接收到ERROR日志:" + msg);
	}
}

5、测试并查看日志

接收到INFO日志:helloFri May 20 17:05:17 CST 2022
接收到ERROR日志:helloFri May 20 17:05:17 CST 2022

三、topic交换器消息流

1、业务场景
多个服务端
路由键里有*号，模糊匹配

2、修改配置文件

#yml不允许有value的key下面一层及有value，要间隔一个空的层级
#设置交换器
mq:
  config:
    exchange: log-direct
    exchange2: log-topic
    queue:
      info: log.info
      error: log.error
      info2: log.info2
      error2: log.error2
      logs: log.msg   #全消息
      routing:
        key:
          info: log.info.routing.key
          error: log.error.routing.key
          userinfo: user.log.info
          userdebug: user.log.debug
          userwarn: user.log.warn
          usererror: user.log.error
          productinfo: product.log.info
          productdebug: product.log.debug
          productwarn: product.log.warn
          producterror: product.log.error
          orderinfo: order.log.info
          orderdebug: order.log.debug
          orderwarn: order.log.warn
          ordererror: order.log.error

3、修改消息发送类

package com.example.web;

import java.util.Date;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;

@Api(description = "rabbitmq测试接口")
@RestController
@RequestMapping("/rabbit")
public class RabbitController {

	@Autowired
	RabbitTemplate rabbitTemplate;
	
	@Value("${mq.config.exchange}")
	private String exchange;
	
	@Value("${mq.config.exchange2}")
	private String exchange2;
	
	@ApiOperation("发送一条记录")
	@GetMapping("/send")
	public void send() {
		String msg = "hello" + new Date();
		//第一个参数是queue名称，第二个参数是msg
		rabbitTemplate.convertAndSend("testQueue", msg);
	}
	
	@ApiOperation("direct交换器测试")
	@GetMapping("/direct")
	public void direct() {
		String msg = "hello" + new Date();
		//第一个参数是交换器，第二个参数是路由键，第三个参数是msg
		rabbitTemplate.convertAndSend(exchange, "log.info.routing.key", msg);
		rabbitTemplate.convertAndSend(exchange, "log.error.routing.key", msg);
	}
	
	@ApiOperation("topic交换器测试")
	@GetMapping("/topic")
	public void topic() {
		//第一个参数是交换器，第二个参数是路由键，第三个参数是msg
		rabbitTemplate.convertAndSend(exchange2, "user.log.info", "user info......");
		rabbitTemplate.convertAndSend(exchange2, "user.log.debug", "user debug......");
		rabbitTemplate.convertAndSend(exchange2, "user.log.warn", "user warn......");
		rabbitTemplate.convertAndSend(exchange2, "user.log.error", "user error......");
		
		rabbitTemplate.convertAndSend(exchange2, "product.log.info", "product info......");
		rabbitTemplate.convertAndSend(exchange2, "product.log.debug", "product debug......");
		rabbitTemplate.convertAndSend(exchange2, "product.log.warn", "product warn......");
		rabbitTemplate.convertAndSend(exchange2, "product.log.error", "product error......");
		
		rabbitTemplate.convertAndSend(exchange2, "order.log.info", "order info......");
		rabbitTemplate.convertAndSend(exchange2, "order.log.debug", "order debug......");
		rabbitTemplate.convertAndSend(exchange2, "order.log.warn", "order warn......");
		rabbitTemplate.convertAndSend(exchange2, "order.log.error", "order error......");
	}
}

4、添加消息接收类
RabbitTopicErrorService.java

package com.example.rabbit;

import org.springframework.amqp.core.ExchangeTypes;
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.stereotype.Component;

@Component
@RabbitListener(bindings = @QueueBinding(
		//绑定一个队列
		value = @Queue(value = "${mq.config.queue.error2}", autoDelete = "true"),
		//绑定一个交换器
		exchange = @Exchange(value = "${mq.config.exchange2}", type = ExchangeTypes.TOPIC),
		//配置路由键
		key = "*.log.error"
		)
		)
public class RabbitTopicErrorService {
	
	@RabbitHandler
	public void process(String msg) {
		System.out.println("error----------日志:" + msg);
	}
}

RabbitTopicInfoService.java

package com.example.rabbit;

import org.springframework.amqp.core.ExchangeTypes;
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.stereotype.Component;

@Component
@RabbitListener(bindings = @QueueBinding(
		//绑定一个队列
		value = @Queue(value = "${mq.config.queue.info2}", autoDelete = "true"),
		//绑定一个交换器
		exchange = @Exchange(value = "${mq.config.exchange2}", type = ExchangeTypes.TOPIC),
		//配置路由键
		key = "*.log.info"
		)
		)
public class RabbitTopicInfoService {
	
	@RabbitHandler
	public void process(String msg) {
		System.out.println("info----------日志:" + msg);
	}
}

RabbitTopicLogsService.java

package com.example.rabbit;

import org.springframework.amqp.core.ExchangeTypes;
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.stereotype.Component;

@Component
@RabbitListener(bindings = @QueueBinding(
		//绑定一个队列
		value = @Queue(value = "${mq.config.queue.logs}", autoDelete = "true"),
		//绑定一个交换器
		exchange = @Exchange(value = "${mq.config.exchange2}", type = ExchangeTypes.TOPIC),
		//配置路由键
		key = "*.log.*"
		)
		)
public class RabbitTopicLogsService {
	
	@RabbitHandler
	public void process(String msg) {
		System.out.println("all----------日志:" + msg);
	}
}

5、测试并查看日志

all----------日志:user info......
info----------日志:user info......
all----------日志:user debug......
all----------日志:user warn......
all----------日志:user error......
all----------日志:product info......
info----------日志:product info......
all----------日志:product debug......
error----------日志:user error......
info----------日志:order info......
error----------日志:product error......
all----------日志:product warn......
error----------日志:order error......
all----------日志:product error......
all----------日志:order info......
all----------日志:order debug......
all----------日志:order warn......
all----------日志:order error......

注意：topic模式绑定的queue不能和direct模式绑定的queue一样，否则会有发往topic交换器的消息给direct交换器接收到了，这样的异常情况
direct和topic区别，direct指定了路由键，topic可以模糊匹配

四、fanout交换器消息流

1、业务场景

2、配置文件修改
添加交换器和队列。广播不需要路由键，因为它是一个接收的关系，它没有指定到某个队列

#yml不允许有value的key下面一层及有value，要间隔一个空的层级
#设置交换器
mq:
  config:
    exchange: log-direct
    exchange2: log-topic
    exchange3: order.fanout
    queue:
      info: log.info
      error: log.error
      info2: log.info2
      error2: log.error2
      logs: log.msg   #全消息
      sms: order.sms
      push: order.push
      routing:
        key:
          info: log.info.routing.key
          error: log.error.routing.key
          userinfo: user.log.info
          userdebug: user.log.debug
          userwarn: user.log.warn
          usererror: user.log.error
          productinfo: product.log.info
          productdebug: product.log.debug
          productwarn: product.log.warn
          producterror: product.log.error
          orderinfo: order.log.info
          orderdebug: order.log.debug
          orderwarn: order.log.warn
          ordererror: order.log.error

3、修改消息发送类

package com.example.web;

import java.util.Date;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;

@Api(description = "rabbitmq测试接口")
@RestController
@RequestMapping("/rabbit")
public class RabbitController {

	@Autowired
	RabbitTemplate rabbitTemplate;
	
	@Value("${mq.config.exchange}")
	private String exchange;
	
	@Value("${mq.config.exchange2}")
	private String exchange2;
	
	@Value("${mq.config.exchange3}")
	private String exchange3;
	
	@ApiOperation("发送一条记录")
	@GetMapping("/send")
	public void send() {
		String msg = "hello" + new Date();
		//第一个参数是queue名称，第二个参数是msg
		rabbitTemplate.convertAndSend("testQueue", msg);
	}
	
	@ApiOperation("direct交换器测试")
	@GetMapping("/direct")
	public void direct() {
		String msg = "hello" + new Date();
		//第一个参数是交换器，第二个参数是路由键，第三个参数是msg
		rabbitTemplate.convertAndSend(exchange, "log.info.routing.key", msg);
		rabbitTemplate.convertAndSend(exchange, "log.error.routing.key", msg);
	}
	
	@ApiOperation("topic交换器测试")
	@GetMapping("/topic")
	public void topic() {
		//第一个参数是交换器，第二个参数是路由键，第三个参数是msg
		rabbitTemplate.convertAndSend(exchange2, "user.log.info", "user info......");
		rabbitTemplate.convertAndSend(exchange2, "user.log.debug", "user debug......");
		rabbitTemplate.convertAndSend(exchange2, "user.log.warn", "user warn......");
		rabbitTemplate.convertAndSend(exchange2, "user.log.error", "user error......");
		
		rabbitTemplate.convertAndSend(exchange2, "product.log.info", "product info......");
		rabbitTemplate.convertAndSend(exchange2, "product.log.debug", "product debug......");
		rabbitTemplate.convertAndSend(exchange2, "product.log.warn", "product warn......");
		rabbitTemplate.convertAndSend(exchange2, "product.log.error", "product error......");
		
		rabbitTemplate.convertAndSend(exchange2, "order.log.info", "order info......");
		rabbitTemplate.convertAndSend(exchange2, "order.log.debug", "order debug......");
		rabbitTemplate.convertAndSend(exchange2, "order.log.warn", "order warn......");
		rabbitTemplate.convertAndSend(exchange2, "order.log.error", "order error......");
	}
	
	@ApiOperation("fanout交换器测试")
	@GetMapping("/fanout")
	public void fanout() {
		String msg = "hello" + new Date();
		rabbitTemplate.convertAndSend(exchange3, "", msg);
	}
}

4、添加消息接收类
RabbitFanoutSmsInfoService.java

package com.example.rabbit;

import org.springframework.amqp.core.ExchangeTypes;
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.stereotype.Component;

@Component
@RabbitListener(bindings = @QueueBinding(
		//绑定一个队列
		value = @Queue(value = "${mq.config.queue.push}", autoDelete = "true"),
		//绑定一个交换器
		exchange = @Exchange(value = "${mq.config.exchange3}", type = ExchangeTypes.FANOUT)
		)
		)
public class RabbitFanoutSmsInfoService {

	@RabbitHandler
	public void process(String msg) {
		System.out.println("推送处理:" + msg);
	}
}

RabbitFanoutPushInfoService.java

package com.example.rabbit;

import org.springframework.amqp.core.ExchangeTypes;
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.stereotype.Component;

@Component
@RabbitListener(bindings = @QueueBinding(
		//绑定一个队列
		value = @Queue(value = "${mq.config.queue.sms}", autoDelete = "true"),
		//绑定一个交换器
		exchange = @Exchange(value = "${mq.config.exchange3}", type = ExchangeTypes.FANOUT)
		)
		)
public class RabbitFanoutPushInfoService {

	@RabbitHandler
	public void process(String msg) {
		System.out.println("短信处理:" + msg);
	}
}

5、测试并查看日志

短信处理:helloSun May 22 13:56:05 CST 2022
推送处理:helloSun May 22 13:56:05 CST 2022

参考资料：
https://www.jianshu.com/p/c561368dd40e

csj50

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录