RabbitMQ快速入门

最新推荐文章于 2025-06-12 09:59:16 发布

codeccb

最新推荐文章于 2025-06-12 09:59:16 发布

阅读量126

点赞数

文章标签： java-rabbitmq rabbitmq java 分布式开发语言

本文链接：https://blog.youkuaiyun.com/weixin_45519907/article/details/129377881

版权

安装

安装教程：https://blog.youkuaiyun.com/tirster/article/details/121938987

安装完成后输入：http://127.0.0.1:15672进入控制台

交换机

Direct Exchange：直连交换器，该交换器将消息发送到指定的队列上，一对一

Topic Exchange：通配符交换器，*用来表示一个单词 (必须要出现的)，#用来表示零个或多个单词

举个例子：
队列Q1绑定键为*.TT.*,队列Q2绑定键为TT.#，如果一条消息携带的路由键为 A.TT.B，队列Q1将会收到；如果一条消息携带的路由键为TT.AA.BB，那么队列Q2将会收到；

Fanout Exchange：广播交换器，这个交换机没有路由键概念，就算绑了路由键也是无视的，在接收到消息后，会直接转发到绑定到它上面的所有队列

快速使用

依赖

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

配置

properties spring.rabbitmq.host=127.0.0.1 spring.rabbitmq.port=5672 spring.rabbitmq.username=guest spring.rabbitmq.password=guest

Direct Exchange

生产者

创建DirectRabbitConfig.java，设置队列、交换器、设置绑定

```java @Configuration public class DirectRabbitConfig { //队列:"TestDirectQueue" @Bean public Queue TestDirectQueue() { return new Queue("TestDirectQueue",true); // durable:是否持久化,默认是false,持久化队列 }

//Direct交换机,起名：TestDirectExchange
@Bean
DirectExchange TestDirectExchange() {
    return new DirectExchange("TestDirectExchange",true,false);
}

//绑定  将队列和交换机绑定, 并设置路由键：TestDirectRouting
@Bean
Binding bindingDirect() {
    return BindingBuilder.bind(TestDirectQueue()).to(TestDirectExchange()).with("TestDirectRouting");
}

} ```

发送消息：

```java @RestController public class SendMessageController {

@Autowired
RabbitTemplate rabbitTemplate;

@GetMapping("/sendDirectMessage")
public String sendDirectMessage() {

    for (int i = 0; i < 100; i++) {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "test message, hello!";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String,Object> map=new HashMap<>();
        map.put("messageId",messageId);
        map.put("messageData",messageData);
        map.put("createTime",createTime);
        //将消息携带绑定键值:"TestDirectRouting" 发送到交换机TestDirectExchange
        rabbitTemplate.convertAndSend("TestDirectExchange", "TestDirectRouting", map);
    }
    return "ok";
}

} ```

消费者

如果多个消费者监听同一个队列，将下面的类再复制一份

```java @Component @RabbitListener(queues = "TestDirectQueue") //监听的队列名称:"TestDirectQueue" public class DirectReceiver { @RabbitHandler public void process(Map testMessage) { System.out.println("DirectReceiver消费者收到消息 : " + testMessage.toString()); }

} ```

Topic Exchange

生产者

```java @Configuration public class TopicRabbitConfig { //绑定键 public final static String man = "topic.man"; public final static String woman = "topic.woman";

@Bean
public Queue firstQueue() {
    return new Queue(TopicRabbitConfig.man);
}

@Bean
public Queue secondQueue() {
    return new Queue(TopicRabbitConfig.woman);
}

@Bean
TopicExchange exchange() {
    return new TopicExchange("topicExchange");
}

// 将firstQueue和topicExchange绑定,绑定的键为topic.man
// 这样只要是消息携带的路由键是topic.man,才会分发到该队列
@Bean
Binding bindingExchangeMessage() {
    return BindingBuilder.bind(firstQueue()).to(exchange()).with(man);
}

// 将secondQueue和topicExchange绑定,绑定的键为topic.#
// 这样只要是消息携带的路由键是以topic.开头,都会分发到该队列
@Bean
Binding bindingExchangeMessage2() {
    return BindingBuilder.bind(secondQueue()).to(exchange()).with("topic.#");
}

} ```

添加多2个接口，用于推送消息到交换机

```java @GetMapping("/sendTopicMessage1") public String sendTopicMessage1() { String messageId = String.valueOf(UUID.randomUUID()); String messageData = "message: M A N "; String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")); Map manMap = new HashMap<>(); manMap.put("messageId", messageId); manMap.put("messageData", messageData); manMap.put("createTime", createTime); rabbitTemplate.convertAndSend("topicExchange", "topic.man", manMap); return "ok"; }

@GetMapping("/sendTopicMessage2") public String sendTopicMessage2() { String messageId = String.valueOf(UUID.randomUUID()); String messageData = "message: woman is all "; String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")); Map womanMap = new HashMap<>(); womanMap.put("messageId", messageId); womanMap.put("messageData", messageData); womanMap.put("createTime", createTime); rabbitTemplate.convertAndSend("topicExchange", "topic.woman", womanMap); return "ok"; } ```

消费者

java @Component @RabbitListener(queues = "topic.man") public class TopicManReceiver { @RabbitHandler public void process(Map testMessage) { System.out.println("TopicManReceiver消费者收到消息 : " + testMessage.toString()); } }

java @Component @RabbitListener(queues = "topic.woman") public class TopicWomenReceiver { @RabbitHandler public void process(Map testMessage) { System.out.println("TopicTotalReceiver消费者收到消息 : " + testMessage.toString()); } }

通配符交换器.png

TopicWomenReceiver监听队列"topic.woman"，绑定键为：topic.#
TopicManReceiver监听队列"topic.man"，绑定键为：topic.#
调用/sendTopicMessage1接口时，由于消息携带的键为"topic.man"，交换机根据匹配规则，这两个队列都会收到消息
调用/sendTopicMessage2接口时，由于消息携带的键为"topic.woman"，交换机根据匹配规则，只会将消息发送到topic.woman队列

Fanout Exchang

生产者

创建FanoutRabbitConfig.java

```java /** * 创建三个队列：fanout.A fanout.B fanout.C * 将三个队列都绑定在交换机 fanoutExchange 上 * 因为是广播交换机, 路由键无需配置,配置也不起作用 */ @Configuration public class FanoutRabbitConfig { @Bean public Queue queueA() { return new Queue("fanout.A"); }

@Bean
public Queue queueB() {
    return new Queue("fanout.B");
}

@Bean
public Queue queueC() {
    return new Queue("fanout.C");
}

@Bean
FanoutExchange fanoutExchange() {
    return new FanoutExchange("fanoutExchange");
}

@Bean
Binding bindingExchangeA() {
    return BindingBuilder.bind(queueA()).to(fanoutExchange());
}

@Bean
Binding bindingExchangeB() {
    return BindingBuilder.bind(queueB()).to(fanoutExchange());
}

@Bean
Binding bindingExchangeC() {
    return BindingBuilder.bind(queueC()).to(fanoutExchange());
}

} ```

然后写一个接口用于推送消息

java @GetMapping("/sendFanoutMessage") public String sendFanoutMessage() { String messageId = String.valueOf(UUID.randomUUID()); String messageData = "message: testFanoutMessage "; String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")); Map<String, Object> map = new HashMap<>(); map.put("messageId", messageId); map.put("messageData", messageData); map.put("createTime", createTime); rabbitTemplate.convertAndSend("fanoutExchange", null, map); return "ok"; }

消费者

在rabbitmq-consumer项目里加上消息消费类:FanoutReceiverA.java、FanoutReceiverB.java、FanoutReceiverC.java

```java @Component @RabbitListener(queues = "fanout.A") public class FanoutReceiverA {

@RabbitHandler
public void process(Map testMessage) {
    System.out.println("FanoutReceiverA消费者收到消息  : " +testMessage.toString());
}

} ```

```java @Component @RabbitListener(queues = "fanout.B") public class FanoutReceiverB {

@RabbitHandler
public void process(Map testMessage) {
    System.out.println("FanoutReceiverB消费者收到消息  : " +testMessage.toString());
}

} ```

```java @Component @RabbitListener(queues = "fanout.C") public class FanoutReceiverC {

@RabbitHandler
public void process(Map testMessage) {
    System.out.println("FanoutReceiverC消费者收到消息  : " +testMessage.toString());
}

} ```

只要发送到fanoutExchange这个交换机的消息，都会发送到与它绑定的队列

消息回调

配置

properties spring.rabbitmq.publisher-confirm-type=correlated

生产者

推送消息存在三种情况：

①消息推送到server，但在server里找不到交换机，触发ConfirmCallback 回调函数

②消息推送到server，找到交换机了，但没找到队列，触发ConfirmCallback和RetrunCallback两个回调函数

③消息推送成功，触发ConfirmCallback回调函数

```java @Configuration public class RabbitConfig {

@Bean
public RabbitTemplate createRabbitTemplate(ConnectionFactory connectionFactory){
    RabbitTemplate rabbitTemplate = new RabbitTemplate();
    rabbitTemplate.setConnectionFactory(connectionFactory);
    //设置开启Mandatory,才能触发回调函数,无论消息推送结果怎么样都强制调用回调函数
    rabbitTemplate.setMandatory(true);

    rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
        @Override
        public void confirm(CorrelationData correlationData, boolean ack, String cause) {
            System.out.println("ConfirmCallback:     "+"相关数据："+correlationData);
            System.out.println("ConfirmCallback:     "+"确认情况："+ack);
            System.out.println("ConfirmCallback:     "+"原因："+cause);
        }
    });

    rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
        @Override
        public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
            System.out.println("ReturnCallback:     "+"消息："+message);
            System.out.println("ReturnCallback:     "+"回应码："+replyCode);
            System.out.println("ReturnCallback:     "+"回应信息："+replyText);
            System.out.println("ReturnCallback:     "+"交换机："+exchange);
            System.out.println("ReturnCallback:     "+"路由键："+routingKey);
        }
    });

    return rabbitTemplate;
}

} ```

消费者

消息接收的确认方式主要有两种：
①自动确认：RabbitMQ成功将消息发出，立即认为本次投递已被正确处理，不管消费者是否成功处理本次投递，所以这种情况如果消费端抛出异常，也就是消费端没有处理成功这条消息，那么就相当于丢失了消息

②手动确认：消费者收到消息后，手动调用basic.ack/basic.reject后，RabbitMQ收到这些消息后，才认为本次投递成功

```java @Configuration public class MessageListenerConfig {

@Autowired
private CachingConnectionFactory connectionFactory;
@Autowired
private MyAckReceiver myAckReceiver;//消息接收处理类

@Bean
public SimpleMessageListenerContainer simpleMessageListenerContainer() {
    SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory);
    container.setConcurrentConsumers(1);
    container.setMaxConcurrentConsumers(1);
    container.setAcknowledgeMode(AcknowledgeMode.MANUAL); // RabbitMQ默认是自动确认，这里改为手动确认消息
    //设置一个队列
    container.setQueueNames("TestDirectQueue");

    // 设置多个队列,就使用addQueues
    // container.setQueues(new Queue("TestDirectQueue",true));
    // container.addQueues(new Queue("TestDirectQueue2",true));
    // container.addQueues(new Queue("TestDirectQueue3",true));
    container.setMessageListener(myAckReceiver);

    return container;
}

} ```

java @Component public class MyAckReceiver implements ChannelAwareMessageListener { @Override public void onMessage(Message message, Channel channel) throws Exception { long deliveryTag = message.getMessageProperties().getDeliveryTag(); try { byte[] body = message.getBody(); ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(body)); Map<String,String> msgMap = (Map<String,String>) ois.readObject(); String messageId = msgMap.get("messageId"); String messageData = msgMap.get("messageData"); ois.close(); System.out.println("MyAckReceiver messageId:"+messageId+" messageData:"+messageData); System.out.println("消费的消息来自："+message.getMessageProperties().getConsumerQueue()); channel.basicAck(deliveryTag, true); // 第二个参数为true, 可以批处理确认消息 } catch (Exception e) { channel.basicReject(deliveryTag, false); e.printStackTrace(); } } }

监听多个队列，不同队列处理的业务逻辑不同

在该MessageListenerConfig.java文件中添加多个队列

```java @Configuration public class MessageListenerConfig {

@Autowired private CachingConnectionFactory connectionFactory; @Autowired private MyAckReceiver myAckReceiver;//消息接收处理类

@Bean public SimpleMessageListenerContainer simpleMessageListenerContainer() { SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory); container.setConcurrentConsumers(1); container.setMaxConcurrentConsumers(1); container.setAcknowledgeMode(AcknowledgeMode.MANUAL); // RabbitMQ默认是自动确认，这里改为手动确认消息 // 设置一个队列 // container.setQueueNames("TestDirectQueue"); // 设置多个队列, 前提是队列必须是已存在的 container.setQueueNames("TestDirectQueue","fanout.A");
```
container.setMessageListener(myAckReceiver);

  return container;
```
} } ```

我们需要做不同的业务处理，那么只需要根据消息的队列名进行区分即可

```java @Component public class MyAckReceiver implements ChannelAwareMessageListener { @Override public void onMessage(Message message, Channel channel) throws Exception { long deliveryTag = message.getMessageProperties().getDeliveryTag();

try {
      byte[] body = message.getBody();
      ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(body));
      Map<String, String> msgMap = (Map<String, String>) ois.readObject();
      String messageId = msgMap.get("messageId");
      String messageData = msgMap.get("messageData");
      ois.close();

      if ("TestDirectQueue".equals(message.getMessageProperties().getConsumerQueue())) {
          System.out.println("消费的消息来自的队列名为：" + message.getMessageProperties().getConsumerQueue());
          System.out.println("消息成功消费到  messageId:" + messageId + "  messageData:" + messageData);
          System.out.println("执行TestDirectQueue中的消息的业务处理流程......");

      }

      if ("fanout.A".equals(message.getMessageProperties().getConsumerQueue())) {
          System.out.println("消费的消息来自的队列名为：" + message.getMessageProperties().getConsumerQueue());
          System.out.println("消息成功消费到  messageId:" + messageId + "  messageData:" + messageData);
          System.out.println("执行fanout.A中的消息的业务处理流程......");

      }
      channel.basicAck(deliveryTag, true);
  } catch (Exception e) {
      channel.basicReject(deliveryTag, false);
      e.printStackTrace();
  }

} } ```

Springboot 整合RabbitMq ，用心看完这一篇就够了