RabbitMQ第一个实操小案例

最新推荐文章于 2024-04-12 02:07:10 发布

Keeling1720

最新推荐文章于 2024-04-12 02:07:10 发布

阅读量572

点赞数 1

分类专栏： RabbitMQ 文章标签： java-rabbitmq rabbitmq java

本文链接：https://blog.csdn.net/weixin_44741023/article/details/127154722

版权

RabbitMQ 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

文章目录

二、RabbitMQ实操小案例
- 2.1 Hello World！
- 2.2 Spring AMQP

二、RabbitMQ实操小案例

进入RabbitMQ的官网。选择 Document 菜单项，然后点击Tutorials下的 Get Started。我们可以看看官网给我们的案例实操。
在这里插入图片描述
里面一共有7个Demo，下面我们就根据他给的Demo进行实操，熟悉一下我们的RabbitMq。
前面的两种，是最基本的，只有发布者和订阅者和一个队列，并没有我们的交换机。
其中，
第一种属于基本消息队列
第二种属于工作消息队列
在这里插入图片描述
后面这三种是有交换机的，根据交换机类型的不同，发布和订阅的方式可以分为三种：

广播（对应官网的案例3——Publish/Subscribe）
路由（对应官网的案例4——Routing）
主题（对应官网的案例5——Topics）

下面，我们就来跑一下官网的这些案例。

2.1 Hello World！

官方的Hello World案例，只有三个角色，Publisher（发布者）、Queue（队列）、Consumer（消费者）。
在这里插入图片描述

其中，

Publisher（发布者）只负责把消息不停地发送到Queue（队列）中
Queue（队列）负责接收并缓存消息
Consumer（消费者）负责订阅队列中的消息

下面，我们来写一个最简单的实例，首先，创建一个空白的Module作为父工程。（结构要多干净就多干净）
在这里插入图片描述
然后我们写一下父工程的pom.xml文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>mq-demo1</artifactId>
    <version>1.0-SNAPSHOT</version>

    <packaging>pom</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.9.RELEASE</version>
        <relativePath/>
    </parent>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--AMQP依赖，包含RabbitMQ-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <!--单元测试-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>

</project>

然后，我们创建两个Module，一个叫publisher（发布者），一个叫consumer（消费者），为了尽可能地干净，我用IDEA，直接创建了两个空白的Maven工程。
在这里插入图片描述
然后，我们先写Publisher这个Module。SpringBoot的流程应该都滚瓜烂熟了吧。首先写我们SpringBoot的启动类 PublisherApplication.java ，如下：

package com.demo.mq;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class PublisherApplication {
    public static void main(String[] args) {
        SpringApplication.run(PublisherApplication.class, args);
    }
}

然后我们写我们的测试文件 PublisherTest.java 如下：

package com.demo.mq.test;


import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import org.junit.Test;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class PublisherTest {
    @Test
    public void sendMsg() throws IOException, TimeoutException{
        //1、建立连接
        ConnectionFactory factory = new ConnectionFactory();
        //1.1 设置连接参数（主机号、端口号、vhost、用户名、密码）
        factory.setHost("192.168.10.20");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("admin");
        factory.setPassword("root");

        //1.2 建立连接
        Connection connection = factory.newConnection();

        //2. 创建通道 Channel
        Channel channel = connection.createChannel();

        //3. 创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        //4. 发送消息
        String msg = "Hello,World!";
        channel.basicPublish("", queueName, null, msg.getBytes());
        System.out.println("消息发送成功："+msg);

        //5. 关闭通道和连接
        channel.close();
        connection.close();
    }
}

运行该测试方法后，我们查看我们的RabbitMQ控制台可以看到，此时在Queues下有一个叫simple.queue的队列，该队列的虚拟主机是/，此时有一条记录（Ready）正准备被别人收听：
在这里插入图片描述
然后，我们写我们的消费者的代码：
首先，先写我们的SpringBoot启动文件 ConsumerApplication.java：

package com.demo.mq;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class, args);
    }
}

然后写我们的测试类 ConsumerTest.java：

package com.demo.mq.test;

import com.rabbitmq.client.*;
import org.junit.Test;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class ConsumerTest {
    @Test
    public void testConsumer() throws IOException, TimeoutException {
        // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1. 设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("192.168.10.20");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("admin");
        factory.setPassword("root");
        // 1.2. 建立连接
        Connection connection = factory.newConnection();

        // 2. 创建通道Channel
        Channel channel = connection.createChannel();

        // 3. 创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        // 4. 订阅消息
        channel.basicConsume(queueName, true, new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 5. 处理消息
                String message = new String(body);
                System.out.println("接收到消息：【" + message + "】");
            }
        });
        System.out.println("等待接收消息。。。。");
    }
}

然后运行我们的启动文件，结果如下：
在这里插入图片描述
这里，之所以先输出等待接收消息，是因为RabbitMQ消息队列传输是异步的，在System.out.println(“等待接收消息。。。。”); 执行完后，Hello，World！才从RabbitMQ中被消费者接收到并打印在控制台上。

此时，我们的RabbitMQ的Queue如下，可以看到，已经等待接收的消息了：
在这里插入图片描述

2.2 Spring AMQP

在介绍第二个案例前，为了简化我们消息的发送和接收，我们先介绍一下SpringAMQP。那么，什么是AMQP，什么又是Spring AMQP呢？

AMQP（Advanced Message Queuing Protocol）：用于在应用程序之间传递业务消息的开放标准。该协议与语言和平台无关，更符合微服务中独立性的要求。
Spring AMQP：基于** AMQP 协议** 定义的一套API规范，提供了模板来发送和接收消息。包含两部分，其中，spring-amqp 是基础抽象，spring-rabbit 是底层的默认实现。

Spring AMQP 是Spring 全家桶里面的一个“小辣翅”。官网地址：https://spring.io/projects/spring-amqp

官方说他的特征主要有三：

用于异步处理入站消息的侦听器容器。
RabbitTemplate，发送和接收消息。
RabbitAdmin，用于自动声明队列，交换和绑定。

说完 SpringAMQP，我们用他来实现上面的Hello World！消息的发送和接收。

步骤一、引入 SpringAMQP 依赖。

<!--AMQP依赖，包含RabbitMQ-->
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-amqp</artifactId>
 </dependency>

步骤二、配置RabbitMQ地址。
使用springAMQP后，我们就不需要每次都自己去配置我们的rabbitMQ的IP地址、端口号、账号、密码和虚拟主机了。我们只需要在application.yaml文件中配置即可：

spring:
  rabbitmq:
    host: 192.168.83.129
    port: 5672
    virtual-host: /
    username: admin
    password: root

步骤三、在publisher服务中编写测试方法，向simple.queue发送消息。

配置好我们的 rabbitMQ 地址后，我们编写我们的测试方法如下：

package com.demo.mq.test;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {
    @Resource
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testPublish() {
        String queueName = "simple.queue";
        String message = "Hello,World!";
        rabbitTemplate.convertAndSend(queueName, message);
    }
}

编写完毕，我们跑一下这个测试方法，结果如下：
在这里插入图片描述
我们再看一下我们的rabbitMQ客户端，可以看到，他确确实实有收到一条消息。

OK，发送我们会了，那么接收呢？其实很简单，也是三个步骤：

步骤一、引入 spring-amqp 依赖。

<!--AMQP依赖，包含RabbitMQ-->
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-amqp</artifactId>
 </dependency>

步骤二、配置 RabbitMQ 地址。

spring:
  rabbitmq:
    host: 192.168.83.129
    port: 5672
    virtual-host: /
    username: admin
    password: root

步骤三、在 consumer 服务中编写方法，接收simple.queue的消息。（记得将服务注册到Spring容器中）

package com.demo.mq.listener;

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

@Component
public class SpringRabbitListener {

    @RabbitListener(queues = "simple.queue")
    public void listenQueueMessage(String msg) throws InterruptedException{
        System.out.println("监听到的消息为：【"+ msg +"】");
    }
}

然后我们运行我们的 ConsumerApplication，可以看到，成功接收到了RabbitMQ请求队列刚才接收到的消息。
在这里插入图片描述
我们甚至可以再去publisher里面再发送几次消息，看看是不是能正常收到。这里，我又跑去发送了两次，可以看到，我们都可以正常的接收到消息。

Keeling1720

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
RabbitMQ第一个实操小案例

然后，我们创建两个Module，一个叫publisher（发布者），一个叫consumer（消费者），为了尽可能地干净，我用IDEA，直接创建了两个空白的Maven工程。这里，我又跑去发送了两次，可以看到，我们都可以正常的接收到消息。下面，我们来写一个最简单的实例，首先，创建一个空白的Module作为父工程。里面一共有7个Demo，下面我们就根据他给的Demo进行实操，熟悉一下我们的RabbitMq。前面的两种，是最基本的，只有发布者和订阅者和一个队列，并没有我们的交换机。OK，发送我们会了，那么接收呢？
复制链接

扫一扫