{"id":25245,"date":"2026-06-03T18:48:36","date_gmt":"2026-06-03T11:48:36","guid":{"rendered":"https:\/\/huongdanjava.com\/?p=25245"},"modified":"2026-06-03T18:49:22","modified_gmt":"2026-06-03T11:49:22","slug":"partitioning-with-rabbitmq-using-spring-cloud-stream","status":"publish","type":"post","link":"https:\/\/huongdanjava.com\/partitioning-with-rabbitmq-using-spring-cloud-stream.html","title":{"rendered":"Partitioning with RabbitMQ using Spring Cloud Stream"},"content":{"rendered":"

Partitioning in message queues is a mechanism that divides topics or queues into multiple partitions. Each partition stores a portion of the data, and this data is processed in parallel. This makes receiving and processing messages faster and more efficient!<\/p>\n

Apache Kafka supports partitioning natively, while RabbitMQ does not. However, you can easily implement partitioning with RabbitMQ using Spring Cloud Stream. Spring Cloud Stream provides solutions for implementing partitioning with any message broker. You can implement partitioning in your application code and easily switch between different message brokers without changing much code. Spring Cloud Stream ensures that related messages, for example, with the same user ID, are handled by the same consumer instance (in cases where multiple consumer instances subscribe to the same queue and process that message). How exactly does this work? Let’s explore this in this tutorial!<\/p>\n

First, I’ll create a new Maven multi-module project as an example:<\/p>\n

\"\"<\/p>\n

Both the producer and consumer projects are Spring Boot projects that use Spring Cloud Starter Stream Rabbit to send and receive messages to RabbitMQ using Spring Cloud Stream.<\/p>\n

For example, to illustrate the partitioning part, we will have a producer application to publish messages to the exchange with three different partitions. We will run three instances of the consumer application to consume messages from these three different partitions.<\/p>\n

The RabbitMQ server information will be defined in the two projects as follows:<\/p>\n

spring:\r\n  rabbitmq:\r\n    host: localhost\r\n    port: 5672\r\n    username: guest\r\n    password: guest<\/pre>\n
For the producer part<\/strong>, I will use the StreamBridge class to send messages as follows:<\/p>\n
package com.huongdanjava.springcloudstream;\r\n\r\nimport org.springframework.beans.factory.annotation.Autowired;\r\nimport org.springframework.boot.CommandLineRunner;\r\nimport org.springframework.boot.SpringApplication;\r\nimport org.springframework.boot.autoconfigure.SpringBootApplication;\r\nimport org.springframework.cloud.stream.function.StreamBridge;\r\nimport org.springframework.context.annotation.Bean;\r\n\r\n@SpringBootApplication\r\npublic class ProducerApplication {\r\n\r\n  @Autowired\r\n  private StreamBridge streamBridge;\r\n\r\n  public static void main(String[] args) {\r\n    SpringApplication.run(ProducerApplication.class, args);\r\n  }\r\n\r\n  @Bean\r\n  CommandLineRunner runner() {\r\n    return args -> {\r\n      streamBridge.send(\"sendMessage\", new Order(100L, \"Laptop\"));\r\n      streamBridge.send(\"sendMessage\", new Order(101L, \"Phone\"));\r\n      streamBridge.send(\"sendMessage\", new Order(102L, \"Keyboard\"));\r\n      streamBridge.send(\"sendMessage\", new Order(100L, \"Mouse\"));\r\n    };\r\n  }\r\n}\r\n<\/pre>\n
As you can see, I’m using the `send()` method of the StreamBridge class to send a message to RabbitMQ using the binding name `sendMessage`. The content of the `Order` class is as follows:<\/p>\n
package com.huongdanjava.springcloudstream;\r\n\r\npublic record Order(Long userId, String product) {\r\n}<\/pre>\n
For the binding part, in the application.yml file, in addition to defining the binding for the `sendMessage` binding name to RabbitMQ’s `exchange`, you also need to define the following two properties:<\/p>\n
spring:\r\n  rabbitmq:\r\n    host: localhost\r\n    port: 5672\r\n    username: guest\r\n    password: guest\r\n\r\n  cloud:\r\n    stream:\r\n      bindings:\r\n        sendMessage:\r\n          destination: message.exchange\r\n          producer:\r\n            partition-key-expression: payload.userId\r\n            partition-count: 3<\/pre>\n
We will use the property spring.cloud.stream.bindings.<binding-name>.producer.partition-count<\/code> to define the number of partitions we want and the property spring.cloud.stream.bindings.<binding-name>.producer.partition-key-expression<\/code> to define the routing key, so that Spring Cloud Stream can route messages related to a specific partition.<\/p>\n
For the consumer part<\/strong>, we will define a bean for the Consumer interface to receive messages from RabbitMQ:<\/p>\n
@Bean\r\npublic Consumer<Order> processOrder() {\r\n  return order -> {\r\n    System.out.println(\"Received: \" + order);\r\n  };\r\n}<\/pre>\n
The content of the Order class is the same as in the producer section!<\/p>\n
We also define the binding information and some other properties related to partitioning in the application.yml file as follows:<\/p>\n
spring:\r\n  cloud:\r\n    stream:\r\n      bindings:\r\n        processOrder-in-0:\r\n          destination: message.exchange\r\n          group: huongdanjava\r\n          consumer:\r\n            partitioned: true\r\n      instance-count: 3<\/pre>\n
The property `spring.cloud.stream.binding.<binding-name>.consumer.partitioned` tells Spring Cloud Stream that we want to enable partitioning for this consumer application. The property `spring.cloud.stream.binding.instance-count` defines the number of partitions. Additionally, there’s another property called `spring.cloud.stream.instance-index` that we’ll use when running the consumer application to mark the corresponding consumer instance number.<\/p>\n
In my example, I’ll be running one producer application and three instances of the consumer application, so to avoid port conflicts, I’ll define the `server.port` property with a value of 0:<\/p>\n
server.port = 0<\/pre>\n
so that these applications can run using random ports.<\/p>\n
For the consumer application, I will run 3 instances with the property spring.cloud.stream.instance-index<\/code>, for example, instance 1 as follows:<\/p>\n
\"\"<\/p>\n
You can run the producer application like a normal Spring Boot application!<\/p>\n
Now, after running the three consumer instances and finally the producer application, you will see the results for each consumer instance as follows:<\/p>\n
Consumer 1:<\/p>\n
\"\"<\/p>\n
Consumer 2:<\/p>\n
\"\"<\/p>\n
Consumer 3:<\/p>\n
\"\"<\/p>\n
If you run the producer application multiple times, you’ll see that all the related messages are consumed by a specific consumer, for example:<\/p>\n
\"\"<\/p>\n
If you check the queue information in RabbitMQ, you will see that Spring Cloud Stream has automatically created 3 queues corresponding to the 3 partitions we want:<\/p>\n
\"\"<\/p>\n
Essentially, each consumer instance will subscribe to a queue corresponding to its consumer instance number, and the relevant messages will be published to each queue!<\/p>\n
So, in this tutorial, I’ve shown you how to implement partitioning with RabbitMQ using Spring Cloud Stream. The process is similar for message brokers that Spring Cloud Stream supports!<\/p>\n
Watch the video here:<\/strong><\/p>\n