RabbitMQ实战篇7-在订单服务中配置RabbitMQ，实现消息发送

阳光穿透心脏的1/2处 2022-05-22 04:47 123阅读 0赞

在这里以订单服务为消息生产者，代码中都有详细的注释和说明，以下是示例：

## 添加依赖 ##

首先，创建一个web工程（在这里我使用springboot2.0.2）。加入rabbitMQ所需要的依赖：

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

同时，我也添加了一些常用依赖

<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-devtools</artifactId>
    			<scope>runtime</scope>
    		</dependency>
    		<dependency>
    			<groupId>org.projectlombok</groupId>
    			<artifactId>lombok</artifactId>
    			<optional>true</optional>
    		</dependency>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-test</artifactId>
    			<scope>test</scope>
    		</dependency>
    
    		<dependency>
    			<groupId>com.google.code.gson</groupId>
    			<artifactId>gson</artifactId>
    			<version>2.8.2</version>
    		</dependency>

## 配置RabbitMQ ##

然后，我们需要在项目中配置RabbitMQ

### 1、配置连接信息 ###

spring:
      rabbitmq:
        host: 116.85.38.99
        port: 5672
        username: xxxxx
        password: xxxxx

### 2、配置消息交换机  exchange ###

新建一个配置类，配置一个消息交换机

package com.space.rbq.order.config;
    
    import org.springframework.amqp.core.DirectExchange;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /**
     * 消息交换机配置  可以配置多个
     * @author zhuzhe
     * @date 2018/5/25 15:40
     * @email 1529949535@qq.com
     */
    @Configuration
    public class ExchangeConfig {
    
        /** 消息交换机1的名字*/
        public final String EXCHANGE_01 = "first_exchange";
    
        /**
         *   1.定义direct exchange，绑定first_exchange
         *   2.durable="true" 持久化交换机， rabbitmq重启的时候不需要创建新的交换机
         *   3.direct交换器相对来说比较简单，匹配规则为：如果路由键匹配，消息就被投送到相关的队列
         *     fanout交换器中没有路由键的概念，他会把消息发送到所有绑定在此交换器上面的队列中。
         *     topic交换器你采用模糊匹配路由键的原则进行转发消息到队列中
         */
        @Bean
        public DirectExchange directExchange(){
            DirectExchange directExchange = new DirectExchange(EXCHANGE_01,true,false);
            return directExchange;
        }
    }

### 3、配置队列  queue ###

*注：在这里，我们只使用到第一个队列  FirstQueue*

package com.space.rbq.order.config;
    
    import org.springframework.amqp.core.Queue;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * 队列配置  可以配置多个队列
     * @author zhuzhe
     * @date 2018/5/25 13:25
     * @email 1529949535@qq.com
     */
    @Configuration
    public class QueueConfig {
    
        /*对列名称*/
        public static final String QUEUE_NAME1 = "first-queue";
        public static final String QUEUE_NAME2 = "second-queue";
        public static final String QUEUE_NAME3 = "third-queue";
    
        @Bean
        public Queue firstQueue() {
            /**
             durable="true" 持久化消息队列 ， rabbitmq重启的时候不需要创建新的队列
             auto-delete 表示消息队列没有在使用时将被自动删除 默认是false
             exclusive  表示该消息队列是否只在当前connection生效,默认是false
             */
            return new Queue(QUEUE_NAME1,true,false,false);
        }
    
        @Bean
        public Queue secondQueue() {
            return new Queue(QUEUE_NAME2,true,false,false);
        }
    
        @Bean
        public Queue thirdQueue() {
            // 配置 自动删除
            Map<String, Object> arguments = new HashMap<>();
            arguments.put("x-message-ttl", 60000);//60秒自动删除
            return new Queue(QUEUE_NAME3,true,false,true,arguments);
        }
    }

### 4、将交换机和队列进行绑定 ###

新建一个RabbitMQConfig配置类，将交换机和队列绑定

package com.space.rbq.order.config;
    
    import org.springframework.amqp.core.Binding;
    import org.springframework.amqp.core.BindingBuilder;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /**
     * RabbitMq配置
     * @author zhuzhe
     * @date 2018/5/25 13:37
     * @email 1529949535@qq.com
     */
    @Configuration
    public class RabbitMqConfig {
    
        /**
         * key: queue在该direct-exchange中的key值，当消息发送给direct-exchange中指定key为设置值时，
         * 消息将会转发给queue参数指定的消息队列
         */
        /** 队列key1*/
        public static final String ROUTING_KEY_1 = "queue_one_key1";
    
        @Autowired
        private QueueConfig queueConfig;
    
        @Autowired
        private ExchangeConfig exchangeConfig;
    
        /**
         * 将消息队列1和交换机1进行绑定,指定队列key1
         */
        @Bean
        public Binding binding_one() {
            return BindingBuilder.bind(queueConfig.firstQueue()).to(exchangeConfig.directExchange()).with(RabbitMqConfig.ROUTING_KEY_1);
        }
    }

这样，我们就完成了RabbitMq的配置，并且成功创建了消息交换机和队列，将其进行绑定。

## 发送消息 ##

新建一个Order类，模拟订单。同时新建一个OrderController，用于发送消息。

package com.space.rbq.order.bean;
    import lombok.Data;
    import java.io.Serializable;
    
    /**
     * Order
     * @author zhuzhe
     * @date 2018/6/7 9:49
     * @email 1529949535@qq.com
     */
    @Data
    public class Order implements Serializable{
    
        private Long id;
    
        private Double price;
    
        private String remark;
    }

package com.space.rbq.order.controller;
    
    import com.google.gson.Gson;
    import com.space.rbq.order.bean.Order;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.amqp.rabbit.core.RabbitTemplate;
    import org.springframework.amqp.rabbit.support.CorrelationData;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.UUID;
    
    /**
     * @author zhuzhe
     * @date 2018/6/7 9:48
     * @email 1529949535@qq.com
     */
    @Slf4j
    @RequestMapping("/order")
    @RestController
    public class OrderController {
    
        @Autowired
        private RabbitTemplate rabbitTemplate;
    
        /**
         * 保存order , 同时需要向store服务发送通知减库存
         * @param order
         * @return
         */
        @PostMapping("/save")
        public Order saveOrder(Order order){
            log.info(order.toString());
            Gson gson = new Gson();
            //将order转换为json字符串，便于传输
            String json = gson.toJson(order);
            String msgId = UUID.randomUUID().toString();
            /**
             * 发送消息
             * 指定消息交换机  "first_exchange"
             * 指定队列key    "queue_one_key1"
             */
            rabbitTemplate.convertAndSend("first_exchange", "queue_one_key1",
                    json, new CorrelationData(msgId));
            return order;
        }
    }

RabbitTemplate是springboot整合rabbitMq为我们默认提供的。里面有一些默认的配置和方法，我们可以直接使用它来发送消息。我们可以大概看看

![70][]

调用convertAndSend方法就可以发送消息。在这里需要指定消息交换机和key。这样就可以将消息发送给指定的队列了（队列和交换机通过key在之前已经绑定过了）

此时，我们只需要启动工程，调用saveOrder接口，就可以成功将消息发送出去。

至此，就成功实现了消息的发送。下节，我们会通过库存服务订阅该消息，实现消息的消费。

[源码：https://github.com/zhuzhegithub/rabbitmq][https_github.com_zhuzhegithub_rabbitmq]

[回到目录][Link 1]

转载请务必保留此出处（原作者）：[https://blog.csdn.net/zhuzhezhuzhe1][https_blog.csdn.net_zhuzhezhuzhe1]

[https://blog.csdn.net/zhuzhezhuzhe1][https_blog.csdn.net_zhuzhezhuzhe1]

[70]: /images/20220522/e0e27581ed6d4bf18f0c9f8f3100c80d.png
[https_github.com_zhuzhegithub_rabbitmq]: https://github.com/zhuzhegithub/rabbitmq
[Link 1]: https://blog.csdn.net/zhuzhezhuzhe1/article/details/80642032
[https_blog.csdn.net_zhuzhezhuzhe1]: https://blog.csdn.net/zhuzhezhuzhe1