RabbitMQ学习笔记

最新推荐文章于 2024-06-26 09:09:54 发布
最新推荐文章于 2024-06-26 09:09:54 发布
阅读量288 收藏
点赞数 1
分类专栏： RabbitMQ 文章标签： RabbitMQ 消息队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Shinka_YXS/article/details/117230454
版权

视频教程【编程不良人】MQ消息中间件之RabbitMQ以及整合SpringBoot2.x实战教程

1.MQ引言

1.1什么是MQ

MQ(Message Quene)：消息队列，也叫消息中间件。
通过典型的生产者和消费者模型，生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。
消息的生产和消费都是异步的，只关心消息的发送和接收，没有业务逻辑的侵入，实现系统间解耦。
通过利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。

1.2不同MQ特点

  • ActiveMQ

    Apache出品，最流行的，能力强劲的开源消息总线。是一个完全支持JMS规范的的消息中间件。丰富的API，多种集群架构模式。
    性能受人诟病，吞吐量不高，适合中小型企业。

  • Kafka

    LinkedIn开源的分布式发布-订阅消息系统，目前归属于Apache顶级项目。
    主要特点是基于Pull的模式来处理消息消费，追求高吞吐量，最初目的就是用于日志收集和传输。
    0.8版本开始支持复制，不支持事务，对消息的重复、丢失、错误没有严格要求，适合产生大量数据的互联网服务的数据收集业务。

  • RocketMQ
    阿里开源的消息中间件，它是纯Java开发，高吞吐量、高可用性、适合大规模分布式系统应用。
    它的思路起源于Kafka，但并不是Kafka的一个Copy，它对消息的可靠传输及事务性做了优化，目前在阿里集团被广泛应用于交易、充值、流计算、消息推送、日志流式处理、binglog分发等场景。

  • RabbitMQ
    使用Erlang语言开发的开源消息队列系统，基于AMOP协议来实现。（erlang做socket编程很不错）
    AMOP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。
    AMOP协议更多用在企业系统内对数据一致性、稳定性和可靠性要求很高的场景，对性能和吞吐量的要求还在其次。

RabbitMQ比Kafka可靠，Kafka更适合IO高吞吐的处理，一般应用在大数据日志处理或对实时性（少量延迟），可靠性（少量丢数据）要求稍低的场景使用，比如ELK日志收集。

2.RabbitMQ引言

RabbitMQ官网

基于AMQP协议，erlang语言开发，是部署最广泛的开源消息中间件，是最受欢迎的开源消息中间件之一。
RabbitMQ可以和Spring框架无缝整合。

AMQP协议
AMQP(advanced message queuing protocol)在2003年时被提出，最早用于解决金融领域不同平台之间的消息传递交互问题。
AMQP是一种协议，更准确的说是一种binary wirelevel protoco1（链接协议），这是其和JMS的本质差别。
AMQP不从API层进行限定，而是直接定义网络交换的数据格式。这使得实现了AOP的provider天然性就是跨平台的。

3.RabbitMQ配置

3.1RabbitMQ管理命令行

# 服务启动相关
systemctl start|restart|stop|status rabbitmq-server
# 管理命令行用来 在不使用web管理界面情况下 命令操作RabbitMQ
rabbitmqctl help	# 可以查看更多命令
# 插件管理命令行
rabbitmq-plugins enable|list|disable

3.2 web管理界面介绍

3.2.1 web管理界面介绍

在这里插入图片描述
【Exchanges 交换机】AMQP里面比较有名的 交换机 也叫路由。在RabbitMQ刚安装成功之后 默认内置了7种路由
在这里插入图片描述AMQP默认协议为direct（直联）
Features的“D”代表“durable(持久)”，意指日后直联的消息是存在磁盘中的，即不会随着RabbitMQ的重启或错误而丢失数据。
后面6个不同交换机的名字对应6个不同特性的交换机：direct直联、fanout广播、headers以头的形式、match以匹配的形式、topic订阅、trace追踪等模式、

4.RabbitMQ的第一个程序

4.1AMQP协议回顾

在这里插入图片描述生产者去与RabbitMQ的Server建立连接，之后会在连接里以通道的形式传递消息
每一个生产者会对应一个专门的虚拟主机Virtual Host，可以把虚拟主机想象成关系型数据库中“库”的概念、
若想访问到一个具体的虚拟主机，需要将虚拟主机与用户进行绑定，所以先创建用户 再创建虚拟主机 然后将虚拟主机与用户绑定、
消息会被放到交换机中还是直接到Queue中，取决于使用哪种消息模型、
消费者与生产者是完全解耦的，消费者不需要关心生产者有没有运行，只需要关心其监听的队列有没有消息即可、

4.2RabbitMQ支持的消息模型

https://www.rabbitmq.com/getstarted.html

1 "Hello World!"点对点、生产者直接发消息给队列 不经过任何交换机
2 Work queues广播、
3 Publish/Subscribe发布和订阅、
4 Routing路由、
5 Topics基于动态路由去做订阅、
6 RPC、
7 Publisher Confirms发布确认模式、

4.3Java实现

工具类

public class MyRabbitMQUtil {

    private static ConnectionFactory connectionFactory;

    static {
        // 重量级资源 类加载时执行 且仅执行一次

        // 创建连接mq的连接工厂对象
        connectionFactory = new ConnectionFactory();
        // 设置连接主机、端口号、虚拟主机、访问虚拟主机的用户名密码
        connectionFactory.setHost("ip");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/test-vh");
        connectionFactory.setUsername("testUser");
        connectionFactory.setPassword("testUser");
    }

    /**
     * 提供连接对象
     *
     * @return
     */
    public static Connection getConnection() {
        try {
            return connectionFactory.newConnection();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 关闭通道和连接
     * @param channel
     * @param connection
     */
    public static void closeCollectionAndChannel(Channel channel, Connection connection) {
        try {
            if (channel != null) {
                channel.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

模型一（直联）

生产者用默认的交换机把消息发送到和routingKey名称相同的队列中，由消费者去队列中获取消息进行消费
在这里插入图片描述
P：生产者，也就是要发送消息的程序
C：消费者，消息的接受者，会一直等待消息到来。
queue︰消息队列，图中红色部分。类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息。

生产者
<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
</dependency>

// 生产消息
@Test
public void sendMessageTest() throws IOException, TimeoutException {

    // 获取连接对象
    Connection connection = MyRabbitMQUtil.getConnection();
    // 创建连接中的通道
    Channel channel = connection.createChannel();

    // 通道绑定对应消息队列
    // 参数1：queue 队列名称，若不存在则自动创建
    // 参数2：durable 队列特性是否持久化
    // 参数3：exclusive 是否独占队列
    // 参数4：autoDelete 是否在消费完成后自动删除队列。设置为true时队列中没有消息且没有消费者在监听 该队列才会被删除
    // 参数5：arguments 额外附加参数
    channel.queueDeclare("hello", false, false, false, null);

    // 发布消息
    // 参数1：exchange 交换机名称
    // 参数2：routingKey 路由名称。此处用默认的交换机把消息发送到和routingKey名称相同的队列中
    // 参数3：props 传递消息额外设置，若需要消息持久化，传入参数MessageProperties.PERSISTENT_TEXT_PLAIN
    // 参数4：body 消息的具体内容
    channel.basicPublish("", "hello", null, "hello rabbitMQ~".getBytes());

    channel.close();
    connection.close();

}
消费者
// 消费消息
public static void main(String[] args) throws IOException, TimeoutException {
    // 获取连接对象
    Connection connection = MyRabbitMQUtil.getConnection();
    // 创建连接中的通道
    Channel channel = connection.createChannel();

    // 通道绑定对应消息队列
    channel.queueDeclare("hello", false, false, false, null);
    
    // 消费消息
    // 参数1：队列名称 消费哪个队列的消息
    // 参数2：开启消息的自动确认机制
    // 参数3：消费时的回调接口，此处用匿名内部类实现
    channel.basicConsume("hello", true, new DefaultConsumer(channel){
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            System.out.println("body内容："+ new String(body));
        }
    });

    // 希望customer一直监听，可把以下两行注释掉
    // channel.close();
    // connection.close();

}
API参数细节
// 通道绑定对应消息队列
// 参数1：queue 声明通道对应的队列
// 参数2：durable 是否持久化队列
// 参数3：exclusive 是否独占队列
// 参数4：autoDelete 是否在消费完成后自动删除队列
// 参数5：arguments 对队列的额外配置
channel.queueDeclare("hello", false, false, false, null);

模型二（work queue）

Work queues（工作模型）也被称为Task queues（任务模型）。
当消息处理比较耗时的时候，可能生产消息的速度会远远大于消息的消费速度。长此以往，消息会堆积越来越多，无法及时处理。
此时可使用work模型：让多个消费者绑定到一个队列，共同消费队列中的消息。队列中的消息一旦消费，就会消失，因此任务不会被重复执行。
在这里插入图片描述
角色：

  • P：生产者，任务的发布者
  • C1：消费者1，领取任务并且完成任务，假设完成速度较慢
  • C2：消费者2，领取任务并完成任务，假设完成速度快
生产者
// 通过通道声明队列
channel.queueDeclare("work", true, false, false, null);

for (int i = 0; i < 10; i++) {
    channel.basicPublish("", "work", null, (i+"-work").getBytes());
}
消费者1
// 通道绑定对应消息队列
channel.queueDeclare("work", false, false, false, null);

// 消费消息 参数1：队列名称；参数2：消息自动确认，true表示消费者自动向RabbitMQ确认消费
channel.basicConsume("work", true, new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        System.out.println("消费者1：" + new String(body));
    }
});
消费者2

与消费者1代码相同，第8行打印“消费者2”。

测试结果

在这里插入图片描述

总结：默认情况下，RabbitMQ将按顺序将每个消息发送给下一个使用者。平均而言，每个消费者都会收到相同数量的消息。这种分发消息的方式称为循环。

消息自动确认机制

Message acknowledgment(消息确认)-rabbitMQ官网介绍

Doing a task can take a few seconds. You may wonder what happens if one of the consumers starts a long task and dies with it only partly done. With our current code, once RabbitMQ delivers a message to the consumer it immediately marks it for deletion. In this case, if you kill a worker we will lose the message it was just processing. We’ll also lose all the messages that were dispatched to this particular worker but were not yet handled.

But we don’t want to lose any tasks. If a worker dies, we’d like the task to be delivered to another worker.

在当前代码中，开启了自动确认，那么一旦RabbitMQ将消息传递给消费者，它就会立即将其标记为删除。
在这种情况下，如果一个消费者只处理了部分消息就宕机，我们将丢失它正在处理的消息 以及 发送给该特定工作进程但尚未处理的所有消息。

但我们希望如果一个消费者宕机，把任务交给其他消费者。

需要修改：

1.关闭自动确认机制
2.告诉消息队列不能一次性地把消息都给当前消费者，让消费者一个通道只能消费一个消息。

消费者1
Connection connection = MyRabbitMQUtil.getConnection();
Channel channel = connection.createChannel();

// 每次只能消费一个消息
channel.basicQos(1);

channel.queueDeclare("work", false, false, false, null);

// 消费消息 参数1：队列名称；参数2：消息自动确认，true表示消费者自动向RabbitMQ确认消费
channel.basicConsume("work", false, new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        try {
            Thread.sleep(2000);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("消费者1：" + new String(body));
        // 手动确认 参数1：手动确认参数标识，即确认队列中哪个具体的消息 参数2：false表示每次只确认一个
        channel.basicAck(envelope.getDeliveryTag(), false);
    }
});
消费者2
Connection connection = MyRabbitMQUtil.getConnection();
Channel channel = connection.createChannel();

// 每次只能消费一个消息
channel.basicQos(1);

channel.queueDeclare("work", false, false, false, null);

// 消费消息 参数1：队列名称；参数2：消息自动确认，true表示消费者自动向RabbitMQ确认消费
channel.basicConsume("work", false, new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        System.out.println("消费者2：" + new String(body));
        // 手动确认 参数1：手动确认参数标识，即确认队列中哪个具体的消息 参数2：false表示每次只确认一个
        channel.basicAck(envelope.getDeliveryTag(), false);
    }
});
测试结果

在这里插入图片描述

模型三（Publish/Subscribe）

fanout 扇出 也就是广播

Publish/Subscribe 发布/订阅 模型，也是广播模型
在这里插入图片描述
消息发送流程

  • 可有多个消费者
  • 每个消费者有自己的queue（队列），queue可以是临时的（没有消息会自动删除）
  • 每个队列都要绑定到exchange（交换机）
  • 生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定。
  • 交换机把消息发送给绑定过的所有队列
  • 队列的消费者都能拿到消息。实现一条消息被多个消费者消费。
生产者
// 获取连接和通道对象
Connection connection = MyRabbitMQUtil.getConnection();
Channel channel = connection.createChannel();

// 将通道声明指定交换机 参数1：交换机名称，不存在则创建；参数2：交换机类型，fanout是广播类型
channel.exchangeDeclare("testExchangeName", "fanout");

// 发送消息 在广播类型下routingKey是没有意义的，还是会广播
channel.basicPublish("testExchangeName", "", null, "这是一条消息".getBytes());

// 关闭资源
MyRabbitMQUtil.closeCollectionAndChannel(channel, connection);

运行后就创建了一个fanout类型的交换机testExchangeName

在这里插入图片描述

消费者1
Connection connection = MyRabbitMQUtil.getConnection();
Channel channel = connection.createChannel();

// 将通道绑定交换机
channel.exchangeDeclare("testExchangeName", "fanout");
// 临时队列
String queueName = channel.queueDeclare().getQueue();
// 绑定交换机和队列
channel.queueBind(queueName, "testExchangeName", "");

// 消费消息 参数1：队列名称；参数2：消息自动确认，true表示消费者自动向RabbitMQ确认消费
channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        System.out.println("Customer1-body内容：" + new String(body));
    }
});

消费者2 和 消费者3 与 消费者1 相同，打印的内容不同。

测试结果

先启动三个消费者，再启动生产者，最后三个消费者都消费了生产的发布的消息。
在这里插入图片描述

模型四（Routing）

1）Routing之订阅模型-Direct(直连)

在Fanout模式中，一条消息，会被所有订阅的队列都消费。
但在某些场景下，我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange。

在Direct模型下：

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

流程：

在这里插入图片描述
图解：

  • P：生产者，向Exchange发送消息时，会指定一个RoutingKey
  • X：Exchange (交换机)，接收生产者的消息，然后把消息递交给与RoutingKey完全匹配的队列
  • C1：消费者，其所在队列指定了需要RoutingKey为error的消息
  • C2：消费者，其所在队列指定了需要RoutingKey为info、error、warning 的消息
生产者
// 获取连接和通道对象...

String exchangeName = "testExchangeName_direct";
// 将通道声明指定交换机 参数1：交换机名称，不存在则创建；参数2：交换机类型，direct是路由模式
channel.exchangeDeclare(exchangeName, "direct");
// 发送消息
String routingKey = "info";
channel.basicPublish(exchangeName, routingKey, null,
                     ("这是direct模型基于routingKey["+routingKey+"]发布的消息").getBytes());
// 关闭资源...
消费者1
String exchangeName = "testExchangeName_direct";
// 将通道绑定交换机
channel.exchangeDeclare(exchangeName, "direct");
// 临时队列
String queueName = channel.queueDeclare().getQueue();
// 绑定交换机和队列
channel.queueBind(queueName, exchangeName, "error");

// 消费消息
channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        System.out.println("Customer1-body内容：" + new String(body));
    }
});
消费者2
String exchangeName = "testExchangeName_direct";
// 将通道绑定交换机
channel.exchangeDeclare(exchangeName, "direct");
// 创建一个临时队列
String queueName = channel.queueDeclare().getQueue();
// 临时队列和交换机绑定
channel.queueBind(queueName, exchangeName, "info");
channel.queueBind(queueName, exchangeName, "error");
channel.queueBind(queueName, exchangeName, "warning");

// 消费消息
channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        System.out.println("Customer2-body内容：" + new String(body));
    }
});
测试结果

先启动两个消费者，再启动生产者，消费者只消费其绑定RoutingKey的消息

当生产者发布消息的routingKey为info时：
在这里插入图片描述当生产者发布消息的routingKey为error时：
在这里插入图片描述

2）Routing之订阅模型-Topic

Topic与Direct类型的Exchange都是可以根据RoutingKey把消息路由到不同的队列。
Topic类型Exchange可以让队列在绑定RoutingKey的时候使用通配符！这种模型Routingkey一般都是由一个或多个单词组成，多个单词之间以"."分割，例如：item.insert
在这里插入图片描述

  • * (star) can substitute for exactly one word. 匹配1个词
  • # (hash) can substitute for zero or more words. 匹配任意个词
生产者
// 获取连接和通道对象

String exchangeName = "testExchangeName_topic";
// 将通道声明指定交换机 参数1：交换机名称，不存在则创建；参数2：交换机类型，topic是路由模式
channel.exchangeDeclare(exchangeName, "topic");
// 发送消息
String routingKey = "user.save";
channel.basicPublish(exchangeName, routingKey, null,
                     ("这是topic动态路由模型基于routingKey["+routingKey+"]发布的消息").getBytes());
// 关闭资源
消费者
String exchangeName = "testExchangeName_topic";
// 将通道绑定交换机
channel.exchangeDeclare(exchangeName, "topic");
// 临时队列
String queueName = channel.queueDeclare().getQueue();
// 绑定交换机和队列
channel.queueBind(queueName, exchangeName, "user.*");
// 消费消息
测试结果

在这里插入图片描述

RPC和Publisher Confirms待补充

5.SpringBoot中使用RabbitMQ

引入依赖

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

application.yml

spring:
  application:
    name: rabbitmq-springboot
  rabbitmq:
    host: ip
    port: 5672
    username: testUser
    password: testUser
    virtual-host: /test-vh

5.1直联

生产者

@SpringBootTest(classes = ShinkaApplication.class)
@RunWith(SpringRunner.class)
public class TestRabbitMQ {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testHello() {
        rabbitTemplate.convertAndSend("testHello", "hello world!");
    }
}

消费者

@Component
@RabbitListener(queuesToDeclare = @Queue(value = "testHello"))  // RabbitListener可以加在类或者方法上，默认是 持久化 非独占 非自动删除 的队列
public class HelloCustomer {

    @RabbitHandler
    public void receive1(String message) {
        System.out.println("消费的消息内容：" + message);
    }
}

测试结果

在这里插入图片描述在这里插入图片描述

5.2Work Queue

说明：默认在Spring AMQP中实现Work这种方式就是公平调度，如果需要实现能者多劳需要额外配置

生产者

TestRabbitMQ.java新增方法testWork()

@Test
public void testWork() {
    for (int i = 0; i < 10; i++) {
        rabbitTemplate.convertAndSend("testWork", "这是work模型的消息-"+i);
    }
}

消费者

@Component
public class WorkCustomer {

    // @RabbitListener直接加在方法上，代表这个方法会处理当前这个RabbitListener所监听的队列的回调
    @RabbitListener(queuesToDeclare = @Queue(value = "testWork"))
    public void receive1(String message) {
        System.out.println("WorkCustomer1-消费的消息内容：" + message);
    }

    @RabbitListener(queuesToDeclare = @Queue(value = "testWork"))
    public void receive2(String message) {
        System.out.println("WorkCustomer2-消费的消息内容：" + message);
    }
}

测试结果

在这里插入图片描述在这里插入图片描述

5.3Fanout

生产者

TestRabbitMQ.java新增方法testFanout()

// fanout 广播
@Test
public void testFanout() {
    rabbitTemplate.convertAndSend("testFanoutExchange", "", "这是Fanout模型的消息");
}

消费者

@Component
public class FanoutCustomer {

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,  // 不@Queue("xxx")指定名称的话就是创建临时队列
                    exchange = @Exchange(value = "testFanoutExchange", type = ExchangeTypes.FANOUT) // 绑定的交换机
            )
    })
    public void receive1(String message) {
        System.out.println("FanoutCustomer1-消费的消息内容：" + message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,  // 不@Queue("xxx")指定名称的话就是创建临时队列
                    exchange = @Exchange(value = "testFanoutExchange", type = ExchangeTypes.FANOUT) // 绑定的交换机
            )
    })
    public void receive2(String message) {
        System.out.println("FanoutCustomer2-消费的消息内容：" + message);
    }
}

测试结果

在这里插入图片描述在这里插入图片描述

5.4Routing-Direct

生产者

@Test
public void testRoutingDirect() {
    rabbitTemplate.convertAndSend("testRoutingDirectExchange", "info", "这是Routing-Direct模型的消息");
}

消费者

@Component
public class DirectCustomer {

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,  // 创建临时队列
                    exchange = @Exchange(value = "testRoutingDirectExchange", type = ExchangeTypes.DIRECT), // 绑定的交换机，默认就是DIRECT 此处其实可以不用写
                    key = {"info", "error", "warn"}
            )
    })
    public void receive1(String message) {
        System.out.println("RoutingDirect1-消费的消息内容：" + message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,  // 创建临时队列
                    exchange = @Exchange(value = "testRoutingDirectExchange", type = ExchangeTypes.DIRECT), // 绑定的交换机，默认就是DIRECT 此处其实可以不用写
                    key = {"error"}
            )
    })
    public void receive2(String message) {
        System.out.println("RoutingDirect2-消费的消息内容：" + message);
    }
}

测试结果

当生产者发布消息的routingKey为info时：
在这里插入图片描述当生产者发布消息的routingKey为error时：
在这里插入图片描述

5.5Routing-Topic

生产者

// Topic 订阅模式
@Test
public void testRoutingTopic() {
    rabbitTemplate.convertAndSend("testRoutingTopicExchange", "user.save",
                                  "这是Routing-Direct模型的路由为user.save的消息");
}

消费者

@Component
public class TopicCustomer {

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(value = "testRoutingTopicExchange", type = ExchangeTypes.TOPIC),
                    key = {"user.save", "user.*"}
            )
    })
    public void receive1(String message) {
        System.out.println("RoutingTopic1-消费的消息内容：" + message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(value = "testRoutingTopicExchange", type = ExchangeTypes.TOPIC),
                    key = {"order.#", "product.#", "user.*"}
            )
    })
    public void receive2(String message) {
        System.out.println("RoutingTopic2-消费的消息内容：" + message);
    }
}

测试结果

在这里插入图片描述

6.MQ的应用场景

https://blog.csdn.net/whoamiyang/article/details/54954780

Shinka-深深
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
RabbitMQ详解
qq_53263107的博客
11-15 3512
说到消息中间件，估计大伙多多少少都能讲出来一些，ActiveMQ、RabbitMQ、RocketMQ、Kafka 等等各种以及 JMS、AMQP 等各种协议，然而这些消息中间件各自都有什么特点，我们在开发中又该选择哪种呢？
RabbitMQ Exchange、Queue详解，控制台的使用
chy1984的博客
01-31 3409
目录exchange相关参数exchange的4种类型queue监控参数说明   exchange   相关参数 name：exchange的名称 type：exchange的类型，指定exchange按何种策略投递消息到queue中 durability：exchange中的消息是否要持久化。durable是要持久化，存储在内存中，并自动持久化到硬盘（备份），重启rabbitmq server时自动从硬盘加载数据，exchange中的消息不会丢失；transient是不支持持久化，
【RabbitMQ实战】Springboot 整合RabbitMQ组件，多种编码示例，带你实践 看完这一篇就够了
最新发布
qq_39666711的博客
06-26 762
该篇文章内容较多，包括有RabbitMQ一些理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout多种交换机的使用，同时简单介绍对消息回调、手动确认等。例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。这里面的每一种使用都包含实际编码示例，供大家理解，共同进步，如有不足。还请指教。
rabbitMQ学习笔记
辰星
08-26 1005
不同MQ的特点 1.ActiveMQ activemq是能力强劲的开源消息总线，它是一个完全支持JMS规范的消息中间件，丰富的api，多种集群架构模式让activemq在业界成为牌的消息中间间，中小企业用的多 缺点：性能不高 命令行的方式操作linux上的rabiitmq systemctl start abbitmq-server #启动命令 systemctl restartrabbitmq-server #重启命令 systemctl s...
RabbitMQ 浅析
Darklovy
06-05 555
转载自：https://www.cnblogs.com/ityouknow/p/6120544.html RabbitMQ 是一个由 Erlang 语言开发的 AMQP（高级消息队列协议） 的开源实现。它主要是用来实现应用程序的异步和解耦，同时也能起到消息缓冲、消息分发的作用。 AMQP AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是...
SpringBoot整合RabbitMQ
K_kzj_K的博客
06-09 4564
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
rabbitmq学习笔记和软件和插件
05-05
**RabbitMQ学习笔记与软件插件详解** RabbitMQ是一种广泛应用的消息中间件，它基于AMQP（Advanced Message Queuing Protocol）协议，提供可靠的消息传递服务。在分布式系统中，RabbitMQ扮演着数据交换中心的角色，...
RabbitMq学习笔记
01-15
RabbitMq是实现AMQP（高级消息队列协议）的消息中间件的一种，与Springboot整合后使用方便简单，功能强大。本文还列举了Springboot整合RabbitMq使用和原版对比、及一些坑，简单易懂。
rabbitMQ 学习笔记
12-27
**正文** ...通过以上的学习，你应该对RabbitMQ有了基本的理解，并掌握了在Java中使用RabbitMQ的基本方法。然而，实际应用中，还需要根据具体业务场景灵活运用和调整策略，以充分发挥RabbitMQ的优势。
rabbitmq学习笔记.zip
10-16
在这个“rabbitmq学习笔记.zip”压缩包中，我们可以期待找到一系列关于RabbitMQ的核心概念、安装教程、使用方法以及常见问题的详细说明。 首先，RabbitMQ的基本概念包括生产者（Producer）、消费者（Consumer）、...
RabbitMq学习笔记1
08-03
在本篇学习笔记中，我们将首先了解RabbitMQ的安装过程。 1. **Erlang的安装**： Erlang是RabbitMQ的基础，因为RabbitMQ是用Erlang编写的。安装Erlang可以通过以下命令完成： ```bash sudo apt-get install ...
RabbitMQ学习 笔记
04-27
我自己的学习笔记，包括python、php、.net的实现，服务的搭建；具体原理的等，80多页，非常细致，学完保证对rabbitmq门儿清！我们公司的rabbit服务就是我搭建的
RabbitMQ与SpringBoot整合实战
tyjlearning的博客
11-01 2982
SpringBoot整合RabbitMQ SpringBoot与RabbitMQ集成非常筒単，不需要做任何的额外设置只需要两步即可： step1：引入相关依赖：spring-boot-starter-amqp step2：対application.properties迸行配置 生产端核心配置 消费端核心配置 SpringBoot整合RabbitMQ实战 1.首先创建一个Spring Boot...
RabbitMQ与SpringBoot整合详解
vanGogh的博客
11-17 6318
一、前言   本文章总体简介，会采用Docker下载安装RabbitMQ，详细介绍RabbitMQ优缺点及其相关技术知识点，SpringBoot作为整合学习的基础架构。看完本片文章，你会了解消息队列RabbitMQ，你会使用消息队列RabbitMQ。 二、消息队列   当第一次出现在我脑中这个词语时，我会问自己什么时消息队列？我做的项目为什么没有消息队列？我做的项目可以用消息队列么？如果可以用消息队列这要怎么使用消息队列？消息队列能解决项目什么问题？等等问题会出现在我的脑海…，然而我将会在面文章中对自己慢慢
SpringBoot集成RabbitMq
m0_55841258的博客
05-05 2511
RabbitMQ是一套开源（MPL）的消息队列服务软件，是由 LShift 提供的一个 Advanced Message Queuing Protocol (AMQP) 的开源实现，由以高性能、健壮以及可伸缩性出名的 Erlang 写成。RabbitMQ是一个消息中间件,它接收并转发消息,但不处理消息。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值