RabbitMQ实战教程(五)-路由模式

最新推荐文章于 2022-06-13 14:36:17 发布
最新推荐文章于 2022-06-13 14:36:17 发布
阅读量306 收藏 1
点赞数 1
分类专栏： RabbitMQ实战教程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37653556/article/details/82754104
版权

1. 路由模式

跟订阅模式类似,只不过在订阅模式的基础上加上路由,订阅模式是分发到所有绑定到该交换机的队列,路由模式只分发到绑定在该交换机上面指定的路由键队列.

2. Direct 直接交换机

直连交换机(Direct Exchange)是一种带路由功能的交换机,它将消息中的Routing Key与该交换机关联的所有Binding中的Routing Key进行比较,如果完全相等将消息发送到Binding对应的队列中 .

适用场景 : 根据任务的优先级把消息发送到对应的队列中,分配更多资源处理优先级高的队列.

生产者声明一个direct类型的交换机,然后发送消息到这个交换机指定路由键. 消费者指定消费交换机的路由键,即可以接到到消息,其他消费者接收不到 .

在Fanout交换机中

生产者 :

// 第二个参数就是路由键
channel.basicPublish(EXCHANE_NAME,"",null,message.getBytes());

消费者 :

// 第三个参数就是路由键
channel.queueBind(QUEUE,EXCAHNGE_NAME,"");

3. 代码演示

同样的,只是交换机类型改为driect,加了个路由键而已 .

这里演示3个,即表示一个日志事件,根据日志类型进行处理

3.1 工具类
package com.makesailing.neo.utils;

import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * # RabbitMQ连接工具类
 *
 * @Author: jamie.li
 * @Date: Created in  2018/9/16 14:38
 */
public class ConnectionUtils {

  public static final String host = "127.0.0.1";

  public static final Integer port = 5672;

  public static Connection getConnection() throws IOException, TimeoutException {
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost(host);
    connectionFactory.setPort(port);
    // 如果有 用户名 密码 vhost 配置即可
    connectionFactory.setUsername("jamie");
    connectionFactory.setPassword("123456");
    connectionFactory.setVirtualHost("/simple");
    return connectionFactory.newConnection();
  }
}
3.2 日志生产者
package com.makesailing.neo.provider;

import com.makesailing.neo.utils.ConnectionUtils;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * # 日志消息 提供者
 *
 * @Author: jamie.li
 * @Date: Created in  2018/9/16 22:41
 */
public class LogSend {

  private static final String EXCHANGE_NAME = "test_exchange_direct";

  private static final String INTO_ROUTING_NAME= "info";
  private static final String WARN_ROUTING_NAME= "warn";
  private static final String ERROR_ROUTING_NAME= "error";


  public static void main(String[] args) throws IOException, TimeoutException {
    // 创建连接
    Connection connection = ConnectionUtils.getConnection();
    // 获取信道
    Channel channel = connection.createChannel();
    // 声明一个direct 路由交换机
    channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);

    // 发送info路由键消息
    String infoMessage = "Hello RabbitMQ Info Log";
    channel.basicPublish(EXCHANGE_NAME, INTO_ROUTING_NAME, null, infoMessage.getBytes());
    System.out.println("  LogSend routing info message : '" + infoMessage + "'");
    // 发送warn路由键消息
    String warnMessage = "Hello RabbitMQ Warn Log";
    channel.basicPublish(EXCHANGE_NAME, WARN_ROUTING_NAME, null, warnMessage.getBytes());
    System.out.println("  LogSend routing warn message : '" + warnMessage + "'");
    // 发送info路由键消息
    String errorMessage = "Hello RabbitMQ Error Log";
    channel.basicPublish(EXCHANGE_NAME, ERROR_ROUTING_NAME, null, errorMessage.getBytes());
    System.out.println("  LogSend routing error message : '" + errorMessage + "'");

    channel.close();
    connection.close();
  }
}
3.3 error日志消费者
package com.makesailing.neo.consumer;

import com.makesailing.neo.utils.ConnectionUtils;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * # 错误日志 消费者
 *
 * @Author: jamie.li
 * @Date: Created in  2018/9/16 23:09
 */
public class ErrorReceive {
  private static final String EXCHANGE_NAME = "test_exchange_direct";
  // info日志队列
  private static final String QUEUE_NAME = "test_queue_routing_error";

  private static final String ERROR_ROUTING_NAME= "error";

  public static void main(String[] args) throws IOException, TimeoutException {
    // 获取连接
    Connection connection = ConnectionUtils.getConnection();

    // 打开通道
    Channel channel = connection.createChannel();

    // 申明要消费的队列
    channel.queueDeclare(QUEUE_NAME, false, false, false, null);

    // 绑定队列到交换机
    channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, ERROR_ROUTING_NAME);

    // 这样RabbitMQ就会使得每个Consumer在同一个时间点最多处理一个Message。换句话说，在接收到该Consumer的ack前，他它不会将新的Message分发给它。
    channel.basicQos(1);

    // 创建一个回调的消费者处理类
    Consumer consumer = new DefaultConsumer(channel) {
      @Override
      public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        // 接收到的消息
        String message = new String(body);
        System.out.println(" ErrorReceive '" + message + "' , 任务处理中");

        try {
          Thread.sleep(1000);
        } catch (InterruptedException e) {
          e.printStackTrace();
        } finally {
          System.out.println(" ErrorReceive done ");
          channel.basicAck(envelope.getDeliveryTag(), false);
        }
      }
    };

    // 消费消息
    channel.basicConsume(QUEUE_NAME, false, consumer);

  }
}
3.4 info日志消费者
package com.makesailing.neo.consumer;

import com.makesailing.neo.utils.ConnectionUtils;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * # info 日志消费者
 *
 * @Author: jamie.li
 * @Date: Created in  2018/9/16 23:02
 */
public class InfoReceive {

  private static final String EXCHANGE_NAME = "test_exchange_direct";
  // info日志队列
  private static final String QUEUE_NAME = "test_queue_routing_info";

  private static final String INTO_ROUTING_NAME= "info";

  public static void main(String[] args) throws IOException, TimeoutException {
    // 获取连接
    Connection connection = ConnectionUtils.getConnection();

    // 打开通道
    Channel channel = connection.createChannel();

    // 申明要消费的队列
    channel.queueDeclare(QUEUE_NAME, false, false, false, null);

    // 绑定队列到交换机
    channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, INTO_ROUTING_NAME);

    // 这样RabbitMQ就会使得每个Consumer在同一个时间点最多处理一个Message。换句话说，在接收到该Consumer的ack前，他它不会将新的Message分发给它。
    channel.basicQos(1);

    // 创建一个回调的消费者处理类
    Consumer consumer = new DefaultConsumer(channel) {
      @Override
      public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        // 接收到的消息
        String message = new String(body);
        System.out.println(" InfoReceive '" + message + "' , 任务处理中");

        try {
          Thread.sleep(1000);
        } catch (InterruptedException e) {
          e.printStackTrace();
        } finally {
          System.out.println(" InfoReceive done ");
          channel.basicAck(envelope.getDeliveryTag(), false);
        }
      }
    };

    // 消费消息
    channel.basicConsume(QUEUE_NAME, false, consumer);

  }
}
3.5 warn日志消费者
package com.makesailing.neo.consumer;

import com.makesailing.neo.utils.ConnectionUtils;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * # 警告日志 消费者
 *
 * @Author: jamie.li
 * @Date: Created in  2018/9/16 23:09
 */
public class WarnReceive {
  private static final String EXCHANGE_NAME = "test_exchange_direct";
  // info日志队列
  private static final String QUEUE_NAME = "test_queue_routing_warn";

  private static final String INTO_ROUTING_NAME= "info";
  private static final String WARN_ROUTING_NAME= "warn";
  private static final String ERROR_ROUTING_NAME= "error";


  public static void main(String[] args) throws IOException, TimeoutException {
    // 获取连接
    Connection connection = ConnectionUtils.getConnection();

    // 打开通道
    Channel channel = connection.createChannel();

    // 申明要消费的队列
    channel.queueDeclare(QUEUE_NAME, false, false, false, null);

    // 绑定队列到交换机
    channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, WARN_ROUTING_NAME);
    //channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, INTO_ROUTING_NAME);
    //channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, ERROR_ROUTING_NAME);

    // 这样RabbitMQ就会使得每个Consumer在同一个时间点最多处理一个Message。换句话说，在接收到该Consumer的ack前，他它不会将新的Message分发给它。
    channel.basicQos(1);

    // 创建一个回调的消费者处理类
    Consumer consumer = new DefaultConsumer(channel) {
      @Override
      public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        // 接收到的消息
        String message = new String(body);
        System.out.println("WarnReceive '" + message + "' , 任务处理中");

        try {
          Thread.sleep(1000);
        } catch (InterruptedException e) {
          e.printStackTrace();
        } finally {
          System.out.println(" WarnReceive done ");
          channel.basicAck(envelope.getDeliveryTag(), false);
        }
      }
    };

    // 消费消息
    channel.basicConsume(QUEUE_NAME, false, consumer);

  }
}

4. 测试

提前在RabbitMQ Management创建一个direct交换机，或者先执行一次生产者（执行时会判断交换机是否存在，不存在则创建交换机），这样保证交换机存在，不然直接启动消费者会提示交换机不存在。

注意点

如果在没有队列绑定在交换机上面时，往交换机发送消息会丢失，之后绑定在交换机上面的队列接收不到之前的消息，也就是先执行第一次发送，创建了交换机，但是还没有队列绑定在交换机上面，如果这次发送的消息就会丢失。

然后再启动3上消费者,最后在启动生产者.

运行结果 :

5. 多绑定情况

5.1 同一消费者绑定队列多个路由键
channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "info");
channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "error");
channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "warn");

在`warn消费者中队列绑定多个路由键 :

package com.makesailing.neo.consumer;

import com.makesailing.neo.utils.ConnectionUtils;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * # 警告日志 消费者
 *
 * @Author: jamie.li
 * @Date: Created in  2018/9/16 23:09
 */
public class WarnReceive {
  private static final String EXCHANGE_NAME = "test_exchange_direct";
  // info日志队列
  private static final String QUEUE_NAME = "test_queue_routing_warn";

  private static final String INTO_ROUTING_NAME= "info";
  private static final String WARN_ROUTING_NAME= "warn";
  private static final String ERROR_ROUTING_NAME= "error";


  public static void main(String[] args) throws IOException, TimeoutException {
    // 获取连接
    Connection connection = ConnectionUtils.getConnection();

    // 打开通道
    Channel channel = connection.createChannel();

    // 申明要消费的队列
    channel.queueDeclare(QUEUE_NAME, false, false, false, null);

    // 绑定队列到交换机
    channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, WARN_ROUTING_NAME);
    channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, INTO_ROUTING_NAME);
    channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, ERROR_ROUTING_NAME);

    // 这样RabbitMQ就会使得每个Consumer在同一个时间点最多处理一个Message。换句话说，在接收到该Consumer的ack前，他它不会将新的Message分发给它。
    channel.basicQos(1);

    // 创建一个回调的消费者处理类
    Consumer consumer = new DefaultConsumer(channel) {
      @Override
      public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        // 接收到的消息
        String message = new String(body);
        System.out.println("WarnReceive '" + message + "' , 任务处理中");

        try {
          Thread.sleep(1000);
        } catch (InterruptedException e) {
          e.printStackTrace();
        } finally {
          System.out.println(" WarnReceive done ");
          channel.basicAck(envelope.getDeliveryTag(), false);
        }
      }
    };

    // 消费消息
    channel.basicConsume(QUEUE_NAME, false, consumer);

  }
}

运行结果:

如果一个消费者绑定了这3个路由键,那么当生产者发送其中一个路由键消息时,该消费者都能接收到消息.

5.2 多个消费者绑定相同的路由键

即消费者1绑定info,消费者2绑定 info、error .

那么生产者发送info路由键消息时,消费者1 、2都能接收到消息,发送error路由键消息时,只有消费者2能接收到消息.

makesailing
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
rabbitMq实战
02-27
RabbiMQ消息队列的介绍和在各个场景下的使用
RibbitMQ入门实战详解
翰萨姆的博客
09-17 729
RabbitMQ 实战教程 MQ(Message Queue)=消息队列，消息中间件,是一种理念（规范）RabbitMQ其中的一个具体产品 1.MQ引言 1.1 什么是MQ MQ(Message Quene) : 翻译为 消息队列,通过典型的 生产者和消费者模型,生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入,轻松的实现系统间解耦。别名为 消息中间件 通过利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数
RabbitMQ-Routing路由模式-Java代码
zpf1813763637的博客
11-08 446
Routing路由模式： 上图中各个模块的名称和作用： 1. P：生产者，向Exchange发送消息，发送消息时，会指定一个routing key。 2. X：Exchange（交换机），接收生产者的消息，然后把消息递交给 与routing key完全匹配的队列 3. C1：消费者，其所在队列指定了需要routing key 为 error 的消息 4. C2：消费者，其所在队列指定了需要routing key 为 info、error、warning 的消息 路由模式特点： 1. 队列与交换机的绑定，不
RabbitMQ实战教程
weixin_45976114的博客
04-06 304
RabbitMQ实战教程1.MQ引言1.1.什么是MQ1.2 MQ有哪些1.3 不同MQ特点2 RabbitMQ 的引言2.1 RabbitMQ2.2 RabbitMQ 的安装2.2.1 下载2.2.2 下载安装包2.2.3 安装步骤3 RabiitMQ 配置3.1 RabbitMQ 管理命令行3.2 web管理界面介绍3.2.1 overview概览3.2.2 Admin用户和虚拟主机管理3.2.2.1 添加用户3.2.2.2 创建虚拟主机3.2.2.3 绑定虚拟主机和用户 1.MQ引言 1.1.什么是M
rabbitmq实战-rabbitmq-action.zip
11-06
rabbitmq实战-rabbitmq-action
rabbitMQ实战java版-rabbitMQ-demo.zip
11-07
rabbitMQ实战java版-rabbitMQ-demo
动力RabbitMQ实战视频教程-视频课程资源网盘链接提取码下载 .txt
最新发布
02-29
本视频教程将从零开始，全方位介绍RabbitMQ消息队列的应用。学员将学习如何配置、部署RabbitMQ，以及如何在不同编程语言中集成RabbitMQ。课程还将深入探讨消息队列的高级特性和最佳实践，帮助学员在实际项目中灵活...
RabbitMQ入门-实战-RabbitMQ.zip
11-07
RabbitMQ入门-实战-RabbitMQ
rabbitmq-server-3.10.5-1.el8.noarch.rpm
07-01
rabbitmq-server-3.10.5-1.el8.noarch.rpm
RabbitMQ 实战教程（一） Hello World
咖啡的博客
03-20 386
准备 本教程假定 RabbitMQ 已在标准端口（5672） 的 localhost 上安装并运行。如果使用不同的主机，端口或凭据，连接设置将需要调整。 介绍 RabbitMQ 是一个消息代理：它接受并转发消息。你可以将其视为邮局：当你将要发布的邮件放在邮箱中时，您可以确信 Postman 先生最终会将邮件发送给收件人。在这个比喻中，RabbitMQ 是一个邮箱，邮局和邮递员。 Rabbi...
RabbitMQ详细实战教程
ZhAoYaJ的博客
06-13 733
RabbitMQ详细实战教程 CSDN创作 C位 CSDN创作 C位
RabbitMQ路由模式（direct）
诚的博客
11-09 5338
1、什么是路由模式（direct） 　　路由模式是在使用交换机的同时，生产者指定路由发送数据，消费者绑定路由接受数据。与发布/订阅模式不同的是，发布/订阅模式只要是绑定了交换机的队列都会收到生产者向交换机推送过来的数据。而路由模式下加了一个路由设置，生产者向交换机发送数据时，会声明发送给交换机下的那个路由，并且只有当消费者的队列绑定了交换机并且声明了路由，才会收到数据。下图取自于官方网站（RabbitMQ）的路由模式的图例 P：消息的生产者 X：交换机 红色：队列 C1，C2：消息消费者 e
RabbitMq------路由模式
weixin_46685039的博客
01-17 1507
生产者按routing key发送消息，不同的消费者端按不同的routing key接收消息。 路由模式消费者端和发布订阅模式消费者端的区别： 1、exchange的type为direct 2、发送消息的时候加入了routing key
RabbitMq 路由模式（Routing）
鹏举的博客
08-24 1777
RabbitMq 路由模式介绍 路由模式主要是在发布订阅模式的前提上增加了一个routingKey，这样就可以给队列绑定一个rotingKey发消息指定routingKey给指定的队列发送消息，这样就只有单独的消费者消费消息了 DirectProducer编写 Routing模式主要是使用的direct交换机 public class DirectProducer { public static void main(String[] args) throws Exception{
RabbitMQ之路由模式
谁对谁错重要吗的博客
06-05 413
RabbitMQ之路由模式简介 生产者发送消息的时候，绑定一个key 消费者在接受消息的时候，也绑定一个key，两个key相同，那么就可以获取到 生产者发送的消息 Routing Key：路由关键字，exchange根据这个关键字进行消息投递。 exchange接收到消息后，就根据消息的key和已经设置的binding，进行消息路由，将消息投递到一个或多个队列里。 代码参考 生...
rabbitmq --list-vhost
06-06
这个命令用于列出 RabbitMQ 中所有的虚拟主机。虚拟主机是 RabbitMQ 的一个重要概念，它可以帮助我们在一个 RabbitMQ 服务器中运行多个独立的消息代理。使用该命令需要先安装 RabbitMQ，并且在命令行中运行 `...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值