RabbitMQ消息分发简单介绍

最新推荐文章于 2024-06-25 01:19:20 发布
最新推荐文章于 2024-06-25 01:19:20 发布
阅读量569 收藏
点赞数
分类专栏： RabbitMQ 文章标签： rabbitmq rabbitmq消息发送 rabbitmq 交换器exchange
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XinhuaShuDiao/article/details/104062730
版权

      通过前面介绍过activemq的文章的时候我们了解到activemq有queue和topic的具体实现，但是在rabbitmq中只有queue的具体实现，是没有具体topic这种说法的，但是虽然没有提供topic的概念，但是却通过交换器exchange、路由routingkey等进行了交换实现，下面我们就来介绍下在rabbitmq中生产者是如何把消息发送到队列中的。

       在介绍消息传递之前我们还得介绍下下面的几个概念：

      vhost：在前面的一篇文章《RabbitMQ的配置文件说明》中提到过一个关于vhost的默认配置为default_vhost = /，它代表一个mini的rabbitmq虚拟主机，除了与其他rabbitmq虚拟主机共享相同的身份认证和加密环境外，它拥有自己独立的queue，exchange，routingkey，binding及权限机制，它可以通过命令行rabbitmqctl add_vhost qa1和在管理界面添加

       channel：通道，是由connection创建的，而connection又是通过ConnectionFactory创建的，在channel中我们可以定义queue、exchange、queuebind、消息发布、消息消费等操作。

       routingkey：路由key，用来路由消息到queue，明确exchange通过routingkey转发到哪个queue上面，用于指定路由的规则。

       exchange：交换器，用于生产者将消息发送到exchange，然后exchange将消息路由给对应的queue，如果无法路由到queue，则消息将会返回给生产者，或者直接丢弃。

       queue：消息队列，用于存储生产者发送的消息。

       binding：用于绑定exchange和routingkey。

       broker：rabbitmq消息节点。在broker上可以定义任意个vhost。

       介绍完上面的一些概念后回到消息传递，在rabbitmq中我们有下面一些应用场景：

       1.一个生产者和一个消费者

       在这种情况下我们可以直接进行消息的发送

       原生生产者代码：

public class Send {

    private final static String QUEUE_NAME = "hello";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            // 定义queue
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            // 发送的消息
            String message = "Hello World!";
            // 定义路由key为hello的发送消息
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8));
            System.out.println(" [x] Sent '" + message + "'");
        }
    }
}

        原生消费者代码：

private final static String QUEUE_NAME = "hello";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        // 定义消息队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

        // 定义消息回调处理
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + message + "'");
        };
        // 消费者定义路由key为hello的消费路径，消息队列也为hello
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> { });
    }

       springboot配置：

spring:
  rabbitmq:
    host: localhost
    port: 5672

       springboot生产者代码：

@SpringBootApplication
@EnableScheduling
public class HelloWorldProducer {
	
	@Bean
	public Queue hello() {
		return new Queue("hello");
	}

	@Autowired
	private RabbitTemplate template;

	@Autowired
	private Queue queue;

    // 定时多次发送消息
	@Scheduled(fixedDelay = 1000)
	public void send() {
		String message = "Hello World!";
		this.template.convertAndSend(queue.getName(), message);
		System.out.println(" [x] Sent '" + message + "'");
	}

	public static void main(String[] args) throws Exception {
		SpringApplication.run(HelloWorldProducer.class, args);
	}
}

       springboot消费者代码：

@RabbitListener(queues = "hello")
public void receive(String in) {
    System.out.println(" [x] Received '" + in + "'");
}

        2.一个生产者多个消费者

        针对这种一个生产者多个消费者的情况时，队列一般是按照顺序依次把消息发送到每一个消费者上面，但是这样会出现一种情况就是当其中一个消费者处理消息的速度过慢，然而queue还是会按照顺序依次把消息发送到该队列上面，这样就会造成消息的积累，而同时生产者产生的消息非常快，这就有可能最终导致内存的溢出，因此我们可以通过设置qos来每次消费多少消息，同时在进消息消费确认完成后才发送新消息到对应的消费者上面，这样就可以避免上面所述的情况出现。

       原生的消费者代码：

private static final String TASK_QUEUE_NAME = "task_queue";

  public static void main(String[] argv) throws Exception {
    ......
    // 进行消息预取
    channel.basicQos(1);

    DeliverCallback deliverCallback = (consumerTag, delivery) -> {
        String message = new String(delivery.getBody(), "UTF-8");

        System.out.println(" [x] Received '" + message + "'");
        try {
            doWork(message);
        } finally {
            System.out.println(" [x] Done");
            // 消息确认
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
        }
    };
    channel.basicConsume(TASK_QUEUE_NAME, false, deliverCallback, consumerTag -> { });
  }

       springboot代码：一些其他相同配置和前面的一样，不再写出

@Bean
public SimpleRabbitListenerContainerFactory myFactory(SimpleRabbitListenerContainerFactoryConfigurer configurer,
			ConnectionFactory connectionFactory) {
    SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
    configurer.configure(factory, connectionFactory);
		// factory.setMessageConverter(myMessageConverter());
    factory.setPrefetchCount(1);
    return factory;
}
// 并发2到5个消费者
@RabbitListener(queues = "hello", concurrency = "2-5", containerFactory = "myFactory")
public void receive(Channel channel, String in) {
    System.out.println("Channel-" + channel.getChannelNumber() + " Received '" + in + "'");
}

       3.一个生产者同时发送到多个队列

       这种方式是通过交换器来实现的，说到这里就必须知道交换器exchange的四种类型：fanout、direct、topic、header。我们先说下fanout类型，其他3种后面一次介绍。通过fanout定义的交换器，只要有队列queue与该交换器exchange进行了绑定操作，那么所有发送到该交换器exchange的消息都会被与该exchange绑定的queue所接收，这个与队列的名称绑定无关，队列名称的绑定只是用于消费者而已。

       原生生产者代码：

 private static final String EXCHANGE_NAME = "logs";

  public static void main(String[] argv) throws Exception {
    ......
    // 定义交换器类型
    channel.exchangeDeclare(EXCHANGE_NAME, "fanout");

    String message = argv.length < 1 ? "info: Hello World!" :
                            String.join(" ", argv);

    channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes("UTF-8"));
    System.out.println(" [x] Sent '" + message + "'");
    ......
  }

        原生消费者代码：

private static final String EXCHANGE_NAME = "logs";

  public static void main(String[] argv) throws Exception {
    ......

    // 定义交换器类型
    channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
    String queueName = channel.queueDeclare().getQueue();
    // 绑定队列与交换器
    channel.queueBind(queueName, EXCHANGE_NAME, "");

    System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

    DeliverCallback deliverCallback = (consumerTag, delivery) -> {
        String message = new String(delivery.getBody(), "UTF-8");
        System.out.println(" [x] Received '" + message + "'");
    };
    channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
  }

      springboot代码，先定义交换器等bean信息：

@Bean
public FanoutExchange fanout() {
    return new FanoutExchange("spring-logs");
}

@Configuration
public static class ReceiverConfig {
    @Bean
    public Queue autoDeleteQueue() {
        return new AnonymousQueue();
    }

    @Bean
    public Binding binding1(FanoutExchange fanout, Queue autoDeleteQueue) {
        return BindingBuilder.bind(autoDeleteQueue).to(fanout);
    }
}

        生产者代码：

@Autowired
private RabbitTemplate template;

@Autowired
private FanoutExchange fanout;

AtomicInteger count = new AtomicInteger(0);

@Scheduled(fixedDelay = 1000)
public void send() {
    String message = "pub/sub message-" + count.incrementAndGet();
    template.convertAndSend(fanout.getName(), "", message);
    System.out.println(" [x] Sent '" + message + "'");
}

public static void main(String[] args) throws Exception {
    SpringApplication.run(Publisher.class, args);
}

      消费者代码：

@RabbitListener(queues = "#{autoDeleteQueue.name}")
public void receive1(Channel channel, String in) {
    System.out.println("Channel-" + channel.getChannelNumber() + " Received '" + in + "'");
}

      4.一个生产者到多个特定的消费者

        从上图可以看出通过生产者产生消息发送到交换器exchange上，然后在路由到特定的队列queue上面，这个交换器的类型需要设置为direct，然后在绑定交换器exchange和路由routingkey及队列queue，然后就可以队列就可以进行消息的接收了，这个与队列的名称绑定无关，队列名称的绑定只是用于消费者而已。

       原生生产者代码：

private static final String EXCHANGE_NAME = "direct_logs";

public static void main(String[] argv) throws Exception {
    ......
    // 定义交换器类型为direct
    channel.exchangeDeclare(EXCHANGE_NAME, "direct");
    String severity = getSeverity(argv);
    String message = getMessage(argv);

    channel.basicPublish(EXCHANGE_NAME, severity, null, message.getBytes("UTF-8"));
    System.out.println(" [x] Sent '" + severity + "':'" + message + "'");
    ......
}

       原生消费者代码：

private static final String EXCHANGE_NAME = "direct_logs";

public static void main(String[] argv) throws Exception {
    ......

    // 定义交换器类型
    channel.exchangeDeclare(EXCHANGE_NAME, "direct");
    // 定义queue
    String queueName = channel.queueDeclare().getQueue();
    ......

    for (String severity : argv) {
        // 绑定queue，exchange，路由
        channel.queueBind(queueName, EXCHANGE_NAME, severity);
    }
    System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

    DeliverCallback deliverCallback = (consumerTag, delivery) -> {
        String message = new String(delivery.getBody(), "UTF-8");
        System.out.println(" [x] Received '" +
            delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
    };
    channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
  }

      springboot代码，先定义交换器等bean信息：

/**
* 定义direct类型的交换器
*/
@Bean
public DirectExchange direct() {
    return new DirectExchange("spring.routing");
}

@Configuration
public static class ReceiverConfig {

    @Bean
    public Queue autoDeleteQueue1() {
        return new AnonymousQueue();
    }

    @Bean
    public Queue autoDeleteQueue2() {
        return new AnonymousQueue();
    }

   /**
   * 绑定交换器，queue和路由关系
   */
    @Bean
    public Binding binding1a(DirectExchange direct, Queue autoDeleteQueue1) {
        return BindingBuilder.bind(autoDeleteQueue1).to(direct).with("orange");
    }

    @Bean
    public Binding binding1b(DirectExchange direct, Queue autoDeleteQueue1) {
        return BindingBuilder.bind(autoDeleteQueue1).to(direct).with("black");
    }

    @Bean
    public Binding binding2a(DirectExchange direct, Queue autoDeleteQueue2) {
        return BindingBuilder.bind(autoDeleteQueue2).to(direct).with("green");
    }

    @Bean
    public Binding binding2b(DirectExchange direct, Queue autoDeleteQueue2) {
        return BindingBuilder.bind(autoDeleteQueue2).to(direct).with("black");
    }
}

       生产者代码：

@Autowired
private RabbitTemplate template;

@Autowired
private DirectExchange direct;

AtomicInteger count = new AtomicInteger(0);

String[] routingKeys = { "orange", "black", "green" };

@Scheduled(fixedDelay = 1000)
public void send() {
    int i = count.incrementAndGet();
    String message = "routing message-" + i + " routingKey=" + routingKeys[i % 3];
    // 随机发送到路由上面
    template.convertAndSend(direct.getName(), routingKeys[i % 3], message);
    System.out.println(" [x] Sent '" + message + "'");
}

public static void main(String[] args) throws Exception {
    SpringApplication.run(Producer.class, args);
}

       消费者代码：

@RabbitListener(queues = "#{autoDeleteQueue1.name}")
public void receive1(Channel channel, String in) {
    System.out.println("Channel-" + channel.getChannelNumber() + " Received '" + in + "'");
}

@RabbitListener(queues = "#{autoDeleteQueue2.name}")
public void receive2(Channel channel, String in) {
    System.out.println("Channel-" + channel.getChannelNumber() + " Received '" + in + "'");
}

       5.一个生产者发送消息到相关的队列

       通过上面的图片我们可以知道，交换器exchange的类型是topic，路由key这次也不再是直接指定的了，而是通过模糊匹配来对应到队列queue的，*表示一个字符串，#表示任意多个字符串， 只要在exchange上面能匹配上对应的路由key就能将消息发送到相应的队列上面。

      原生生产者代码：

private static final String EXCHANGE_NAME = "topic_logs";

public static void main(String[] argv) throws Exception {
    ......
    // 定义类型为topic的exchange
    channel.exchangeDeclare(EXCHANGE_NAME, "topic");

    // 获取路由key
    String routingKey = getRouting(argv);
    String message = getMessage(argv);
    // 发送消息
    channel.basicPublish(EXCHANGE_NAME, routingKey, null, message.getBytes("UTF-8"));
    System.out.println(" [x] Sent '" + routingKey + "':'" + message + "'");
  }

       原生消费者代码：

private static final String EXCHANGE_NAME = "topic_logs";

public static void main(String[] argv) throws Exception {
    ......
    // 定义exchange的类型为topic
    channel.exchangeDeclare(EXCHANGE_NAME, "topic");
    String queueName = channel.queueDeclare().getQueue();

    if (argv.length < 1) {
        System.err.println("Usage: ReceiveLogsTopic [binding_key]...");
        System.exit(1);
    }

    for (String bindingKey : argv) {
        // 绑定queue、exchange和路由key的关系
        channel.queueBind(queueName, EXCHANGE_NAME, bindingKey);
    }

    System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

    DeliverCallback deliverCallback = (consumerTag, delivery) -> {
        String message = new String(delivery.getBody(), "UTF-8");
        System.out.println(" [x] Received '" +
            delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
    };
    channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
  }

       springboot代码，先定义交换器等bean信息：

/**
* 定义类型为topic的交换器exchange
*/
@Bean
public TopicExchange topic() {
    return new TopicExchange("spring.topic");
}

@Configuration
public static class ReceiverConfig {

    @Bean
    public Queue autoDeleteQueue1() {
       return new AnonymousQueue();
    }

    @Bean
    public Queue autoDeleteQueue2() {
       return new AnonymousQueue();
    }

    /**
    * 绑定queue、exchange和routingkey匹配的关系
    */
    @Bean
    public Binding binding1a(TopicExchange topic, Queue autoDeleteQueue1) {
        return BindingBuilder.bind(autoDeleteQueue1).to(topic).with("*.orange.*");
    }

    @Bean
    public Binding binding2a(TopicExchange topic, Queue autoDeleteQueue2) {
        return BindingBuilder.bind(autoDeleteQueue2).to(topic).with("*.*.rabbit");
    }

    @Bean
    public Binding binding2b(TopicExchange topic, Queue autoDeleteQueue2) {
        return BindingBuilder.bind(autoDeleteQueue2).to(topic).with("lazy.#");
    }
}

       生产者代码：

@Autowired
private RabbitTemplate template;

@Autowired
private TopicExchange topic;

AtomicInteger count = new AtomicInteger(0);

Random random = new Random();
String[] speeds = { "higher", "middle", "lazy" };
String[] colours = { "red", "orange", "blue", "black", "yellow", "green" };
String[] species = { "pig", "rabbit", "monkey", "dog", "cat" };

@Scheduled(fixedDelay = 3000)
public void send() {
    // 随机组装routingkey来继续消息路由
    String routingKey = speeds[random.nextInt(100) % speeds.length] + "."
				+ colours[random.nextInt(100) % colours.length] + "." + species[random.nextInt(100) % species.length];

    int i = count.incrementAndGet();

    String message = "topic message-" + i + " routingKey=" + routingKey;

    // 发送消息到exchange对应的路由key上
    template.convertAndSend(topic.getName(), routingKey, message);

    System.out.println(" [x] Sent '" + message + "'");
}

public static void main(String[] args) throws Exception {
    SpringApplication.run(Producer.class, args);
}

      消费者代码：

@RabbitListener(queues = "#{autoDeleteQueue1.name}")
public void receive1(Channel channel, String in) {
    System.out.println("Channel-" + channel.getChannelNumber() + " Received '" + in + "'");
}

@RabbitListener(queues = "#{autoDeleteQueue2.name}")
public void receive2(Channel channel, String in) {
    System.out.println("Channel-" + channel.getChannelNumber() + " Received '" + in + "'");
}

       6.header类型的exchange

      它不依赖于路由规则来进行消息的发送，它是根据发送的消息内容中的headers属性进行匹配的，因此它的性能非常差，而且也不实用，因此一般都不使用这个交换器类型。

      更多的内容可以参考官网https://www.rabbitmq.com/getstarted.html。代码上面参考了官网及一些其他文档。

玉&心
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ高级特性 - 消息分发（限流、负载均衡）
CYK_byte的博客
08-03 1246
RabbitMQ 的队列在有多个消费者订阅时，默认会通过轮询的机制将消息分发给不同的消费者，但是有些消费者消费速度慢，有些消费者消费速度快，就会导致消费速度慢的消费者影响整个的任务的吞吐量下降例如，公司有1个正式员工和1个实习生，现在有 10 个任务分配平均给他们（各 5 个），而由于实习生干活比较慢，就会导致整个完成任务的吞吐量下降.消息分发机制给 “正式工” 多分一些任务，给 “实习生” 少分一些任务.
RabbitMQ消息中间件技术精讲
10-28
3. **分布式任务调度**：使用RabbitMQ分发任务给不同的工作节点执行，实现任务的高效调度。 #### 九、最佳实践与优化建议 1. **合理设计消息模型**：根据业务需求选择合适的消息传递模式。 2. **性能调优**：通过...
RabbitMQ消息队列（三）：任务分发机制[转]
diaguo7961的博客
01-06 141
在上篇文章中，我们解决了从发送端（Producer）向接收端（Consumer）发送“Hello World”的问题。在实际的应用场景中，这是远远不够的。从本篇文章开始，我们将结合更加实际的应用场景来讲解更多的高级用法。 当有Consumer需要大量的运算时，RabbitMQ Server需要一定的分发机制来balance每个Consumer的load。接下来我们分布讲解。 ...
SpringBoot集成RabbitMq中channel.basicQos()无效
最新发布
congyijiu的博客
06-25 298
在使用 channel.basicQos(6) 设置预取值时，发现 channel.basicQos(6) 无效，导致未确认消息数远高于预期。通过在 application.yml 中配置 spring.rabbitmq.listener.simple.prefetch: 6 成功解决了问题。可能是SpringBoot整合RabbitMQ的bug。
RabbitMQ：消息分发模型
栗筝i的博客
12-26 2937
Work queues，也被称为 Task queues，任务模型，当消息处理比较耗时时的时候，可能产生消息的速度会远远大于消息的消费速度，消息会堆积越来越多，无法及时处理，此时就可以使用work模型：让多个消费者绑定一个队列，共同消费队列中的消息，队列中的消息一旦消费，就会消失，因此任务不会被重复执行。
RabbitMQ学习(四)——消息分发机制
Anumbrella
05-24 7846
在前面的一篇博文中，我们对RabbitMQ中的交换机有了大致的了解，同时结合Spring boot的实例，让我们对RabbitMQ的用法有了更清晰的认识。如果忘记了可以去复习一下，RabbitMQ学习(三)——探索交换机(Exchange)，结合SpringBoot实战。 今天我们将要对RabbitMQ的消息机制进行更详细的探究，在上一篇文章中其实也涉及到了该消息机制的问题。只是没有深入探究，今...
RabbitMQ学习总结（四）之消息分发机制
a2321123的博客
03-18 3511
RabbitMQ的个人学习笔记，讲解了RabbitMQ的分发机制。更多为个人理解的大白话
RabbitMQ消息中间件视频教程
05-14
它支持多种消息发布订阅模式，包括简单模式（Simple）、工作队列模式（Work Queues）、发布/订阅模式（Publish/Subscribe）、路由模式（Routing）、RPC模式（Remote Procedure Call）、Fanout模式等。RabbitMQ具有高...
rabbitmq简单示例
11-08
通过这个简单的RabbitMQ demo，你可以理解消息队列的基本工作原理，掌握如何设置不同的交换器类型，并学会使用RabbitMQ API进行消息的发布与消费。实践中，你可以根据项目需求，结合Exchange Types和API实现更复杂的...
rabbitMQ 消息队列 Demo
10-18
这个例子帮助我们理解RabbitMQ的基本工作流程：生产者创建消息，将消息发送到交换机，交换机根据绑定规则将消息放入队列，最后消费者从队列中接收并处理消息。 2. **02WorkQueues（任务队列）** 在这个示例中，多...
rabbitMQ代码案例 简单入门
10-31
交换器根据预定义的路由规则将消息分发到对应的队列。 3. **绑定（Binding）**：这是交换器与队列之间的关系定义，指定哪些消息应该被路由到哪个队列。绑定可以包含路由键，用于更精确的消息过滤。 4. **通道...
基于RabbitMQ的消息路由分发实例
05-06
基于RabbitMQ消息队列的路由分发实例源码，直接可以运行。
【深入理解RabbitMQ原理】RabbitMQ 消息分发
王小明的专栏
07-25 1875
RabbitMQ 消息分发 如果有一个消息队列，有两个消费者，两个队列会同时收到消息么？ 请看官方文档： https://www.rabbitmq.com/tutorials/tutorial-two-java.html 当RabbitMQ队列拥有多个消费者时候，队列将以轮询（round-roubin)的方式发送给消费者 每个消息只会发送给消费者表里的一个消费者 Round-r...
RabbitMQ系列（二）RabbitMQ架构原理及消息分发机制
CountryLord的博客
12-03 1090
RabbitMQ架构原理及消息分发机制
RabbitMQ消息分发机制
倔强100%的博客
08-01 1054
RabbitMQ消息分发机制及运行原理
RabbitMQ 消息公平分发
十年饮冰，难凉热血
09-03 1387
概念： 如果Rabbit只管按顺序把消息发到各个消费者身上，不考虑消费者负载的话，很可能出现，一个机器配置不高的消费者那里堆积了很多消息处理不完，同时配置高的消费者却一直很轻松。为解决此问题，可以在各个消费者端，配置perfetch=1,意思就是告诉RabbitMQ在我这个消费者当前消息还没处理完的时候就不要再给我发新消息了。 ...
rabbitmq之消息分发策略
Java领域优秀创作者
03-19 1510
RabbitMQ 提供了丰富的消息分发策略和高级特性，帮助开发者构建高效、可靠的分布式系统。在实际应用中，选择合适的消息分发策略（如轮训分发和公平分发）以及合理配置高级特性（如消息持久化、死信队列、消息优先级、延迟队列、事务支持和确认机制）可以显著提高系统的性能和稳定性。通过本文的详细介绍和示例代码，您可以在 Spring Boot 项目中灵活应用 RabbitMQ 的各种功能，优化消息队列的处理流程，确保消息的高效处理和分发。
Java使用RabbitMQ（五）--消息分发策略
ljz2016的博客
04-17 1738
消息分发策略 RabbitMQ默认的消息分发策略是公平分发（Fair dispatch），把消息轮流发给每个worker者。 这样有个问题：某个worker很忙的 时候，会累积大量的消息，导致异常、内存溢出等问题。 一个解决方案是：设置某一时间只给一个worker者发送一条消息，在没有收到ack消息回应时，不给发第二个。 int prefetchCount = 1; channel.b...
RabbitMQ的分发机制
qq_44933676的博客
09-07 1287
MQ消息队列有如下几个角色：1、生产者2、存储消息3、消费者。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值