RabbitMQ是如何运转的？ 认识RabbitMQ交换机模型

前言

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

　　本文主要介绍RabbitMQ的消息是怎么产生，怎么接收到的、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语言写的。

　　　　下载

　　2、安装RabbiMQ

　　3、运行RabbitMQ

------明天再补充........

四、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!