1. Install rabbitmq
2. Create a new spring Book project: rabbitmq_demo
3. Adding pom dependencies:
<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> </dependencies>
4.application.properties:
server.port=8080 spring.application.name=rabbitmq_demo spring.rabbitmq.host=localhost spring.rabbitmq.port=5672 spring.rabbitmq.username=guest spring.rabbitmq.password=guest spring.rabbitmq.publisher-confirms=true spring.rabbitmq.virtual-host=/
5. The startup class declares a Queue for testing:
package com; import org.springframework.amqp.core.Binding; import org.springframework.amqp.core.BindingBuilder; import org.springframework.amqp.core.FanoutExchange; import org.springframework.amqp.core.Queue; import org.springframework.amqp.core.TopicExchange; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.annotation.Bean; @SpringBootApplication public class RabbitmqDemoApplication { @Bean public Queue helloQueue() { return new Queue("helloQueue"); } public static void main(String[] args) { SpringApplication.run(RabbitmqDemoApplication.class, args); } }
Multi-scenario implementation:
1. Single producer and single consumer
Producer 1:
package com.demo.sender; import com.demo.model.User; import org.springframework.amqp.core.AmqpTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import java.util.Date; /** * @Description: * Producer 1 */ @Component public class Sender1 { @Autowired private AmqpTemplate rabbitTemplate; public void send() { String sendMsg = "hello1 " + new Date(); System.out.println("Sender1:" + sendMsg); rabbitTemplate.convertAndSend("helloQueue", sendMsg); } }
Consumer 1:
package com.demo.receiver; import com.demo.model.User; import org.springframework.amqp.rabbit.annotation.RabbitHandler; import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; /** * @Description: * helloQueue Consumer 1 */ @Component @RabbitListener(queues = "helloQueue") public class HelloReceiver1 { @RabbitHandler public void process(String hello) { System.out.println("Receiver1:" + hello); } }
Testing controller:
package com.demo.controller; import com.demo.model.User; import com.demo.sender.Sender1; import com.demo.sender.Sender2; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; /** * @Description: Test class */ @RestController public class RabbitController { @Autowired private Sender1 helloSender1; @RequestMapping("/hello") public String hello() { helloSender1.send(); return "ok"; } }
Run the project and visit http:localhost:8080/hello:
Sender1:hello1 Thu May 11 17:23:31 CST 2017 Receiver1:hello1 Thu May 11 17:23:31 CST 2017
2. Single producer-multi-consumer
Producer 1 remains unchanged
Increase consumer 2:
package com.demo.receiver; import com.demo.model.User; import org.springframework.amqp.rabbit.annotation.RabbitHandler; import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; /** * @Description: * helloQueue Consumer 2 */ @Component @RabbitListener(queues = "helloQueue") public class HelloReceiver2 { @RabbitHandler public void process(String mesg) { System.out.println("Receiver2:" + mesg); } }
Testing controller:
package com.demo.controller; import com.demo.model.User; import com.demo.sender.Sender1; import com.demo.sender.Sender2; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; /** * @Description: Test class */ @RestController public class RabbitController { @Autowired private Sender1 helloSender1; @RequestMapping("/hello") public String hello() { helloSender1.send(); helloSender1.send(); return "ok"; } }
Run the project and visit http:localhost:8080/hello:
Sender1:hello1 Thu May 11 17:23:31 CST 2017 Sender1:hello1 Thu May 11 17:23:31 CST 2017 Receiver1:hello1 Thu May 11 17:23:31 CST 2017 Receiver2:hello1 Thu May 11 17:23:31 CST 2017
Messages are consumed alternately by multiple consumers, and each message can only be received by one consumer.
3. Multi-producer-multi-consumer
Increase producer 2:
package com.demo.sender; import com.demo.model.User; import org.springframework.amqp.core.AmqpTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import java.util.Date; /** * @Description: Producer 2 */ @Component public class Sender2 { @Autowired private AmqpTemplate rabbitTemplate; public void send() { String sendMsg = "hello2 " + new Date(); System.out.println("Sender2:" + sendMsg); rabbitTemplate.convertAndSend("helloQueue", sendMsg); } }
Consumer 1 and 2 remain unchanged
Test controller:
package com.demo.controller; import com.demo.model.User; import com.demo.sender.Sender1; import com.demo.sender.Sender2; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; /** * @Description: Test class */ @RestController public class RabbitController { @Autowired private Sender1 helloSender1; @Autowired private Sender2 helloSender2; @RequestMapping("/hello") public String hello() { helloSender1.send(); helloSender2.send(); return "ok"; } }
Run the project and visit http:localhost:8080/hello:
Sender1:hello1 Thu May 11 17:23:31 CST 2017 Sender2:hello2 Thu May 11 17:23:31 CST 2017 Receiver1:hello2 Thu May 11 17:23:31 CST 2017 Receiver2:hello1 Thu May 11 17:23:31 CST 2017
Multiple producers put messages into the helloQueue queue, and messages in the queue are consumed alternately by multiple consumers, each message can only be received by one consumer.
4. Entity class transport
To support the sending and receiving of objects, entity classes only need to support serialization.
Entity class
package com.demo.model; import java.io.Serializable; /** * @Description: */ public class User implements Serializable { private String userName; private String password; private String sex; private String level; public String getUserName() { return userName; } public void setUserName(String userName) { this.userName = userName; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } public String getLevel() { return level; } public void setLevel(String level) { this.level = level; } }
Producer 1:
package com.demo.sender; import com.demo.model.User; import org.springframework.amqp.core.AmqpTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import java.util.Date; /** * @Description: * Producer 1 */ @Component public class Sender1 { @Autowired private AmqpTemplate rabbitTemplate; public void send() { String sendMsg = "hello1 " + new Date(); System.out.println("Sender1:" + sendMsg); rabbitTemplate.convertAndSend("helloQueue", sendMsg); } public void sendUser(User user){ System.out.println("user Sender1:" + user.getUserName()+"/"+user.getPassword()); rabbitTemplate.convertAndSend("helloQueue", user); } }
Producer 2:
package com.demo.sender; import com.demo.model.User; import org.springframework.amqp.core.AmqpTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import java.util.Date; /** * @Description: Producer 2 */ @Component public class Sender2 { @Autowired private AmqpTemplate rabbitTemplate; public void send() { String sendMsg = "hello2 " + new Date(); System.out.println("Sender2:" + sendMsg); rabbitTemplate.convertAndSend("helloQueue", sendMsg); } public void sendUser(User user) { System.out.println("user Sender2:" + user.getUserName() + "/" + user.getPassword()); rabbitTemplate.convertAndSend("helloQueue", user); } }
Consumer 1:
package com.demo.receiver; import com.demo.model.User; import org.springframework.amqp.rabbit.annotation.RabbitHandler; import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; /** * @Description: * helloQueue Consumer 1 */ @Component @RabbitListener(queues = "helloQueue") public class HelloReceiver1 { @RabbitHandler public void process(String hello) { System.out.println("Receiver1:" + hello); } @RabbitHandler public void processUser(User user) { System.out.println("user receive1:" + user.getUserName()+"/"+user.getPassword()); } }
Consumer 2:
package com.demo.receiver; import com.demo.model.User; import org.springframework.amqp.rabbit.annotation.RabbitHandler; import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; /** * @Description: * helloQueue Consumer 2 */ @Component @RabbitListener(queues = "helloQueue") public class HelloReceiver2 { @RabbitHandler public void process(String mesg) { System.out.println("Receiver2:" + mesg); } @RabbitHandler public void processUser(User user) { System.out.println("user receive2:" + user.getUserName()+"/"+user.getPassword()); } }
controller for testing:
package com.demo.controller; import com.demo.model.User; import com.demo.sender.Sender1; import com.demo.sender.Sender2; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; /** * @Description: Test class */ @RestController public class RabbitController { @Autowired private Sender1 helloSender1; @Autowired private Sender2 helloSender2; @RequestMapping("/hello") public String hello() { helloSender1.send(); helloSender2.send(); return "ok"; } @RequestMapping("/user") public String user() { User user=new User(); user.setUserName("a"); user.setPassword("1"); user.setSex("m"); user.setLevel("1"); helloSender1.sendUser(user); helloSender2.sendUser(user); return "ok"; } }
Run the project and visit http:localhost:8080/user:
user Sender1:a/1 user Sender2:a/1 user receive1:a/1 user receive2:a/1
5. Use of Topic Exchange
The startup class declares two new Queue s for testing:
package com; import org.springframework.amqp.core.Binding; import org.springframework.amqp.core.BindingBuilder; import org.springframework.amqp.core.FanoutExchange; import org.springframework.amqp.core.Queue; import org.springframework.amqp.core.TopicExchange; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.annotation.Bean; @SpringBootApplication public class RabbitmqDemoApplication { /***************************************Queue***********************************************************************************/ @Bean public Queue helloQueue() { return new Queue("helloQueue"); } @Bean public Queue topicMessage() { return new Queue("topicMessage"); } @Bean public Queue topicMessages() { return new Queue("topicMessages"); } /***************************************exchange***********************************************/ @Bean TopicExchange topicExchange() { return new TopicExchange("topicExchange"); } /***************************************Binding queues and exchange s *****************************************************************************************************************/ /** * Binding queue topicMessage to topicExchange, * Only the column name is topic.Message can match. * Get the current Queue * @param topicMessage * @param topicExchange * @return */ @Bean Binding bindingExchangeMessage(Queue topicMessage, TopicExchange topicExchange) { return BindingBuilder.bind(topicMessage).to(topicExchange).with("topic.Message"); } /** * Binding queue topicMessages to topicExchange, * Column names that start with topic are ambiguously matched. * Get the current Queue * @param topicMessages * @param topicExchange * @return */ @Bean Binding bindingExchangeMessages(Queue topicMessages, TopicExchange topicExchange) { return BindingBuilder.bind(topicMessages).to(topicExchange).with("topic.#"); } public static void main(String[] args) { SpringApplication.run(RabbitmqDemoApplication.class, args); } }
Producer 1:
package com.demo.sender; import com.demo.model.User; import org.springframework.amqp.core.AmqpTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import java.util.Date; /** * @Description: * Producer 1 */ @Component public class Sender1 { @Autowired private AmqpTemplate rabbitTemplate; public void send() { String sendMsg = "hello1 " + new Date(); System.out.println("Sender1:" + sendMsg); rabbitTemplate.convertAndSend("helloQueue", sendMsg); } public void sendUser(User user){ System.out.println("user Sender1:" + user.getUserName()+"/"+user.getPassword()); rabbitTemplate.convertAndSend("helloQueue", user); } public void testTopPicMessage() { String msg = "sendTopPicMessage"; System.out.println("sendTopPicMessage1:" + msg); //First parameter: exchange is specified //The second parameter: specifies the column name of the message to be received //The third parameter: message content //Go to the specified exchange to find the regular expression with the second parameter, get the corresponding Queue, and listen to the consumers of the corresponding Queue to receive the message. rabbitTemplate.convertAndSend("topicExchange", "topic.Message", msg);//Top. Message, topic. # both fit msg = "sendTopPicMessages"; System.out.println("sendTopPicMessages1:" + msg); rabbitTemplate.convertAndSend("topicExchange", "topic.Messages", msg);//Only topic. # corresponds. } }
Producer 2:
package com.demo.sender; import com.demo.model.User; import org.springframework.amqp.core.AmqpTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import java.util.Date; /** * @Description: Producer 2 */ @Component public class Sender2 { @Autowired private AmqpTemplate rabbitTemplate; public void send() { String sendMsg = "hello2 " + new Date(); System.out.println("Sender2:" + sendMsg); rabbitTemplate.convertAndSend("helloQueue", sendMsg); } public void sendUser(User user) { System.out.println("user Sender2:" + user.getUserName() + "/" + user.getPassword()); rabbitTemplate.convertAndSend("helloQueue", user); } public void testTopPicMessage() { String msg = "sendTopPicMessage"; System.out.println("sendTopPicMessage2:" + msg); //First parameter: exchange is specified //The second parameter: specifies the column name of the message to be received //The third parameter: message content //Go to the specified exchange to find the regular expression with the second parameter, get the corresponding Queue, and listen to the consumers of the corresponding Queue to receive the message. rabbitTemplate.convertAndSend("topicExchange", "topic.Message", msg);//Top. Message, topic. # both fit msg = "sendTopPicMessages"; System.out.println("sendTopPicMessages2:" + msg); rabbitTemplate.convertAndSend("topicExchange", "topic.Messages", msg);//Only topic. # corresponds. } }
topicMessage consumers:
package com.demo.receiver; import org.springframework.amqp.rabbit.annotation.RabbitHandler; import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; /** * @Description: * topicMessage Consumer */ @Component @RabbitListener(queues = "topicMessage") public class TopMessageReceiver { @RabbitHandler public void process(String msg) { System.out.println("topMessageReceiver:" +msg); } }
topicMessages consumers:
package com.demo.receiver; import org.springframework.amqp.rabbit.annotation.RabbitHandler; import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; /** * @Description: * topicMessages Consumer */ @Component @RabbitListener(queues = "topicMessages") public class TopMessagesReceiver { @RabbitHandler public void process(String msg) { System.out.println("topMessagesReceiver:" +msg); } }
Testing controller:
package com.demo.controller; import com.demo.model.User; import com.demo.sender.Sender1; import com.demo.sender.Sender2; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; /** * @Description: Test class */ @RestController public class RabbitController { @Autowired private Sender1 helloSender1; @Autowired private Sender2 helloSender2; @RequestMapping("/hello") public String hello() { helloSender1.send(); helloSender2.send(); return "ok"; } @RequestMapping("/user") public String user() { User user=new User(); user.setUserName("a"); user.setPassword("1"); user.setSex("m"); user.setLevel("1"); helloSender1.sendUser(user); helloSender2.sendUser(user); return "ok"; } @RequestMapping("/topMessage") public String topMessage() { helloSender1.testTopPicMessage(); helloSender2.testTopPicMessage(); return "ok"; } }
Run the project and access http:localhost:8080/topMessage:
sendTopPicMessage1:sendTopPicMessage
sendTopPicMessages1:sendTopPicMessages
sendTopPicMessage2:sendTopPicMessage
sendTopPicMessages2:sendTopPicMessages
topMessageReceiver:sendTopPicMessage
topMessagesReceiver:sendTopPicMessage
topMessagesReceiver:sendTopPicMessages
topMessageReceiver:sendTopPicMessage
topMessagesReceiver:sendTopPicMessage
topMessagesReceiver:sendTopPicMessages
Every message sent through exchange can be received by all consumers.
Attention should be paid to:
Rabbit Template. ConversAndSend ("topicExchange", "topic. Message", "msg); //topic. Message, topic. # both meet, so both consumers receive messages.
Rabbit Template. ConversAndSend ("topicExchange", "topic. Messages", "msg); //Only topic. # meets, only topMessages meets the criteria for accepting messages.
6. Use of FanoutExchange
The startup class declares three new Queue s for testing:
package com; import org.springframework.amqp.core.Binding; import org.springframework.amqp.core.BindingBuilder; import org.springframework.amqp.core.FanoutExchange; import org.springframework.amqp.core.Queue; import org.springframework.amqp.core.TopicExchange; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.annotation.Bean; @SpringBootApplication public class RabbitmqDemoApplication { /***************************************Queue***********************************************************************************/ @Bean public Queue helloQueue() { return new Queue("helloQueue"); } @Bean public Queue topicMessage() { return new Queue("topicMessage"); } @Bean public Queue topicMessages() { return new Queue("topicMessages"); } @Bean public Queue fanoutA() { return new Queue("fanoutA"); } @Bean public Queue fanoutB() { return new Queue("fanoutB"); } @Bean public Queue fanoutC() { return new Queue("fanoutC"); } /***************************************exchange***********************************************/ @Bean TopicExchange topicExchange() { return new TopicExchange("topicExchange"); } @Bean FanoutExchange fanoutExchange() { return new FanoutExchange("fanoutExchange"); } /***************************************Binding queues and exchange s *****************************************************************************************************************/ /** * Binding queue topicMessage to topicExchange, * Only the column name is topic.Message can match. * Get the current Queue * @param topicMessage * @param topicExchange * @return */ @Bean Binding bindingExchangeMessage(Queue topicMessage, TopicExchange topicExchange) { return BindingBuilder.bind(topicMessage).to(topicExchange).with("topic.Message"); } /** * Binding queue topicMessages to topicExchange, * Column names that start with topic are ambiguously matched. * Get the current Queue * @param topicMessages * @param topicExchange * @return */ @Bean Binding bindingExchangeMessages(Queue topicMessages, TopicExchange topicExchange) { return BindingBuilder.bind(topicMessages).to(topicExchange).with("topic.#"); } /** * Binding queue fanoutA to fanoutExchange * * @param fanoutA * @param fanoutExchange * @return */ @Bean Binding bindingExchangeA(Queue fanoutA, FanoutExchange fanoutExchange) { return BindingBuilder.bind(fanoutA).to(fanoutExchange); } /** * Binding queue fanoutA to fanoutExchange * * @param fanoutB * @param fanoutExchange * @return */ @Bean Binding bindingExchangeB(Queue fanoutB, FanoutExchange fanoutExchange) { return BindingBuilder.bind(fanoutB).to(fanoutExchange); } /** * Binding queue fanoutA to fanoutExchange * * @param fanoutC * @param fanoutExchange * @return */ @Bean Binding bindingExchangeC(Queue fanoutC, FanoutExchange fanoutExchange) { return BindingBuilder.bind(fanoutC).to(fanoutExchange); } public static void main(String[] args) { SpringApplication.run(RabbitmqDemoApplication.class, args); } }
Producer 1:
package com.demo.sender; import com.demo.model.User; import org.springframework.amqp.core.AmqpTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import java.util.Date; /** * @Description: * Producer 1 */ @Component public class Sender1 { @Autowired private AmqpTemplate rabbitTemplate; public void send() { String sendMsg = "hello1 " + new Date(); System.out.println("Sender1:" + sendMsg); rabbitTemplate.convertAndSend("helloQueue", sendMsg); } public void sendUser(User user){ System.out.println("user Sender1:" + user.getUserName()+"/"+user.getPassword()); rabbitTemplate.convertAndSend("helloQueue", user); } public void testTopPicMessage() { String msg = "sendTopPicMessage"; System.out.println("sendTopPicMessage1:" + msg); //First parameter: exchange is specified //The second parameter: specifies the column name of the message to be received //The third parameter: message content //Go to the specified exchange to find the regular expression with the second parameter, get the corresponding Queue, and listen to the consumers of the corresponding Queue to receive the message. rabbitTemplate.convertAndSend("topicExchange", "topic.Message", msg);//Top. Message, topic. # both fit msg = "sendTopPicMessages"; System.out.println("sendTopPicMessages1:" + msg); rabbitTemplate.convertAndSend("topicExchange", "topic.Messages", msg);//Only topic. # corresponds. } public void testFanoutMessage(){ String sendMsg = "sendFanoutMessage"; System.out.println("fanout Sender1:" + sendMsg); //The second parameter does not filter regular expressions //But you have to fill in to find the relevant Queue based on exchange rabbitTemplate.convertAndSend("fanoutExchange","", sendMsg); } }
Producer 2:
package com.demo.sender; import com.demo.model.User; import org.springframework.amqp.core.AmqpTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import java.util.Date; /** * @Description: Producer 2 */ @Component public class Sender2 { @Autowired private AmqpTemplate rabbitTemplate; public void send() { String sendMsg = "hello2 " + new Date(); System.out.println("Sender2:" + sendMsg); rabbitTemplate.convertAndSend("helloQueue", sendMsg); } public void sendUser(User user) { System.out.println("user Sender2:" + user.getUserName() + "/" + user.getPassword()); rabbitTemplate.convertAndSend("helloQueue", user); } public void testTopPicMessage() { String msg = "sendTopPicMessage"; System.out.println("sendTopPicMessage2:" + msg); //First parameter: exchange is specified //The second parameter: specifies the column name of the message to be received //The third parameter: message content //Go to the specified exchange to find the regular expression with the second parameter, get the corresponding Queue, and listen to the consumers of the corresponding Queue to receive the message. rabbitTemplate.convertAndSend("topicExchange", "topic.Message", msg);//Top. Message, topic. # both fit msg = "sendTopPicMessages"; System.out.println("sendTopPicMessages2:" + msg); rabbitTemplate.convertAndSend("topicExchange", "topic.Messages", msg);//Only topic. # corresponds. } public void testFanoutMessage(){ String sendMsg = "sendFanoutMessage"; System.out.println("fanout Sender2:" + sendMsg); //The second parameter does not filter regular expressions //But you have to fill in to find the relevant Queue based on exchange rabbitTemplate.convertAndSend("fanoutExchange","", sendMsg); } }
fanoutA consumers
package com.demo.receiver; import org.springframework.amqp.rabbit.annotation.RabbitHandler; import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; /** * @Description: * fanoutA Consumer */ @Component @RabbitListener(queues = "fanoutA") public class FanoutReceiverA { @RabbitHandler public void process(String msg) { System.out.println("FanoutReceiverA:" + msg); } }
fanoutB consumers
package com.demo.receiver; import org.springframework.amqp.rabbit.annotation.RabbitHandler; import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; /** * @Description: * fanoutB Consumer */ @Component @RabbitListener(queues = "fanoutB") public class FanoutReceiverB { @RabbitHandler public void process(String msg) { System.out.println("FanoutReceiverB:" + msg); } }
fanoutC consumers
package com.demo.receiver; import org.springframework.amqp.rabbit.annotation.RabbitHandler; import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; /** * @Description: * fanoutC Consumer */ @Component @RabbitListener(queues = "fanoutC") public class FanoutReceiverC { @RabbitHandler public void process(String msg) { System.out.println("FanoutReceiverC:" + msg); } }
Testing controller:
package com.demo.controller; import com.demo.model.User; import com.demo.sender.Sender1; import com.demo.sender.Sender2; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; /** * @Description: Test class */ @RestController public class RabbitController { @Autowired private Sender1 helloSender1; @Autowired private Sender2 helloSender2; @RequestMapping("/hello") public String hello() { helloSender1.send(); helloSender2.send(); return "ok"; } @RequestMapping("/user") public String user() { User user=new User(); user.setUserName("a"); user.setPassword("1"); user.setSex("m"); user.setLevel("1"); helloSender1.sendUser(user); helloSender2.sendUser(user); return "ok"; } @RequestMapping("/topMessage") public String topMessage() { helloSender1.testTopPicMessage(); helloSender2.testTopPicMessage(); return "ok"; } @RequestMapping("/fanoutMessage") public String fanoutMessage() { helloSender1.testFanoutMessage(); helloSender2.testFanoutMessage(); return "ok"; } }
Run the project and visit http:localhost:8080/fanoutMessage:
fanout Sender1:sendFanoutMessage
fanout Sender2:sendFanoutMessage
FanoutReceiverA:sendFanoutMessage
FanoutReceiverB:sendFanoutMessage
FanoutReceiverC:sendFanoutMessage
FanoutReceiverA:sendFanoutMessage
FanoutReceiverB:sendFanoutMessage
FanoutReceiverC:sendFanoutMessage
Every message sent through exchange can be received by all consumers.