03 RabbitMQ的路由模式和topic模式

最新推荐文章于 2024-08-02 06:30:00 发布
最新推荐文章于 2024-08-02 06:30:00 发布
阅读量1.9k 收藏 1
点赞数 1
分类专栏： rabbitMQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wyaoyao93/article/details/111772510
版权

文章目录

1 Rabbit中完整的消息传递模型

RabbitMQ消息传递模型中的核心思想是生产者从不将任何消息直接发送到队列。生产者经常甚至根本不知道是否将消息传递到任何队列。

生产者只能将消息发送到交换机。交换机，一方面，它接收来自生产者的消息，另一方面，将它们推入队列。
消息传递模型

交换机必须知道如何处理收到的消息，是否应将其附加到特定队列？是否应该将其附加到许多队列中？还是应该丢弃它。规则由交换类型定义 。

  1. 每个队列都要绑定到交换机
  2. 生产者发送消息，只能发给交换机，由交换机来决定要发给哪个队列
  3. 交换机把消息根据一定的规则路由到需要的队列中
  4. 交换机把消息分发给队列

1.1 交换机的类型

  • direct
  • topic
  • headers
  • fanout

在这里插入图片描述
在前面部分中，我们对交换一无所知，但仍然能够将消息发送到队列。这是可能的，因为我们使用的是默认交换，我们通过空字符串（“”）进行标识：

channel.basicPublish（“”，“ routingKey”，null，message.getBytes（））;

第一个参数是交换的名称。空字符串表示默认或无名称交换：消息将以routingKey指定的名称路由到队列（如果存在）

2 fanout（广播）

2.1 介绍

扇出，也就是广播。
在这里插入图片描述

消息的流程如下：

  1. 可以有多个消费者
  2. 每个消费者有自己的队列
  3. 每个队列都要绑定到交换机
  4. 生产者发送消息，只能发给交换机
  5. 交换机把消息发送给绑定的所有队列
  6. 队列的消费者都能拿到消息，实现一条消息被多个消费者消费（这就是广播）

2.2 API介绍

  1. 如何将通道（Channel）和交换机建立关系
// 声明交换机
// 参数一：交换机的名称，rabbitMq如果不存在，会自动创建
// 参数二：交换机的类型，这里就是fanout
channel.exchangeDeclare("fanout_demo","fanout");
  1. 发送消息的时候指定交换机
// 发送消息，此时就是把消息投递给了交换机
// 参数一：交换机的名称
// 参数二：路由key，在广播模式下，路由key是没有意义的，因为广播，要把消息投递给所有的队列，才能实现广播不是
// 参数三：传递消息的额外设置
// 参数四：消息体
channel.basicPublish("fanout_demo","",null,message.getBytes(Charset.defaultCharset()));

之前两种没有交换机参与的模式，路由key就是队列的名称，因为直接和队列沟通的
而这里需要交换机根据key将消息路由到不同的队列。

  1. 临时队列

    • 无论何时连接到Rabbit，我们都需要一个全新的空队列。为此，我们可以创建一个具有随机名称的队列，或者甚至更好-让服务器为我们选择一个随机队列名称。

    • 其次，一旦我们断开了使用者的连接，队列将被自动删除。

不向queueDeclare（）提供任何参数时，将 使用生成的名称创建一个非持久的，排他的，自动删除的队列：

// 8 创建一个临时队列, 返回队列的名字
 String queueName = channel.queueDeclare().getQueue();
  1. 消费消息的时候将队列和交换机绑定，由于广播的时候没有设置路由key，交换机会把消息投递给所有的队列，消费者消费的时候需要从队列中获取，就需要知道是个哪个交换机的队列
// 参数一：队列的名字
// 参数二：交换机的名字
// 参数三：路由的key
channel.queueBind(queueName,"fanout_demo","");

2.3 代码示例

  1. 新建一个model：03-rabbitmq-fanout
  2. 导入依赖
<dependencies>
     <!--rabbitmq客户端-->
     <dependency>
         <groupId>com.rabbitmq</groupId>
         <artifactId>amqp-client</artifactId>
         <version>5.10.0</version>
     </dependency>
     <dependency>
         <groupId>org.projectlombok</groupId>
         <artifactId>lombok</artifactId>
         <version>1.18.16</version>
     </dependency>
     <dependency>
         <groupId>org.slf4j</groupId>
         <artifactId>slf4j-api</artifactId>
         <version>1.7.30</version>
     </dependency>
     <dependency>
         <groupId>ch.qos.logback</groupId>
         <artifactId>logback-classic</artifactId>
         <version>1.2.3</version>
     </dependency>
     <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>4.13.1</version>
         <scope>test</scope>
     </dependency>
 </dependencies>
2.3.1 生产者
  1. 生产者
package study.wyy.mq.rabbit.fanout.producer;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.nio.charset.Charset;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.TimeoutException;

/**
 * @author by wyaoyao
 * @Description: 生产者
 * @Date 2020/12/27 9:45 上午
 */
public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 1 构建连接对象
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2 设置mq的主机地址
        connectionFactory.setHost("localhost");
        // 3 设置端口号
        connectionFactory.setPort(5672);
        // 4 设置要连接的虚拟主机
        connectionFactory.setVirtualHost("/rabbit_study");
        // 5 设置用户名和密码
        connectionFactory.setUsername("wyy");
        connectionFactory.setPassword("wyy123");
        // 6 创建连接对象
        Connection connection = connectionFactory.newConnection();
        // 7 创建连接中的chanel
        Channel channel = connection.createChannel();
        // 8 声明交换机
        // 参数一：交换机的名称，rabbitMq如果不存在，会自动创建
        // 参数二：交换机的类型，这里就是fanout
        channel.exchangeDeclare("fanout_demo","fanout");

        // 9 发送消息，此时就是把消息投递给了交换机
        // 参数一：交换机的名称
        // 参数二：路由key，在广播模式下，路由key是没有意义的，因为广播，要把消息投递给所有的队列，才能实现广播不是
        // 参数三：传递消息的额外设置
        // 参数四：消息体
        String format = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss"));
        String message = "一条广播消息 " + format;
        channel.basicPublish("fanout_demo","",null,message.getBytes(Charset.defaultCharset()));
        channel.close();
     	connection.close();
    }
    
}
2.3.4 消费者
  1. 消费者
    Consumer1
package study.wyy.mq.rabbit.fanout.consumer;

import com.rabbitmq.client.*;
import lombok.extern.slf4j.Slf4j;
import sun.jvm.hotspot.debugger.win32.coff.COFFLineNumber;

import java.io.IOException;
import java.nio.charset.Charset;
import java.util.concurrent.TimeoutException;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/27 11:05 上午
 */
@Slf4j
public class Consumer1 {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 1 链接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2 设置mq的地址
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        // 3 设置连接的虚拟主机
        connectionFactory.setVirtualHost("/rabbit_study");
        // 4 设置用户名和密码
        connectionFactory.setUsername("wyy");
        connectionFactory.setPassword("wyy123");
        // 5 获取连接对象
        Connection connection = connectionFactory.newConnection();
        // 6 获取channel
        Channel channel = connection.createChannel();

        // 7 绑定刚刚的交换机
        channel.exchangeDeclare("fanout_demo","fanout");

        // 8 创建一个临时队列, 返回队列的名字, 当然也可以不使用临时队列，想之前一样生命一个队列
        String queueName = channel.queueDeclare().getQueue();

        // 9 绑定交换机和队列
        // 参数一：队列的名字
        // 参数二：交换机的名字
        // 参数三：路由的key
        channel.queueBind(queueName,"fanout_demo","");

        // 消费消息
        // 参数一：队列的名字
        // 参数二：是否开启自动化确认
        // 参数三：回调接口
        channel.basicConsume(queueName,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                log.info("消费者1：{}",new String(body, Charset.defaultCharset()));
            }
        });
    }
}

Consumer2:

package study.wyy.mq.rabbit.fanout.consumer;

import com.rabbitmq.client.*;
import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.nio.charset.Charset;
import java.util.concurrent.TimeoutException;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/27 11:05 上午
 */
@Slf4j
public class Consumer2 {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 1 链接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2 设置mq的地址
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        // 3 设置连接的虚拟主机
        connectionFactory.setVirtualHost("/rabbit_study");
        // 4 设置用户名和密码
        connectionFactory.setUsername("wyy");
        connectionFactory.setPassword("wyy123");
        // 5 获取连接对象
        Connection connection = connectionFactory.newConnection();
        // 6 获取channel
        Channel channel = connection.createChannel();

        // 7 绑定刚刚的交换机
        channel.exchangeDeclare("fanout_demo","fanout");

        // 8 声明一个队列
        // 参数一：队列的名称
        // 参数二：是否持久化
        // 参数三：是否独占
        // 参数四：是否在消费完成后自动删除队列
        AMQP.Queue.DeclareOk fanout_queue = channel.queueDeclare("fanout_queue", false, false, true, null);

        // 9 绑定交换机和队列
        // 参数一：队列的名字
        // 参数二：交换机的名字
        // 参数三：路由的key
        channel.queueBind(fanout_queue.getQueue(),"fanout_demo","");

        // 消费消息
        // 参数一：队列的名字
        // 参数二：是否开启自动化确认
        // 参数三：回调接口
        channel.basicConsume(fanout_queue.getQueue(),true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                log.info("消费者2：{}",new String(body, Charset.defaultCharset()));
            }
        });
    }
}
  1. 测试
11:21:13.060 [pool-1-thread-4] INFO study.wyy.mq.rabbit.fanout.consumer.Consumer1 - 消费者1：一条广播消息 2020-12-27 11:21:13

11:21:13.052 [pool-1-thread-4] INFO study.wyy.mq.rabbit.fanout.consumer.Consumer2 - 消费者2：一条广播消息 2020-12-27 11:21:13

两个消费者都收到了消息

3 路由

3.1 介绍

在Fanout模式中，一条消息会被所有订阅的队列都消费。但是，某些情况下，希望不同的消息被不同的队列消费，这时就要用到Direct类型的Exchange（交换机）

在Direct模型下：

  • 队列与交换机绑定，不能是任意绑定了，而是要指定一个RouteKey（路由key）
  • 消息的发送方在向交换机发送消息的时候，必须指定RouteKey（路由key）
  • 交换机不再把消息交给每个绑定的队列，而是根据消息的路由key进行判断，只有队列的RouteKey（路由key）和消息的RouteKey（路由key）完全一致，才会接受到消息。

在这里插入图片描述
上图中的orange，black，green就是不同的路由key

3.2 代码演示

新建一个model：04-rabbitmq-route

<dependencies>
        <!--rabbitmq客户端-->
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.10.0</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.30</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
3.2.1 生产者
package study.wyy.mq.rabbit.route.producer;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.nio.charset.Charset;
import java.util.concurrent.TimeoutException;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/27 2:35 下午
 */
public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 1 连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2 设置mq地址
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        // 3 设置要连接的虚拟主机
        connectionFactory.setVirtualHost("/rabbit_study");
        // 4 设置账户
        connectionFactory.setUsername("wyy");
        connectionFactory.setPassword("wyy123");
        // 5 获取连接
        Connection connection = connectionFactory.newConnection();
        // 6 创建连接中的通道
        Channel channel = connection.createChannel();

        // 7 通过channel声明交换机
        // 参数一：交换机名称
        // 参数二：交换机类型
        String exchangeName = "direct_demo";
        channel.exchangeDeclare(exchangeName,"direct");

        // 8 发送消息
        // 参数一：交换机的名称
        // 参数二：路由key：
        // 参数三：传递消息的的其他配置，比如是否持久化消息
        // 参数四：消息体
        // 这里就发三条消息
        channel.basicPublish(exchangeName,"orange",null,"current color is orange".getBytes(Charset.defaultCharset()));
        channel.basicPublish(exchangeName,"green",null,"current color is green".getBytes(Charset.defaultCharset()));
        channel.basicPublish(exchangeName,"black",null,"current color is black".getBytes(Charset.defaultCharset()));

        // 关闭资源
        channel.close();
        connection.close();

    }
}
3.2.2 消费者
  1. 消费者，只消费路由key是orange的消息
package study.wyy.mq.rabbit.route.consumer;

import com.rabbitmq.client.*;
import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.nio.charset.Charset;
import java.util.concurrent.TimeoutException;

/**
 * @author by wyaoyao
 * @Description: 消费者，只消费路由key是orange的消息
 * @Date 2020/12/27 2:47 下午
 */
@Slf4j
public class Consumer1 {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 1 连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2 设置mq地址
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        // 3 设置要连接的虚拟主机
        connectionFactory.setVirtualHost("/rabbit_study");
        // 4 设置用户名和密码
        connectionFactory.setUsername("wyy");
        connectionFactory.setPassword("wyy123");
        // 5 获取连接
        Connection connection = connectionFactory.newConnection();
        // 6 创建通道
        Channel channel = connection.createChannel();

        String exchangeName = "direct_demo";
        // 7 通过通道声明交换机
        // 参数一：交换机的名称   参数二：交换机的类型
        channel.exchangeDeclare(exchangeName,"direct");

        // 8 创建一个临时队列
        String queue = channel.queueDeclare().getQueue();
        // 9 基于路由key，绑定交换机和队列
        channel.queueBind(queue,exchangeName,"orange");

        // 10 消费消息
        // 参数一：队列的名字
        // 参数二：是否自动确认
        // 参数三：回调函数
        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                log.info("消费者1 -> {}", new String(body, Charset.defaultCharset()));
            }
        });

    }
}
  1. 消费者，只消费路由key是green和black的消息
package study.wyy.mq.rabbit.route.consumer;

import com.rabbitmq.client.*;
import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.nio.charset.Charset;
import java.util.concurrent.TimeoutException;

/**
 * @author by wyaoyao
 * @Description: 消费者，只消费路由key是green和black的消息
 * @Date 2020/12/27 2:47 下午
 */
@Slf4j
public class Consumer2 {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 1 连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2 设置mq地址
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        // 3 设置要连接的虚拟主机
        connectionFactory.setVirtualHost("/rabbit_study");
        // 4 设置用户名和密码
        connectionFactory.setUsername("wyy");
        connectionFactory.setPassword("wyy123");
        // 5 获取连接
        Connection connection = connectionFactory.newConnection();
        // 6 创建通道
        Channel channel = connection.createChannel();

        String exchangeName = "direct_demo";
        // 7 通过通道声明交换机
        // 参数一：交换机的名称   参数二：交换机的类型
        channel.exchangeDeclare(exchangeName,"direct");

        // 8 创建一个临时队列
        String queue = channel.queueDeclare().getQueue();
        // 9 基于路由key，绑定交换机和队列，将路由是green和black绑定到这个队列中
        channel.queueBind(queue,exchangeName,"green");
        channel.queueBind(queue,exchangeName,"black");


        // 10 消费消息
        // 参数一：队列的名字
        // 参数二：是否自动确认
        // 参数三：回调函数
        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                log.info("消费者2 -> {}", new String(body, Charset.defaultCharset()));
            }
        });

    }
}
  1. 测试
    启动消费者和生产者
15:00:48.345 [pool-1-thread-4] INFO study.wyy.mq.rabbit.route.consumer.Consumer1 - 消费者1 -> current color is orange

15:00:48.345 [pool-1-thread-4] INFO study.wyy.mq.rabbit.route.consumer.Consumer2 - 消费者2 -> current color is green
15:00:48.349 [pool-1-thread-4] INFO study.wyy.mq.rabbit.route.consumer.Consumer2 - 消费者2 -> current color is black

可见消费者1只消费了消费路由orange的消息
消费者2只消费了消费路由key是green和black的消息

4 Topic类型的交换机

4.1 介绍

可以使用占位符，动态配置路由key，实现动态路由

在这里插入图片描述
Topic类型的交换机和Direct类型相比，都是可以根据routeKey把消息路由到不同的消息队列，只不过topic类型的交换机可以让队列绑定routeKey的时候使用通配符。一般是由一个或者多个单词组成的，多个单词之前使用.分割，例如：user.save

  • *可以代替一个单词。
  • ＃可以替代零个或多个单词。

4.2 代码案例

生产者
package study.wyy.mq.rabbit.topic.producer;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.nio.charset.Charset;
import java.util.concurrent.TimeoutException;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/27 3:56 下午
 */
@Slf4j
public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 1 连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2 设置mq地址
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        // 3 设置虚拟主机
        connectionFactory.setVirtualHost("/rabbit_study");
        // 4 设置用户
        connectionFactory.setUsername("wyy");
        connectionFactory.setPassword("wyy123");
        // 5 获取连接
        Connection connection = connectionFactory.newConnection();
        // 6 创建通道
        Channel channel = connection.createChannel();

        // 7 声明交换机
        // 参数一：交换机的名字
        // 参数二：交换机的类型
        channel.exchangeDeclare("topic_demo","topic");
        // 8 发送消息
        // 参数一交换机的名字
        // 参数二： 路由key
        // 参数三：额外设置，比如是否持久化数据
        // 参数四：消息体
        String routeKey1 = "user.*";
        channel.basicPublish("topic_demo",routeKey1,null,"user is save".getBytes(Charset.defaultCharset()));
        channel.basicPublish("topic_demo",routeKey1,null,"user is update".getBytes(Charset.defaultCharset()));
        // 再发两条信息，使用的是routeKey2
        String routeKey2 = "item.*";
        channel.basicPublish("topic_demo",routeKey2,null,"item is save".getBytes(Charset.defaultCharset()));
        channel.basicPublish("topic_demo",routeKey2,null,"item is update".getBytes(Charset.defaultCharset()));
        // 9 关闭资源
        channel.close();
        connection.close();

    }
}
消费者
package study.wyy.mq.rabbit.topic.consumer;

import com.rabbitmq.client.*;
import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.nio.charset.Charset;
import java.util.concurrent.TimeoutException;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/27 4:06 下午
 */
@Slf4j
public class ItemConsumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 1 链接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2 设置mq地址
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        // 3 设置虚拟主机
        connectionFactory.setVirtualHost("/rabbit_study");
        // 4 设置用户名和密码
        connectionFactory.setUsername("wyy");
        connectionFactory.setPassword("wyy123");
        // 5 获取连接
        Connection connection = connectionFactory.newConnection();
        // 6 获取通道
        Channel channel = connection.createChannel();
        // 7 声明交换机
        channel.exchangeDeclare("topic_demo","topic");
        // 8 创建队列
        String queue = channel.queueDeclare().getQueue();
        // 9 绑定队列和交换机
        // 参数一：队列名称
        // 参数二：交换机名称
        // 参数三：路由key
        channel.queueBind(queue,"topic_demo","item.*");
        // 8 消费消息
        // 参数一：队列名称
        // 参数二：是否自动确认
        // 参数三：回调接口
        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                log.info("itemConsumer -> {}",new String(body, Charset.defaultCharset()));
            }
        });
    }
}


package study.wyy.mq.rabbit.topic.consumer;

import com.rabbitmq.client.*;
import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.nio.charset.Charset;
import java.util.concurrent.TimeoutException;

/**
 * @author by wyaoyao
 * @Description
 * @Date 2020/12/27 4:06 下午
 */
@Slf4j
public class UserConsumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        // 1 链接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2 设置mq地址
        connectionFactory.setHost("localhost");
        connectionFactory.setPort(5672);
        // 3 设置虚拟主机
        connectionFactory.setVirtualHost("/rabbit_study");
        // 4 设置用户名和密码
        connectionFactory.setUsername("wyy");
        connectionFactory.setPassword("wyy123");
        // 5 获取连接
        Connection connection = connectionFactory.newConnection();
        // 6 获取通道
        Channel channel = connection.createChannel();
        // 7 声明交换机
        channel.exchangeDeclare("topic_demo","topic");
        // 8 创建队列
        String queue = channel.queueDeclare().getQueue();
        // 9 绑定队列和交换机
        // 参数一：队列名称
        // 参数二：交换机名称
        // 参数三：路由key
        channel.queueBind(queue,"topic_demo","user.*");
        // 8 消费消息
        // 参数一：队列名称
        // 参数二：是否自动确认
        // 参数三：回调接口
        channel.basicConsume(queue,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                log.info("userConsumer -> {}",new String(body, Charset.defaultCharset()));
            }
        });
    }
}

测试结果

16:47:12.250 [pool-1-thread-4] INFO study.wyy.mq.rabbit.topic.consumer.ItemConsumer - itemConsumer -> item is save
16:47:12.265 [pool-1-thread-4] INFO study.wyy.mq.rabbit.topic.consumer.ItemConsumer - itemConsumer -> item is update

16:47:12.259 [pool-1-thread-4] INFO study.wyy.mq.rabbit.topic.consumer.UserConsumer - userConsumer -> user is save
16:47:12.267 [pool-1-thread-5] INFO study.wyy.mq.rabbit.topic.consumer.UserConsumer - userConsumer -> user is update

路由key为user.* 被UserConsumer监听到消费了
路由key为item.* 被ItemConsumer监听到消费了

wyaoyao93
关注
专栏目录
【RabbitMQ之路由类型Topic】
代号_巧克力
07-29 384
Topic Exchange–将路由键和topic进行匹配。此时队列需要绑定要一个topic上。 任何发送到Topic Exchange的消息都会被转发到所有关心RouteKey中指定topic的Queue上 1、这种模式较为复杂，简单来说，就是每个队列都有其关心的topic，所有的消息都带有一个“标题”(RouteKey)，Exchange会将消息转发到所有关注主题能与RouteKey模糊匹配的队列。 2、这种模式需要RouteKey，也许要提前绑定Exchange与Queue。 3、...
rabbitMQ主题模式(topic)发送消息Demo
songling515010475的专栏
08-01 2110
主题模式是根据路由键去模糊匹配队列，把该队列的消息接收过来，也就是说该消费者可以同时接收多个队列 1、在这里准备两个maven工程分别如下： rqbbitmq-topic-consumer rqbbitmq-topic-provider 2、配置pom.xml <dependency> <groupId>org.springframework.boot</...
RabbitMQ 的路由模式 Topic模式
weixin_34077371的博客
12-05 289
模型 生产者 1 package cn.wh; 2 3 import java.io.IOException; 4 import java.util.concurrent.TimeoutException; 5 6 import cn.util.RabbitMqConnectionUtil; 7 8 import com.rabbitmq.clien...
【RabbitMQ】路由模式（Routing）
最新发布
wosixiaokeai的博客
08-02 423
路由模式适用于需要根据不同的消息属性将消息路由到不同队列的场景，例如：
rabbitmq--topic主题路由模型
jasnet_u的博客
11-18 785
上一篇，我们介绍了直接路由模型，这一篇我们介绍下主题路由模型。 就如同上一篇所说，直接路由模型和主题路由模型非常相似，它们唯一区别在于：直接路由模型对于路由key是精确匹配的，而主题路由模型对于路由key是模糊匹配的(使用通配符 )。 因此当我们了解上一篇中的直接路由模型，也不难理解本篇中的主题路由模型了。如图： 那么topic中的路由key的匹配规则是什么呢？  topic模式中路由...
rabbitMQ第五种模型 --topic动态路由
佐岸的博客
04-10 1105
动态路由就是我们可以通过一定匹配规则来绑定交换机与通道 *表示一个单词 #表示一个或者多个单词 生产者 package com.zuoan.topics; import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; import com.zuoan.utils.RabbitMQUtils; import java.io.IOException; /** * @Description: TODO * @Aut.
RabbitMQ学习系列（五）：routing路由模式和Topic主题模式
Java鱼仔的博客
02-24 3717
（一）routing路由模式 在前面一篇博客中讲到了exchange的类型，其中direct类型的exchange就是用于routing路由模式。direct类型的交换机是指：交换机和队列绑定时会设置路由键（routingkey），当消息从生产者发送给交换机时也会发送一个路由键。只有当这两个路由键相同时，交换机才会把消息发送给队列。 如上图所示，当生产者发送消息的路由键为error时，两个...
Spring Boot整合RabbitMQ实例（Topic模式）
08-30
Topic Exchange 模式是一种基于通配符的消息路由机制，通过定义路由模式和路由键，可以实现灵活的消息路由。 1. Topic Exchange 简介 Topic Exchange 是一种特殊的交换器，它可以根据通配符来路由消息。在这种...
rabbitmq五种工作模式
huapro.vip的程序人生
03-05 3164
1、简单模式 在这里插入图片描述 1个生产者将消息交给默认的交换机(AMQP default) 2 交换机获取消息后交给绑定这个生产者的队列(关系是通过队列名称完成) 3 监听当前队列的消费者获取消息,执行消费逻辑 应用场景:短信,聊天 2、工作模式(资源争抢) 1 生产者将消息交个交换机 2 交换机交给绑定的队列 3 队列由多个消费者同时监听,只有其中一个能够获取这一条消息,形成了资源的争抢,谁的资源空闲大,争抢到的可能越大; 应用场景:抢红包,大型系统的资源调度 3 发布订阅(publish/fanou
springboot整合RabbitMQ（五）：topic模式（动态路由模式）
Garry
10-28 1136
1、生产者代码 package com.zjl; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.amqp.rabbit.core.RabbitTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.Sprin.
springboot整合rabbitMq实践操作（包括简单模式、工厂队列模式、发布订阅模式、路由模式、topic模式的使用）
07-27
springboot整合rabbit实践操作（包括简单模式、工厂队列模式、发布订阅模式、路由模式、topic模式的使用）
RabbitMQ中topic模式下设置的routingKey范围不生效的问题
这就是快乐嘛
07-08 3632
出现这个问题是因为多次在代码里改变了routingkey的范围，每次更改都会在RabbitMQ中添加范围，但代码修改后，该范围仍然存在。例如channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "routekey.*");运行后RabbitMQ会绑定这个routingkey，当修改代码为channel.queueBind(QUEUE_NAME, EXCHANGE...
rabbitMq中使用topic进行消息传递时，设置routingkey失效问题
m0_67391518的博客
04-22 2392
消息提供者发送消息时会携带routingKey。 消息消费者接收消息时会接收事前设置好的routingkey进行接收。 发送消息： String routingKey="test"+".test22"+".test3"; rabbitTemplate.convertAndSend(TopicCallbackConfig.EXCHANGE,routingKey, message, correlationData); 接收消息设置绑定的routingkey： @Bean
JMS(RabbitMQ)的进阶三：Topic（routerkey匹配模式)处理
rocklee的专栏
01-10 1449
   发送方routerkey在bind routerkey的时候传入的是表达式，包含通配符(包含*/#)，发送的时候则需要明确指出routerkey（不能含*/#)； 接收方则需要包含通配符(*/#)。 1、定义常量 public final static String SMS_EXCHANGE_TOPIC ="sms-exchange-topic"; public final static String SMS_QUEUE_TOPIC ="sms-queue-topic"; public fina
RabbitMQ 探究（五、topic 路由匹配队列）
会飞的小蜗
08-30 406
生产者： package rabbitMq.topic; import Utils.RabbitMqUtil; import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; import java.io.IOException; import java.util.concurrent.TimeoutException; //生产者 public class TestRabbitMqP { public s.
RabbitMQ工作模式之Topics
03-18 266
RabbitMQ有以下几种工作模式 ：    1、Work queues    2、Publish/Subscribe    3、Routing    4、Topics 通配符模式    5、Header    ...
（八）RabbitMQ消息队列-通过Topic主题模式分发消息
热门推荐
巴拉巴拉小魔仙
04-27 1万+
前两章我们讲了RabbitMQ的direct模式和fanout模式，本章介绍topic主题模式的应用。如果对direct模式下通过routingkey来匹配消息的模式已经有一定了解那fanout也很好理解。简单的可以理解成direct是通过routingkey精准匹配的，而topic是通过routingkey来模糊匹配。 在topic模式下支持两个特殊字符的匹配。 * (星号) 代表任意 一个单词
RabbitMQ（7）工作模式：Route、Topic
учёба
01-25 860
Route路由模式 模式说明 1.队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey (路由key) 2.消息的发送方在向Exchange发送消息时，也必须指定消息的RoutingKey 3.Exchange不再把消息交给每一个绑定的队列， 而是根据消息的Routing Key进行判断，只有队列的Routingkey与消息的Routing key完全一致, 才会接收到消息 图解: P:生产者，向Exchange发送消息，发送消息时，会指定-个routing key X: Excha
RabbitMQ 发布订阅模式,routing路由模式,topic模式
tiantiantbtb的博客
05-01 1712
第三个参数:是否排他性(是否在同一个Connection,如果设置为true,不同的Connection是获得不到消息的)* 第三个参数:是否排他性(是否在同一个Connection,如果设置为true,不同的Connection是获得不到消息的)* 第三个参数:是否排他性(是否在同一个Connection,如果设置为true,不同的Connection是获得不到消息的)* 第三个参数:是否排他性(是否在同一个Connection,如果设置为true,不同的Connection是获得不到消息的)
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值