RabbitMQ是如何运转的？

前言

　　之前已经介绍了RabbitMQ交换机模型的相关简单概念，都是作为此篇的基础铺垫，如果对此篇不懂的可以先看我上一篇的介绍认识RabbitMQ交换机模型，或者联系评论，分享《RabbitMQ实战指南》电子书给大家，里面虽然有些许错误，但总体还是很棒的一本书！

　　本文主要介绍RabbitMQ的消息是怎么产生和通过它是怎么接收消息的（RabbitMQ如何运转）、Connection和Channel概念、RabbitMQ的简单部署、Java代码简单实践三个部分

一、RabbitMQ的运转流程

　　1、生产者流程　　

　　　　　　1）生产者连接到RabbitMQ Broker，建立Connection，开启信道Channel（Connection与Channel概念下面会介绍）

　　　　　　2）生产者声明一个交换器，设置相关属性。

　　　　　　3）生产者声明一个队列并设置相关属性

　　　　　　4）生产者通过路由键将交换器和队列绑定起来

　　　　　　5）生产者发送消息到RabbitMQ Broker，包括路由键、交换器信息等

　　　　　　6）相应的交换器根据路由键查找匹配的队列

　　　　　　7）如果找到则消息存入相应队列中

　　　　　　8）如果没找到则根据配置的属性丢弃或者回退给生产者

　　　　　　9）关闭信道

　　　　　　10）关闭连接

　　2、消费者流程

　　　　　　1）消费者连接到RabbitMQ Broker，建立Connection，开启Channel

　　　　　　2）消费者向RabbitMQ Broker请求消费相应队列中消息，可能会设置相应的回调函数。

　　　　　　3）等待RabbitMQ Broker回应并投递相应队列中的消息，消费者接收消息。

　　　　　　4）消费者确认ack接收到的消息。

　　　　　　5） RabbitMQ从队列中删除相应已经被确认的消息。

　　　　　　6）关闭信道。

　　　　　　7）关闭连接

　　　　其实，最主要最不好理解的也就是Connection与Channel这两个概念，如果只是光看这些流程会相当不理解，为什么先建立Connection再建立Channel，这两个又是什么区别？所以再往下就是介绍Connection与Channel了！

二、Connection与Channel概念

　　1、 Connection：实际就是一条TCP连接，TCP一旦建立起来，客户端紧接着可以创建AMQP信道。

　　2、 Channel：每个Channel都有唯一的ID，都是建立在Connection上的虚拟连接，RabbitMQ处理每条AMQP指令都是通过信道完成的

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　（结合两张图，更好理解Connection与Channel两个概念）

　　3、单TCP复用连接与多信道的优势

　　　　　　1）为什么TCP连接只有一条，而每个生产者都会创建一条唯一的信道呢？想象下，实际情况，会有很多的生产者生产消息，多个消费者消费消息，那么就不得不创建多个线程，建立多个TCP连接。多个TCP连接的建立必然会对操作系统性能消耗较高，也不方便管理。从而选择一种类似于NIO（非阻塞I/O, Non-blocking I/O）技术是很有必要的，多信道的在TCP基础上的建立就是这么实现的。

　　　　　　2）每个线程都有自己的一个信道，复用了Connection的TCP连接，信道之间相互独立，相互保持神秘，节约TCP连接资源，当然本身信道的流量很大的话，也可以创建多个适当的Connection的TCP连接，需要根据具体业务情况制定。

三、RabbitMQ部署

　　主要以Linux CentOS 7举例部署，

1、准备Erlang环境

安装运行RabbitMQ之前，先安装Erlang环境，因为RabbitMQ是relang语言写的。下载http://www.erlang.org/downloads得到otp_src_21.2.tar.gz包

　1）解压到/opt/erlang目录下，./configure配置生成make make install

[root@hidden]# tar xvf otp_src_21.2.tar.gz 
[root@hidden]# cd otp_src_21.2 
[root@hidden otp_src_21.2]#./configure --prefix=/opt/er1ang

　如果安装过程出现"No curses library functions found"，则需要安装ncurses

[root@hidden otp_src_21.2]# yum install ncurses-devel

　2）编译安装make & make install

[root@hidden otp_src_21.2]# make & make install

　3）修改/etc/profile文件，增加如下语句

ERLANG_HOME=/opt/erlang
export PATH=$PATH:$ERLANG_HOME/bin
export ERLANG_HOME

　4）执行/etc/profile配置文件

[root@hidden otp_src_21.2]# source /etc/profile

　5）测试是否安装成功

[root@hidden otp_src_21.2]#erl

如果出现如下语句，则说明安装成功

Erlang/OTP 21 [erts-10.2] [source] [64-bit] [smp:1:1] [ds:1:1:10] [async-threads:1] [hipe]

Eshell V10.2  (abort with ^G)
1>

　2、安装RabbiMQ

　RabbitMQ安装比Erlang安装简单很多，下载generic压缩包：rabbitmq-server-generic-unix-3.7.11.tar.xz

　1）解压压缩到到Erlang同目录/opt下

[root@hidden]# tar zvxf rabbitmq-server-generic-unix-3.7.11.tar.xz
[root@hidden]# cd /opt
[root@hidden]# mv rabbitmq-server-generic-unix-3.7.11.tar.xz rabbitmq

　2）修改/etc/profile文件，增加如下语句

export PATH=$PATH:/opt/rabbitmq/sbin
export RABBITMQ_HOME=/opt/rabbitmq

　3）执行profile文件，使其生效

[root@hidden otp_src_21.2]# source /etc/profile

　4）修改运行为守护进程模式

[root@hidden otp_src_21.2]# rabbitmq-server -detached

　5）测试是否安装成功，出现Status of node rabbit@.........如下语句则说明安装成功

[root@hidden rabbitmq]# rabbitmqctl status

Status of node rabbit@iz2ze49fh77zgs1rzxo0l7z ...
[{pid,11462},
{running_applications,
[{rabbit,"RabbitMQ","3.7.11"},
{mnesia,"MNESIA CXC 138 12","4.15.5"},
{os_mon,"CPO CXC 138 46","2.4.7"},
{sysmon_handler,"Rate-limiting system_monitor event handler","1.1.0"},
{rabbit_common,
"Modules shared by rabbitmq-server and rabbitmq-erlang-client",
"3.7.11"},
{ranch,"Socket acceptor pool for TCP protocols.","1.7.1"},
{ssl,"Erlang/OTP SSL application","9.1"},
{public_key,"Public key infrastructure","1.6.4"},
{asn1,"The Erlang ASN1 compiler version 5.0.8","5.0.8"},
{inets,"INETS CXC 138 49","7.0.3"},
{recon,"Diagnostic tools for production use","2.3.6"},
{xmerl,"XML parser","1.3.18"},
{jsx,"a streaming, evented json parsing toolkit","2.9.0"},

..........

　3、新增用户与授权

RabbitMQ默认情况下用户和密码都为“guest”，但只能通过默认的本地网络localhost访问，网络访问受限，所以需要再单独新增用户授予权限

　1）新增root用户

新增用户名为root，密码为root

[root@hidden rabbitmq]# rabbitmqctl add_user root root

　2）授权root用户到默认vhost可配置、可读、可写权限

[root@hidden rabbitmq]# rabbitmqctl set_permissions -p / root ".*" ".*" ".*"

　3）设置root为管理员角色

[root@hidden rabbitmq]# rabbitmqctl set_user_tags root administrator

四、Java代码实践

首先maven下载jar包：

<!-- rabbitmq-->
    <dependency>
      <groupId>com.rabbitmq</groupId>
      <artifactId>amqp-client</artifactId>
      <version>5.6.0</version>
    </dependency>

1、生产者类

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.MessageProperties;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @author jian
 * @date 2019/2/14
 * @description RabbitMQ测试: 消息服务端
 *
 */
public class RabbitProducer {
    // 路由键
    private static final String ROUTING_KEY = "routingkey_demo";
    // 交换机名称
    private static final String EXCHANGE_NAME = "exchange_demo";
    // 队列名称
    private static final String QUEUE_NAME = "queue_demo";
    // RabbitMQ地址
    private static final String IP_ADDRESS = "xxx.xxx.xxx.xxx";
    // RabbitMQ默认端口5672
    private static final int PORT = 5672;

    public static void publicMeesage () {
        // 1)通过连接工厂建立复用TCP连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost(IP_ADDRESS);
        connectionFactory.setPort(PORT);
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("root");
        try {
            Connection connection = connectionFactory.newConnection();
            // 2)建立多信道
            Channel channel = connection.createChannel();
            // 3)声明交换器：创建一个direct、持久化、非自动删除的交换器
            channel.exchangeDeclare(EXCHANGE_NAME, "direct", true, false, null);
            // 4)声明队列：创建一个持久化、非排他的、非自动删除的队列
            channel.queueDeclare(QUEUE_NAME, true, false, false, null);
            // 5)将交换器与队列通过路由键绑定
            channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, ROUTING_KEY);
            // 6) 发送持久化消息
            String message = "hello world!";
            channel.basicPublish(EXCHANGE_NAME, ROUTING_KEY, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());
            System.out.println("producer published message: " + message);
            // 7)关闭信道
            channel.close();
            // 8)关闭连接
            connection.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

2、消费者类　

import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * @author jian
 * @date 2019/2/14
 * @description RabbitMQ测试：消费者消费消息
 */
public class RabbitConsumer {

    // 队列名称
    private static final String QUEUE_NAME = "queue_demo";
    // RabbitMQ地址
    private static final String IP_ADDRESS = "xxx.xxx.xxx.xxx";
    // RabbitMQ默认端口5672
    private static final int PORT = 5672;

    public static void recevieMessage() {
        Address[] addresses = new Address[]{
                new Address(IP_ADDRESS, PORT)
        };
        // 1)通过连接工厂建立复用TCP连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("root");
        try {
            // 2）建立连接：此处与生产者建立建立连接是不同的
            Connection connection = connectionFactory.newConnection(addresses);
            // 3) 创建channel信道
            Channel channel = connection.createChannel();
            // 设置客户端最多接收未被ack消息的个数
            channel.basicQos(64);
            // 4）消费者向RabbitMQ Broker请求消费相应队列中消息： 有消息就会执行回调函数handleDelivery
            DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("consumer received message: " + new String(body, "UTF-8"));
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            // 5）消费者确认ack接收 到的消息:自动回复队列应答
            channel.basicConsume(QUEUE_NAME, true, defaultConsumer);
            // 等待回调函数执行完毕
            TimeUnit.SECONDS.sleep(5);
            // 6) 关闭信道
            channel.close();
            // 7) 关闭连接
            connection.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

3、测试类

public class RabbitMQTest {

    public static void main(String[] args) {
        RabbitProducer.publicMeesage();
        RabbitConsumer.recevieMessage();
    }
}

4、测试结果

producer published message: hello world!
consumer received message: hello world!

posted @ 2019-02-21 11:27 JJian 阅读(1410) 评论(0) 编辑收藏举报

刷新页面返回顶部

Jian

我是一个木得感情，木得钱，木得...头发的程序猿！