MQ介绍 & 实例

阅读目录

• 定义
• 优秀MQ特点
• 产品比较
• 实例（简单的实战）
• 关于消息队列与分布式的那些事

定义：

消息队列（MQ）是一种应用程序对应用程序的通信方法，应用程序通过队列进行通信，而不是通过直接调用彼此来通信，队列的使用除去了接收和发送应用程序同时执行的要求。是进行通信的中间件产品。（换言之：MQ负责两个系统之间传递消息，这两个系统可以是异构的，处于不同硬件、不同操作系统、用不同语言编写，只需要简单的调用几个MQ的API，就可以互相通讯，你不必考虑底层系统和网络的复杂性。MQ能够应付多种异常情况，例如网络阻塞、临时中断等等）

PS：直接调用通常是用于诸如远程过程调用的技术。

补充知识：MB(消息路由、数据转换)

aaarticlea/png;base64,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" alt="" />

优秀MQ特点

　　a>.高可用性，希望MQ能支撑7x24小时应用，而不是三天两头当机，要做到高可用性，就需要做MQ的集群，一台当了，不影响整个集群的服务能力，这里涉及到告警、流控、消息的负载均衡、数据库的使用、测试的完备程度等等。

　　b>.消息存储的高可靠性。要保证100%不丢消息。这不仅仅是MQ的责任，更涉及到硬件、操作系统、语言平台和数据库的一整套方案。许多号称可靠存储的MQ产品其实都不可靠，要知道，硬件错误是常态，如果在硬件错误的情况下还能保证消息的可靠存储这才是难题。这里可能需要用到特殊的存储硬件，特殊的数据库，分布式的数据存储，数据库的分库分表和同步等等。你要考虑消息存储在哪里，是文件系统，还是数据库，是本地文件，还是分布式文 件，是搞主辅备份呢还是多主机写入等等。

　　c>.高可扩展性，MQ集群能很好地支持水平扩展，这就要求我们的节点之间最好不要有通信和数据同步。

　　d>.性能，性能是实现高可用性的前提，很难想象单机性能极差的MQ组成的集群能在高负载下幸免于难。性能因素跟采用的平台、语言、操作系统、代码质量、数据 库、网络息息相关。MQ产品的核心其实是消息的存储，在保证存储安全的前提下如何保证和提高消息入队的效率是性能的关键因素。这里需要开发人员建立起性能观念，不需要你对一行行代码斤斤计较，但是你需要知道这样做会造成什么后果，有没有更好更快的方式，你怎么证明它更好更快。软件实现的性能是一方面，另一 方面就是平台相关了，因为MQ本质上是IO密集型的系统，瓶颈在IO，如何优化网络IO、文件IO这需要专门的知识。性能另一个相关因素是消息的调度上， 引入消息顺序和消息优先级，允许消息的延迟发送，都将增大消息发送调度的复杂性，如何保证高负载下的调度也是要特别注意的地方。

　　e>.高可配置性和监控工具的完整，这是一个MQ产品容易忽略的地方。异步通信造成了查找问题的难度，不像同步调用那样有相对明确的时序关系。因此查找异步通信 的异常是很困难的，这就需要MQ提供方便的DEBUG工具，查找分析日志的工具，查看消息生命周期的工具，查看系统间依赖关系的工具等等。可定制也是MQ 产品非常重要的一方面，可方便地配置各类参数并在集群中同步，并且可动态调整各类参数，这将大大降低维护难度。

Ps:一句话总结：全天候不宕机，安全消息存储，100%不丢失数据，高效率的写入读出，同时要求方便查错。

产品比较　

RabbitMQ

是使用Erlang编写的一个开源的消息队列，本身支持很多的协议：AMQP，XMPP, SMTP, STOMP，也正是如此，使的它变的非常重量级，更适合于企业级的开发。同时实现了一个经纪人(Broker)构架，这意味着消息在发送给客户端时先在中 心队列排队。对路由(Routing)，负载均衡(Load balance)或者数据持久化都有很好的支持。

Ps: 结合erlang语言本身的并发优势，性能较好，但是不利于做二次开发和维护

Redis

是一个Key-Value的NoSQL数据库，开发维护很活跃，虽然它是一个Key-Value数据库存储系统，但它本身支持MQ功能，所以完全可 以当做一个轻量级的队列服务来使用。对于RabbitMQ和Redis的入队和出队操作，各执行100万次，每10万次记录一次执行时间。测试数据分为 128Bytes、512Bytes、1K和10K四个不同大小的数据。实验表明：入队时，当数据比较小时Redis的性能要高于RabbitMQ，而如 果数据大小超过了10K，Redis则慢的无法忍受；出队时，无论数据大小，Redis都表现出非常好的性能，而RabbitMQ的出队性能则远低于 Redis。

	入队				出队
	128B	512B	1K	10K	128B	512B	1K	10K
Redis	16088	15961	17094	25	15955	20449	18098	9355
RabbitMQ	10627	9916	9370	2366	3219	3174	2982	1588

Ps: 做为一个基于内存的K-V数据库，其提供了消息订阅的服务，可以当作MQ来使用，目前应用案例较少，且不方便扩展

ZeroMQ

号称最快的消息队列系统，尤其针对大吞吐量的需求场景。ZMQ能够实现RabbitMQ不擅长的高级/复杂的队列，但是开发人员需要自己组合多种技 术框架，技术上的复杂度是对这MQ能够应用成功的挑战。ZeroMQ具有一个独特的非中间件的模式，你不需要安装和运行一个消息服务器或中间件，因为你的 应用程序将扮演了这个服务角色。你只需要简单的引用ZeroMQ程序库，可以使用NuGet安装，然后你就可以愉快的在应用程序之间发送消息了。但是 ZeroMQ仅提供非持久性的队列，也就是说如果down机，数据将会丢失。其中，Twitter的Storm中使用ZeroMQ作为数据流的传输。

Ps: 扩展性好，开发比较灵活，采用C语言实现，实际上他只是一个socket库的重新封装，如果我们做为消息队列使用，需要开发大量的代码

ActiveMQ

是Apache下的一个子项目。 类似于ZeroMQ，它能够以代理人和点对点的技术实现队列。同时类似于RabbitMQ，它少量代码就可以高效地实现高级应用场景。RabbitMQ、 ZeroMQ、ActiveMQ均支持常用的多种语言客户端 C++、Java、.Net,、Python、 Php、 Ruby等。

Ps: 历史悠久的开源项目，已经在很多产品中得到应用，实现了JMS1.1规范，可以和spring-jms轻松融合，实现了多种协议，不够轻巧（源代码比RocketMQ多）.支持持久化到数据库，对队列数较多的情况支持不好.

Jafka/Kafka

Kafka是Apache下的一个子项目，是一个高性能跨语言分布式Publish/Subscribe消息队列系统，而Jafka是在Kafka 之上孵化而来的，即Kafka的一个升级版。具有以下特性：快速持久化，可以在O(1)的系统开销下进行消息持久化；高吞吐，在一台普通的服务器上既可以 达到10W/s的吞吐速率；完全的分布式系统，Broker、Producer、Consumer都原生自动支持分布式，自动实现复杂均衡；支持 Hadoop数据并行加载，对于像Hadoop的一样的日志数据和离线分析系统，但又要求实时处理的限制，这是一个可行的解决方案。Kafka通过 Hadoop的并行加载机制来统一了在线和离线的消息处理，这一点也是本课题所研究系统所看重的。Apache Kafka相对于ActiveMQ是一个非常轻量级的消息系统，除了性能非常好之外，还是一个工作良好的分布式系统。

RocketMQ

阿里巴巴的MQ中间件，在其多个产品下使用，并能够撑住双十一的大流量，他并没有实现JMS规范，使用起来很简单。部署由一个 命名服务（nameserver）和一个代理（broker）组成，nameserver和broker以及producer都支持集群，队列的容量受机器硬盘的限制，队列满后可以支持持久化到硬盘（也可以自己适配代码，将其持久化到NOSQL数据库中），队列满后会影响吞吐量，可以采用主备来保证稳定性，支持回溯消费，可以在broker端进行消息过滤.

其他一些队列列表HornetQ、Apache Qpid、Sparrow、Starling、Kestrel、Beanstalkd、Amazon SQS就不再一一分析。

比较ActiveMQ and RocketMQ

	RocketMQ	ActiveMQ
优先级	需要新建一个特殊队列来接收优先级高的队列，无法实现从0-65535这种细粒度的控制	可以精细控制
顺序	可以保证严格的消费顺序	无法保证严格的顺序
持久化	支持	支持
稳定性	更高
消息过滤	RocketMQ可以在broker端进行过滤，对于我们的消息总线，这里可以节省大量的网络传输是否会有消息重发造成的重复消费：RocketMQ可以保证，ActiveMQ无法保证	仅支持在客户端消费的时候进行判断是否是自己需要的消息
回溯消费	支持	不支持	即重新将某一个时刻之前的消息重新消费一遍
事务	支持	支持
定时消费	支持	不支持
消息堆积	更优		就是当缓存消息的内存满了之后的解决方案，一种是丢弃策略，这种不会影响吞吐量，还有一种就是将消息持久化到磁盘，这种会影响吞吐量
客户端不在线	RocketMQ可以在客户端上线后继续将未消费的消息推送到客户端

比较主流的MQ：

	ActiveMQ	RabbitMQ	RocketMq	ZeroMQ
关注度	高	高	中	中
成熟度	成熟	成熟	比较成熟	不成熟
所属社区/公司	Apache	Mozilla Public License	Alibaba
社区活跃度	高	高	中	低
文档	多	多	中	中
特点	功能齐全，被大量开源项目使用	由于Erlang 语言的并发能力，性能很好	各个环节分布式扩展设计，主从 HA；支持上万个队列；多种消费模式；性能很好	低延时，高性能，最高 43万条消息每秒
授权方式	开源	开源	开源	开源
开发语言	Java	Erlang	Java	C
支持的协议	OpenWire、STOMP、REST、XMPP、AMQP	AMQP	自己定义的一套(社区提供JMS--不成熟)	TCP、UDP
客户端支持语言	Java、C、C++、Python、PHP、Perl、.net 等	Java、C、C++、Python、 PHP、Perl 等	Java、C++（不成熟）	python、 java、 php、.net 等
持久化	内存、文件、数据库	内存、文件	磁盘文件	在消息发送端保存
事务	支持	不支持	支持	不支持
集群	支持	支持	支持	不支持
负载均衡	支持	支持	支持	不支持
管理界面	一般	好	无社区有 webconsole   实现	无
部署方式	独立、嵌入	独立	独立	独立
评价	优点：成熟的产品，已经在很多公司得到应用（非大规模场景）。有较多的文档。各种协议支持较好，有多重语言的成熟的客户端； 缺点：根据其他用户反馈，会出莫名其妙的问题，切会丢失消息。其重心放到activemq6.0 产品—apollo上去了，目前社区不活跃，且对5.x维护较少； Activemq不适合用于上千个队列的应用场景	优点：由于erlang语言的特性，mq性能较好；管理界面较丰富，在互联网公司也有较大规模的应用；支持amqp系诶，有多中语言且支持amqp的客户端可用 缺点：erlang语言难度较大。集群不支持动态扩展。	优点：模型简单，接口易用（JMS的接口很多场合并不太实用）。在阿里大规模应用。目前支付宝中的余额宝等新兴产品均使用rocketmq。集群规模大概在50 台左右，单日处理消息上百亿；性能非常好，可以大量堆积消息在broker中；支持多种消费，包括集群消费、广播消费等。开发度较活跃，版本更新很快。 缺点：没有在mq核心中去实现JMS等接口，

实例（简单的实战）

　　ActiveMQ入门实例：

　　　　1.去官方网站下载：http://activemq.apache.org/
　　　　2.运行ActiveMQ
解压缩apache-activemq-5.8.0-bin.zip，然后双击apache-activemq-5.5.1\bin\activemq.bat运行ActiveMQ程序。

　　　　　　启动ActiveMQ以后，登陆：http://localhost:8161/admin/，创建一个Queue，命名为FirstQueue。

　　　　3.创建Eclipse项目并运行

　　　　创建java project：ActiveMQ，新建lib文件夹,导入如下Jar包

　　　　activemq-broker-5.8.0.jar 、activemq-client-5.8.0.jar
、geronimo-j2ee-management_1.1_spec-1.0.1.jar
、geronimo-jms_1.1_spec-1.1.1.jar
、slf4j-api-1.6.6.jar

　　　　创建类如下类：
　　　　aaarticlea/png;base64,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" alt="" />

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.DeliveryMode;
import javax.jms.Destination;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;  

public class Sender {
    private static final int SEND_NUMBER = ;  

    public static void main(String[] args) {
        // ConnectionFactory ：连接工厂，JMS 用它创建连接
        ConnectionFactory connectionFactory; // Connection ：JMS 客户端到JMS
        // Provider 的连接
        Connection connection = null; // Session： 一个发送或接收消息的线程
        Session session; // Destination ：消息的目的地;消息发送给谁.
        Destination destination; // MessageProducer：消息发送者
        MessageProducer producer; // TextMessage message;
        // 构造ConnectionFactory实例对象，此处采用ActiveMq的实现jar
        connectionFactory = new ActiveMQConnectionFactory(
                ActiveMQConnection.DEFAULT_USER,
                ActiveMQConnection.DEFAULT_PASSWORD, "tcp://localhost:61616");
        try { // 构造从工厂得到连接对象
            connection = connectionFactory.createConnection();
            // 启动
            connection.start();
            // 获取操作连接
            session = connection.createSession(Boolean.TRUE,
                    Session.AUTO_ACKNOWLEDGE);
            // 获取session注意参数值xingbo.xu-queue是一个服务器的queue，须在在ActiveMq的console配置
            destination = session.createQueue("FirstQueue");
            // 得到消息生成者【发送者】
            producer = session.createProducer(destination);
            // 设置不持久化，此处学习，实际根据项目决定
            producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
            // 构造消息，此处写死，项目就是参数，或者方法获取
            sendMessage(session, producer);
            session.commit();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (null != connection)
                    connection.close();
            } catch (Throwable ignore) {
            }
        }
    }  

    public static void sendMessage(Session session, MessageProducer producer)
            throws Exception {
        for (int i = ; i <= SEND_NUMBER; i++) {
            TextMessage message = session.createTextMessage("ActiveMq 发送的消息"  + i);
            // 发送消息到目的地方
            System.out.println("发送消息：" + "ActiveMq 发送的消息" + i);
            producer.send(message);
        }
    }
}  

import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
import javax.jms.MessageConsumer;
import javax.jms.Session;
import javax.jms.TextMessage;
import org.apache.activemq.ActiveMQConnection;
import org.apache.activemq.ActiveMQConnectionFactory;  

public class Receiver {
    public static void main(String[] args) {
        // ConnectionFactory ：连接工厂，JMS 用它创建连接
        ConnectionFactory connectionFactory;
        // Connection ：JMS 客户端到JMS Provider 的连接
        Connection connection = null;
        // Session： 一个发送或接收消息的线程
        Session session;
        // Destination ：消息的目的地;消息发送给谁.
        Destination destination;
        // 消费者，消息接收者
        MessageConsumer consumer;
        connectionFactory = new ActiveMQConnectionFactory(
                ActiveMQConnection.DEFAULT_USER,
                ActiveMQConnection.DEFAULT_PASSWORD, "tcp://localhost:61616");
        try {
            // 构造从工厂得到连接对象
            connection = connectionFactory.createConnection();
            // 启动
            connection.start();
            // 获取操作连接
            session = connection.createSession(Boolean.FALSE,
                    Session.AUTO_ACKNOWLEDGE);
            // 获取session注意参数值xingbo.xu-queue是一个服务器的queue，须在在ActiveMq的console配置
            destination = session.createQueue("FirstQueue");
            consumer = session.createConsumer(destination);
            while (true) {
                // 设置接收者接收消息的时间，为了便于测试，这里谁定为100s
                TextMessage message = (TextMessage) consumer.receive(100000);
                if (null != message) {
                    System.out.println("收到消息" + message.getText());
                } else {
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (null != connection)
                    connection.close();
            } catch (Throwable ignore) {
            }
        }
    }
}  

IBM WebSphere MQ介绍安装以及配置服务详解（链接）

关于消息队列与分布式的那些事

　　消息队列技术是分布式应用间交换信息的一种技术。消息队列可驻留在内存或磁盘上,队列存储消息直到它们被应用程序读走。通过消息队列，应用程序可独立地执行--它们不需要知道彼此的位置、或在继续执行前不需要等待接收程序接收此消息。在分布式计算环境中，为了集成分布式应用，开发者需要对异构网络环境下的分布式应用提供有效的通信手段。为了管理需要共享的信息，对应用提供公共的信息交换机制是重要的。

设计分布式应用的方法主要有：

远程过程调用(PRC)--分布式计算环境(DCE)的基础标准成分之一；

对象事务监控(OTM)--基于CORBA的面向对象工业标准与事务处理(TP)监控技术的组合；

消息队列(MessageQueue)--构造分布式应用的松耦合方法。

　　(a) 分布计算环境/远程过程调用 (DCE/RPC)

　　RPC是DCE的成分，是一个由开放软件基金会(OSF)发布的应用集成的软件标准。RPC模仿一个程序用函数引用来引用另一程序的传统程序设计方法，此引用是过程调用的形式，一旦被调用，程序的控制则　　　　转向被调用程序。

　　在RPC实现时，被调用过程可在本地或远地的另一系统中驻留并在执行。当被调用程序完成处理输入数据，结果放在过程调用的返回变量中返回到调用程序。RPC完成后程序控制则立即返回到调用程序。因此　　　　RPC模仿子程序的调用/返回结构，它仅提供了Client(调用程序)和Server(被调用过程)间的同步数据交换。

　　(b) 对象事务监控 (OTM)

　　基于CORBA的面向对象工业标准与事务处理(TP)监控技术的组合，在CORBA规范中定义了：使用面向对象技术和方法的体系结构；公共的Client/Server程序设计接口；多平台间传输和翻译数据的指导方　　　　　针；开发分布式应用接口的语言(IDL)等，并为构造分布的Client/Server应用提供了广泛及一致的模式。

　　(c) 消息队列 (Message Queue)

　　消息队列为构造以同步或异步方式实现的分布式应用提供了松耦合方法。消息队列的API调用被嵌入到新的或现存的应用中，通过消息发送到内存或基于磁盘的队列或从它读出而提供信息交换。消息队列可用　　　　在应用中以执行多种功能，比如要求服务、交换信息或异步处理等。

中间件是一种独立的系统软件或服务程序，分布式应用系统借助这种软件在不同的技术之间共享资源，管理计算资源和网络通讯。它在计算机系统中是一个关键软件，它能实现应用的互连和互操作性，能保证　　　　系统的安全、可靠、高效的运行。中间件位于用户应用和操作系统及网络软件之间，它为应用提供了公用的通信手段，并且独立于网络和操作系统。中间件为开发者提供了公用于所有环境的应用程序接口，当　　　　应用程序中嵌入其函数调用，它便可利用其运行的特定操作系统和网络环境的功能，为应用执行通信功能。

如果没有消息中间件完成信息交换，应用开发者为了传输数据，必须要学会如何用网络和操作系统软件的功能，编写相应的应用程序来发送和接收信息，且交换信息没有标准方法，每个应用必须进行特定的编程从而和多平台、不同环境下的一个或多个应用通信。例如，为了实现网络上不同主机系统间的通信，将要求具备在网络上如何交换信息的知识（比如用TCP/IP的socket程序设计）；为了实现同一主机内不同进程之间的通讯，将要求具备操作系统的消息队列或命名管道(Pipes)等知识。

　　目前中间件的种类很多，如交易管理中间件(如IBM的CICS)、面向Java应用的Web应用服务器中间件(如IBM的WebSphere Application Server)等，而消息传输中间件(MOM)是其中的一种。它简化了应用之间数据的传输，屏蔽底层异构操作系统和网络平台，提供一致的通讯标准和应用开发，确保分布式计算网络环境下可靠的、跨平台的信息传输和数据交换。它基于消息队列的存储-转发机制，并提供特有的异步传输机制，能够基于消息传输和异步事务处理实现应用整合与数据交换。

出处：https://www.cnblogs.com/swugogo/p/5910128.html