RabbitMQ学习，几种发送订阅方式

最新推荐文章于 2024-08-16 13:50:17 发布

tom有了cat

最新推荐文章于 2024-08-16 13:50:17 发布

阅读量1.7k

点赞数

分类专栏：分布式文章标签： RabbitMQ 消息队列

本文链接：https://blog.csdn.net/qq_35410620/article/details/94125339

版权

分布式专栏收录该内容

12 篇文章 0 订阅

订阅专栏

前面一篇文章介绍了一些概念性的东西。真的很重要，之前自己感觉对RabbitMQ掌握的不扎实就是因为自己对BingKEY和RoutingKey的关系没有搞清，下面将以实例代码演示我自己的学习过程

测试代码将放在github上，地址https://github.com/wws11/RabbitMQ-Code.git

最简单的订阅模式-——对对点Direct类型

RabbitMQ支持4种消息类型，direct，topic,faount,head。direct是直接发送给指定的消息队列，通过Routingkey和BingKey进行区分，只要交换机类型声明为Direct类型的，并且routigKey和BingKey是相等的，那么他们就会进行匹配。

模式关系图，如下：

图片来自上篇博客首先来看一下我自己的项目结构

这里定义了一个公共bean的模块，用于存放公共的bean,两个消费者，一个消息发送者，其中消费者配置完成以后让它启动着，处于监听状态即可，send端执行的时候进行发送，由于发送消息只负责发送消息的功能，所以我把队列，交换机的初始化工作交给了其中一个consumer。

生产者的代码如下：

package com.gysoft.rabbitmqsoft.send;

import com.gysoft.entrity.User;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;



/**
 * @Description
 * @Author DJZ-WWS
 * @Date 2019/6/26 15:06
 */
@Component
public class HelloSender {


    @Autowired
    private AmqpTemplate amqpTemplate;




    public   void sendDirect(){
        String  context="66666666666666666666666666666666666666";
        System.out.println("开始发送消息消息内容："+context);
        amqpTemplate.convertAndSend("directExchange","ddddd",context);
    }



}

本次demo使用Springboot的方式进行整合，非常的方便，发送消息采用了单元测试，调用如下：

package com.gysoft.rabbitmqsoft;

import com.gysoft.entrity.User;
import com.gysoft.rabbitmqsoft.send.HelloSender;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;


@RunWith(SpringRunner.class)
@SpringBootTest
public class RabbitmqSoftApplicationTests {

    @Resource
    private HelloSender helloSender;

   
    /**
     * 测试发单个 点对点的模式
     */
    @Test
    public  void  testDirect(){
        helloSender.sendDirect();
    }




}

消费者的配置如下：

package com.gysoft.rabbitmqconsumer2.receive;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


/**
 * @Description
 * @Author DJZ-WWS
 * @Date 2019/6/27 15:11
 */

@Configuration
public class RabbitMqConfig {
 
   
    @Bean
    public Queue testDirectQueue() {
        return new Queue("testDirectQueue");
    }

 

    @Bean
    DirectExchange  directExchange(){
        return  new DirectExchange("directExchange");
    }


    /**
     * 测试点对点的模式
     */
    @Bean
    Binding  bindDirect(){
        return  BindingBuilder.bind(testDirectQueue()).to(directExchange()).with("ddddd");
    }



}

这里声明了一个交换机，一个队列，并且指定了通过ddddd的BingKey去实现了队列和交换机的关系建立，因为我们在发消息的时候指定了routingkey，routingkey匹配成功即相等就可以实现消息的入队。

建立一个监听实现消息的实时监听

package com.gysoft.rabbitmqconsumer2.receive;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @Description
 * @Author DJZ-WWS
 * @Date 2019/6/28 16:39
 */
@Component
@RabbitListener(queues = "testDirectQueue")
public class DirectListener {


    //消息处理器
    @RabbitHandler
    public   void  process(String  message){
        System.out.println("Direct收到消息，消息内容："+message);
    }
}

监听需要声明监听的队列，即使这个监听服务不起，只要发送了消息，消息就会存储在队列了里，一旦服务起来了以后他就会接收到生产者发送的消息，从而进行工作。

启动消费者，发送消息，控台打印如下：

这里声明一下，在我们的配置里进行的声明，只要服务起来了，在RabbitMQ界面工具里面都可以看到我们配置的相关属性，

声明的队列如下：

、

界面点击队列进去以后会看奥我们将队列和交换机绑定的routngKey

这次在做个测试，监听服务不启动，发送几条消息，理论消息会暂时存在队列，我们可以来看一下，这次我停了所有的监听服务，没有消费者，发送了几条消息，初始队列消息是0的，

发送了两条消息，队列变化如下：

打开，消费者，启动消费者服务，当接收消息以后，消息被消费了，又变化如下：

服务启动的时候控台收到我们发送的消息。

以上是一个简单的小demo，介绍了消息的整个发送流程，其他模式也是和这类似，都是一样，只是交换机的声明方式不同，routingKey不同而已。

Direct类型的是可以进行多重绑定的，意思就是一个交换机绑定多个消息队列，他们会根据routingkey的不同会选择自己消息routingkey不同进入到不同的队列，借上篇博客一张图说明一下，

我们在发送消息的时候指定的消息的routingKey,他会和交换机与队列绑定的bingKey进行匹配，进入和自己routingkey相等的队列。下面这个图是我们项目中所采用的方式：

用于记录不同平台的日志，不同平台的日志发送者有不同的routingkey，他们会和bingkey进行匹进行入队操作。所有的日志记录都放在一个队列里面。采用了Direct的声明方式。

Topic的实现方式

下面介绍一下topic方式的代码实现：

发送端代码：

  @Test
    public   void  testTopic(){
        helloSender.topicSend1();

    }

代码实现如下：

package com.gysoft.rabbitmqsoft.send;

import com.gysoft.entrity.User;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;


/**
 * @Description
 * @Author DJZ-WWS
 * @Date 2019/6/26 15:06
 */
@Component
public class HelloSender {


    @Autowired
    private AmqpTemplate amqpTemplate;



   

    public void  topicSend1() {
        String context = "my topic 1";
        System.out.println("发送者说 : " + context);
        amqpTemplate.convertAndSend("exchange", "topic.message", context);
    }


    public   void sendDirect(){
        String  context="66666666666666666666666666666666666666";
        System.out.println("开始发送消息消息内容："+context);
        amqpTemplate.convertAndSend("directExchange","ddddd",context);
    }



}

消费者端进行的配置如下：

package com.gysoft.rabbitmqconsumer2.receive;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


/**
 * @Description
 * @Author DJZ-WWS
 * @Date 2019/6/27 15:11
 */

@Configuration
public class RabbitMqConfig {
    /**
     * 只接一个topic
     */
    final static String message = "topic.message";
    /**
     * 接收多个topic
     */
    final static String messages = "topic.messages";


    /**
     * 队列声明
     *
     * @return
     */
    @Bean
    public Queue queueMessager() {
        return new Queue(RabbitMqConfig.message);
    }

    @Bean
    public Queue queueMessages() {
        return new Queue(RabbitMqConfig.messages);
    }
    @Bean
    public Queue testDirectQueue() {
        return new Queue("testDirectQueue");
    }

    /**
     *声明一个Topic交换机
     *
     * @return
     */
    @Bean
    TopicExchange exchange() {
        return new TopicExchange("exchange");
    }

    @Bean
    DirectExchange  directExchange(){
        return  new DirectExchange("directExchange");
    }


    /**
     * 测试topic模式
     * @return
     */
    @Bean
    Binding bindingExchangeMessage() {
        return BindingBuilder.bind(queueMessager()).to(exchange()).with("topic.message");
    }

    @Bean
    Binding bindingExchangeMessages() {
        //这里的#表示零个或多个词。
        return BindingBuilder.bind(queueMessages()).to(exchange()).with("topic.#");
    }
    /**
     * 测试点对点的模式
     */
    @Bean
    Binding  bindDirect(){
        return  BindingBuilder.bind(testDirectQueue()).to(directExchange()).with("ddddd");
    }



}

注意Topic方式声明的交换机类型为TopicExchange类型，它的routingkey可以声明多种方式，通配符匹配，或者单词匹配，这里暂不做介绍，就是一种匹配原则，实现订阅指定类型的消息。

可以参照下图