交换机
简单介绍
上一篇博客都是创建了一个工作队列,假设的是工作队列背后,每个任务都恰好交付给一个消费者(工作线程)。在这一部分,我们将做一些完全不同的事情。我们将消息传递给多个消费者,这种模式就是 “发布、订阅”
简单实验
构建一个简单的日志系统,将两个程序组成:第一个程序将发出日志消费,第二个程序是消费者,其中我们会启动两个消费者,其中一个消费者接收到消息后把日志存储早磁盘。另外一个消费者接收到消息后把消息打印出来 ,事实上第一个程序发出的日志消息将广播给所有消费者。
Exchanges 概念
RabbitMQ 消息传递模型的核心思想是:生产者的消息从不会直接发送到队列 实际上,通常生产者甚至都不知道这些消息传递到了那些队列中。
生产者只能将消息发送到交换机 ,交换机的工作非常简单。接收来自生产者的消息。推入队列,交换机必须知道如何处理收到的消息,应该把这些消息放到特定队列。都是由交换机的类型决定的。
交换机的类型
直接,主题,标题,扇出
无名(Exchange)
之前上篇博客中我们对于交换机的部分都是一个空的字符串
临时队列
每当我们链接Rabbit 的时候 我们都需要一个全新的空的队列,为此可以创建一个具有随机名称的队列,或者能让服务器为我们选择一个随机队列名称就好了,其次一旦我们断开了消费者的链接,队列就会被自动删除。
创建临时队列方式‘
String queueName = channel.queneDeclare().getQuene();
Fanout (扇出)
Fanout 这种类型非常简单 正如从名称中猜到的那样 它将接收到的所有消息广播到它知道的所有队列中,系统中默认有些 exchange 类型。
消费者代码 01
// 消息接收
public class ReceiveLogs01 {
// 交换机名称
public static final String EXCHANGE_NAME ="logs";
public static void main(String[] args) throws Exception{
// 创建链接
Channel channel = RabbitmqUtil.getChannel();
// 创建一个交换机
channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
// 生成一盒临时的队列
String queueName = channel.queueDeclare().getQueue();
// 绑定交换机与队列
channel.queueBind(queueName,EXCHANGE_NAME,"");
System.out.println("等待接收消息");
// 接收消息
DeliverCallback deliverCallback = (consumerTag,message) ->{
System.out.println("02 new String(message.getBody(),\"UTF-8\") = " + new String(message.getBody(),"UTF-8"));
};
channel.basicConsume(queueName,true,deliverCallback,consumerTag ->{});
}
}
消费者一和二是一样的
生产者代码
public class LOgs {
// 交换机名称
public static final String EXCHANGE_NAME ="logs";
public static void main(String[] args) throws Exception{
// 创建连接的对象
Channel channel = RabbitmqUtil.getChannel();
// 交换机
channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
String message = scanner.next();
channel.basicPublish(EXCHANGE_NAME,"",null,message.getBytes("UTF-8"));
System.out.println("message = " + message);
}
}
}
效果
这样一个消息可以被2个不同的消费者获取。
Direct exchange
小总结
上面构建一个简单的日志系统。可以接收许多接受者广播的日志消息。但是这个交换机的可以只让某个消费者订阅发布的部分内容。加入说我们只想吧错误的定向存储到日志文件 同时任然能够打印出所有的信息。
Direct exchange 介绍
这个就可以很好的把我们日志消息写入磁盘的程序,接收严重的错误(errors)不存储那些警告或者其他的日志消息写入磁盘空间,Fanout 这种交换并不能给我们带来很大的灵活性 他只能进行无意识的广播,在这里我们将使用 direct 这种类型来进行替换 这种类型的工作方式是 消息只去到它绑定的 routingkey 队列中去
代码
**这个负责 info 和 警告 **
public class Direct {
// 交换机的名字
public static final String EXCHANGE_NAME = "DirectLogs";
public static void main(String[] args) throws Exception {
// 获取到 信道
Channel channel = RabbitmqUtil.getChannel();
// 声明交换机
channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
// 声明一个队列
channel.queueDeclare("console",false,false,false,null);
channel.queueBind("console",EXCHANGE_NAME,"info");
channel.queueBind("console",EXCHANGE_NAME,"warning");
// 接收消息
DeliverCallback deliverCallback = (consumerTag,message) ->{
System.out.println("new String(message.getBody(),\"UTF-8\") = " + new String(message.getBody(),"UTF-8"));
};
// 消费者取消消息时回调接口
channel.basicConsume("cosole",true,deliverCallback,consumerTag ->{});
}
}
这个是 错误
public class Direct_1 {
// 交换机的名字
public static final String EXCHANGE_NAME = "DirectLogs";
public static void main(String[] args) throws Exception {
// 获取到 信道
Channel channel = RabbitmqUtil.getChannel();
// 声明交换机
channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
// 声明一个队列
channel.queueDeclare("disk",false,false,false,null);
channel.queueBind("disk",EXCHANGE_NAME,"error");
// 接收消息
DeliverCallback deliverCallback = (consumerTag,message) ->{
System.out.println("new String(message.getBody(),\"UTF-8\") = " + new String(message.getBody(),"UTF-8"));
};
// 消费者取消消息时回调接口
channel.basicConsume("disk",true,deliverCallback,consumerTag ->{});
}
}
在这里插入代码片
生产者
public class Demo {
// 交换机的名字
public static final String EXCHANGE_NAME = "DirectLogs";
public static void main(String[] args) throws Exception {
// 创建管道
Channel channel = RabbitmqUtil.getChannel();
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
String next = scanner.next();
channel.basicPublish(EXCHANGE_NAME,"error",null,next.getBytes());
System.out.println("next = " + next);
}
}
}
Topics
之前类型的问题
上面的交换机 改进了日志记录系统 没有使用只能进行随意广播的fanout 交换机,而是使用了direct 交换机,从而有能实现有选择地接收日志。
尽管使用direct 交换机改进了我们的系统,但是他仍然存在局限性 比方说我们想接收的日志类型有 info.base 和 info.advantage ,某个队列只想要 info.base 的消息 那这个时候direct 就办不到了。 这个时候这个就不能满足我们的要求了。
Topic 的要求
发送到类型是topic 交换机的消息 routing_key 不能随便写,必须满足一定的要求 它必须是一个单词列表 用逗号分隔开,这些单词可以是任意单词 不能超过 255 个字节
PS (星号) * 可以代替一个单词
# (井号)可以替代零个或多个单词
代码
消费者一
public class Topic01 {
// 交换机名字
public static final String EXCHANGE_NAME ="topic_logs";
// 开始接收消息
public static void main(String[] args) throws Exception {
// 创建链接的信道
Channel channel = RabbitmqUtil.getChannel();
// 声明交换机
channel.exchangeDeclare(EXCHANGE_NAME,"topic");
// 声明队列
String queueName = "TopicQ1";
channel.queueDeclare(queueName,false,false,false,null);
channel.queueBind(queueName,EXCHANGE_NAME,"*.orange.*");
System.out.println(" 等待接收消息");
// 函数式接口
DeliverCallback deliverCallback = (consumerTag,message) ->{
System.out.println(new String(message.getBody(),"Utf-8"));
System.out.println("接收队列: " + queueName );
};
// 接收消息
channel.basicConsume(queueName,true,deliverCallback,consumerTag ->{});
}
}
消费者二
public class Topic02 {
// 交换机名字
public static final String EXCHANGE_NAME ="topic_logs";
// 开始接收消息
public static void main(String[] args) throws Exception {
// 创建链接的信道
Channel channel = RabbitmqUtil.getChannel();
// 声明交换机
channel.exchangeDeclare(EXCHANGE_NAME,"topic");
// 声明队列
String queueName = "TopicQ2";
channel.queueDeclare(queueName,false,false,false,null);
channel.queueBind(queueName,EXCHANGE_NAME,"*.*.rabbit");
channel.queueBind(queueName,EXCHANGE_NAME,"lazy.#");
System.out.println(" 等待接收消息");
// 函数式接口
DeliverCallback deliverCallback = (consumerTag,message) ->{
System.out.println(new String(message.getBody(),"Utf-8"));
System.out.println("接收队列: " + queueName );
};
// 接收消息
channel.basicConsume(queueName,true,deliverCallback,consumerTag ->{});
}
}
生产者
public class Topic03 {
// 交换机名字
public static final String EXCHANGE_NAME ="topic_logs";
public static void main(String[] args) throws Exception {
// 创建信道
Channel channel = RabbitmqUtil.getChannel();
// 设置发送的消息
HashMap<String, String> map = new HashMap<>();
map.put("quick.orange.rabbit","被q1q2 接收到");
for (Map.Entry<String, String> entry : map.entrySet()) {
String key = entry.getKey();
String value = entry.getValue();
channel.basicPublish(EXCHANGE_NAME, key,null,value.getBytes("UTF-8"));
}
}
}
死信队列
概念
就是无法被消费的消息,字面意思就是 一般来说,producer 将消息投递broker 或者直接到queue 里了,consumer 从 queue 取出来消息进行消费 但某些时候由于特定的原因导致queue 中某些消息无法被消息,这样的消息如果没有后续的处理,就变成了死信,有死信自然就有了死信队列。
应该场景: 为了保证订单业务的消息数据不丢失,需要使用到 RABBITMQ 的死信队列机制,当消息消费发生异常时,将消息投入死信队列中 。比如说:用户在商场下单成功并点击去支付后在指定时间未支付时自动失效。
死信的来源
消息TTL 过期
队列达到最大长度(队列满了。无法在添加数据到mq 中)
消费被拒绝。
过期时间代码
public class dead01 {
// 创建普通的交换机名称
public static final String nomal_exchang ="NOMAL_EXCHANG";
// 创建死信的交换机名称
public static final String DEAD_EXCHANG ="DEAD_EXCHANG";
// 创建死信的队列名称
public static final String Nomal_queue ="NOMAL_QUEUE";
// 创建普通的队列名称
public static final String DEAD_queue ="DEAD_QUEUE";
public static void main(String[] args) throws Exception{
// 创建通道
Channel channel = RabbitmqUtil.getChannel();
// 声明死信和普通交换机 类型为 direct
channel.exchangeDeclare(nomal_exchang, BuiltinExchangeType.DIRECT);
channel.exchangeDeclare(DEAD_EXCHANG, BuiltinExchangeType.DIRECT);
// 声明普通队列
HashMap<String, Object> map = new HashMap<>();
// 正常队列设置死信交换机
// map.put("x-message-ttl",10000);
map.put("x-dead-letter-exchange",DEAD_EXCHANG);
map.put("x-dead-letter-routing-key","feng");
channel.queueDeclare(Nomal_queue,false,false,false,map);
channel.queueDeclare(DEAD_queue,false,false,false,null);
channel.queueBind(Nomal_queue,nomal_exchang,"jioajioa");
channel.queueBind(DEAD_queue,DEAD_EXCHANG,"feng");
System.out.println("等待接收消息");
DeliverCallback deliverCallback = (consumerTag,message) ->{
System.out.println(new String(message.getBody(),"utf-8"));
};
channel.basicConsume(Nomal_queue,true,deliverCallback,consumerTag ->{});
}
}
生产者
public class dead02 {
// 普通交换机名称
public static final String nomal_exchang ="nomal_exchang";
public static void main(String[] args) throws Exception {
Channel channel = RabbitmqUtil.getChannel();
AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("10000").build();
for (int i = 1; i < 11; i++) {
String message = "info" +i;
channel.basicPublish(nomal_exchang,"feng",properties,message.getBytes());
}
}
}
效果 当我们的消费者1 死掉的时候 这个时候数据就会到我们的死信队列中去
消费者2的代码
public class dead03 {
// 队列的名称
public static final String DEAD_queue ="DEAD_QUEUE";
public static void main(String[] args) throws Exception {
// 创建信道
Channel channel = RabbitmqUtil.getChannel();
System.out.println("channel = " + channel);
DeliverCallback deliverCallback = (consumerTag,message) ->{
System.out.println("message = " + new String(message.getBody(),"utf-8"));
};
channel.basicConsume(DEAD_queue,true,deliverCallback,consumerTag ->{});
}
}
最大长度代码
修改消费者1 的代码
三个参数
启动生产者 让普通的先假死一下
普通消费者拒绝的
由于我们发送的消息都是info+i i是数字
我们可以再消费者1 的代码里修改一下
延迟队列
概念
延迟队列,队列内部是有序的,最重要的特殊性就体现在它的延时属性上,延时队列中的元素是希望在指定时间到了以后或之前取出和处理,简单来说 延时队列就是用来存放需要在指定时间被处理的元素的队列
整合Springboot 来做延迟队列的代码
pom.xml
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger2 -->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.7.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger-ui -->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.7.0</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<!-- <scope>provided</scope>-->
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.20</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.54</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.rabbitmq/amqp-client -->
<!-- rabbitmq依赖 -->
<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>
<scope>test</scope>
</dependency>
</dependencies>
配置swagger
@Configuration
//加入Swagger 的注解 ,开启
@EnableSwagger2
public class Swaggerconfig {
// 配置Swagger 的 Docket 的bean 实例
@Bean
public Docket docket() {
return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo())
.select()
// RequestHandlerSelectors 配置要扫描接口的方式
// basePackage :指定要扫描的包
// any() :扫描全部
// none():不扫描
// withClassAnnotation //扫描类上的注解,参数市一个注解的反射对象
// withMethodAnnotation // 扫描方法上的注解
// 。paths()过滤什么路径
.apis(RequestHandlerSelectors.basePackage("com.jj.demo.Controller"))
.build()
;
}
// 配置Swagger 信息
private ApiInfo apiInfo() {
// 作者信息
Contact contact = new Contact("娇娇", "", "1782579163@qq.com");
return new ApiInfo(
"娇娇的Api 文档", "生而为人,务必善良", "1.0", "", contact, "", "", new ArrayList<>()
);
}
}
yml 文件
spring:
rabbitmq:
port: 5672
host: localhost
username: guest
password: guest
队列TTL
配置类的代码
public class TTLrABBIT {
// 创建交换机的名称
public static final String A_EXCHANGE ="A";
public static final String DEAD_EXCHANGE ="B";
// 创建队列
public static final String QUEUE_A="QA";
public static final String QUEUE_B="QB";
// 死信队列的名称
public static final String DEAD_LETTER_QUEUE ="QD";
@Bean("A_EXCHANGE")
public DirectExchange A_EXCHANGE () {
return new DirectExchange(A_EXCHANGE);
}
@Bean("DEAD_EXCHANGE")
public DirectExchange DEAD_EXCHANGE () {
return new DirectExchange(DEAD_EXCHANGE);
}
@Bean("QUEUE_A")
public Queue queuea () {
HashMap<String, Object> map = new HashMap<>(3);
map.put("x-dead-letter-exchange",DEAD_EXCHANGE);
map.put("x-dead-letter-routing-key","fengjiaojiao");
map.put("x-message-ttl",10000);
return QueueBuilder.durable(QUEUE_A).withArguments(map).build();
}
@Bean("QUEUE_B")
public Queue QUEUE_B () {
HashMap<String, Object> map = new HashMap<>(3);
map.put("x-dead-letter-exchange",DEAD_EXCHANGE);
map.put("x-dead-letter-routing-key","jiaojiao");
map.put("x-message-ttl",40000);
return QueueBuilder.durable(QUEUE_B).withArguments(map).build();
}
@Bean("DEAD_LETTER_QUEUE")
public Queue DEAD_LETTER_QUEUE () {
return QueueBuilder.durable(DEAD_LETTER_QUEUE).withArguments(null).build();
}
@Bean
public Binding QUEUE_A_A_EXCHANGE (@Qualifier("QUEUE_A") Queue queueA,@Qualifier("A_EXCHANGE") DirectExchange A_EXCHANGE) {
return BindingBuilder.bind(queueA).to(A_EXCHANGE).with("fengjiaojiao");
}
@Bean
public Binding QUEUE_B_B_EXCHANGE (@Qualifier("QUEUE_B") Queue queueB,@Qualifier("A_EXCHANGE") DirectExchange A_EXCHANGE) {
return BindingBuilder.bind(queueB).to(A_EXCHANGE).with("jiaojiao");
}
@Bean
public Binding DEAD_LETTER_QUEUE_D_EXCHANGE (@Qualifier("DEAD_LETTER_QUEUE") Queue DEAD_LETTER_QUEUE,@Qualifier("DEAD_EXCHANGE") DirectExchange DEAD_EXCHANGE) {
return BindingBuilder.bind(DEAD_LETTER_QUEUE).to(DEAD_EXCHANGE).with("D");
}
}
生产者代码
@RestController
@Slf4j
@RequestMapping("/ttl")
public class TTLController {
@Autowired
private RabbitTemplate rabbitTemplate;
@GetMapping ("/sendMsg/{message}")
public void sengMsg (@PathVariable String message) {
log.info("当前时间:{},发送一条消息:{}给两个TTL 队列 ",new Date().toString(),message);
System.out.println("message = " + message);
rabbitTemplate.convertAndSend("A","fengjiaojiao","来自10s 的队列"+message);
rabbitTemplate.convertAndSend("A","jiaojiao","来自10s 的队列"+message);
}
}
消费者代码
@Component
@Slf4j
public class DeadTTLConsumer {
// 接收消息
@RabbitListener(queues = "QD")
public void receiveD (Message message, Channel channel) throws Exception {
String msg = new String(message.getBody());
log.info("当前时间:{},收到死信队列的消息:{}",new Date().toString(),msg);
}
}