RabbitMQ整合SpringBoot

最新推荐文章于 2026-06-24 15:36:43 发布

原创最新推荐文章于 2026-06-24 15:36:43 发布 · 133 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#rabbitmq #队列 #交换机

中间件专栏收录该内容

3 篇文章

订阅专栏

本文介绍如何通过Spring Boot实现RabbitMQ消息队列的生产者与消费者应用，包括配置依赖、设置交换机和队列，以及消息的发送与接收。

包结构

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <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.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

生产者配置文件：

#端口号
server:
  port: 8080

spring:
  rabbitmq:
    username: admin
    password: admin
    #虚拟主机   默认为 /
    virtual-host: /
    host: 192.168.xxx.xxx
    port: xxxx

消费者配置文件：

配置文件

#端口号
server:
  port: 8848

spring:
  rabbitmq:
    username: admin
    password: admin
    #虚拟主机   默认为 /
    virtual-host: /
    host: 192.168.xxx.xxx
    port: xxxx

在RabbitMQ与SpringBoot的整合中我们选择使用配置类的方法来把交换机和队列创建出来

这个配置类可以放在生产者中也可以放在消费者里面当然如果你想保险一点也可以都写上一个配置类

我习惯把配置类写在消费者中下面我就把代码放上

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMQConfiguration {
    //1.创建交换机
    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange("order_system_exchange",true,false);
    }
    //2.创建队列
    //商家队列
    @Bean
    public Queue queueBusiness(){
        return new Queue("queue.business",true);
    }
    //订单系统队列
    @Bean
    public Queue queueOrder(){
        return new Queue("queue.order",true);
    }
    //3.交换机绑定队列
    //绑定商家队列
    @Bean
    public Binding busBinding(){
        return BindingBuilder.bind(queueBusiness()).to(directExchange()).with("bus");
    }
	//绑定订单系统队列
    @Bean
    public Binding ordertBinding(){
        return BindingBuilder.bind(queueOrder()).to(directExchange()).with("order");
    }

}

生产者

@Service
public class OrderService {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void creatorder(OrderCreateVO orderCreateVO){
        //向消息队列发送消息
        //订单消息
        //创建一个用于传递信息的对象
        OrderMessageDTO orderMessageDTO = new OrderMessageDTO();
        //订单的id
        orderMessageDTO.setOrderId(orderPO.getId());
        //商品的id
        orderMessageDTO.setProductId(orderPO.getProductId());
        //用户id
        orderMessageDTO.setAccountId(orderCreateVO.getAccountId());
        //交换机
        String eachangeName = "order_system_exchange";
        //路由
        String routingKey = "bus";
        //发送消息
        String s = JSON.toJSONString(orderMessageDTO);//转为JOSN
        rabbitTemplate.convertAndSend(eachangeName,routingKey,s);
        System.out.println("发送消息-----------------------》");
    }
}

消费者

@Service
@RabbitListener(queues = "queue.business")
public class OrderMessagesService {

    ObjectMapper objectMapper = new ObjectMapper();
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @RabbitHandler
    public void reviceMessages(String message) throws JsonProcessingException {
        System.out.println("商家收到消息----------->"+message);
        //把收到的消息（json）转成对象
        OrderMessageDTO orderMessageDTO = objectMapper.readValue(message, OrderMessageDTO.class);
        //查询商品是否可用
        
        //查询商家是否还营业
        
        //判断商品是否可用&判断商家是否还在营业
        
        //把响应消息发送给订单系统
        //交换机
        String eachangeName = "order_system_exchange";
        //路由
        String routingKey = "order";
        rabbitTemplate.convertAndSend(eachangeName,routingKey,"商家返回消息");
    }
}

上面两个类就是生产者把一个订单的消息发送给商家商家确认以后再把确认以后的消息传给订单系统

订单系统接收商家发送的消息

@Service
@RabbitListener(queues = "queue.order")
public class BusinessMessageService {
    @RabbitHandler
    public void BusinessMessage(String message){
        System.out.println("----------->"+message);
    }
}