RabbitMQ Tutorials
rabbitmq+学习手册
Redhat、iMatix 等联合制定了 AMQP 的公开标准。 Introduction: RabbitMQ is a complete and highly reliable enterprise messaging system based on the emerging AMQP
standard. It is licensed under the open source Mozilla Public License and has a platform-neutral distribution, plus platform-specific packages and bundles for easy installation.
rabbitmq 学习-1-AMQP介绍
本文档来自网上.[ 看否网正使用rabbitmq做爬虫队列,欢迎大家交流q
AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准， 为面向消息的中间件设计。
若下载的是rabbitmq-server-generic-unix-1.7.2.tar.gz，可以直接解压，像windows上一样启动，然后使用 即可
rabbitmq 学习-3-初试1
本例是一个简单的异步发送消息实例 1，发送端 @Test(groups = { "sunjun" }) public class RabbitmqTest {
rabbitmq 学习-2-安装
Windows 1，下载 下载erlang： 下载rabbitmq：/download.html 2，安装 先安装erlang，C:\Program Files\erl5.7.5 设置环境变量：ERLANG_HOME=C:\Program Files\erl5.7.5 解压rabbitmq，进入dos下， >cd C:\rabbitmq_server-1.7.2\sbin >rabbitmq-service install 3，启动 >cd C:\rabbitmq_server-1.7.2\sbin >rabbitmq-service start 或都直接双击C:\rabbitmq_server-1.7.2\sbin\rabbitmq-service.bat Linux 1，下载erlang for linux版本，安装
RabbitMQ入门教程（PHP版）使用rabbitmq-delayed-message-。。。
RabbitMQ⼊门教程（PHP版）使⽤rabbitmq-delayed-message-。
延迟任务应⽤场景场景⼀：物联⽹系统经常会遇到向终端下发命令，如果命令⼀段时间没有应答，就需要设置成超时。
场景⼆：订单下单之后30分钟后，如果⽤户没有付钱，则系统⾃动取消订单。
场景三：过1分钟给新注册会员的⽤户，发送注册邮件等。
php 使⽤rabbitmq-delayed-message-exchange插件实现延迟功能1.安装下载后解压，并将其拷贝⾄(使⽤Linux Debian/RPM部署)rabbitmq服务器⽬录：/usr/local/rabbitmq/plugins中（ windows安装⽬录\rabbitmq_server-version\plugins ）.2.启⽤插件使⽤命令rabbitmq-plugins enable rabbitmq_delayed_message_exchang启⽤插件rabbitmq-plugins enable rabbitmq_delayed_message_exchang输出如下：The following plugins have been enabled:rabbitmq_delayed_message_exchange通过rabbitmq-plugins list查看已安装列表,如下：...[ ] rabbitmq_delayed_message_exchange 20171215-3.6.x...3.机制解释安装插件后会⽣成新的Exchange类型x-delayed-message，该类型消息⽀持延迟投递机制,接收到消息后并未⽴即将消息投递⾄⽬标队列中，⽽是存储在mnesia(⼀个分布式数据系统)表中，检测消息延迟时间，如达到可投递时间时并将其通过x-delayed-type类型标记的交换机类型投递⾄⽬标队列。
4.php实现过程消费者 delay_consumer2.php:<?php//header('Content-Type:text/html;charset=utf8;');$params = array('exchangeName' => 'delayed_exchange_test','queueName' => 'delayed_queue_test','routeKey' => 'delayed_route_test',);$connectConfig = array('host' => 'localhost','port' => 5672,'login' => 'guest','password' => 'guest','vhost' => '/');//var_dump(extension_loaded('amqp'));//exit();try {$conn = new AMQPConnection($connectConfig);$conn->connect();if (!$conn->isConnected()) {//die('Conexiune esuata');//TODO 记录⽇志echo 'rabbit-mq 连接错误:', json_encode($connectConfig);exit();}$channel = new AMQPChannel($conn);if (!$channel->isConnected()) {// die('Connection through channel failed');//TODO 记录⽇志echo 'rabbit-mq Connection through channel failed:', json_encode($connectConfig);exit();}$exchange = new AMQPExchange($channel);//$exchange->setFlags(AMQP_DURABLE);//声明⼀个已存在的交换器的，如果不存在将抛出异常，这个⼀般⽤在consume端$exchange->setName($params['exchangeName']);$exchange->setType('x-delayed-message'); //x-delayed-message类型/*RabbitMQ常⽤的Exchange Type有三种：fanout、direct、topic。
rabbitmq 使用手册
rabbitmq 使用手册RabbitMQ 是一个开源的消息代理软件，它实现了高效的消息传递机制，可以在分布式系统中进行消息的发布和订阅。
下面是 RabbitMQ 的使用手册的详细精确说明：1. 安装 RabbitMQ：首先，你需要下载并安装 RabbitMQ。
你可以从RabbitMQ 官方网站上下载适合你操作系统的安装包，并按照官方文档中的说明进行安装。
2. 启动 RabbitMQ 服务器：安装完成后，你可以启动 RabbitMQ 服务器。
在大多数操作系统中，你可以通过命令行执行以下命令来启动RabbitMQ：```rabbitmq-server```如果一切正常，你将会看到 RabbitMQ 服务器成功启动的日志信息。
3. 创建和管理队列：RabbitMQ 使用队列来存储消息。
你可以使用 RabbitMQ 的管理界面或者命令行工具来创建和管理队列。
以下是一些常用的队列操作命令：- 创建队列：```rabbitmqadmin declare queue name=<queue_name>```- 查看队列列表：```rabbitmqadmin list queues```- 删除队列：```rabbitmqadmin delete queue name=<queue_name>```4. 发布和消费消息：使用 RabbitMQ，你可以将消息发布到队列中，并从队列中消费消息。
以下是一些常用的消息操作命令：- 发布消息：```rabbitmqadmin publish routing_key=<routing_key>payload=<message>```- 消费消息：```rabbitmqadmin get queue=<queue_name>```- 确认消息已被消费：```rabbitmqadmin ack delivery_tag=<delivery_tag> ```5. 设置消息交换机和绑定：RabbitMQ 使用消息交换机来将消息路由到队列。
RabbitMQ-最完整最全教程
RabbitMQ-Day1学习目标1. 消息队列介绍2. 安装RabbitMQ3. 编写RabbitMQ的入门程序4. RabbitMQ的5种模式讲解5. SpringBoot整合RabbitMQ1消息队列概述1.1消息队列MQMQ全称为Message Queue，消息队列是应用程序和应用程序之间的通信方法。
为什么使用MQ？在项目中，可将一些无需即时返回且耗时的操作提取出来，进行异步处理，而这种异步处理的方式大大的节省了服务器的请求响应时间，从而提高了系统的吞吐量。
开发中消息队列通常有如下应用场景：1.2AMQP 和JMSMQ是消息通信的模型；实现MQ的大致有两种主流方式：AMQP、JMS。
1.2.1AMQPAMQP高级消息队列协议，是一个进程间传递异步消息的网络协议，更准确的说是一种binary wire-level protocol（链接协议）。
这是其和JMS的本质差别，AMQP不从API层进行限定，而是直接定义网络交换的数据格式。
1.2.2JMSJMS即Java消息服务（JavaMessage Service）应用程序接口，是一个Java平台中关于面向消息中间件（MOM）的API，用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。
1.2.3AMQP 与JMS 区别JMS是定义了统一的接口，来对消息操作进行统一；AMQP是通过规定协议来统一数据交互的格式JMS限定了必须使用Java语言；AMQP只是协议，不规定实现方式，因此是跨语言的。
JMS规定了两种消息模式；而AMQP的消息模式更加丰富1.3消息队列产品目前市面上成熟主流的MQ有Kafka 、RocketMQ、RabbitMQ，我们这里对每款MQ做一个简单介绍。
1.4RabbitMQ介绍RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。
RabbitMQ入门到精通_余胜军版笔记
RabbitMQ⼊门到精通_余胜军版笔记原视频链接：MQ架构设计原理什么是消息中间件消息中间件基于队列模型实现异步/同步传输数据作⽤：可以实现⽀撑⾼并发、异步解耦、流量削峰、降低耦合度。
在了解中间件之前，我们先了解⼀下什么是同步？⾸先我们想⼀下，两个公司之间如果有互相调⽤接⼝的业务需求，如果没有引⼊中间件技术，是怎么实现的呢？⽤户发起请求给系统A，系统A接到请求直接调⽤系统B，系统B返回结果后，系统A才能返回结果给⽤户，这种模式就是同步调⽤。
所谓同步调⽤就是各个系统之间互相依赖，⼀个系统发送请求，其他系统也会跟着依次进⾏处理，只有所有系统处理完成后对于⽤户来讲才算完成了⼀次请求。
只要其他系统出现故障，就会报错给⽤户。
那么引⼊中间件后，是如何做到异步调⽤的呢？⽤户发起请求给系统A，此时系统A发送消息给MQ，然后就返回结果给⽤户，不去管系统B了。
然后系统B根据⾃⼰的情况，去MQ中获取消息，获取到消息的时候可能已经过了1分钟甚⾄1⼩时，再根据消息的指⽰执⾏相应的操作。
那么想⼀想，系统A和系统B互相之间是否有通信？这种调⽤⽅式是同步调⽤吗？系统A发送消息给中间件后，⾃⼰的⼯作已经完成了，不⽤再去管系统B什么时候完成操作。
⽽系统B拉去消息后，执⾏⾃⼰的操作也不⽤告诉系统A执⾏结果，所以整个的通信过程是异步调⽤的。
说到这⾥，我们可以做个总结，消息中间件到底是什么呢？其实消息中间件就是⼀个独⽴部署的系统。
可以实现各个系统之间的异步调⽤。
当然它的作⽤可不⽌这些，通过它可以解决⼤量的技术痛点，我们接下来会进⾏介绍。
消息中间件，总结起来作⽤有三个：异步化提升性能、降低耦合度、流量削峰。
异步化提升性能先来说说异步化提升性能，上边我们介绍中间件的时候已经解释了引⼊中间件后，是如何实现异步化的，但没有解释具体性能是怎么提升的，我们来看⼀下下边的图。
没有引⼊中间件的时候，⽤户发起请求到系统A，系统A耗时20ms，接下来系统A调⽤系统B，系统B耗时200ms，带给⽤户的体验就是，⼀个操作全部结束⼀共耗时220ms。
RabbitMQ官方教程一HelloWorld（GOLANG语言实现）
RabbitMQ官⽅教程⼀HelloWorld（GOLANG语⾔实现）介绍RabbitMQ是消息中间件：它接受并转发消息。
您可以将其视为邮局系统：将要发送的邮件放在邮箱中时，可以确保邮递员最终将邮件传递给收件⼈。
以此类推，RabbitMQ是⼀个邮箱，⼀个邮局和⼀个邮递员。
RabbitMQ与邮局之间的主要区别在于，它不处理纸张，⽽是接收，存储和转发数据消息的⼆进制数据。
以下是RabbitMQ和消息发送的术语Producer：⽣产者。
负责⽣产消息。
Queue：队列。
负责存储消息。
队列在RabbitMQ中充当邮箱的⾓⾊,消息传递到RabbitMQ中，只能存储在队列中。
队列受主机内存和磁盘⼤⼩的约束。
本质是⼀个很⼤的消息缓冲区。
许多⽣产者可以将消息发送到⼀个队列，许多消费者可以尝试从⼀个队列接收数据。
Consumer：消费者。
负责处理消息。
** 笔者补充Connect：连接。
⽣产者和RabbitMQ服务之间建⽴的TCP连接。
Channel：信道，⼀条连接可包含多条信道，不同信道之间通信互不⼲扰。
考虑下多线程应⽤场景，每个线程对应⼀条信道，⽽不是对应⼀条连接，这样可以提⾼性能。
body：消息主体，要传递的数据。
exchange：交换器，负责把消息转发到对应的队列。
交换器本⾝没有缓存消息的功能，消息是在队列中缓存的，如果队列不存在，则交换器会直接丢弃消息。
常⽤的有四种类型的交换器：direct、fanout、topic、headers。
不同类型的交换器有不同的交换规则，交换器会根据交换规则把消息转发到对应的队列。
exchangeName：交换器名称，每个交换器对应⼀个名称，发送消息时会附带交换器名称，根据交换器名称选择对应的交换器。
BandingKey：绑定键，⼀个队列可以有⼀个到多个绑定键，通过绑定操作可以绑定交换器和队列，交换器会根据绑定键的名称找到对应的队列。
RotingKey：路由键，发送消息时，需要附带⼀条路由键，交换器会对路由键和绑定键进⾏匹配，如果匹配成功，则消息会转发到绑定键对应的队列中。
rabbitmq使用手册
rabbitmq使用手册RabbitMQ是一种开源的消息队列中间件，采用AMQP协议，被广泛应用于构建可靠、高效的分布式系统。
本手册将详细介绍RabbitMQ 的安装、配置、使用和常见问题解决方案，帮助读者快速上手使用RabbitMQ。
第一章安装与配置1.1 环境准备在开始安装RabbitMQ之前，需要确保系统满足以下要求：操作系统（例如Linux、Windows）、Erlang运行时环境以及RabbitMQ软件包。
1.2 安装RabbitMQ按照文档提供的方式，在所选的操作系统上安装RabbitMQ。
安装过程中需注意版本兼容性和安全配置。
1.3 配置RabbitMQ在安装完成后，需要对RabbitMQ进行适当的配置。
主要包括网络配置、认证与授权、虚拟主机、交换机和队列的创建等。
第二章消息发布与订阅2.1 消息生产者通过使用RabbitMQ的API，开发者可以编写生产者代码将消息发布到RabbitMQ的交换机上。
这里需要注意消息的序列化和指定交换机名称。
2.2 消息消费者RabbitMQ的消费者通过订阅交换机的队列来接收消息，可以使用RabbitMQ的API编写消费者代码，并实现消息的处理逻辑。
2.3 消息确认机制RabbitMQ提供了消息的确认机制，确保消息在传输过程中的可靠性。
开发者可以选择隐式确认或显式确认来保证消息的消费状态。
第三章消息路由与过滤3.1 路由模式RabbitMQ支持多种路由模式，如直接路由、主题路由和广播路由。
开发者可以根据实际需求选择最适合的路由模式。
3.2 消息过滤通过使用RabbitMQ的消息过滤功能，可以根据消息的属性进行过滤，只有满足条件的消息才会被消费者接收。
第四章高级特性与扩展4.1 持久化使用RabbitMQ的持久化机制，可以确保消息在服务器重启后依然存在，防止消息丢失。
4.2 集群与高可用通过搭建RabbitMQ集群，可以提高系统的可用性和扩展性。
在集群中，消息将自动在节点之间进行复制。
RabbitMQ安装配置步骤详解
R a b b i t M Q安装配置步骤详解Revised by Petrel at 2021R a b b i t M Q安装配置步骤详解1.下载RabbitMQ下载RabbitMQ安装包，下载地址：使用mkdir命令在usr下新建rabbitmq目录，如：mkdir/usr/rabbitmq 用SSH工具将下载的上传到Linux系统中的/usr/rabbitmq/目录。
2.安装RabbitMQ由于Rabbitmq是用erlang语言写的，所以我们需要安装Erlang，安装erlang又需要安装python与simplejson,所以我们从python开始：2.1安装预环境a)查看gccgcc-c++、zlibzlin-devel是否安装，执行如下命令：rpm-qa|grepgccrpm-qa|grepzlib如果未安装需要执行一下命令：yuminstallgccgcc-c++yuminstallzlibzlin-develb)查看是否安装Pythonrpm-qa|grep Python下载并解压：tar-zxvfcdPython-2.7.6配置安装目录，命令如下./configure--prefix=/usr/local/python27编译&&安装，命令如下：make&&makeinstallc)Erlang安装安装如下makegccgcc-c++kernel-develm4ncurses-developenssl-devel依赖包，命令：yum-yinstallmakegccgcc-c++kernel-develm4ncurses-developenssl-develtar-xvf配置安装：使用cd命令到Erlang的解压目录，如：cdotp_src_R16B02配置安装路径，命令如下：./configure--prefix=/usr/local/erlang--with-ssl-enable-threads-enable-smmp-support-enable-kernel-poll--enable-hipe--without-javac//不用java编译，故去掉java避免错误编译安装，命令如下make&&makeinstall配置环境变量,vi/etc/profile,添加如下内容:ERLANG_HOME=/usr/local/erlangPATH=$ERLANG_HOME/bin:$PATHexportERLANG_HOMEexportPATH按ESC退出编辑，使用:wq命令保存退出，不保存退出：:q或者:q!使用source命令使环境变量立即生效，如：source/etc/profile测试是否安装成功：安装完成以后，执行erl看是否能打开eshell，用’halt().’退出，注意后面的点号，那是erlang的结束符。
rabbitmq五种模式详解（含实现代码）
rabbitmq五种模式详解（含实现代码）⼀、五种模式详解1.简单模式(Queue模式)当⽣产端发送消息到交换机,交换机根据消息属性发送到队列,消费者监听绑定队列实现消息的接收和消费逻辑编写.简单模式下,强调的⼀个队列queue只被⼀个消费者监听消费.1.1 结构⽣产者:⽣成消息,发送到交换机交换机:根据消息属性,将消息发送给队列消费者:监听这个队列,发现消息后,获取消息执⾏消费逻辑1.2应⽤场景常见的应⽤场景就是⼀发,⼀接的结构例如:⼿机短信邮件单发2.争抢模式(Work模式)强调的也是后端队列与消费者绑定的结构2.1结构⽣产者:发送消息到交换机交换机:根据消息属性将消息发送给队列消费者:多个消费者,同时绑定监听⼀个队列,之间形成了争抢消息的效果2.2应⽤场景抢红包资源分配系统3.路由模式(Route模式 Direct定向)从路由模式开始，关⼼的就是消息如何到达的队列，路由模式需要使⽤的交换机类型就是路由交换机（direct）3.1 结构⽣产端：发送消息，在消息中处理消息内容，携带⼀个routingkey交换机：接收消息，根据消息的routingkey去计算匹配后端队列的routingkey队列：存储交换机发送的消息消费端：简单模式⼯作争抢3.2应⽤场景短信聊天⼯具邮箱。
⼿机号/邮箱地址，都可以是路由key4.发布订阅模式(Pulish/Subscribe模式 Fanout⼴播)不计算路由的⼀种特殊交换机4.1结构4.2应⽤场景消息推送⼴告5.主题模式(Topics模式 Tpoic通配符)路由key值是⼀种多级路径。
中国.四川.成都.武侯区5.1结构⽣产端：携带路由key，发送消息到交换机队列：绑定交换机和路由不⼀样，不是⼀个具体的路由key，⽽可以使⽤*和#代替⼀个范围| * | 字符串，只能表⽰⼀级 || --- | --- || # | 多级字符串 |交换机：根据匹配规则，将路由key对应发送到队列消息路由key:北京市.朝阳区.酒仙桥北京市.#: 匹配true上海市.浦东区.*: 没匹配false新疆.乌鲁⽊齐.#5.2 应⽤场景做物流分拣的多级传递.6.完整结构⼆、代码实现1.创建SpringBoot⼯程1.1 ⼯程基本信息1.2 依赖信息1.3 配置⽂件applicasion.properties# 应⽤名称=springboot-demo# Actuator Web 访问端⼝management.server.port=8801management.endpoints.jmx.exposure.include=*management.endpoints.web.exposure.include=*management.endpoint.health.show-details=always# 应⽤服务 WEB 访问端⼝server.port=8801######################### RabbitMQ配置 ######################### RabbitMQ主机spring.rabbitmq.host=127.0.0.1# RabbitMQ虚拟主机spring.rabbitmq.virtual-host=demo# RabbitMQ服务端⼝spring.rabbitmq.port=5672# RabbitMQ服务⽤户名ername=admin# RabbitMQ服务密码spring.rabbitmq.password=admin# RabbitMQ服务发布确认属性配置## NONE值是禁⽤发布确认模式，是默认值## CORRELATED值是发布消息成功到交换器后会触发回调⽅法## SIMPLE值经测试有两种效果，其⼀效果和CORRELATED值⼀样会触发回调⽅法，其⼆在发布消息成功后使⽤rabbitTemplate调⽤waitForConfirms或waitForConfirmsOrDie⽅法等待broker节点返回发送结果，根据返回结果来判定下⼀步的逻辑，要注意的点是wa spring.rabbitmq.publisher-confirm-type=simple# RabbitMQ服务开启消息发送确认spring.rabbitmq.publisher-returns=true######################### simple模式配置 ######################### RabbitMQ服务消息接收确认模式## NONE：不确认## AUTO：⾃动确认## MANUAL：⼿动确认spring.rabbitmq.listener.simple.acknowledge-mode=manual# 指定最⼩的消费者数量spring.rabbitmq.listener.simple.concurrency=1# 指定最⼤的消费者数量spring.rabbitmq.listener.simple.max-concurrency=1# 开启⽀持重试spring.rabbitmq.listener.simple.retry.enabled=true2.简单模式2.1 创建SimpleQueueConfig 简单队列配置类package com.gmtgo.demo.simple;import org.springframework.amqp.core.Queue;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;/*** @author ⼤帅*/@Configurationpublic class SimpleQueueConfig {/*** 定义简单队列名.*/private final String simpleQueue = "queue_simple";@Beanpublic Queue simpleQueue() {return new Queue(simpleQueue);}}2.2 编写⽣产者package com.gmtgo.demo.simple;import lombok.extern.slf4j.Slf4j;import org.springframework.amqp.rabbit.core.RabbitTemplate;import org.springframework.beans.factory.annotation.Autowired;import ponent;/*** @author ⼤帅*/@Slf4j@Componentpublic class SimpleProducer {@Autowiredprivate RabbitTemplate rabbitTemplate;public void sendMessage() {for (int i = 0; i < 5; i++) {String message = "简单消息" + i;("我是⽣产信息:{}", message);rabbitTemplate.convertAndSend( "queue_simple", message);}}}2.3 编写消费者package com.gmtgo.demo.simple;import com.rabbitmq.client.Channel;import lombok.extern.slf4j.Slf4j;import org.springframework.amqp.core.Message;import org.springframework.amqp.rabbit.annotation.RabbitListener;import ponent;import java.io.IOException;/*** @author ⼤帅*/@Slf4j@Componentpublic class SimpleConsumers {@RabbitListener(queues = "queue_simple")public void readMessage(Message message, Channel channel) throws IOException {channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);("我是消费信息:{}", new String(message.getBody()));}}2.4 编写访问类package com.gmtgo.demo.simple;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;/*** @author ⼤帅*/@RestController@RequestMapping(value = "/rabbitMq")public class SimpleRabbitMqController {@Autowiredprivate SimpleProducer simpleProducer;@RequestMapping(value = "/simpleQueueTest")public String simpleQueueTest() {simpleProducer.sendMessage();return "success";}}2.5 测试启动项⽬访问 simpleQueueTest访问地址:结果：3.Work队列3.1 编写⼯作配置package com.gmtgo.demo.work;import org.springframework.amqp.core.Queue;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;/*** @author ⼤帅*/@Configurationpublic class WorkQueueConfig {/*** 队列名.*/private final String work = "work_queue";@Beanpublic Queue workQueue() {return new Queue(work);}}3.2 编写⽣产者package com.gmtgo.demo.work;import lombok.extern.slf4j.Slf4j;import org.springframework.amqp.rabbit.core.RabbitTemplate;import org.springframework.beans.factory.annotation.Autowired;import ponent;/*** @author ⼤帅*/@Slf4j@Componentpublic class WorkProducer {@Autowiredprivate RabbitTemplate rabbitTemplate;public void sendMessage() {for (int i = 0; i < 10; i++) {String message = "⼯作消息" + i;("我是⽣产信息:{}", message);rabbitTemplate.convertAndSend("work_queue", message);}}}3.3 编写消费者1package com.gmtgo.demo.work;import com.rabbitmq.client.Channel;import lombok.extern.slf4j.Slf4j;import org.springframework.amqp.core.Message;import org.springframework.amqp.rabbit.annotation.RabbitListener;import ponent;import java.io.IOException;/*** @author ⼤帅*/@Slf4j@Componentpublic class WorkConsumers1 {@RabbitListener(queues = "work_queue")public void readMessage(Message message, Channel channel) throws IOException { channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);("我是消费信息1:{}", new String(message.getBody()));}}3.4 编写消费者2package com.gmtgo.demo.work;import com.rabbitmq.client.Channel;import lombok.extern.slf4j.Slf4j;import org.springframework.amqp.core.Message;import org.springframework.amqp.rabbit.annotation.RabbitListener;import ponent;import java.io.IOException;/*** @author ⼤帅*/@Slf4j@Componentpublic class WorkConsumers2 {@RabbitListener(queues = "work_queue")public void readMessage(Message message, Channel channel) throws IOException { channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);("我是消费信息2:{}", new String(message.getBody()));}}3.5 编写测试⽅法package com.gmtgo.demo.work;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;/*** @author ⼤帅*/@RestController@RequestMapping(value = "rabbitMq")public class WorkRabbitMqController {@Autowiredprivate WorkProducer workProducer;@RequestMapping(value = "workQueueTest")public String workQueueTest() {workProducer.sendMessage();return "success";}}3.6 测试启动项⽬访问 workQueueTest访问地址结果：控制台打印，发现10条消息 偶数条消费者1获取，奇数条消费者2获取，并且平均分配。
rabbitmq使用手册
RabbitMQ使用手册一、简介RabbitMQ是一个开源的消息代理软件，它实现了AMQP（高级消息队列协议）。
RabbitMQ可以在分布式系统中可靠地传递消息，并提供了多种消息传递模式。
通过使用RabbitMQ，应用程序可以解耦和简化其组件之间的通信。
二、安装与配置RabbitMQ可以通过包管理器（如APT或YUM）或直接从源代码进行安装。
安装完成后，您需要配置RabbitMQ服务器，包括设置用户、创建虚拟主机和配置交换机等。
三、生产者与消费者在RabbitMQ中，生产者负责创建并发送消息，而消费者负责接收和处理这些消息。
生产者需要先连接到RabbitMQ服务器，然后创建一个通道，并使用该通道发送消息到一个队列中。
消费者也需要连接到服务器，创建一个通道，然后从队列中接收消息。
四、消息路由RabbitMQ通过交换机和队列来实现消息路由。
交换机负责接收生产者发送的消息，并根据绑定的队列将消息转发给它们。
队列是存储消息的地方，消费者可以从队列中获取并处理消息。
五、可靠性RabbitMQ提供了多种可靠性机制，以确保消息在传输过程中不会丢失或重复。
例如，您可以使用持久化队列和交换机来确保即使在服务器重启后，消息也不会丢失。
此外，您还可以使用确认机制来确保消息被成功处理。
六、插件与扩展RabbitMQ提供了许多插件和扩展，以支持更多的功能和协议。
例如，您可以使用RabbitMQ的插件来支持延迟消息、主题交换、集群等。
此外，还有一些第三方插件可以与RabbitMQ集成，以支持其他协议和功能。
七、监控与管理RabbitMQ提供了丰富的监控和管理工具，以帮助您了解系统的运行状况和性能。
您可以使用RabbitMQ的管理插件来查看队列的统计信息、监视内存使用情况、查看日志等。
此外，您还可以使用第三方工具来进一步扩展监控和管理功能。
rabbitmq系统使用教程
rabbitmq系统使用教程RabbitMQ是使用Erlang语言开发的开源消息队列系统，基于AMQP协议来实现。
AMQP的主要特征是面向消息、队列、路由(包括点对点和发布)、可靠性、安全。
AMQP协议更多用在企业系统内，对数据一致性、稳定性和可靠性要求很高的场景，对性能和吞吐量的要求还在其次。
MQ全称为Message Queue, 消息队列(MQ)是一种应用程序对应用程序的通信方法。
应用程序通过读写出入队列的消息(针对应用程序的数据)来通信，而无需专用连接来链接它们。
消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是用于诸如远程过程调用的技术。
排队指的是应用程序通过队列来通信。
队列的使用除去了接收和发送应用程序同时执行的要求。
解耦当发送短信执行成功后页面才执行倒计时60秒，假如在发送短信时网速原因，导致短信一直被阻塞，那么倒计时也会被一直延迟，这样及其影响用户体验感。
这时候就可以使用RabbitMQ了，将发送短信和倒计时解耦，基于消息的模型，关心的是“通知”，而非“处理”。
像下订单、邮件通知、缓存刷新等操作都可以使用消息队列进行优化。
异步提升效率场景说明：用户需发送短信验证码时，点击发送短信，第三方平台发送短信至用户手机成功，执行倒计时60秒。
传统的做法有两种 1.串行的方式;2.并行方式：(1) 串行方式：将用户点击发送短信，第三方平台发送短信至用户手机成功，执行倒计时60秒。
以上三个任务全部完成后，返回给客户端(响应150ms)。
(2) 并行方式：在用户点击发送短信成功后，第三方平台发送短信的同时，执行倒计时60秒。
与串行的差别是，并行的方式可以提高处理的时间(响应100ms)。
(3) 引入消息队列，将不是必须的业务逻辑，异步处理(55ms)。
改造后的架构如下：流量削峰流量削锋(流量错峰)也是消息队列中的常用场景，一般在秒杀或团抢活动中使用广泛。
rabbitMQ教程（三）一篇文章看懂rabbitMQ
rabbitMQ教程（三）⼀篇⽂章看懂rabbitMQ⼀、rabbitMQ是什么： RabbitMQ,遵循AMQP协议，由内在⾼并发的erlanng语⾔开发，⽤在实时的对可靠性要求⽐较⾼的消息传递上。
学过websocket的来理解rabbitMQ应该是⾮常简单的了，websocket是基于服务器和页⾯之间的通信协议，⼀次握⼿，多次通信。
⽽rabbitMQ就像是服务器之间的socket，⼀个服务器连上MQ监听，⽽另⼀个服务器只要通过MQ发送消息就能被监听服务器所接收。
但是MQ和socket还是有区别的，socket相当于是页⾯直接监听服务器。
⽽MQ就是服务器之间的中转站，例如邮箱，⼀个⼈投递信件给邮箱，另⼀个⼈去邮箱取，他们中间没有直接的关系，所以耦合度相⽐socket⼩了很多。
上图是最简单的MQ关系，⽣产者-MQ队列-消费者⼆、MQ使⽤场景： 别啥固定式使⽤场景了，说的透彻⼀点，他就是服务器之间通信的，前⾯博⽂中提到的Httpclient也可以做到，但是这个相对于其他通信在中间做了⼀个中间仓库。
好处1：降低了两台服务器之间的耦合，哪怕是⼀台服务器挂了，另外⼀台服务器也不会报错或者休克，反正他监听的是MQ，只要服务器恢复再重新连上MQ发送消息，监听服务器就能再次接收。
好处2：MQ作为⼀个仓库，本⾝就提供了⾮常强⼤的功能，例如不再是简单的⼀对⼀功能，还能⼀对多，多对⼀，⾃⼰脑补保险箱场景，只要有特定的密码，谁都能存，谁都能取。
也就是说能实现群发消息和以此衍⽣的功能。
好处3：现在普遍化的持久化功能，当MQ挂掉可以存储在磁盘等下重启恢复。
（需要设置）三、专业术语介绍：1. ⽣产者：在现实⽣活中就好⽐制造商品的⼯⼚，他们是商品的⽣产者。
⽣产者只意味着发送。
发送消息的程序称之为⼀个⽣产者。
2. 队列：rabbitMQ就像⼀个仓库，⼀个仓库⾥⾯可以有很多队列，每个队列才是服务器之间消息通信的载体。
rabbitmq入门详解大神勿喷自己总结的
rabbitMQ入门详解，大神勿喷。
自己总结的rabbitMQ说明文档rabbitMQ是什么RabbitMQ是由LShift提供的一个Advanced Message Queuing Protocol (AMQP)的开源实现，由以高性能、健壮以及可伸缩性出名的Erlang写成（因此也是继承了这些优点）。
首先介绍AMQP和一些基本概念：当前各种应用大量使用异步消息模型，并随之产生众多消息中间件产品及协议，标准的不一致使应用与中间件之间的耦合限制产品的选择，并增加维护成本。
AMQP是一个提供统一消息服务的应用层标准协议，基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同开发语言等条件的限制。
当然这种降低耦合的机制是基于与上层产品，语言无关的协议。
AMQP协议是一种二进制协议，提供客户端应用与消息中间件之间异步、安全、高效地交互。
从整体来看，AMQP协议可划分为三层。
这种分层架构类似于OSI网络协议，可替换各层实现而不影响与其它层的交互。
AMQP定义了合适的服务器端域模型，用于规范服务器的行为(AMQP服务器端可称为broker)。
Model层决定这些基本域模型所产生的行为，这种行为在AMQP中用”command”表示，在后文中会着重来分析这些域模型。
Session层定义客户端与broker之间的通信(通信双方都是一个peer，可互称做partner)，为command的可靠传输提供保障。
Transport层专注于数据传送，并与Session保持交互，接受上层的数据，组装成二进制流，传送到receiver后再解析数据，交付给Session层。
Session层需要Transport层完成网络异常情况的汇报，顺序传送command等工作。
AMQP当中有四个概念非常重要：虚拟主机（virtual host），交换机（exchange），队列（queue）和绑定（binding）。
虚拟主机（virtual host）：一个虚拟主机持有一组交换机、队列和绑定。
rabbitMQ队列使用及常用命令
rabbitMQ队列使⽤及常⽤命令⼀、RabbitMQ常⽤命令启动监控管理器：rabbitmq-plugins enable rabbitmq_management关闭监控管理器：rabbitmq-plugins disable rabbitmq_management启动rabbitmq：rabbitmq-service start关闭rabbitmq：rabbitmq-service stop查看所有的队列：rabbitmqctl list_queues清除所有的队列：rabbitmqctl reset关闭应⽤：rabbitmqctl stop_app启动应⽤：rabbitmqctl start_app⽤户和权限设置（后⾯⽤处）添加⽤户：rabbitmqctl add_user username password分配⾓⾊：rabbitmqctl set_user_tags username administrator新增虚拟主机：rabbitmqctl add_vhost vhost_name将新虚拟主机授权给新⽤户：rabbitmqctl set_permissions -p vhost_name username '.*' '.*' '.*'⾓⾊说明none 最⼩权限⾓⾊management 管理员⾓⾊policymaker 决策者monitoring 监控administrator 超级管理员⼆、RabbitMQ使⽤（1）介绍①什么叫消息队列消息（Message）是指在应⽤间传送的数据。
消息可以⾮常简单，⽐如只包含⽂本字符串，也可以更复杂，可能包含嵌⼊对象。
消息队列（Message Queue）是⼀种应⽤间的通信⽅式，消息发送后可以⽴即返回，由消息系统来确保消息的可靠传递。
消息发布者只管把消息发布到 MQ 中⽽不⽤管谁来取，消息使⽤者只管从 MQ 中取消息⽽不管是谁发布的。
RabbitMQ从入门到精通
RabbitMQ从入门到精通安装脚本1 2 3 4 5 6 7 8 9 10yum install wget -y#Download RabbitMQ and Erlangwget https:///releases/rabbitmq-server/v3.6.9/rabbitmq-server-3.6.9-1.el6.noarch.rpm wget https:///releases/erlang/erlang-19.0.4-1.el6.x86_64.rpm#Install Erlang and RabbitMQrpm -ivh erlang-19.0.4-1.el6.x86_64.rpmrpm --import /rabbitmq-signing-key-public.ascyum install rabbitmq-server-3.6.9-1.el6.noarch.rpm -y发现错误1 21. 安装依赖Requires: socat2. 安装socat的时候提示需要tcp_wrappers解决方案1 2wget –no-cache /repos/definitions/rhel/6.x/convirt.repo -O /etc/yum.repos.d/convirt.repo yum install socat -y1使用https:///linux/rpm2html/search.php搜索tcp_wrappers，下载，rpm -ivh tcp_wrappers.version 启动Rabbit MQ1 2 3 4 5 6chkconfig rabbitmq-server on/sbin/service rabbitmq-server start# 修改密码rabbitmqctl change_password guest welcome123 # 启动管理界面rabbitmq-plugins enable rabbitmq_management使用过程错误小记use r ‘g ue st’ - Use r can o nly lo g in via lo calho st登录响应如下：1{"error":"not_authorised","reason":"User can only log in via localhost"}我实在docker中创建rabbitmq的，然后将端口15672映射到宿主机器上的15672，所以也算是远程登录，而guest用户要求只能使用localhost登录，所以要想远程登录必须新建用户。
RabbitMQ简单使用教程
RabbitMQ简单使⽤教程RabbitMQ 简单使⽤教程安装安装 RabbitMQ 服务安装 Python RabbitMQ 模块# ⽅式⼀pip install pika# ⽅式⼆easy_install pika# ⽅式三# 源码https:///pypi/pika实现简单队列通信send端#!/usr/bin/env pythonimport pikaconnection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))channel = connection.channel()# 声明 queuechannel.queue_declare(queue='hello')# n RabbitMQ a message can never be sent directly to the queue, it always needs to go through an exchange.# ⼀条消息永远不能直接发送到队列中，它总是需要经过⼀个交换。
channel.basic_publish(exchange='', routing_key='hello', body='Hello World!')print(" [x] Sent 'Hello World!'")connection.close()receive#_*_coding:utf-8_*_import pikaconnection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))channel = connection.channel()# You may ask why we declare the queue again ‒ we have already declared it in our previous code.# 你可能会问我们为什么要再次声明队列——我们已经在之前的代码中声明了它。
C#消息队列之RabbitMQ进阶篇
C#消息队列之RabbitMQ进阶篇Ø简介在之前的中介绍了 RabbitMQ 的基本⽤法，其实要更全⾯的掌握 RabbitMQ 这个消息队列服务，我们还需要掌握以下内容：1.轮询分发2.消息响应3.公平分发4.消息持久化1)轮询分发轮询分发。
话平均的，这种分发⽅式称之为轮询分发默认情况下，Ra b b it M Q 会按照消息的顺序依次分发给每个消费者顺序依次分发给每个消费者，也就是每个消费者接收到的消息基本是平均的不多说看⽰例：1)⽣产者代码（其他代码省略）//随机⼀个“⽣产者”名称string pname = $"[P{(new Random()).Next(1, 1000)}]";Console.WriteLine($"⽣产者{pname}已启动：");for (int i = 0; i < 6; i++){string message;if (i == 1) //第⼆条消息，需要耗时10秒message = $"{pname}, task{i + 1}, time of 10 seconds";elsemessage = $"{pname}, task{i + 1}, time of 1 seconds";byte[] body = Encoding.UTF8.GetBytes(message);channel.BasicPublish("", "myQueue1", properties, body);Console.WriteLine($"⽣产者{message}\t{DateTime.Now.ToString("HH:mm:ss fff")}");}2)消费者代码（其他代码省略）//随机⼀个“消费者”名称string cname = $"[C{(new Random()).Next(1, 1000)}]";Console.WriteLine($"消费者{cname}已开启");consumer.Received += (sender, e) =>{byte[] body = e.Body; //消息字节数组string message = Encoding.UTF8.GetString(body); //消息内容Console.WriteLine($"消费者{cname}接收到消息：{message}\t{DateTime.Now.ToString("HH:mm:ss fff")}，开始处理...");//模拟处理耗时操作string second = Regex.Replace(message, ".+time of ", "");second = Regex.Replace(second, " seconds", "");System.Threading.Thread.Sleep(1000 * int.Parse(second));};3)运⾏代码⾸先，开启两个消费者，再打开⼀个⽣产者发送6条消息，运⾏结果如下：从以上结果中可以得出以下结论：1.⼀共6条消息，2个消费者接收的消息数量是⼀致的（各3条）；2.尽管 Task2 消息处理时间较长，也会等待该消息处理完成之后，再处理被依次分发的消息，所以导致了 Task4 的处理时间在 Task5 之后；3.同⼀时间段⼀个消费者只会处理⼀条消息，只有当该消息处理完成之后，才会处理下⼀条消息（或者说接收下⼀条消息），并不会同时处理多条消息。
RabbitMQ学习步骤
RabbitMQ主要学习步骤1.了解 RabbitMQ的基本概念：学习 RabbitMQ的基本语法、消息类型、监听事件等。
2.学习 RabbitMQ的实现原理：了解 RabbitMQ的体系结构，包括队列、消息循环、线程池等。
3.学习 RabbitMQ的使用：通过阅读相关书籍、教程和实践项目，了解RabbitMQ的具体应用。
4.练习编写实际的项目：通过编写实际的项目，掌握 RabbitMQ的应用场景和实现技巧。
5.了解 RabbitMQ与其他 Java平台集成：通过阅读相关书籍、教程和实践项目，了解 RabbitMQ与其他 Java平台集成的方式和方法。
RabbitMQ详细学习步骤RabbitMQ是一款分布式消息队列，用于实时传输文件和数据。
下面是一个详细的学习步骤，以帮助您学会 abbitMQ：1、选择一款合适的分布式系统开发工具：选择一款适合进行分布式数据处理和传输的工具，如 Git、 ExtJS等。
2、安装 abbitMQ：通过安装 abbitMQ来初始化系统，并确保它们支持各种分布式系统。
3、配置 abbitMQ以支持各种分布式系统，如 JVM、 ElasticSearch等。
4、创建一个或多个进程来运行 abbitMQ，并配置其相关参数以支持分布式数据处理和传输。
5、编写代码：使用 abbitMQ编写各种类型的数据传输代码，并练习根据不同的用途灵活使用 abbitMQ。
6、测试和运行项目：通过测试和运行项目来验证 abbitMQ的功能和性能，并逐渐提高您的技能水平。
7、了解 abbitMQ与其他 Java平台集成：通过了解 abbitMQ与其他 Java 平台集成，如 ElasticSearch、 ExtJS等，以提高您的开发效率。
8、建议先学习一下 Java语言和分布式系统知识，这对学习 abbitMQ非常有帮助。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
(6) 交换器的属性： - 持久性：如果启用，交换器将会在server重启前都有效。 - 自动删除：如果启用，那么交换器将会在其绑定的队列都被删除掉之后自动删除掉自身。 - 惰性：如果没有声明交换器，那么在执行到使用的时候会导致异常，并不会主动声明。
基本示意图
虚拟主机（virtual host）
一个虚拟主机持有一组交换机、队列和绑定。为什么需要多个虚拟主机呢？很简单，
RabbitMQ当中，用户只能在虚拟主机的粒度进行权限控制。因此，如果需要禁止A组访问B组 的交换机/队列/绑定，必须为A和B分别创 建一个虚拟主机。每一个RabbitMQ服务器都有一个 默认的虚拟主机“/”。
选择RabbitMQ一个重要原因就是消息的持久化。
RabbitMQ简介
AMQP，即Advanced Message Queuing Protocol，高级消息队列协议， 是应用层协议的一个开放标准，为面向消息的中间件设计。
消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者 的存在，反之亦然。
Producer 要产生消息必须要创建一个 Exchange ，Exchange 用于转发消息，但是它不会 做存储，如果没有 Queue bind 到 Exchange 的话，它会直接丢弃掉 Producer 发送过来的消 息，当然如果消息总是发送过去就被直接丢弃那就没有什么意思了，一个 Consumer 想要接受 消息的话，就要创建一个 Queue ，并把这个 Queue bind 到指定的 Exchange 上，然后 Exchange 会把消息转发到 Queue 那里，Queue 会负责存储消息，Consumer 可以通过主动 P从 Queue 中取得消息。
消息传递
(1) 消息在队列中保存，以轮询的方式将消息发送给监听消息队列的消费者，可以动态的增加 消费者以提高消息的处理能力。
(2) 为了实现负载均衡，可以在消费者端通知RabbitMQ，一个消息处理完之后才会接受下一个 消息。
channel.basic_qos(prefetch_count=1) 注意：要防止如果所有的消费者都在处理中，则队列中的消息会累积的情况。
(3) 队列的属性： - 持久性：如果启用，队列将会在server重启前都有效。 - 自动删除：如果启用，那么队列将会在所有的消费者停止使用之后自动删除掉自身。 - 惰性：如果没有声明队列，那么在执行到使用的时候会导致异常，并不会主动声明。 - 排他性：如果启用，队列只能被声明它的消费者使用。 这些性质可以用来创建例如排他和自删除的transient或者私有队列。这种队列将会在所有链接 到它的客户端断开连接之后被自动删除掉。它们只是短暂地连接到server，但是可以用于实现 例如RPC或者在AMQ上的对等通信。(关于rpc没进行研究，后面说明原因)
关于RPC
A note on RPC Although RPC is a pretty common pattern in computing, it's often criticised. The problems arise when a programmer is not aware whether a function call is local or if it's a slow RPC. Confusions like that result in an unpredictable system and adds unnecessary complexity to debugging. Instead of simplifying software, misused RPC can result in unmaintainable spaghetti code.
简单来说就是使用RPC增加了不确定，以及增加调试的复杂度。官网的思想是简化你的软件， 滥用RPC可能会造成很多错误。所以没去研究rpc。 研究rpc可以去官网看看例子，反正我是没看 /tutorials/tutorial-six-python.html
Message acknowledgment：
当“Consumer”接受到一个消息并作长时间处理时，有可能发生意外状况，如运行 “Consumer”的机器突然关闭，这时这个消息所要执行的任务可能没有得到正确处理。
RabittMQ Tutorials
占涛
引言
你是否遇到过两个（多个）系统间需要通过定时任务来同步某些数据？你 是否在为异构系统的不同进程间相互调用、通讯的问题而苦恼、挣扎？ 如果是，那么恭喜你，消息服务让你可以很轻松地解决这些问题。
消息服务擅长于解决多系统、异构系统间的数据交换（消息通知/通讯） 问题，你也可以把它用于系统间服务的相互调用（RPC）。 本文将要介绍的RabbitMQ就是当前最主流的消息中间件之一。
(3) 消息有14个属性，最常用的几种： deliveryMode：持久化属性 contentType：编码 replyTo：指定一个回调队列 correlationId：消息id (4) 消息生产者可以选择是否在消息被发送到交换器并且还未投递到队列（没有绑定器存在） 和/或没有消费者能够立即处理的时候得到通知。通过设置消息的mandatory和/或immediate属 性为真，这些投递保障机制的能力得到了强化。
集群（cluster）：
(1) 不支持跨网段（如需支持，需要shovel或federation插件） (2) 可以随意的动态增加或减少、启动或停止节点，允许节点故障 (3) 集群分为RAM节点和DISK节点，一个集群最好至少有一个DISK节点保存集群的状态。 (4) 集群的配置可以通过命令行，也可以通过配置文件，命令行优先。
交换机（Exchang）
(1) 接收消息，转发消息到绑定的队列。四种类型：direct, topic, headers and fanout direct：转发消息到routigKey指定的队列 topic：按规则转发消息（最灵活） headers：（较为少用） fanout：转发消息到所有绑定队列 (2) 如果没有队列绑定在交换机上，则发送到该交换机上的消息会丢失。交换机不做消息存储。 (3) 一个交换机可以绑定多个队列，一个队列可以被多个交换机绑定。 (4) topic类型交换器通过模式匹配分析消息的routing-key属性。它将routing-key和binding-key 的字符串切分成单词。这些单词之间用点隔开。它同样也会识别两个通配符：#匹配0个或者多 个单词，*匹配一个单词。例如，binding key：*.stock.#匹配routing key：usd.stcok和 eur.stock.db，但是不匹配stock.nana。 还有一些其他的交换器类型，如header、failover、system等，现在在当前的RabbitMQ版本中 均未实现。
(5) 此外，一个生产者可以设置消息的persistent属性为真。这样一来，server将会尝试将这些 消息存储在一个稳定的位置，直到server崩溃。当然，这些消息肯定不会被投递到非持久的队 列中。
高可用性（HA）
(1) 消息ACK，通知RabbitMQ消息已被处理，可以从内存删除。如果消费者因宕机或链接失败 等原因没有发送ACK（不同于ActiveMQ，在RabbitMQ里，消息没有过期的概念），则 RabbitMQ会将消息重新发送给其他监听在队列的下一个消费者。
AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、 可靠性、安全。
RabbitMQ是一个开源的AMQP实现，服务器端用Erlang语言编写，支持 多种客户端，如：Python、Ruby、.NET、Java、JMS、C、PHP、 ActionScript、XMPP、STOMP等，支持AJAX。用于在分布式系统中存储转发 消息，在易用性、扩展性、高可用性等方面表现不俗。 下面将重点介绍RabbitMQ中的一些基础概念，了解了这些概念，是使用好 RabbitMQ的基础。
channel.basicPublish(exchangeName, routingKey,
MessageProperties.PERSISTENT_TEXT_PLAIN,
message.getBytes()); 这样，即使RabbitMQ服务器重启，也不会丢失队列和消息。
(3) publisher confirms (4) master/slave机制，配合Mirrored Queue，这种情况下，publisher会正常发送消息和接收消 息的confirm，但对于subscriber来说，需要接收Consumer Cancellation Notifications来得到主 节点失败的通知，然后re-consume from the queue，此时要求client有处理重复消息的能力。 注意：如果queue在一个新加入的节点上增加了一个slave，此时slave上没有此前queue的信息 （目前还没有同步机制）。 （通过命令行或管理插件可以查看哪个slave是同步的： rabbitmqctl list_queues name slave_pids synchronised_slave_pids） 当一个slave重新加入mirrored-queue时，如果queue是durable的，则会被清空。
队列（Queues）
是你的消息（messages）的终点，可以理解成装消息的容器。消息就一直在里面，直到 有客户端（也就是消费者，Consumer）连接到这个队列并且将其取走为止。
需要记住的是，队列是由消费者（Consumer）通过程序建立的，不是通过配置文件或者 命令行工具。这没什么问题，如果一个消费者试图创建一个已经存在的队列，RabbitMQ会忽 略这个请求。因此你可以将消息队列的配置写在应用程序的代码里面。这个概念不错。