RabbitMQ简介
RabbitMQ是一个由erlang开发的AMQP(Advanved Message Queue)的开源实现。
最初起源于金融系统，用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。RabbitMQ主要是为了实现系统之间的双向解耦而实现的。当生产者大量产生数据时，消费者无法快速消费，那么需要一个中间层。保存这个数据。
AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。
RabbitMQ是一个开源的AMQP实现，服务器端用Erlang语言编写，支持多种客户端，如：Python、Ruby、.NET、Java、JMS、C、PHP、ActionScript、XMPP、STOMP等，支持AJAX。用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。
RabbitMQ 即一个消息队列，主要是用来实现应用程序的异步和解耦，同时也能起到消息缓冲，消息分发的作用。
RabbitMQ 特点
AMQP ：Advanced Message Queue，高级消息队列协议。它是应用层协议的一个开放标准，为面向消息的中间件设计，基于此协议的客户端与消息中间件可传递消息，并不受产品、开发语言等条件的限制。
RabbitMQ 最初起源于金融系统，用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。具体特点包括：
可靠性（Reliability）
灵活的路由（Flexible Routing）
消息集群（Clustering）
高可用（Highly Available Queues）
多种协议（Multi-protocol）
多语言客户端（Many Clients）
管理界面（Management UI）
跟踪机制（Tracing）
插件机制（Plugin System）
RabbitMQ使用场景 1. 异步处理
2. 应用解耦
3. 流量削峰
具体可参照：RabbitMQ的应用场景以及基本原理介绍
RabbitMQ 基本概念
通常我们谈到队列服务, 会有三个概念： 发消息者、队列、收消息者，RabbitMQ 在这个基本概念之上, 多做了一层抽象, 在发消息者和 队列之间, 加入了交换器 (Exchange). 这样发消息者和队列就没有直接联系, 转而变成发消息者把消息给交换器, 交换器根据调度策略再把消息再给队列。
Message
Exchange
交换器，用来接收生产者发送的消息并将这些消息路由给服务器中的队列。但是它不会做存储 ，如果没有 Queue bind 到 Exchange 的话，它会直接丢弃掉 Producer 发送过来的消息。
Binding
路由键 将交换器和消息队列连接起来的路由规则，所以可以将交换器理解成一个由绑定构成的路由表。
Queue
Connection
Channel
Consumer
Virtual Host
Broker
交换机（Exchange）
交换机的功能主要是接收消息并且转发到绑定的队列，交换机不存储消息，在启用ack模式后，交换机找不到队列会返回错误。交换机有四种类型：Direct, topic, Headers and Fanout
Direct：direct 类型的行为是"先匹配, 再投送". 即在绑定时设定一个 routing_key , 消息的routing_key 匹配时, 才会被交换器投送到绑定的队列中去. Topic：按规则转发消息（最灵活） Headers：设置header attribute参数类型的交换机 Fanout：转发消息到所有绑定队列
Direct Exchange
第一个 X - Q1 就有一个 binding key，名字为 orange； X - Q2 就有 2 个 binding key，名字为 black 和 green。当消息中的 路由键 和 这个 binding key 对应上的时候，那么就知道了该消息去到哪一个队列中。
Ps：为什么 X 到 Q2 要有 black，green，2个 binding key呢，一个不就行了吗？ - 这个主要是因为可能又有 Q3，而Q3只接受 black 的信息，而Q2不仅接受black 的信息，还接受 green 的信息。
Topic Exchange
Topic Exchange 转发消息主要是根据通配符。 在这种交换机下，队列和交换机的绑定会定义一种路由模式，那么，通配符就要在这种路由模式和路由键之间匹配后交换机才能转发消息。
在这种交换机模式下：
路由键必须是一串字符，用句号（.） 隔开，比如说 agreements.us，或者 agreements.eu.stockholm 等。 路由模式必须包含一个 星号（*），主要用于匹配路由键指定位置的一个单词，比如说，一个路由模式是这样子：agreements..b.*，那么就只能匹配路由键是这样子的：第一个单词是 agreements，第四个单词是 b。 井号（#）就表示相当于一个或者多个单词，例如一个匹配模式是agreements.eu.berlin.#，那么，以agreements.eu.berlin开头的路由键都是可以的。
具体代码发送的时候还是一样，第一个参数表示交换机，第二个参数表示routing key，第三个参数即消息。如下：
rabbitTemplate.convertAndSend ("testTopicExchange" "key1.a.c.key2" " this is RabbitMQ!"
topic 和 direct 类似, 只是匹配上支持了"模式", 在"点分"的 routing_key 形式中, 可以使用两个通配符:
Headers Exchange
headers 也是根据规则匹配, 相较于 direct 和 topic 固定地使用 routing_key , headers 则是一个自定义匹配规则的类型.
默认的exchange:如果用空字符串去声明一个exchange，那么系统就会使用”amq.direct”这个exchange，我们创建一个queue时,默认的都会有一个和新建queue同名的routingKey绑定到这个默认的exchange上去
channel.BasicPublish ("" , "TaskQueue" , properties, bytes)因为在第一个参数选择了默认的exchange，而我们申明的队列叫TaskQueue，所以默认的，它在新建一个也叫TaskQueue的routingKey，并绑定在默认的exchange上，导致了我们可以在第二个参数routingKey中写TaskQueue，这样它就会找到定义的同名的queue，并把消息放进去。
Fanout Exchange
Fanout Exchange 消息广播的模式，不管路由键或者是路由模式，会把消息发给绑定给它的全部队列 ，如果配置了routing_key会被忽略。
任务分发机制
1.Round-robin dispathching循环分发
RabbbitMQ的分发机制非常适合扩展,而且它是专门为并发程序设计的,如果现在load加重,那么只需要创建更多的Consumer来进行任务处理。
2.Message acknowledgment消息确认
为了保证数据不被丢失,RabbitMQ支持消息确认机制,为了保证数据能被正确处理而不仅仅是被Consumer收到,那么我们不能采用no-ack，而应该是在处理完数据之后发送ack. 在处理完数据之后发送ack,就是告诉RabbitMQ数据已经被接收,处理完成,RabbitMQ可以安全的删除它了. 如果Consumer退出了但是没有发送ack,那么RabbitMQ就会把这个Message发送到下一个Consumer，这样就保证在Consumer异常退出情况下数据也不会丢失. RabbitMQ它没有用到超时机制.RabbitMQ仅仅通过Consumer的连接中断来确认该Message并没有正确处理，也就是说RabbitMQ给了Consumer足够长的时间做数据处理。
如果忘记ack,那么当Consumer退出时,Mesage会重新分发,然后RabbitMQ会占用越来越多的内存.
Message durability消息持久化
要持久化队列queue的持久化需要在声明时指定durable=True;
这里要注意,队列的名字一定要是Broker中不存在的,不然不能改变此队列的任何属性.
队列和交换机有一个创建时候指定的标志durable,durable的唯一含义就是具有这个标志的队列和交换机会在重启之后重新建立,它不表示在队列中的消息会在重启后恢复
1. exchange持久化,在声明时指定durable => true
channel.ExchangeDeclare(ExchangeName, "direct" , durable: true , autoDelete: false , arguments : null );2.queue持久化,在声明时指定durable => true
channel.QueueDeclare(QueueName, durable: true , exclusive: false , autoDelete: false , arguments : null );3.消息持久化,在投递basicPublish 时指定delivery_mode => 2(1是非持久化).
channel.basicPublish ("" , queueName, MessageProperties.PERSISTENT _TEXT_PLAIN, msg.getBytes ())如果exchange和queue都是持久化的,那么它们之间的binding也是持久化的,如果exchange和queue两者之间有一个持久化，一个非持久化,则不允许建立绑定.
注意 ：一旦创建了队列和交换机,就不能修改其标志了,例如,创建了一个non-durable的队列,然后想把它改变成durable的,唯一的办法就是删除这个队列然后重现创建。
Fair dispath 公平分发
你可能也注意到了,分发机制不是那么优雅,默认状态下,RabbitMQ将第n个Message分发给第n个Consumer。n是取余后的,它不管Consumer是否还有unacked Message，只是按照这个默认的机制进行分发.
channel.basic_qos(prefetch_count =1) 注意，这种方法可能会导致queue满。当然，这种情况下你可能需要添加更多的Consumer，或者创建更多的virtualHost来细化你的设计。
消息序列化
RabbitMQ使用ProtoBuf序列化消息,它可作为RabbitMQ的Message的数据格式进行传输,由于是结构化的数据,这样就极大的方便了Consumer的数据高效处理,当然也可以使用XML，与XML相比,ProtoBuf有以下优势:
6.减少了语义的歧义.
ProtoBuf具有速度和空间的优势，使得它现在应用非常广泛
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 超级管理员
Java 客户端访问
RabbitMQ 支持多种语言访问，以 Java 为例看下一般使用 RabbitMQ 的步骤。
maven工程的pom文件中添加依赖
<dependency >
<groupId > com.rabbitmqgroupId >
<artifactId > amqp-clientartifactId >
<version > 4.1.0version >
dependency >
消息生产者
package org.study.rabbitmq;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Producer public static void main (String[] args) throws IOException, TimeoutException new ConnectionFactory();
factory.setUsername("guest" );
factory.setPassword("guest" );
factory.setHost("localhost" );
Connection conn = factory.newConnection();
Channel channel = conn.createChannel();
String exchangeName = "hello-exchange" ;
channel.exchangeDeclare(exchangeName, "direct" , true );
String routingKey = "hola" ;
byte [] messageBodyBytes = "quit" .getBytes();
channel.basicPublish(exchangeName, routingKey, null , messageBodyBytes);
channel.close();
conn.close();
}
}
消息消费者
package org.study.rabbitmq;
import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
public class Consumer public static void main (String[] args) throws IOException, TimeoutException new ConnectionFactory();
factory.setUsername("guest" );
factory.setPassword("guest" );
factory.setHost("localhost" );
Connection conn = factory.newConnection();
final Channel channel = conn.createChannel();
String exchangeName = "hello-exchange" ;
channel.exchangeDeclare(exchangeName, "direct" , true );
String queueName = channel.queueDeclare().getQueue();
String routingKey = "hola" ;
channel.queueBind(queueName, exchangeName, routingKey);
while (true ) {
boolean autoAck = false ;
String consumerTag = "" ;
channel.basicConsume(queueName, autoAck, consumerTag, new DefaultConsumer(channel) {
@Override
public void handleDelivery (String consumerTag,
Envelope envelope,
AMQP.BasicProperties properties,
byte [] body) throws IOException "消费的路由键：" + routingKey);
System.out.println("消费的内容类型：" + contentType);
long deliveryTag = envelope.getDeliveryTag();
channel.basicAck(deliveryTag, false );
System.out.println("消费的消息体内容：" );
String bodyStr = new String(body, "UTF-8" );
System.out.println(bodyStr);
}
});
}
}
}
启动 RabbitMQ 服务器
./sbin/rabbitmq-server
运行 Consumer
运行 Producer
作者：预流
链接：https://www.jianshu.com/p/79ca08116d57
RabbitMQ实现异步及同步RPC 一、同步RPC
客户端：
package com.rabbitmq.synchronization;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.UUID;
import java.util.concurrent.TimeoutException;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.ConsumerCancelledException;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.client.ShutdownSignalException;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.AMQP.BasicProperties;
import com.rabbitmq.utility.BlockingCell;
import com.xinwei.rabbitmq.RabbitConfig;
public class RPCClient {
private final Map> _contibuationMap = new HashMap>();
private int correlationId = 0;
private Connection connection;
private Channel channel;
private String requestQueuename = "rpc_queue";
private String replyQueueName;
private DefaultConsumer _consumer;
public RPCClient() throws IOException, TimeoutException{
//1.创建一个ConnectionFactory连接工厂connectionFactory
ConnectionFactory factory =new ConnectionFactory();
//2.通过connectionFactory设置RabbitMQ所在IP、端口等信息
factory.setHost(RabbitConfig.ip);
factory.setPort(RabbitConfig.port);
factory.setUsername(RabbitConfig.username);
factory.setPassword(RabbitConfig.password);
//3.通过connectionFactory创建一个连接connection
connection = factory.newConnection();
//4.通过connection创建一个频道channel
channel = connection.createChannel();
//5.通过channel创建一个匿名队列
replyQueueName = channel.queueDeclare().getQueue();
_consumer = setupConsumer();
}
public String call(String message) throws IOException,
ShutdownSignalException, ConsumerCancelledException,
InterruptedException, TimeoutException{
if(_consumer == null)
return null;
BlockingCell k = new BlockingCell();
BasicProperties props;
synchronized (_contibuationMap) {
correlationId++;
String corrId = "" + correlationId;
props = new BasicProperties.Builder()
.correlationId(corrId)
.replyTo(replyQueueName)
.build();
_contibuationMap.put(corrId, k);
}
//6.通过channel向队列中添加消息
channel.basicPublish("", requestQueuename, props, message.getBytes());
Object reply = k.uninterruptibleGet(4000);
if (reply instanceof ShutdownSignalException) {
ShutdownSignalException sig = (ShutdownSignalException) reply;
ShutdownSignalException wrapper = new ShutdownSignalException(
sig.isHardError(), sig.isInitiatedByApplication(),
sig.getReason(), sig.getReference());
wrapper.initCause(sig);
throw wrapper;
} else {
return (String)reply;
}
}
public void close() throws IOException{
connection.close();
}
protected DefaultConsumer setupConsumer() throws IOException {
DefaultConsumer consumer = new DefaultConsumer(channel) { //创建队列消费者
@Override
public void handleShutdownSignal(String consumerTag,
ShutdownSignalException signal) {
synchronized (_contibuationMap) {
for (Entry> entry : _contibuationMap
.entrySet()) {
entry.getValue().set(signal);
}
_consumer = null;
}
}
@Override
public void handleDelivery(String consumerTag, Envelope envelope,
AMQP.BasicProperties properties, byte[] body)
throws IOException {
synchronized (_contibuationMap) {
String replyId = properties.getCorrelationId();
BlockingCell blocker = _contibuationMap
.get(replyId);
_contibuationMap.remove(replyId);
if (null != body) {
String replyBoay = new String(body, "UTF-8");
blocker.set(replyBoay);
} else {
blocker.set(body);
}
}
}
};
//7.为channel指定消费者
channel.basicConsume(replyQueueName, true, consumer);
return consumer;
}
public static void main(String[] args) throws Exception {
RPCClient fibrpc = new RPCClient();
System.out.println("request fib(30)");
String response = fibrpc.call("30");
System.out.println("got "+response+",");
fibrpc.close();
}
} 服务器端
package com .rabbitmq .synchronization
import com .rabbitmq .client .AMQP .BasicProperties
import com .rabbitmq .client .Channel
import com .rabbitmq .client .Connection
import com .rabbitmq .client .ConnectionFactory
import com .rabbitmq .client .QueueingConsumer
public class RPCServer {
public static final String RPC_QUENE_NAME = "rpc_queue"
public static void main(String[] args)
throws Exception {
ConnectionFactory factory = new ConnectionFactory()
factory.setHost (RPCConfig.ip )
factory.setPort (RPCConfig.port )
factory.setUsername (RPCConfig.username )
factory.setPassword (RPCConfig.password )
Connection connection = factory.newConnection ()
Channel channel = connection.createChannel ()
channel.queueDeclare (RPC_QUENE_NAME, false, false, false, null)
channel.basicQos (1 )
QueueingConsumer consumer = new QueueingConsumer(channel)
channel.basicConsume (RPC_QUENE_NAME, false,consumer)
System.out .println ("Awaiting RPCrequests" )
while(true){
QueueingConsumer.Delivery delivery = consumer.nextDelivery ()
BasicProperties props = delivery.getProperties ()
BasicProperties replyProps = new BasicProperties.Builder ().correlationId (props.getCorrelationId ()).build ()
String message = new String(delivery.getBody ())
int n = Integer.parseInt (message)
System.out .println ("fib(" +message+")" )
String response = "" +fib(n)
channel.basicPublish ("" , props.getReplyTo (), replyProps, response.getBytes ())
channel.basicAck (delivery.getEnvelope ().getDeliveryTag (), false)
}
}
private static int fib(int n)
throws Exception{
if(n==0 ) return 0
if(n==1 ) return 1
return fib(n-1 ) + fib(n-2 )
}
}
二、异步RPC
package com .rabbitmq
import java.io .IOException
import java.util .UUID
import java.util .concurrent .TimeoutException
import com .rabbitmq .client .AMQP .BasicProperties
import com .rabbitmq .client .Channel
import com .rabbitmq .client .Connection
import com .rabbitmq .client .ConnectionFactory
import com .rabbitmq .client .ConsumerCancelledException
import com .rabbitmq .client .QueueingConsumer
import com .rabbitmq .client .ShutdownSignalException
import com .rabbitmq .utility .BlockingCell
public class RPCClient {
private Connection connection
private Channel channel
private String requestQueuename = "rpc_queue"
private String replyQueueName
private QueueingConsumer consumer
public RPCClient() throws IOException, TimeoutException{
ConnectionFactory factory =new ConnectionFactory()
factory.setHost (RabbitConfig.ip )
factory.setPort (RabbitConfig.port )
factory.setUsername (RabbitConfig.username )
factory.setPassword (RabbitConfig.password )
connection = factory.newConnection ()
channel = connection.createChannel ()
replyQueueName = channel.queueDeclare ().getQueue ()
consumer = new QueueingConsumer(channel)
channel.basicConsume (replyQueueName, true,consumer)
}
public String call (String message) throws IOException,
ShutdownSignalException, ConsumerCancelledException,
InterruptedException, TimeoutException{
String response = null
String corrId = UUID.randomUUID ().toString ()
BasicProperties props = new BasicProperties.Builder ()
.correlationId (corrId)
.replyTo (replyQueueName)
.build ()
channel.basicPublish ("" , requestQueuename, props, message.getBytes ())
BlockingCell k = new BlockingCell()
Object reply = k.uninterruptibleGet ()
System.out .println ("reply:" +reply.toString ())
while(true){
QueueingConsumer.Delivery delivery = consumer.nextDelivery ()
if(delivery.getProperties ().getCorrelationId ().equals (corrId)){
response = new String(delivery.getBody ())
break
}
}
return response
}
public void close() throws IOException{
connection.close ()
}
public static void main(String[] args) throws Exception {
RPCClient fibrpc = new RPCClient()
System.out .println ("request fib(30)" )
String response = fibrpc.call ("30" )
System.out .println ("got " +response+"," )
fibrpc.close ()
}
} 服务器端
package com .rabbitmq
import com .rabbitmq .client .AMQP .BasicProperties
import com .rabbitmq .client .Channel
import com .rabbitmq .client .Connection
import com .rabbitmq .client .ConnectionFactory
import com .rabbitmq .client .QueueingConsumer
public class RPCServer {
public static final String RPC_QUENE_NAME = "rpc_queue"
public static void main(String[] args)
throws Exception {
ConnectionFactory factory = new ConnectionFactory()
factory.setHost (RabbitConfig.ip )
factory.setPort (RabbitConfig.port )
factory.setUsername (RabbitConfig.username )
factory.setPassword (RabbitConfig.password )
Connection connection = factory.newConnection ()
Channel channel = connection.createChannel ()
channel.queueDeclare (RPC_QUENE_NAME, false, false, false, null)
channel.basicQos (1 )
QueueingConsumer consumer = new QueueingConsumer(channel)
channel.basicConsume (RPC_QUENE_NAME, false,consumer)
System.out .println ("Awaiting RPCrequests" )
while(true){
QueueingConsumer.Delivery delivery = consumer.nextDelivery ()
BasicProperties props = delivery.getProperties ()
BasicProperties replyProps = new BasicProperties.Builder ().correlationId (props.getCorrelationId ()).build ()
String message = new String(delivery.getBody ())
int n = Integer.parseInt (message)
System.out .println ("fib(" +message+")" )
String response = "" +fib(n)
channel.basicPublish ("" , props.getReplyTo (), replyProps, response.getBytes ())
channel.basicAck (delivery.getEnvelope ().getDeliveryTag (), false)
}
}
private static int fib(int n)
throws Exception{
if(n==0 ) return 0
if(n==1 ) return 1
return fib(n-1 ) + fib(n-2 )
}
}
