rabbitmq消息队列学习之入门

最新推荐文章于 2023-06-07 09:19:37 发布

yangyanping20108

最新推荐文章于 2023-06-07 09:19:37 发布

阅读量222

点赞数

分类专栏：消息队列文章标签：队列 rabbitmq java

本文链接：https://blog.csdn.net/yangyanping20108/article/details/115690348

版权

消息队列专栏收录该内容

12 篇文章 1 订阅

订阅专栏

rabbitmq学习之入门

RabbitMQ 是什么？

RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ服务器是用Erlang语言编写的，而集群和故障转移是构建在开放电信平台框架上的。所有主要的编程语言均有与代理接口通讯的客户端库。

什么叫消息队列

消息（Message）是指在应用间传送的数据。消息可以非常简单，比如只包含文本字符串，也可以更复杂，可能包含嵌入对象。

消息队列（Message Queue）是一种应用间的通信方式，消息发送后可以立即返回，由消息系统来确保消息的可靠传递。消息发布者只管把消息发布到 MQ 中而不用管谁来取，消息使用者只管从 MQ 中取消息而不管是谁发布的。这样发布者和使用者都不用知道对方的存在。

如何安装RabbitMQ

查看本地镜像
使用以下命令来查看是否已安装了 rabbitmq：

ZBMAC-2f32839f6: ***$ docker images
REPOSITORY          TAG                       IMAGE ID            CREATED             SIZE
rabbitmq            latest                    f83a0c22b15a        2 weeks ago         156MB
rabbitmq            management                fa535c4b51fe        11 months ago       181MB
rabbitmq            <none>                    c1a845de8052        11 months ago       151MB
runbbo/ubuntu       v2                        c057ebebda91        12 months ago       64.2MB
test/ubuntu         v1                        857133fff59e        12 months ago       0B
yyp/hello-world     v2                        a7c20b0a76ab        12 months ago       1.84kB
docker              latest                    61b2e482e9de        12 months ago       222MB
ubuntu              latest                    4e5021d210f6        12 months ago       64.2MB
rabbitmq            3.8.0-beta.4-management   692a3186e01e        21 months ago       180MB
hello-world         <none>                    fce289e99eb9        2 years ago         1.84kB

运行容器
安装完成后，我们可以使用以下命令来运行 rabbitmq 容器：

docker run -d -p 5672:5672 -p 15672:15672 --name myrabbit rabbitmq

安装成功
最后我们可以通过 docker ps 命令查看容器的运行信息：

ZBMAC-2f32839f6: ***$ docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                                                                                              NAMES
5b0f471e4160        rabbitmq            "docker-entrypoint.s…"   12 seconds ago      Up 11 seconds       4369/tcp, 0.0.0.0:5672->5672/tcp, 5671/tcp, 15691-15692/tcp, 25672/tcp, 0.0.0.0:15672->15672/tcp   myrabbit

接着我们通过 rabbitmqctl 连接测试使用 rabbitMQ 服务。

ZBMAC-2f32839f6:nginx yangyanping$ docker exec -it myrabbit /bin/bash

运行rabbitmqctl status 命令查看RabbitMQ是否正常启动，实例如下：

root@5b0f471e4160:/# rabbitmqctl status
Status of node rabbit@5b0f471e4160 ...
Runtime

OS PID: 298
OS: Linux
Uptime (seconds): 122
Is under maintenance?: false
RabbitMQ version: 3.8.14
Node name: rabbit@5b0f471e4160
Erlang configuration: Erlang/OTP 23 [erts-11.2] [source] [64-bit] [smp:4:4] [ds:4:4:10] [async-threads:1]
Erlang processes: 403 used, 1048576 limit
Scheduler run queue: 1
Cluster heartbeat timeout (net_ticktime): 60

Plugins

Enabled plugin file: /etc/rabbitmq/enabled_plugins
Enabled plugins:

 * rabbitmq_prometheus
 * rabbitmq_web_dispatch
 * prometheus
 * rabbitmq_management_agent
 * cowboy
 * cowlib

Data directory

Node data directory: /var/lib/rabbitmq/mnesia/rabbit@5b0f471e4160
Raft data directory: /var/lib/rabbitmq/mnesia/rabbit@5b0f471e4160/quorum/rabbit@5b0f471e4160

Config files

 * /etc/rabbitmq/rabbitmq.conf
 * /etc/rabbitmq/conf.d/management_agent.disable_metrics_collector.conf

Log file(s)

 * <stdout>

Alarms

(none)

Memory

Total memory used: 0.1139 gb
Calculation strategy: rss
Memory high watermark setting: 0.4 of available memory, computed to: 0.8354 gb

code: 0.0316 gb (25.92 %)
other_proc: 0.0299 gb (24.51 %)
other_system: 0.026 gb (21.29 %)
allocated_unused: 0.0215 gb (17.6 %)
plugins: 0.008 gb (6.57 %)
other_ets: 0.003 gb (2.47 %)
atom: 0.0015 gb (1.2 %)
metrics: 0.0002 gb (0.19 %)
binary: 0.0001 gb (0.12 %)
mnesia: 0.0001 gb (0.07 %)
quorum_ets: 0.0 gb (0.04 %)
msg_index: 0.0 gb (0.02 %)
connection_channels: 0.0 gb (0.0 %)
connection_other: 0.0 gb (0.0 %)
connection_readers: 0.0 gb (0.0 %)
connection_writers: 0.0 gb (0.0 %)
mgmt_db: 0.0 gb (0.0 %)
queue_procs: 0.0 gb (0.0 %)
queue_slave_procs: 0.0 gb (0.0 %)
quorum_queue_procs: 0.0 gb (0.0 %)
reserved_unallocated: 0.0 gb (0.0 %)

File Descriptors

Total: 2, limit: 1048479
Sockets: 0, limit: 943629

Free Disk Space

Low free disk space watermark: 0.05 gb
Free disk space: 54.5074 gb

Totals

Connection count: 0
Queue count: 0
Virtual host count: 1

Listeners

Interface: [::], port: 15692, protocol: http/prometheus, purpose: Prometheus exporter API over HTTP
Interface: [::], port: 25672, protocol: clustering, purpose: inter-node and CLI tool communication
Interface: [::], port: 5672, protocol: amqp, purpose: AMQP 0-9-1 and AMQP 1.0
root@5b0f471e4160:/#

当然也可以通过rabbitmqctl cluster_status 命令来查看集群信息，目前只有一个RabbitMQ 服务节点，可以看做单节点集群

root@5b0f471e4160:/# rabbitmqctl cluster_status
Cluster status of node rabbit@5b0f471e4160 ...
Basics

Cluster name: rabbit@5b0f471e4160

Disk Nodes

rabbit@5b0f471e4160

Running Nodes

rabbit@5b0f471e4160

Versions

rabbit@5b0f471e4160: RabbitMQ 3.8.14 on Erlang 23.3.1

Maintenance status

Node: rabbit@5b0f471e4160, status: not under maintenance

Alarms

(none)

Network Partitions

(none)

Listeners

Node: rabbit@5b0f471e4160, interface: [::], port: 15692, protocol: http/prometheus, purpose: Prometheus exporter API over HTTP
Node: rabbit@5b0f471e4160, interface: [::], port: 25672, protocol: clustering, purpose: inter-node and CLI tool communication
Node: rabbit@5b0f471e4160, interface: [::], port: 5672, protocol: amqp, purpose: AMQP 0-9-1 and AMQP 1.0

Feature flags

Flag: drop_unroutable_metric, state: enabled
Flag: empty_basic_get_metric, state: enabled
Flag: implicit_default_bindings, state: enabled
Flag: maintenance_mode_status, state: enabled
Flag: quorum_queue, state: enabled
Flag: user_limits, state: enabled
Flag: virtual_host_metadata, state: enabled
root@5b0f471e4160:/#

添加用户

添加新用户，用户名为 root ，密码为 root :

root@5b0f471e4160:/# rabbitmqctl add_user root root
Adding user "root" ...
Done. Don't forget to grant the user permissions to some virtual hosts! See 'rabbitmqctl help set_permissions' to learn more.

为 root 用户设置所有权限

root@5b0f471e4160:/# rabbitmqctl set_permissions -p / root ".*" ".*" ".*"
Setting permissions for user "root" in vhost "/" ...

设置 root 用户为管理员角色

root@5b0f471e4160:/# rabbitmqctl set_user_tags root administrator
Setting tags for user "root" to [administrator] ...

代码演示

计算机的世界是从 “Hello World ! ” 开始的，这里我们也沿用惯例，首先生产者发送一条消息 “Hello World ! ” 至 RabbitMQ 中，之后由消费者消费，下面先演示生产者客户端的代码

package com.study.rabbit;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

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


public class DirectProducer {
    //交换机名称
    private static final String EXCHANGE_DIRECT = "exchange_direct_test";
    private static final String ROUTING_KEY = "direct_demo";
    private final static String QUEUE_NAME = "direct_test";

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = null;

        Channel channel = null;
        try {
            //通过连接工厂创建新的连接和mq进行连接
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("127.0.0.1"); //设置mq所在服务器的ip
            factory.setPort(5672);  //设置mq所在服务器的端口号
            factory.setUsername("root");//设置登录用户名
            factory.setPassword("root");//设置登录密码
            factory.setVirtualHost("/");//rabbitmq默认虚拟机名称为“/”，相当于一个独立的mq服务

            //创建与RabbitMQ服务的TCP连接
            connection = factory.newConnection();
            //创建与Exchange(交换机)的通道，每个连接可以创建多个通道，每个通道代表一个会话任务
            channel = connection.createChannel();

            /**
             * //声明交换机 String exchange, BuiltinExchangeType type
             * 参数明细
             * 1、交换机名称
             * 2、交换机类型，fanout、topic、direct、headers
             */
            channel.exchangeDeclare(EXCHANGE_DIRECT, ROUTING_KEY, true, false, null);

            channel.queueDeclare(QUEUE_NAME, true, false, false, null);

            /**
             * //交换机和队列绑定String queue, String exchange, String routingKey
             * 参数明细
             * 1、队列名称
             * 2、交换机名称
             * 3、路由key
             */
            channel.queueBind(QUEUE_NAME, EXCHANGE_DIRECT, QUEUE_NAME);

            channel.basicPublish(EXCHANGE_DIRECT, QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN, "Hello World".toString().getBytes());
            System.out.println("Send message is:'" + "Hello World" + "'");

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (channel != null) {
                channel.close();
            }
            if (connection != null) {
                connection.close();
            }
        }
    }
}

生产者代码顺序：

创建一个连接Connection 。
在这个连接上创建一个信道 Channel 。
创建一个交换器 Exchange。
创建一个队列 Queue 。
通过路由键进行绑定。
发送消息
关闭资源

消费端客户端代码：

package com.study.rabbit;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

import java.io.IOException;

public class DirectConsumer {
    private final static String EXCHANGE_NAME = "exchange_direct_test";
    private final static String QUEUE_NAME = "direct_test";

    public static void main(String[] argv) throws java.io.IOException {
        // 创建连接和频道
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1"); //设置mq所在服务器的ip
        factory.setPort(5672);  //设置mq所在服务器的端口号
        factory.setUsername("root");//设置登录用户名
        factory.setPassword("root");//设置登录密码
        factory.setVirtualHost("/");//rabbitmq默认虚拟机名称为“/”，相当于一个独立的mq服务
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.exchangeDeclare(EXCHANGE_NAME, "direct", true, false, null);
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, QUEUE_NAME);

        System.out.println(" [" + DirectConsumer.class + "] Waiting for messages................");

        Consumer consumer = new DefaultConsumer(channel) {
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("Received : " + new String(body));

                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        // 指定接收者，第二个参数为自动应答，无需手动应答
        channel.basicConsume(QUEUE_NAME, true, consumer);
    }
}

RabbitMQ 架构图

在这里插入图片描述

product ：生产者，就是投递消息的一方。
生产者创建消息，然后发布到 RabbitMQ 中。消息一般可以包含2个部分：消息体和标签Label 。消息体也可以称之为 payload 。在实际应用中，消息体一般是一个带有业务逻辑结构的数据，比如一个JSON字符串。当然可以进一步对这个消息进行序列化操作，消息的标签用来描述这条消息，比如一个交换器的名称和一个路由键。生产者把消息交由RabbitMQ，RabbitMQ之后会根据标签把消息发送给感兴趣的消费者Consumer。
Consumer ：消费者，就是接收消息的一方。
消费者连接到 RabbitMQ 服务器，并订阅到队列上，当消费者消费一条消息时，只是消费消息的消息体 playload 。在消息路由的过程中，消息的标签会丢弃，存入到队列中的消息只有消息体，消费者也只会消费到消息体，也就不知道消息的生产者是谁，当然消费者也不需要知道。
Binding
绑定，用于消息队列和交换器之间的关联。一个绑定就是基于路由键将交换器和消息队列连接起来的路由规则，所以可以将交换器理解成一个由绑定构成的路由表。
Broker ：消息中间件的服务节点
对于RabbitMQ 来说，一个 RabbitMQ Broker 可以简单地看作一个RabbitMQ 服务节点，或者 RabbitMQ 服务实例，大多数情况下一个可以将一个 RabbitMQ Broker 看作一台 RabbitMQ 服务器。
交换器，路由键，绑定

交换器类型

Fanout Exchange
每个发到 fanout 类型交换器的消息都会分到所有绑定的队列上去。fanout 交换器不处理路由键，只是简单的将队列绑定到交换器上，每个发送到交换器的消息都会被转发到与该交换器绑定的所有队列上。很像子网广播，每台子网内的主机都获得了一份复制的消息。fanout 类型转发消息是最快的。
Direct Exchange
消息中的路由键（routing key）如果和 Binding 中的 binding key 一致，交换器就将消息发到对应的队列中。路由键与队列名完全匹配，如果一个队列绑定到交换机要求路由键为“dog”，则只转发 routing key 标记为“dog”的消息，不会转发“dog.puppy”，也不会转发“dog.guard”等等。它是完全匹配、单播的模式。
Topic Exchange
topic 交换器通过模式匹配分配消息的路由键属性，将路由键和某个模式进行匹配，此时队列需要绑定到一个模式上。它将路由键和绑定键的字符串切分成单词，这些单词之间用点隔开。它同样也会识别两个通配符：符号“#”和符号“*”。#匹配0个或多个单词，*匹配不多不少一个单词。

yangyanping20108

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
rabbitmq消息队列学习之入门

RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ服务器是用Erlang语言编写的，而集群和故障转移是构建在开放电信平台框架上的。所有主要的编程语言均有与代理接口通讯的客户端库。
复制链接

扫一扫