【消息队列开发】 实现 VirtualHostTests 类——测试虚拟主机操作

最新推荐文章于 2024-06-17 14:41:35 发布
最新推荐文章于 2024-06-17 14:41:35 发布
阅读量1k 收藏 16
点赞数 27
分类专栏： 消息队列开发 文章标签： 数据库 spring boot spring java 单元测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71731682/article/details/136962425
版权

文章目录

🍃前言

本次开发任务

  • 实现 VirtualHostTests 类，对虚拟主机进行测试

在这里插入图片描述

🎍准备与收尾工作

准备工作我们需要做的有

  1. 虚拟机操作后续涉及操作数据库，所以我们需要将spring上下文进行获取一下；
  2. 创建一个虚拟主机

收尾工作我们需要做的有：

  1. 关闭上下文

  2. 虚拟主机置为null

  3. 删除硬盘上的目录及目录下的文件

代码实现如下：

private VirtualHost virtualHost = null;

@BeforeEach
public void setUp() {
    MqApplication.context = SpringApplication.run(MqApplication.class);
    virtualHost = new VirtualHost("default");
}

@AfterEach
public void tearDown() throws IOException {
    MqApplication.context.close();
    virtualHost = null;
    // 把硬盘的目录删除掉
    File dataDir = new File("./data");
    FileUtils.deleteDirectory(dataDir);
}

🍀测试交换机与队列操作

测试交换机我们主要测试四方法：

  1. 增加交换机
  2. 删除交换机
  3. 增加队列
  4. 删除队列

由于虚拟机里面的方法，都是调用我们前面已经测试过了的方法，所以我们这里只用看该方法返回值知否未true就好

代码实现如下:

@Test
public void testExchangeDeclare() {
    boolean ok = virtualHost.exchangeDeclare("testExchange", ExchangeType.DIRECT,
            true, false, null);
    Assertions.assertTrue(ok);
}

@Test
public void testExchangeDelete() {
    boolean ok = virtualHost.exchangeDeclare("testExchange", ExchangeType.DIRECT,
            true, false, null);
    Assertions.assertTrue(ok);

    ok = virtualHost.exchangeDelete("testExchange");
    Assertions.assertTrue(ok);
}

@Test
public void testQueueDeclare() {
    boolean ok = virtualHost.queueDeclare("testQueue", true,
            false, false, null);
    Assertions.assertTrue(ok);
}

@Test
public void testQueueDelete() {
    boolean ok = virtualHost.queueDeclare("testQueue", true,
            false, false, null);
    Assertions.assertTrue(ok);

    ok = virtualHost.queueDelete("testQueue");
    Assertions.assertTrue(ok);
}

🎄测试绑定操作

创建相应的队列与交换机，然后将这些队列交换机添加绑定即可

删除也是如此：

代码实现如下：

@Test
public void testQueueBind() {
    boolean ok = virtualHost.queueDeclare("testQueue", true,
            false, false, null);
    Assertions.assertTrue(ok);

    ok = virtualHost.exchangeDeclare("testExchange", ExchangeType.DIRECT,
            true, false, null);
    Assertions.assertTrue(ok);

    ok = virtualHost.queueBind("testQueue", "testExchange", "testBindingKey");
    Assertions.assertTrue(ok);
}

@Test
public void testQueueUnbind() {
    boolean ok = virtualHost.queueDeclare("testQueue", true,
            false, false, null);
    Assertions.assertTrue(ok);

    ok = virtualHost.exchangeDeclare("testExchange", ExchangeType.DIRECT,
            true, false, null);
    Assertions.assertTrue(ok);

    ok = virtualHost.queueBind("testQueue", "testExchange", "testBindingKey");
    Assertions.assertTrue(ok);

    ok = virtualHost.queueUnbind("testQueue", "testExchange");
    Assertions.assertTrue(ok);
}

🌴测试将消息发入交换机

传参调用即可，代码实现如下：

@Test
public void testBasicPublish() {
    boolean ok = virtualHost.queueDeclare("testQueue", true,
            false, false, null);
    Assertions.assertTrue(ok);

    ok = virtualHost.exchangeDeclare("testExchange", ExchangeType.DIRECT,
            true, false, null);
    Assertions.assertTrue(ok);

    ok = virtualHost.basicPublish("testExchange", "testQueue", null,
            "hello".getBytes());
    Assertions.assertTrue(ok);
}

🌲测试订阅消息

订阅消息我们分为两种情况：

  1. 先订阅队列，再发送消息
  2. 先发送消息，再订阅队列

订阅队列操作，我们只需要出入相应的参数，再实现以下消费者自身的回调方法即可。

发送消息直径发送即可

代码实现如下：

// 先订阅队列, 后发送消息
@Test
public void testBasicConsume1() throws InterruptedException {
    boolean ok = virtualHost.queueDeclare("testQueue", true,
            false, false, null);
    Assertions.assertTrue(ok);
    ok = virtualHost.exchangeDeclare("testExchange", ExchangeType.DIRECT,
            true, false, null);
    Assertions.assertTrue(ok);

    // 先订阅队列
    ok = virtualHost.basicConsume("testConsumerTag", "testQueue", true, new Consumer() {
        @Override
        public void handleDelivery(String consumerTag, BasicProperties basicProperties, byte[] body) {
            try {
                // 消费者自身设定的回调方法.
                System.out.println("messageId=" + basicProperties.getMessageId());
                System.out.println("body=" + new String(body, 0, body.length));

                Assertions.assertEquals("testQueue", basicProperties.getRoutingKey());
                Assertions.assertEquals(1, basicProperties.getDeliverMode());
                Assertions.assertArrayEquals("hello".getBytes(), body);
            } catch (Error e) {
                // 断言如果失败, 抛出的是 Error, 而不是 Exception!
                e.printStackTrace();
                System.out.println("error");
            }
        }
    });
    Assertions.assertTrue(ok);

    Thread.sleep(500);

    // 再发送消息
    ok = virtualHost.basicPublish("testExchange", "testQueue", null,
            "hello".getBytes());
    Assertions.assertTrue(ok);
}

// 先发送消息, 后订阅队列.
@Test
public void testBasicConsume2() throws InterruptedException {
    boolean ok = virtualHost.queueDeclare("testQueue", true,
            false, false, null);
    Assertions.assertTrue(ok);
    ok = virtualHost.exchangeDeclare("testExchange", ExchangeType.DIRECT,
            true, false, null);
    Assertions.assertTrue(ok);

    // 先发送消息
    ok = virtualHost.basicPublish("testExchange", "testQueue", null,
            "hello".getBytes());
    Assertions.assertTrue(ok);

    // 再订阅队列
    ok = virtualHost.basicConsume("testConsumerTag", "testQueue", true, new Consumer() {
        @Override
        public void handleDelivery(String consumerTag, BasicProperties basicProperties, byte[] body) {
            // 消费者自身设定的回调方法.
            System.out.println("messageId=" + basicProperties.getMessageId());
            System.out.println("body=" + new String(body, 0, body.length));

            Assertions.assertEquals("testQueue", basicProperties.getRoutingKey());
            Assertions.assertEquals(1, basicProperties.getDeliverMode());
            Assertions.assertArrayEquals("hello".getBytes(), body);
        }
    });
    Assertions.assertTrue(ok);

    Thread.sleep(500);
}

🌳测试FANOUT与TOPIC类型的交换机

上面我们只测试了 DIRECT 类型的交换机，接下来我们测试一下FANOUT与TOPIC类型的交换机。

测试步骤与上述类似，准备数据传入，进行测试就好

代码实现如下：

@Test
public void testBasicConsumeFanout() throws InterruptedException {
    boolean ok = virtualHost.exchangeDeclare("testExchange", ExchangeType.FANOUT, false, false, null);
    Assertions.assertTrue(ok);

    ok = virtualHost.queueDeclare("testQueue1", false, false, false, null);
    Assertions.assertTrue(ok);
    ok = virtualHost.queueBind("testQueue1", "testExchange", "");
    Assertions.assertTrue(ok);

    ok = virtualHost.queueDeclare("testQueue2", false, false, false, null);
    Assertions.assertTrue(ok);
    ok = virtualHost.queueBind("testQueue2", "testExchange", "");
    Assertions.assertTrue(ok);

    // 往交换机中发布一个消息
    ok = virtualHost.basicPublish("testExchange", "", null, "hello".getBytes());
    Assertions.assertTrue(ok);

    Thread.sleep(500);

    // 两个消费者订阅上述的两个队列.
    ok = virtualHost.basicConsume("testConsumer1", "testQueue1", true, new Consumer() {
        @Override
        public void handleDelivery(String consumerTag, BasicProperties basicProperties, byte[] body) {
            System.out.println("consumerTag=" + consumerTag);
            System.out.println("messageId=" + basicProperties.getMessageId());
            Assertions.assertArrayEquals("hello".getBytes(), body);
        }
    });
    Assertions.assertTrue(ok);

    ok = virtualHost.basicConsume("testConsumer2", "testQueue2", true, new Consumer() {
        @Override
        public void handleDelivery(String consumerTag, BasicProperties basicProperties, byte[] body) {
            System.out.println("consumerTag=" + consumerTag);
            System.out.println("messageId=" + basicProperties.getMessageId());
            Assertions.assertArrayEquals("hello".getBytes(), body);
        }
    });
    Assertions.assertTrue(ok);

    Thread.sleep(500);
}

@Test
public void testBasicConsumeTopic() throws InterruptedException {
    boolean ok = virtualHost.exchangeDeclare("testExchange", ExchangeType.TOPIC, false, false, null);
    Assertions.assertTrue(ok);

    ok = virtualHost.queueDeclare("testQueue", false, false, false, null);
    Assertions.assertTrue(ok);

    ok = virtualHost.queueBind("testQueue", "testExchange", "aaa.*.bbb");
    Assertions.assertTrue(ok);

    ok = virtualHost.basicPublish("testExchange", "aaa.ccc.bbb", null, "hello".getBytes());
    Assertions.assertTrue(ok);

    ok = virtualHost.basicConsume("testConsumer", "testQueue", true, new Consumer() {
        @Override
        public void handleDelivery(String consumerTag, BasicProperties basicProperties, byte[] body) {
            System.out.println("consumerTag=" + consumerTag);
            System.out.println("messageId=" + basicProperties.getMessageId());
            Assertions.assertArrayEquals("hello".getBytes(), body);
        }
    });
    Assertions.assertTrue(ok);

    Thread.sleep(500);
}

🎋测试手动应答

测试手动应答的时候。

我们需要在订阅队列时，将 autoAck 改成 false；

并且我们需要在消费者的回调方法里进行调用手动应答的方法。

代码实现如下：

@Test
public void testBasicAck() throws InterruptedException {
    boolean ok = virtualHost.queueDeclare("testQueue", true,
            false, false, null);
    Assertions.assertTrue(ok);
    ok = virtualHost.exchangeDeclare("testExchange", ExchangeType.DIRECT,
            true, false, null);
    Assertions.assertTrue(ok);

    // 先发送消息
    ok = virtualHost.basicPublish("testExchange", "testQueue", null,
            "hello".getBytes());
    Assertions.assertTrue(ok);

    // 再订阅队列 [要改的地方, 把 autoAck 改成 false]
    ok = virtualHost.basicConsume("testConsumerTag", "testQueue", false, new Consumer() {
        @Override
        public void handleDelivery(String consumerTag, BasicProperties basicProperties, byte[] body) {
            // 消费者自身设定的回调方法.
            System.out.println("messageId=" + basicProperties.getMessageId());
            System.out.println("body=" + new String(body, 0, body.length));

            Assertions.assertEquals("testQueue", basicProperties.getRoutingKey());
            Assertions.assertEquals(1, basicProperties.getDeliverMode());
            Assertions.assertArrayEquals("hello".getBytes(), body);

            // [要改的地方, 新增手动调用 basicAck]
            boolean ok = virtualHost.basicAck("testQueue", basicProperties.getMessageId());
            Assertions.assertTrue(ok);
        }
    });
    Assertions.assertTrue(ok);

    Thread.sleep(500);
}

⭕总结

关于《【消息队列开发】 实现 VirtualHostTests 类——测试虚拟主机操作》就讲解到这儿，感谢大家的支持，欢迎各位留言交流以及批评指正，如果文章对您有帮助或者觉得作者写的还不错可以点一下关注，点赞，收藏支持一下

遇事问春风乄
关注
  • 27
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
【SpringBoot】43、SpringBoot中整合RabbitMQ实现延时队列（延时插件篇）
Asurplus
02-21 21万+
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 （1）商城订单超时未支付，取消订单 （2）使用权限到期前十分钟提醒用户 （3）收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis 监听过期 Key 可以参考我的博客【SpringBoot】三十五、SpringBoot整合Redis监听Ke
（一）消息队列——什么是消息队列及其作用
方方土的博客
02-14 3132
消息队列——什么是消息队列及其理解一、什么是 MQ：二、MQ 作用：1、流量削峰：2、 消息队列——什么是消息队列及其理解 一、什么是 MQ： MQ(message queue)，从字面意思上看，本质是个队列，FIFO 先入先出，只不过队列中存放的内容是message 而已，还是一种跨进程的通信机制，用于上下游传递消息。在互联网架构中，MQ 是一种非常常见的上下游“逻辑解耦+物理解耦”的消息通信服务。使用了 MQ 之后，消息发送上游只需要依赖 MQ，不用依赖其他服务。 上游给下游发送消息，只需要将消息放到.
C++ 实现一个消息队列
codeofcc的博客
10-29 1万+
消息队列在多线程的场景有时会用到，尤其是线程通信跨线程调用的时候，就可以使用消息队列进行通信。C++实现一个能用的消息队列还是比较简单的，只需要一个队列一个互斥变量和一个条件变量，这些在标准库中都有提供。基于曾经写过的项目，总结出来最简单的消息队列的实现将在下文中介绍。
Java开发之消息队列
shadon178 博客
01-18 8402
简介 介绍消息队列的重要性 介绍Java程序员常用的Kafka消息队列 介绍Kafka内部的一些机制及注意问题 为什么要使用消息队列？ 比较常见的作用有3点，解耦、异步处理、流量削峰，这里分别一一介绍这些特点。 解耦 我们在设计微服务的时候经常会出现几个模块之间需要相互依赖，例如A和B服务相互依赖，那么部署一个A，必须部署一个B，导致A模块和B模块之间形成了强耦合。如果此时我们在A和B模块之间引入消息队列，那么A可以不用依赖B，只需要A和B之间规定通用的消息格式即可，这样A和B就解耦了，这样以后别的模块
Kafka--延迟队列--使用/实现/原理
热门推荐
IT利刃出鞘的博客
11-17 5万+
本文介绍Kafka如何使用延迟队列的功能。 Kafka是很长用的消息队列，但Kafka本身是没有延迟队列功能的，RabbitMQ、RocketMQ有延迟队列的功能。本文介绍如何手动给Kafka添加延迟消息的功能。 虽然Kafka内部有时间轮，支持延时操作，例如：延迟生产、延迟拉取以及延迟删除，但这是Kafka自己内部使用的，用户无法将其作为延迟队列来使用。 本内容也是Java后端面试常问的问题 。...
阿里云消息队列服务(MQS) ——入门指南
11-13
阿里云消息队列服务(MQS) ——入门指南 带目录 MQS 是一种高效、可靠、安全、便捷、可弹性扩展的分布式消息队列服务。MQS 能够帮助应用开发者在他们应用的分布式组件上自由的传递数据，构建松耦合系统。
基于python实现操作redis及消息队列
09-08
主要介绍了基于python操作redis及消息队列,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
php实现队列操作的类.zip
07-11
php实现一个队列操作的类，称为queueOp.class.php
消息队列-利用事务消息实现分布式事务
02-24
订单模块创建订单的过程实际执行了俩操作：在订单DB插一条订单数据，用来创建订单发消息给MQ，消息内容即刚创建的订单购物车模块订阅相应主题，接收订单创建的消息，然后清理购物车，在购物车中删除订单
【Qt实现录频】
m0_45463480的博客
06-13 162
请注意，这只是一个简单的示例代码，实际应用中你可能需要处理更多的细节，如捕获不同视频格式、处理录制过程中的错误等。希望这个示例对你有所帮助，另外你也可以在Qt官方文档中找到更多关于Qt Multimedia模块的详细信息。在Qt中实现录制视频可以通过使用Qt Multimedia模块来实现。在上面的示例中，VideoRecorder类提供了一个简单的界面，其中包括一个用于录制视频的按钮。当按钮被点击时，toggleRecord()槽函数将会启动或停止录制。
趋势Deep Security（Trend Micro Deep Security）安装
weixin_45945976的博客
06-17 99
Trend Micro Deep Security是一个提供深度包检查、入侵防御、恶意软件保护以及其他多层安全措施的综合性安全解决方案。由趋势科技（Trend Micro）开发，这个解决方案旨在为物理、虚拟、云环境中的服务器和应用提供保护。
canal应用
qq_33816292的博客
06-12 147
canal分享模块链接。
MySQL触发器基本结构
最新发布
2301_80388658的博客
06-17 204
4、for each row 声明每次触发都被执行。create trigger 函数名。3、什么样的操作出发，操作那个表。after：......之后触发。befor：......之前触发。6、歘发起触发后执行代码块。可以修改成$$ //都行。2、创建触发器函数名称。insert：插入被触发。update：修改被触发。delete：删除被触发。
源码编译安装LAMP
潇的博客
06-12 884
LAMP 架构是目前成熟的企业网站应用模式之一，指的是协同工作的一整套系统和相关软件，能够提供动态Web站点服务及其应用开发环境。LAMP是一个缩写词，具体包括Linux操作系统、Apache网站服务器、MySQL数据库服务器、PHP(或Perl、Python)网页编程语言。本章将以源码编译的方式搭建LAMP环境，能够满足企业定制化的需求。在构建LAMP平台时，各组件的安装顺序依次为Linux、Apache、MySQL、PHP。其中Apache和MySQL的安装并没有严格的顺序；
盲盒App开发时有哪些技术框架可以借鉴
bytekj的博客
06-14 533
在开发盲盒App时，可以根据项目需求和团队技术栈选择合适的技术框架。前端可以选择微信小程序框架、React Native或Vue.js等；后端可以选择Node.js或Spring Boot等；数据库可以选择MySQL或MongoDB等。同时，还需要考虑缓存、消息队列、支付和物流接口等其他技术来完善应用的功能和性能。
SpringBoot+MyBatis批量插入数据的三种方式
pscool的博客
06-12 846
在开发过程中，我们经常会遇到往数据库表中插入大量数据的场景，比如excel批量导入数据。那么该如何快速地插入数据呢？我们可以考虑使用批量插入来实现，实测100000条数据添加，后附具体实现代码。用一个 for 循环，把数据一条一条地插入。/*** 第一种方案，用 for语句循环插入 10万 条数据*/i < count;i++) {user.setName("方案1测试" + i);user.setGender("男");user.setUsername("方案1测试");
day01 MYSQL基础
Liang_z_的博客
06-13 1026
今日内容：MYSQL基础
Nginx网站服务
henanchenxuyuan的博客
06-17 1229
Nginx与 Apahce 一样，可以实现基于用户授权的访问控制，当客户端想要访问相应网站或者目录时，要求用户输入用户名和密码才能正常访问，配置步骤与 Apache 基本一致。概括为以下几个步骤。
java：使用JSqlParser给sql语句增加tenant_id和deleted条件
陈鸿圳的专栏
06-11 430
【pom.xml】
用 java语言以测试驱动开发实现队列
04-06
以下是用 Java 语言以测试驱动开发实现队列的示例代码： ``` import org.junit.Test; import static org.junit.Assert.*; public class QueueTest { @Test public void testEnqueue() { Queue<Integer> queue = new Queue<>(); queue.enqueue(1); queue.enqueue(2); queue.enqueue(3); assertEquals(3, queue.size()); } @Test public void testDequeue() { Queue<Integer> queue = new Queue<>(); queue.enqueue(1); queue.enqueue(2); queue.enqueue(3); int item = queue.dequeue(); assertEquals(1, item); assertEquals(2, queue.size()); } @Test public void testIsEmpty() { Queue<Integer> queue = new Queue<>(); assertTrue(queue.isEmpty()); queue.enqueue(1); assertFalse(queue.isEmpty()); } @Test public void testSize() { Queue<Integer> queue = new Queue<>(); assertEquals(0, queue.size()); queue.enqueue(1); queue.enqueue(2); queue.enqueue(3); assertEquals(3, queue.size()); } } class Queue<T> { private Node<T> first; private Node<T> last; private int size; private static class Node<T> { private T item; private Node<T> next; } public void enqueue(T item) { Node<T> oldLast = last; last = new Node<>(); last.item = item; last.next = null; if (isEmpty()) { first = last; } else { oldLast.next = last; } size++; } public T dequeue() { T item = first.item; first = first.next; size--; if (isEmpty()) { last = null; } return item; } public boolean isEmpty() { return first == null; } public int size() { return size; } } ``` 上述代码中，我们通过四个测试方法来测试队列的四个基本操作，分别为入队、出队、判空和取队列大小。在 Queue 类中，我们使用一个内部类 Node 来表示队列中的每个节点，其中包含一个 item 和一个 next 指针。Queue 类中的四个方法均基于这个节点类实现，通过操作节点来完成队列的相应操作。在测试方法中，我们先创建一个空队列，然后依次执行相应的操作，并使用断言来验证操作的正确性。如果某个测试方法失败了，则说明队列的相应操作存在问题，需要进行修正。最终，当所有测试方法均通过时，我们就可以保证队列的基本操作是正确的。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

遇事问春风乄

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值