Spring Boot 整合 RabbitMQ 多种消息模式

川长思鸟来 2023-09-29 23:37 15阅读 0赞

#### Spring Boot 整合 RabbitMQ 多种消息模式 ####

*  准备工作
 *  集成 RabbitMQ
 *  发布/订阅模式
 *  点对点模式
 *  主题模式
 *  总结

Spring Boot 是一个流行的 Java 应用程序开发框架，而 RabbitMQ 是一款可靠的消息队列软件。将 Spring Boot 和 RabbitMQ 结合起来可以帮助我们轻松地实现异步消息传递。RabbitMQ 提供了多种消息模式，如发布/订阅模式、点对点模式、主题模式等。在本篇博客中，我们将讨论如何使用 Spring Boot 整合 RabbitMQ 并实现这些模式。

![在这里插入图片描述][a977a270735443b4a00a1047beb54d67.png]

## 准备工作 ##

在开始之前，您需要确保已经安装好 RabbitMQ，并且具有 Spring Boot 开发的基本知识。

## 集成 RabbitMQ ##

为了将 RabbitMQ 集成到 Spring Boot 中，我们需要使用以下 Maven 依赖：

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

该依赖项将提供 RabbitMQ 所需的所有类和配置。

## 发布/订阅模式 ##

在发布/订阅模式中，一个消息会被发送到多个消费者。要使用此模式，我们需要创建一个交换器，并将其绑定到一个或多个队列上。

首先，我们需要在 RabbitMQ 中创建一个交换器。在本例中，我们将使用 fanout 类型的交换器：

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

然后，我们需要创建一个或多个队列，并将其绑定到该交换器上：

@Bean
    public Queue queue1() {
        
        return new Queue("queue1");
    }
    
    @Bean
    public Queue queue2() {
        
        return new Queue("queue2");
    }
    
    @Bean
    public Binding binding1(FanoutExchange fanout, Queue queue1) {
        
        return BindingBuilder.bind(queue1).to(fanout);
    }
    
    @Bean
    public Binding binding2(FanoutExchange fanout, Queue queue2) {
        
        return BindingBuilder.bind(queue2).to(fanout);
    }

最后，我们需要创建一个消息生产者和一个消息消费者。生产者将消息发送到交换器中，消费者将从队列中接收消息：

@Service
    public class MessageProducer {
        
        private final RabbitTemplate rabbitTemplate;
    
        public MessageProducer(RabbitTemplate rabbitTemplate) {
        
            this.rabbitTemplate = rabbitTemplate;
        }
    
        public void sendMessage(String message) {
        
            rabbitTemplate.convertAndSend("fanout", "", message);
        }
    }
    
    @Service
    public class MessageConsumer1 {
        
        @RabbitListener(queues = "queue1")
        public void receiveMessage(String message) {
        
            System.out.println("Consumer 1 received message: " + message);
        }
    }
    
    @Service
    public class MessageConsumer2 {
        
        @RabbitListener(queues = "queue2")
        public void receiveMessage(String message) {
        
            System.out.println("Consumer 2 received message: " + message);
        }
    }

这样，我们就完成了发布/订阅模式的集成。

## 点对点模式 ##

在点对点模式中，一个消息只能被一个消费者接收。要使用此模式，我们需要创建一个队列，并将其绑定到一个交换器上。

首先，我们需要在 RabbitMQ 中创建一个交换器。在本例中，我们将使用 direct 类型的交换器：

@Bean
    public DirectExchange direct() {
        
        return new DirectExchange("direct");
    }

然后，我们需要创建一个队列，并将其绑定到该交换器上：

@Bean
    public Queue queue() {
        
        return new Queue("queue");
    }
    
    @Bean
    public Binding binding(DirectExchange direct, Queue queue) {
        
        return BindingBuilder.bind(queue).to(direct).with("routingKey");
    }

最后，我们需要创建一个消息生产者和一个消息消费者。生产者将消息发送到交换器中，消费者将从队列中接收消息：

@Service
    public class MessageProducer {
        
        private final RabbitTemplate rabbitTemplate;
    
        public MessageProducer(RabbitTemplate rabbitTemplate) {
        
            this.rabbitTemplate = rabbitTemplate;
        }
    
        public void sendMessage(String message) {
        
            rabbitTemplate.convertAndSend("direct", "routingKey", message);
        }
    }
    
    @Service
    public class MessageConsumer {
        
        @RabbitListener(queues = "queue")
        public void receiveMessage(String message) {
        
            System.out.println("Consumer received message: " + message);
        }
    }

这样，我们就完成了点对点模式的集成。

## 主题模式 ##

在主题模式中，一个消息可以被多个消费者接收，但是只有与消息匹配的消费者才能接收该消息。要使用此模式，我们需要创建一个交换器，并将其绑定到一个或多个队列上。交换器类型应该是 topic。

首先，我们需要在 RabbitMQ 中创建一个交换器。在本例中，我们将使用 topic 类型的交换器：

@Bean
    public TopicExchange topic() {
        
        return new TopicExchange("topic");
    }

然后，我们需要创建一个或多个队列，并将其绑定到该交换器上：

@Bean
    public Queue queue1() {
        
        return new Queue("queue1");
    }
    
    @Bean
    public Queue queue2() {
        
        return new Queue("queue2");
    }
    
    @Bean
    public Binding binding1(TopicExchange topic, Queue queue1) {
        
        return BindingBuilder.bind(queue1).to(topic).with("*.key.*");
    }
    
    @Bean
    public Binding binding2(TopicExchange topic, Queue queue2) {
        
        return BindingBuilder.bind(queue2).to(topic).with("key.#");
    }

注意，binding1 中的路由键是 “.key.”，这表示匹配任何以 “key” 为中心的单词。binding2 中的路由键是 “key.\#”，这表示匹配以 “key” 开头的所有单词。

最后，我们需要创建一个消息生产者和一个消息消费者。生产者将消息发送到交换器中，消费者将从队列中接收消息：

@Service
    public class MessageProducer {
        
        private final RabbitTemplate rabbitTemplate;
    
        public MessageProducer(RabbitTemplate rabbitTemplate) {
        
            this.rabbitTemplate = rabbitTemplate;
        }
    
        public void sendMessage(String message, String routingKey) {
        
            rabbitTemplate.convertAndSend("topic", routingKey, message);
        }
    }
    
    @Service
    public class MessageConsumer1 {
        
        @RabbitListener(queues = "queue1")
    	public void receiveMessageFromQueue1(String message) {
        
    		System.out.println("Consumer1 received message: " + message);
    	}
    }
    
    @Service
    public class MessageConsumer2 {
        
    	@RabbitListener(queues = "queue2")
    	public void receiveMessageFromQueue2(String message) {
        
    		System.out.println("Consumer2 received message: " + message);
    	}
    }

这样，我们就完成了主题模式的集成。

## 总结 ##

Spring Boot 可以轻松地集成 RabbitMQ，并支持多种消息传递模式，包括点对点模式、主题模式和发布/订阅模式。通过合理的使用这些模式，我们可以实现高效的消息传递，并使我们的应用程序更加健壮和可扩展。

[a977a270735443b4a00a1047beb54d67.png]: https://img-blog.csdnimg.cn/a977a270735443b4a00a1047beb54d67.png