消息队列RabbitMQ快速入门 一文搞懂RabbitMQ原理以及安装配置启动 掌握SpringBoot集成整合RabbitMQ

RabbitMQ介绍

定义

MQ全称为Message Queue，即消息队列. 它也是一个队列,遵循FIFO原则 。RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue Protocol高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开 发中应用非常广泛。

使用场景

开发中消息队列通常有如下应用场景：

• 提高系统响应速度

任务异步处理。 将不需要同步处理的并且耗时长的操作由消息队列通知消息接收方进行异步处理。 提高了应用程序的响应时间。

• 提高系统稳定性

系统挂了关系,操作内容放到消息队列。

• 服务调用异步化

服务没有直接的调用关系，而是通过队列进行服务通信。

• 服务解耦

 应用程序解耦合 MQ相当于一个中介，生产方通过MQ与消费方交互，它将应用程序进行解耦合。

• 排序保证 FIFO

遵循队列先进先出的特点。

• 消除峰值

异步化提速(发消息),提高系统稳定性(多系统调用),服务解耦(5-10个服务),排序保证，消除峰值。

主要常见消息队列：

ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ、Redis。

为什么选择RabbitMQ?

1. 使得简单，功能强大。
2. 基于AMQP协议。
3. 社区活跃，文档完善。
4. 高并发性能好，这主要得益于Erlang语言。
5. Spring Boot默认已集成RabbitMQ

AMQP介绍

AMQP，即Advanced Message Queuing Protocol，一个提供统一消息服务的应用层标准高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同的开发语言等条件的限制。Erlang
中的实现有RabbitMQ等。

JMS介绍

JMS是Java消息服务，是java提供的一套消息服务API标准，其目的是为所有的Java应用程序提供统一的消息通信的标准，类似java的 jdbc，只要遵循JMS标准的应用程序之间都可以进行消息通信。它和AMQP有什么 不同，JMS是Java语言专属的消 息服务标准，它是在api层定义标准，并且只能用于Java应用；而AMQP是在协议层定义的标准，是跨语言的。

RabbitMQ安装配置详细步骤

RabbitMQ由Erlang语言开发，Erlang语言用于并发及分布式系统的开发，在电信领域应用广泛，OTP（Open Telecom Platform）作为Erlang语言的一部分，包含了很多基于Erlang开发的中间件及工具库，安装RabbitMQ需要安装Erlang/OTP，并保持版本匹配。

RabbitMQ的下载地址：Downloading and Installing RabbitMQ — RabbitMQ

1.下载Erlang

下载地址:Downloads - Erlang/OTP   以管理员方式运行此文件，安装。
erlang安装完成需要配置erlang环境变量:
ERLANG_HOME = D:\javasoft\erl-24.2.1 
在path中添加:
%ERLANG_HOME%\bin

2.安装RabbitMQ

官网下载RabbitMQ,以管理员方式运行此文件，安装。

3.启动RabbitMQ

安装成功会自动创建RabbitMQ服务并且启动，从开始菜单启动RabbitMQ 完成在开始菜单找到RabbitMQ的菜单：

先点击(re)install再点击start

RabbitMQ Service-install :安装服务

RabbitMQ Service-remove 删除服务

RabbitMQ Service-start 启动

RabbitMQ Service-stop 停止

如果没有开始菜单则进入安装目录下sbin目录手动启动：

安装并运行服务

rabbitmq-service.bat install 安装服务

rabbitmq-service.bat stop 停止服务

rabbitmq-service.bat start 启动服务

4.安装管理插件

安装rabbitMQ的管理插件，方便在浏览器端管理RabbitMQ ,进入到Rabbit的sbin目录，使用cmd执行命令： rabbitmq-plugins.bat enable rabbitmq_management ，安装成功后重新启动RabbitMQ。

5.登录RabbitMQ

进入浏览器，输入：http://localhost:15672  ,初始账号和密码：guest/guest

登录进去的页面如下:

注意：
1.如果安装路径有中文，或系统登录用户是中文账户，启动RabbitMQ会闪退，需修改MQ的配置。
解决方案：https://blog.csdn.net/leoma2012/article/details/97636859 
2.安装erlang和rabbitMQ以管理员身份运行。 
3.当卸载重新安装时会出现RabbitMQ服务注册失败，此时需要进入注册表清理erlang 搜索RabbitMQ、ErlSrv，将对应的项全部删除。

RabbitMQ的工作原理

组成部分说明如下：
Broker：消息队列服务进程，此进程包括两个部分：Exchange和Queue。
Exchange：消息队列交换机，按一定的规则将消息路由转发到某个队列，对消息进行过虑。
Queue：消息队列，存储消息的队列，消息到达队列并转发给指定的消费方。 
Producer：消息生产者，即生产方客户端，生产方客户端将消息发送到MQ。 
Consumer：消息消费者，即消费方客户端，接收MQ转发的消息。
消息发布接收流程：
发送消息
1、生产者和Broker建立TCP连接。
2、生产者和Broker建立通道。
3、生产者通过通道消息发送给Broker，由Exchange将消息进行转发。
4、Exchange将消息转发到指定的Queue（队列） 
接收消息
1、消费者和Broker建立TCP连接 
2、消费者和Broker建立通道 
3、消费者监听指定的Queue（队列）
4、当有消息到达Queue时Broker默认将消息推送给消费者。
5、消费者接收到消息。 

RabbitMQ 常见模型

rabbitMQ提供了6种消息模型，但是第6种其实是RPC，并不是MQ，那么也就剩下5种。

但是其实3、4、5这三种都属于订阅模型，只不过进行路由的方式不同。

 

SpringBoot集成整合RabbitMQ

1.导入相关maven依赖

<dependencies>
    <dependency>
        <groupId>com.rabbitmq</groupId>
        <artifactId>amqp-client</artifactId>
        <!--和springboot2.0.5对应-->
        <version>5.4.1</version>
    </dependency>
</dependencies>

2.连接工具类

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

public class ConnectionUtil {
    /**
     * 建立与RabbitMQ的连接
     * @return
     * @throws Exception
     */
    public static Connection getConnection() throws Exception {
        //定义连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //设置服务地址
        factory.setHost("127.0.0.1");
        //端口
        factory.setPort(5672);
        //设置账号信息，用户名、密码、vhost
        factory.setVirtualHost("/");
        factory.setUsername("guest");
        factory.setPassword("guest");
        // 通过工程获取连接
        Connection connection = factory.newConnection();
        return connection;
    }
}

3.创建生产者

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

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

public class Producer01 {
    //队列名称
    private static final String QUEUE = "helloworld";

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = null;
        Channel channel = null;
        try {
            //获取连接
            connection = ConnectionUtil.getConnection();
            //创建与Exchange的通道，每个连接可以创建多个通道，每个通道代表一个会话任务
            channel = connection.createChannel();
            /**
             * 声明队列，如果Rabbit中没有此队列将自动创建
             * param1:队列名称
             * param2:是否持久化
             * param3:队列是否独占此连接
             * param4:队列不再使用时是否自动删除此队列
             * param5:队列参数
             */
            channel.queueDeclare(QUEUE, true, false, false, null);
            String message = "helloworld小明" + System.currentTimeMillis();
            /**
             * 消息发布方法
             * param1：Exchange的名称，如果没有指定，则使用Default Exchange
             * param2:routingKey,消息的路由Key，是用于Exchange（交换机）将消息转发到指定的消息队列
             * param3:消息包含的属性
             * param4：消息体
             */
            /**
             * 这里没有指定交换机，消息将发送给默认交换机，每个队列也会绑定那个默认的交换机，但是不能显
             示绑定或解除绑定
             * 默认的交换机，routingKey等于队列名称
             */
            channel.basicPublish("", QUEUE, null, message.getBytes());
            System.out.println("Send Message is:'" + message + "'");
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            if (channel != null) {
                channel.close();
            }
            if (connection != null) {
                connection.close();
            }
        }
    }
} 

启动后在管理界面查看队列

点击队列名称，进入详情页，可以查看消息：

 4.创建消费者

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

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

public class Consumer01 {
    private static final String QUEUE = "helloworld";

    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        //定义消费方法
        DefaultConsumer consumer = new DefaultConsumer(channel) {
        /**
         * 消费者接收消息调用此方法
         * @param consumerTag 消费者的标签，在channel.basicConsume()去指定
         * @param envelope 消息包的内容，可从中获取消息id，消息routingkey，交换机，消息和重传标志
        (收到消息失败后是否需要重新发送)
         * @param properties
         * @param body
         */
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            //交换机
            String exchange = envelope.getExchange();
            //路由key
            String routingKey = envelope.getRoutingKey();
            //消息id
            long deliveryTag = envelope.getDeliveryTag();
            //消息内容
            String msg = new String(body, "utf8");
            System.out.println("receive message.." + msg);
        }
    };
        /**
         * 监听队列String queue, boolean autoAck,Consumer callback
         * 参数明细
         * 1、队列名称
         * 2、是否自动回复，设置为true为表示消息接收到自动向mq回复接收到了，mq接收到回复会删除消息，设置
         为false则需要手动回复
         * 3、消费消息的方法，消费者接收到消息后调用此方法
         */
        channel.basicConsume(QUEUE, true, consumer);
    }
}

运行之后消费者已经获取了消息，但是程序没有停止，一直在监听队列中是否有新的消息。一旦有新的消息进入队列，就会立即打印。

消息确认机制（ACK)

我们知道消息一旦被消费者接收，队列中的消息就会被删除。那么RabbitMQ怎么知道消息被接收了呢？

如果消费者领取消息后，还没执行操作就挂掉了呢？或者抛出了异常？消息消费失败，但是RabbitMQ却不知道，这样消息就造成了丢失。

因此，RabbitMQ有一个ACK机制。当消费者获取消息后，会向RabbitMQ发送回执ACK，告知消息已经被接收。不过这种回执ACK分两种情况：

• 自动ACK：消息一旦被接收，消费者自动发送ACK
• 手动ACK：消息接收后，不会发送ACK，需要手动调用