【技术解析】消息中间件MQ：从原理到RabbitMQ实战(深入浅出)

文章目录

【技术解析】消息中间件MQ：从原理到RabbitMQ实战(深入浅出)
- 1.简介
- - [1.1 什么是消息中间件](#1.1 什么是消息中间件)
  - [1.2 传统的http请求存在那些缺点](#1.2 传统的http请求存在那些缺点)
  - [1.3 Mq应用场景有那些](#1.3 Mq应用场景有那些)
  - [1.4 为什么需要使用mq](#1.4 为什么需要使用mq)
  - [1.5 Mq与多线程之间区别](#1.5 Mq与多线程之间区别)
  - [1.6 Mq消息中间件名词](#1.6 Mq消息中间件名词)
  - 1.7主流mq区别对比
  - [1.8 Mq设计基础知识](#1.8 Mq设计基础知识)
- 2.RabbitMQ
- - [2.1 RabbitMQ环境的基本安装](#2.1 RabbitMQ环境的基本安装)
  - [2.2 liunx安装rabbitmq](#2.2 liunx安装rabbitmq)
  - 2.3快速入门RabbitMQ简单队列
  - [2.4 RabbitMQ如何保证消息不丢失](#2.4 RabbitMQ如何保证消息不丢失)
  - [2.5 RabbitMQ五种消息模式](#2.5 RabbitMQ五种消息模式)
  - - [2.5.1 RabbitMQ Fanout 发布订阅](#2.5.1 RabbitMQ Fanout 发布订阅)
    - [2.5.2 Direct路由模式](#2.5.2 Direct路由模式)
    - [2.5.3 Topic主题模式](#2.5.3 Topic主题模式)
  - [2.6 SpringBoot整合RabbitMQ](#2.6 SpringBoot整合RabbitMQ)
- [3. RabbitMQ实战解决方案](#3. RabbitMQ实战解决方案)
- - [3.1 RabbitMQ死信队列](#3.1 RabbitMQ死信队列)
  - [3.2 RabbitMQ消息幂等问题](#3.2 RabbitMQ消息幂等问题)
  - [3.3 SpringBoot开启消息确认机制](#3.3 SpringBoot开启消息确认机制)

【技术解析】消息中间件MQ：从原理到RabbitMQ实战(深入浅出)

1.简介

1.1 什么是消息中间件

消息中间件基于队列模型实现异步/同步传输数据
作用：可以实现支撑高并发、异步解耦、流量削峰、降低耦合度。

1.2 传统的http请求存在那些缺点

Http请求基于请求与响应的模型，在高并发的情况下，客户端发送大量的请求达到

服务器端有可能会导致我们服务器端处理请求堆积。
Tomcat服务器处理每个请求都有自己独立的线程，如果超过最大线程数会将该请求缓存到队列中，如果请求堆积过多的情况下，有可能会导致tomcat服务器崩溃的问题。所以一般都会在nginx入口实现限流，整合服务保护框架。
http请求处理业务逻辑如果比较耗时的情况下，容易造成客户端一直等待，阻塞等待过程中会导致客户端超时发生重试策略，有可能会引发幂等性问题。

注意事项：接口是为http协议的情况下，最好不要处理比较耗时的业务逻辑，耗时的业务逻辑应该单独交给多线程或者是mq处理。

1.3 Mq应用场景有那些

异步发送短信
异步发送新人优惠券
处理一些比较耗时的操作

1.4 为什么需要使用mq

可以实现支撑高并发、异步解耦、流量削峰、降低耦合度。

同步发送http请求

客户端发送请求到达服务器端，服务器端实现会员注册业务逻辑，

insertMember() --插入会员数据 1s
sendSms()----发送登陆短信提醒 3s
sendCoupons()----发送新人优惠券 3s

总共响应需要6s时间，可能会导致客户端阻塞6s时间，对用户体验不是很好。

多线程处理业务逻辑

用户向数据库中插入一条数据之后，在单独开启一个线程异步发送短信和优惠操作。

客户端只需要等待1s时间
优点：适合于小项目实现异步
缺点：有可能会消耗服务器cpu资源资源

MQ处理业务逻辑

先向数据库中插入一条会员数据，让后再向MQ中投递一个消息，MQ服务器端在将消息推送给消费者异步解耦处理发送短信和优惠券。

1.5 Mq与多线程之间区别

MQ可以实现异步/解耦/流量削峰问题；
多线程也可以实现异步，但是消耗到cpu资源，没有实现解耦。

1.6 Mq消息中间件名词

Producer 生产者：投递消息到MQ服务器端；
Consumer 消费者：从MQ服务器端获取消息处理业务逻辑；
Broker MQ服务器端
Topic 主题：分类业务逻辑发送短信主题、发送优惠券主题
Queue 存放消息模型队列先进先出后进后出原则数组/链表
Message 生产者投递消息报文：json

1.7主流mq区别对比

特性	ActiveMQ	RabbitMQ	RocketMQ	Kafka
开发语言	java	erlang	java	scala
单机吞吐量	万级	万级	10万级	10万级
时效性	ms级	us级	ms级	ms级以内
可用性	高(主从架构)	高(主从架构)	非常高(分布式架构)	非常高(分布式架构)
功能特性	成熟的产品，在很多公司得到应用；有较多的文档；各种协议支持较好	基于erlang开发，所以并发能力很强，性能极其好，延时很低管理界面较丰富	MQ功能比较完备，扩展性佳	只支持主要的MQ功能，像一些消息查询，消息回溯等功能没有提供，毕竟是为大数据准备的，在大数据领域应用广。

1.8 Mq设计基础知识

Maven依赖

xml 复制代码

<dependencies>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.62</version>
    </dependency>

    <dependency>
        <groupId>io.netty</groupId>
        <artifactId>netty-all</artifactId>
        <version>4.0.23.Final</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.62</version>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>3.11</version>
    </dependency>
</dependencies>

基于多线程队列简单实现mq

java 复制代码

public class MayiktThreadMQ {
    private static LinkedBlockingDeque<JSONObject> msgs = new LinkedBlockingDeque<>();

    public static void main(String[] args) {
        //生产者线程
        Thread producerThread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while (true){
                        //每隔一秒时间存放一个消息到队列里面去
                        Thread.sleep(1000);
                        JSONObject data = new JSONObject();
                        data.put("userId", "1234");
                        msgs.offer(data);//存入队列
                    }
                } catch (Exception e) {

                }
            }
        }, "生产者");
        producerThread.start();
        //消费者线程
        Thread consumerThread = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while (true) {
                        JSONObject data = msgs.poll();//取出消息
                        if (data != null) {
                            System.out.println(Thread.currentThread().getName() + "," + data);
                        }
                    }
                } catch (Exception e) {

                }
            }
        }, "消费者");
        consumerThread.start();
    }
}

基于netty实现mq

消费者netty客户端与nettyServer端MQ服务器端保持长连接，MQ服务器端保存消费者连接。

生产者netty客户端发送请求给nettyServer端MQ服务器端，MQ服务器端在将该消息内容发送给消费者。

body:{"msg":{"userId":"123456","age":"23"},"type":"producer"，"topic":""}

生产者投递消息给MQ服务器端，MQ服务器端需要缓存该消息如果mq服务器端宕机之后，消息如何保证不丢失

持久化机制
如果mq接收到生产者投递消息，如果消费者不在的情况下，该消息是否会丢失？

不会丢失，消息确认机制必须要消费者消费该消息成功之后，在通知给mq服务器端删除该消息。
Mq服务器端将该消息推送消费者：
- 消费者已经和mq服务器保持长连接。
- 消费者主动拉取消息：
- 消费者第一次刚启动的时候

Mq如何实现抗高并发思想

Mq消费者根据自身能力情况，拉取mq服务器端消息消费。

默认的情况下是取出一条消息。

缺点：存在延迟的问题

需要考虑mq消费者提高速率的问题：如何消费者提高速率：消费者实现集群、消费者批量获取消息即可。

2.RabbitMQ

RabbitMQ基本介绍

RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件），RabbitMQ服务器是用Erlang语言编写的。
RabitMQ官方网站

https://www.rabbitmq.com/getstarted.html

点对点(简单)的队列
工作(公平性)队列模式
发布订阅模式
路由模式Routing
通配符模式Topics
RPC

2.1 RabbitMQ环境的基本安装

下载并安装erlang,下载地址：http://www.erlang.org/download
配置erlang环境变量信息

新增环境变量ERLANG_HOME=erlang的安装地址
将%ERLANG_HOME%\bin加入到path中

下载并安装RabbitMQ，下载地址：http://www.rabbitmq.com/download.html

注意: RabbitMQ 它依赖于Erlang,需要先安装Erlang。
https://www.rabbitmq.com/install-windows.html

安装RabbitMQ环境步骤

配置Erlang环境变量：

安装rabbitmq-server-3.6.9

如何启动Rabbitmq
RabbitMQ Service - start

启动Rabbitmq常见问题

如果rabbitmq 启动成功无法访问管理平台页面

进入到D:\java\rabbitmq-server-3.6.9\rabbitmq_server-3.6.9\sbin

执行
rabbitmq-plugins enable rabbitmq_management
rabbitmqctl start_app

Rabbitmq管理平台中心

RabbitMQ 管理平台地址 http://127.0.0.1:15672

默认账号:guest/guest 用户可以自己创建新的账号

Virtual Hosts :

像mysql有数据库的概念并且可以指定用户对库和表等操作的权限。那RabbitMQ呢？

RabbitMQ也有类似的权限管理。在RabbitMQ中可以虚拟消息服务器VirtualHost，每个VirtualHost相当月一个相对独立的RabbitMQ服务器，每个VirtualHost之间是相互隔离的。exchange、queue、message不能互通。

默认的端口15672：rabbitmq管理平台端口号

默认的端口5672： rabbitmq消息中间内部通讯的端口

默认的端口号25672 rabbitmq集群的端口号

RabbitMQ常见名词
/Virtual Hosts---分类
/队列 存放我们消息
Exchange 分派我们消息在那个队列存放起来类似于nginx

15672---rabbitmq控制台管理平台 http协议
25672 rabbitmq 集群通信端口号
Amqp 5672 rabbitmq内部通信的一个端口号

2.2 liunx安装rabbitmq

shell 复制代码

# 安装启动rabbitmq容器
docker run -d --name myRabbitMQ -e RABBITMQ_DEFAULT_USER=root -e RABBITMQ_DEFAULT_PASS=0806 -p 15672:15672 -p 5672:5672 rabbitmq:3.8.14-management

-d ：表示以后台（detached）模式运行容器
--name myRabbitMQ ：指定容器的名称为"myRabbitMQ"
-e RABBITMQ_DEFAULT_USER=root -e RABBITMQ_DEFAULT_PASS=0806：设置RabbitMQ的默认用户名为"root"，默认密码为"0806"
-p 15672:15672 -p 5672:5672 ：将容器的15672端口映射到主机的15672端口（用于访问管理界面），将容器的5672端口映射到主机的5672端口（用于消息传输）
rabbitmq:3.8.14-management ：指定使用的RabbitMQ镜像及版本号，这里使用了带管理插件的版本"rabbitmq:3.8.14-management"

2.3快速入门RabbitMQ简单队列

首先需要再RabbitMQ平台创建Virtual Hosts 和队列。
/meiteVirtualHosts

Maven依赖

xml 复制代码

<dependencies>
    <dependency>
        <groupId>com.rabbitmq</groupId>
        <artifactId>amqp-client</artifactId>
        <version>3.6.5 </version>
    </dependency>
</dependencies>

RabbitMQConnection

java 复制代码

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

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

public class RabbitMQConnection {
    /**
     * 获取链接
     */
    public static Connection getConnection() throws IOException, TimeoutException {
        // 1.创建连接
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2.设置连接地址
        connectionFactory.setHost("192.168.249.129");
        // 3.设置端口号
        connectionFactory.setPort(5672);
        // 4.设置账号和密码
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("0806");
        // 5.设置VirtualHost
        connectionFactory.setVirtualHost("/meiteVirtualHosts");
        return connectionFactory.newConnection();
    }
}

生产者

java 复制代码

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

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

public class Producer {
/**
     * 生产者
     */
    private static final String QUEUE_NAME = "mayikt-queue";//队列名称

    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建连接
        Connection connection = RabbitMQConnection.getConnection();
        //2.创建通道
        Channel channel = connection.createChannel();
        String msg = "测试555";
        channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
        //3.关闭通道和连接
        channel.close();
        connection.close();
    }
}

运行前

运行后

mayikt-queue队列里面有一条消息没有被消费者消费(没被消费就会一直在队列中缓存)

java 复制代码

import com.rabbitmq.client.*;

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

public class Consume {
    /**
     * 消费者
     */
    private static final String QUEUE_NAME = "mayikt-queue";//队列名称

    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建连接
        Connection connection = RabbitMQConnection.getConnection();
        //2.设置通道
        Channel channel = connection.createChannel();
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws UnsupportedEncodingException {
                String msg = new String(body, "UTF-8");
                System.out.println("消费者获取消息:" + msg);
            }
        };
        //3.监听队列
        //autoAck ture:自动签收
        //autoAck false:手动签收
        channel.basicConsume(QUEUE_NAME, true, defaultConsumer);
    }
}

若报此错误 :Caused by: com.rabbitmq.client.ShutdownSignalException: channel error; protocol method: #method<channel.close>(reply-code=404, reply-text=NOT_FOUND - no queue 'mayikt-queu' in vhost '/meiteVirtualHosts', class-id=60, method-id=20)

证明没有名为此'mayikt-queu'的队列

2.4 RabbitMQ如何保证消息不丢失

Mq如何保证消息不丢失：

生产者角色

确保生产者投递消息到MQ服务器端成功。

Ack 消息确认机制

同步或者异步的形式

方式1：Confirms

方式2：事务消息
消费者角色

在rabbitmq情况下：

必须要将消息消费成功之后，才会将该消息从mq服务器端中移除。

在kafka中的情况下：

不管是消费成功还是消费失败，该消息都不会立即从mq服务器端移除。
Mq服务器端在默认的情况下都会对队列中的消息实现持久化持久化硬盘。

使用消息确认机制+持久技术
A.消费者确认收到消息机制
channel.basicConsume(QUEUE_NAME, false, defaultConsumer);
注：第二个参数值为false代表关闭RabbitMQ的自动应答机制，改为手动应答。
在处理完消息时，返回应答状态，true表示为自动应答模式。
channel.basicAck(envelope.getDeliveryTag(), false);
B.生产者确认投递消息成功使用Confirm机制或者事务消息

Confirm机制同步或者是异步的形式

RabbitMQ默认创建是持久化的

(durable为持久化到硬盘 Transient为持久化到内存)

代码中设置 durable为true

参数名称详解：

durable是否持久化 durable为持久化、 Transient 不持久化

autoDelete 是否自动删除，当最后一个消费者断开连接之后队列是否自动被删除，可以通过RabbitMQ Management，查看某个队列的消费者数量，当consumers = 0时队列就会自动删除

使用rabbitmq事务消息；

java 复制代码

	channel.txSelect();
	channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
//	  int i = 1 / 0;
	channel.txCommit();

相关核心代码
生产者

java 复制代码

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

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

public class Producer {
    private static final String QUEUE_NAME = "mayikt-queue";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //1.创建一个新连接
        Connection connection = RabbitMQConnection.getConnection();
        //2.设置channel
        Channel channel = connection.createChannel();
        //3.发送消息
        String msg = "每特教育6666";
channel.confirmSelect();

        channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
        boolean result = channel.waitForConfirms();
        if (result) {
            System.out.println("消息投递成功");
        } else {
            System.out.println("消息投递失败");
        }
        channel.close();
        connection.close();
    }
}

消费者

java 复制代码

import com.rabbitmq.client.*;
import com.zhaoli.RabbitMQConnection;

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

public class Consumer {
    private static final String QUEUE_NAME = "mayikt-queue";

    public static void main(String[] args) throws IOException, TimeoutException, IOException, TimeoutException {
        // 1.创建连接
        Connection connection = RabbitMQConnection.getConnection();
        // 2.设置通道
        Channel channel = connection.createChannel();
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("消费者获取消息:" + msg);
                // 消费者完成 消费该消息
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        // 3.监听队列
        channel.basicConsume(QUEUE_NAME, false, defaultConsumer);

    }
}

2.5 RabbitMQ五种消息模式

RabitMQ工作队列

默认的传统队列是为均摊消费，存在不公平性；如果每个消费者速度不一样的情况下，均摊消费是不公平的，应该是能者多劳。

采用工作队列

在通道中只需要设置basicQos为1即可，表示MQ服务器每次只会给消费者推送1条消息必须手动ack确认之后才会继续发送。
channel.basicQos(1);

RabbitMQ交换机类型

交换机类型	描述
Direct	直连交换机
Fanout	扇型交换机
Topic	主题交换机
Headers	头交换机
`/Virtual Hosts`---区分不同的团队
----队列存放消息
----交换机路由消息存放在那个队列中类似于nginx
---路由key 分发规则

2.5.1 RabbitMQ Fanout 发布订阅

生产者发送一条消息，经过交换机转发到多个不同的队列，多个不同的队列就多个不同的消费者。

原理：

需要创建两个队列，每个队列对应一个消费者；
队列需要绑定我们交换机
生产者投递消息到交换机中，交换机在将消息分配给两个队列中都存放起来；
消费者从队列中获取这个消息。

生产者代码

java 复制代码

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

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

public class ProducerFanout {//生产者
    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "fanout_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        //  创建Connection
        Connection connection = RabbitMQConnection.getConnection();
        // 创建Channel
        Channel channel = connection.createChannel();
        // 通道关联交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout", true);
        String msg = "赵立6666";
        channel.basicPublish(EXCHANGE_NAME, "", null, msg.getBytes());
        channel.close();
        connection.close();
    }
}

添加交换机

消费者代码

邮件消费者

java 复制代码

import com.rabbitmq.client.*;
import com.zhaoli.RabbitMQConnection;

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

public class MailConsumer {//邮件消费者
    /**
     * 定义邮件队列
     */
    private static final String QUEUE_NAME = "fanout_email_queue";
    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "fanout_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        System.out.println("邮件消费者...");
        // 创建我们的连接
        Connection connection = RabbitMQConnection.getConnection();
        // 创建我们通道
        final Channel channel = connection.createChannel();
        // 关联队列消费者关联队列
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("邮件消费者获取消息:" + msg);
            }
        };
        // 开始监听消息 自动签收
        channel.basicConsume(QUEUE_NAME, true, defaultConsumer);
    }
}

短信消费者

java 复制代码

import com.rabbitmq.client.*;
import com.zhaoli.RabbitMQConnection;

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

public class SmsConsumer {//短信消费者
    /**
     * 定义短信队列
     */
    private static final String QUEUE_NAME = "fanout_email_sms";
    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "fanout_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        System.out.println("短信消费者...");
        // 创建我们的连接
        Connection connection = RabbitMQConnection.getConnection();
        // 创建我们通道
        final Channel channel = connection.createChannel();
        // 关联队列消费者关联队列
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "");
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("短信消费者获取消息:" + msg);
            }
        };
        // 开始监听消息 自动签收
        channel.basicConsume(QUEUE_NAME, true, defaultConsumer);
    }
}

添加队列

2.5.2 Direct路由模式

当交换机类型为direct类型时，根据队列绑定的路由建转发到具体的队列中存放消息

生产者

java 复制代码

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

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

public class ProducerDirect {

    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "direct_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        //  创建Connection
        Connection connection = RabbitMQConnection.getConnection();
        // 创建Channel
        Channel channel = connection.createChannel();
        // 通道关联交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "direct", true);
        String msg = "每特教育6666";
        channel.basicPublish(EXCHANGE_NAME, "email", null, msg.getBytes());
        channel.close();
        connection.close();
    }
}

添加交换机

消费者

邮件消费者

java 复制代码

import com.rabbitmq.client.*;
import com.zhaoli.RabbitMQConnection;

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

public class MailConsumer {
    /**
     * 定义邮件队列
     */
    private static final String QUEUE_NAME = "direct_email_queue";
    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "direct_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        System.out.println("邮件消费者...");
        // 创建我们的连接
        Connection connection = RabbitMQConnection.getConnection();
        // 创建我们通道
        final Channel channel = connection.createChannel();
        // 关联队列消费者关联队列
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "email");
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("邮件消费者获取消息:" + msg);
            }
        };
        // 开始监听消息 自动签收
        channel.basicConsume(QUEUE_NAME, true, defaultConsumer);
    }
}

短信消费者

java 复制代码

import com.rabbitmq.client.*;
import com.zhaoli.RabbitMQConnection;

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

public class SmsConsumer {
    /**
     * 定义短信队列
     */
    private static final String QUEUE_NAME = "direct_sms_queue";
    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "direct_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        System.out.println("短信消费者...");
        // 创建我们的连接
        Connection connection = RabbitMQConnection.getConnection();
        // 创建我们通道
        final Channel channel = connection.createChannel();
        // 关联队列消费者关联队列
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "sms");
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("短信消费者获取消息:" + msg);
            }
        };
        // 开始监听消息 自动签收
        channel.basicConsume(QUEUE_NAME, true, defaultConsumer);
    }
}

添加队列

2.5.3 Topic主题模式

当交换机类型为topic类型时，根据队列绑定的路由建模糊转发到具体的队列中存放。
#号表示支持匹配多个词；
*号表示只能匹配一个词

生产者

java 复制代码

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

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

public class ProducerTopic {

    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "topic_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        //  创建Connection
        Connection connection = RabbitMQConnection.getConnection();
        // 创建Channel
        Channel channel = connection.createChannel();
        // 通道关联交换机
        channel.exchangeDeclare(EXCHANGE_NAME, "topic", true);
        String msg = "每特教育6666";
        channel.basicPublish(EXCHANGE_NAME, "mayikt.sms", null, msg.getBytes());
        channel.close();
        connection.close();
    }
}

添加交换机

消费者

邮件消费者

java 复制代码

import com.rabbitmq.client.*;
import com.zhaoli.RabbitMQConnection;

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

public class MailConsumer {
    /**
     * 定义邮件队列
     */
    private static final String QUEUE_NAME = "topic_email_queue";
    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "topic_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        System.out.println("邮件消费者...");
        // 创建我们的连接
        Connection connection = RabbitMQConnection.getConnection();
        // 创建我们通道
        final Channel channel = connection.createChannel();
        // 关联队列消费者关联队列
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "mayikt.*");
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("邮件消费者获取消息:" + msg);
            }
        };
        // 开始监听消息 自动签收
        channel.basicConsume(QUEUE_NAME, true, defaultConsumer);
    }
}

短信消费者

java 复制代码

import com.rabbitmq.client.*;
import com.zhaoli.RabbitMQConnection;

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

public class SmsConsumer {
    /**
     * 定义短信队列
     */
    private static final String QUEUE_NAME = "topic_sms_queue";
    /**
     * 定义交换机的名称
     */
    private static final String EXCHANGE_NAME = "topic_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        System.out.println("短信消费者...");
        // 创建我们的连接
        Connection connection = RabbitMQConnection.getConnection();
        // 创建我们通道
        final Channel channel = connection.createChannel();
        // 关联队列消费者关联队列
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "meite.*");
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "UTF-8");
                System.out.println("短信消费者获取消息:" + msg);
            }
        };
        // 开始监听消息 自动签收
        channel.basicConsume(QUEUE_NAME, true, defaultConsumer);
    }
}

添加队列

2.6 SpringBoot整合RabbitMQ

Maven依赖

xml 复制代码

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.0.RELEASE</version>
</parent>
<dependencies>

    <!-- springboot-web组件 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- 添加springboot对amqp的支持 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
    </dependency>
    <!--fastjson -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.49</version>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
</dependencies>

配置类

java 复制代码

package com.zhaoli.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

@Component
public class RabbitMQConfig {
    /**
     * 定义交换机
     */
    private String EXCHANGE_SPRINGBOOT_NAME = "/mayikt_ex";
    /**
     * 短信队列
     */
    private String FANOUT_SMS_QUEUE = "fanout_sms_queue";
    /**
     * 邮件队列
     */
    private String FANOUT_EMAIL_QUEUE = "fanout_email_queue";

    //1.注入队列和交换机到spring容器中
    //2.关联交换机 xml中用的是<bean id="" class="";>  注解用@bean

    /**
     * 邮件队列、短信队列、交换机 注入到spring 容器中
     */
    @Bean
    public Queue smsQueue() {
        return new Queue(FANOUT_SMS_QUEUE);
    }

    @Bean
    public Queue emailQueue() {
        return new Queue(FANOUT_EMAIL_QUEUE);
    }

    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange(EXCHANGE_SPRINGBOOT_NAME);
    }

    /**
     * 关联交换机
     * 根据参数名称在 ioc 容器中获取 Queue 对象
     */
    @Bean
    public Binding bindingSmsFanoutExchange(Queue smsQueue, FanoutExchange fanoutExchange) {
        //将 FANOUT_SMS_QUEUE 队列关联 EXCHANGE_SPRINGBOOT_NAME 交换机
        return BindingBuilder.bind(smsQueue).to(fanoutExchange);
    }

    @Bean
    public Binding bindingEmailFanoutExchange(Queue emailQueue, FanoutExchange fanoutExchange) {
        //将 FANOUT_EMAIL_QUEUE 队列关联 EXCHANGE_SPRINGBOOT_NAME 交换机
        return BindingBuilder.bind(emailQueue).to(fanoutExchange);
    }
}

配置文件

yml 复制代码

Resources/application.yml
spring:
  rabbitmq:
    ####连接地址
    host: 192.168.249.129
    ####端口号
    port: 5672
    ####账号
    username: guest
    ####密码
    password: guest
    ### 地址
    virtual-host: /meiteVirtualHosts

配置账号访问权限

Entity

java 复制代码

package com.zhaoli.entity;

import lombok.Data;

import java.io.Serializable;

@Data
public class MsgEntity implements Serializable {
    private String msgId;
    private String userId;
    private String phone;
    private String email;

    public MsgEntity(String msgId, String userId, String phone, String email) {
        this.msgId = msgId;
        this.userId = userId;
        this.phone = phone;
        this.email = email;
    }
}

启动类

java 复制代码

package com.zhaoli;

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

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

生产者

java 复制代码

package com.zhaoli.service;

import com.zhaoli.entity.MsgEntity;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.UUID;

@RestController
public class ProducerService {

    /**
     * 从 springboot ioc 容器中拿到整合好的 rabbitmq 中的 AmqpTemplate 模板
     */
    @Autowired
    private AmqpTemplate amqpTemplate;

    @RequestMapping("/sendMsg")
    public void sendMsg() {
        MsgEntity msgEntity = new MsgEntity(UUID.randomUUID().toString(), "1234", "1764654557", "5204567891@qq.com");
        /**
         * 参数1 交换机名称
         * 参数2 路由 key
         * 参数3 发送内容
         */
        amqpTemplate.convertAndSend("/mayikt_ex", "", msgEntity);
    }
}

消费者

java 复制代码

package com.zhaoli;

import com.zhaoli.entity.MsgEntity;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@RabbitListener(queues = "fanout_email_queue")
public class FanoutEmailConsumer {
    @RabbitHandler
    public void process(MsgEntity msgEntity) {
        log.info("email:msgEntity:" + msgEntity);
    }
}
package com.zhaoli;

import com.zhaoli.entity.MsgEntity;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@RabbitListener(queues = "fanout_sms_queue")
public class FanoutSmsConsumer {
    @RabbitHandler
    public void process(MsgEntity msgEntity) {
        log.info("sms:msgEntity:" + msgEntity);
    }
}

在配置文件 Resources/application.yml 中设置一个新的端口号，避免同时启动端口号冲突

yml 复制代码

server:
  port: 8082

整个项目结构

生产者如何获取消费结果

根据业务来定

消费者消费成功结果：

能够在数据库中插入一条数据
Rocketmq 自带全局消息id，能够根据该全局消息获取消费结果

原理：生产者投递消息到mq服务器，mq服务器端在这时候返回一个全局的消息id，

当我们消费者消费该消息成功之后，消费者会给我们mq服务器端发送通知标记该消息

消费成功。

生产者获取到该消息全局id，每隔2s时间调用mq服务器端接口查询该消息是否

有被消费成功。
异步返回一个全局id，前端使用ajax定时主动查询；
在rocketmq中，自带根据消息id查询是否消费成功

3. RabbitMQ实战解决方案

3.1 RabbitMQ死信队列

死信队列产生的背景

RabbitMQ死信队列俗称，备胎队列；消息中间件因为某种原因拒收该消息后，可以转移到死信队列中存放，死信队列也可以有交换机和路由key等。

产生死信队列的原因

消息投递到MQ中存放消息已经过期消费者没有及时的获取到我们消息，消息如果存放到mq服务器中过期之后，会转移到备胎死信队列存放。
队列达到最大的长度（队列容器已经满了）
消费者消费多次消息失败，就会转移存放到死信队列中

代码整合参考 mayikt-springboot-rabbitmq|#中order-dead-letter-queue项目

死信队列的架构原理

死信队列和普通队列区别不是很大，普通与死信队列都有自己独立的交换机和路由key、队列和消费者。

区别：

生产者投递消息先投递到我们普通交换机中，普通交换机在将该消息投到普通队列中缓存起来，普通队列对应有自己独立普通消费者。
如果生产者投递消息到普通队列中，普通队列发现该消息一直没有被消费者消费的情况下，在这时候会将该消息转移到死信（备胎）交换机中，死信（备胎）交换机对应有自己独立的死信（备胎）队列对应独立死信（备胎）消费者。

死信队列应用场景

30分钟订单超时设计

A.Redis过期key ：

在设计 Redis 的过期 key 时，可以使用 Redis 的过期时间特性来自动删除超时的订单。可以通过以下步骤实现：

创建订单时，生成一个唯一的订单 ID。
将订单 ID 作为 Redis 键（key）。例如，可以使用 "order:{订单ID}" 这样的键命名格式。
在订单创建完成后，设置 Redis 键的过期时间（TTL）为 30 分钟。可以使用 Redis 命令 EXPIRE 或 SETEX 设置过期时间。
当需要检查订单是否超时时，可以使用 Redis 的 TTL 命令来查看键的剩余生存时间。如果返回值小于 0，说明订单已超时。
如果订单超时，则根据业务需求执行相应的处理操作，例如取消订单、发送通知等。
通过以上设计，Redis 会自动管理订单的过期与删除，避免了手动操作，并且可以提高订单过期检查的效率。

B.死信延迟队列实现：

采用死信队列，创建一个普通队列没有对应的消费者消费消息，在30分钟过后就会将该消息转移到死信备胎消费者实现消费。

备胎死信消费者会根据该订单号码查询是否已经支付过，如果没有支付的情况下则会开始回滚库存操作。

3.2 RabbitMQ消息幂等问题

RabbitMQ消息自动重试机制

当我们消费者处理执行我们业务代码的时候，如果抛出异常的情况下在这时候mq会自动触发重试机制，默认的情况下rabbitmq是无限次数的重试需要人为指定重试次数限制问题
在什么情况下消费者需要实现重试策略？
A.消费者获取消息后，调用第三方接口，但是调用第三方接口失败呢？是否需要重试？
该情况下需要实现重试策略，网络延迟只是暂时调用不通，重试多次有可能会调用通。

B.消费者获取消息后，因为代码问题抛出数据异常，是否需要重试？

该情况下是不需要实现重试策略，就算重试多次，最终还是失败的，可以将日志存放起来，后期通过定时任务或者人工补偿形式。

如果是重试多次还是失败消息，需要重新发布消费者版本实现消费。

可以使用死信队列。

Mq在重试的过程中，有可能会引发消费者重复消费的问题。

Mq消费者需要解决幂等性问题

幂等性保证数据唯一

方式1：

生产者在投递消息的时候，生成一个全局唯一id，放在我们消息中。

消费者获取到我们该消息，可以根据该全局唯一id实现去重复。

全局唯一id 根据业务来定的订单号码作为全局的id

实际上还是需要再db层面解决数据防重复。

业务逻辑是在做insert操作使用唯一主键约束

业务逻辑是在做update操作使用乐观锁

当消费者业务逻辑代码中，抛出异常自动实现重试（默认是无数次重试）
应该对RabbitMQ重试次数实现限制，比如最多重试5次，每次间隔3s；重试多次还是失败的情况下，存放到死信队列或者存放到数据库表中记录后期人工补偿

如何合理选择消息重试

消费者获取消息后，调用第三方接口，但是调用第三方接口失败呢？是否需要重试？
消费者获取消息后，应该代码问题抛出数据异常，是否需要重试？

总结：如果消费者处理消息时，因为代码原因抛出异常是需要从新发布版本才能解决的，那么就不需要重试，重试也解决不了该问题的。存放到死信队列或者是数据库表记录、后期人工实现补偿。

Rabbitmq如何开启重试策略

yml 复制代码

spring:
  rabbitmq:
    ####连接地址
    host: 127.0.0.1
    ####端口号
    port: 5672
    ####账号
    username: guest
    ####密码
    password: guest
    ### 地址
    virtual-host: /meite_rabbitmq
    listener:
      simple:
        retry:
          ####开启消费者（程序出现异常的情况下会）进行重试
          enabled: true
          ####最大重试次数
          max-attempts: 5
          ####重试间隔次数
          initial-interval: 3000

消费者重试过程中，如何避免幂等性问题

重试的过程中，为了避免业务逻辑重复执行，建议提前全局id提前查询，如果存在的情况下，就无需再继续做该流程。

重试的次数最好有一定间隔次数，在数据库底层层面保证数据唯一性，比如加上唯一id。

3.3 SpringBoot开启消息确认机制

配置文件新增

yml 复制代码

spring:
  rabbitmq:
    ####连接地址
    host: 127.0.0.1
    ####端口号
    port: 5672
    ####账号
    username: guest
    ####密码
    password: guest
    ### 地址
    virtual-host: /meiteVirtualHosts
    listener:
      simple:
        retry:
          ####开启消费者（程序出现异常的情况下会）进行重试
          enabled: true
          ####最大重试次数
          max-attempts: 5
          ####重试间隔次数
          initial-interval: 3000
        acknowledge-mode: manual
  datasource:
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8
    username: root
    password: root
    driver-class-name: com.mysql.jdbc.Driver

消费者ack代码

java 复制代码

@Slf4j
@Component
@RabbitListener(queues = "fanout_order_queue")
public class FanoutOrderConsumer {

    @Autowired
    private OrderManager orderManager;
    @Autowired
    private OrderMapper orderMapper;

    @RabbitHandler
    public void process(OrderEntity orderEntity, Message message, Channel channel) throws IOException {
//        try {
        log.info(">>orderEntity:{}<<", orderEntity.toString());
        String orderId = orderEntity.getOrderId();
        if (StringUtils.isEmpty(orderId)) {
            log.error(">>orderId is null<<");
            return;
        }
        OrderEntity dbOrderEntity = orderMapper.getOrder(orderId);
        if (dbOrderEntity != null) {
            log.info(">>该订单已经被消费过，无需重复消费!<<");
            // 无需继续重试
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
            return;
        }
        int result = orderManager.addOrder(orderEntity);

        log.info(">>插入数据库中数据成功<<");
        if (result >= 0) {
            // 开启消息确认机制
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        }
//        int i = 1 / 0;
//        } catch (Exception e) {
//            // 将失败的消息记录下来，后期采用人工补偿的形式
//        }
    }
}