RabbitMQ的介绍与spring整合

本文主要讲述的是个人参考官网及其他前辈博客，对RabbitMQ的一些理解与spring整个RabbitMQ.

一、RabbitMQ的介绍

1.1、什么是RabbitMQ

RabbitMQ是一个由erlang开发的AMQP（Advanced Message Queue ）的开源实现，官网地址http://www.rabbitmq.com

1.2、什么是AMQP

AMQP就是一个协议，是一个高级抽象层消息通信协议。

虽然在同步消息通讯的世界里有很多公开标准（如 COBAR的 IIOP ，或者是 SOAP 等），但是在异步消息处理中却不是这样，只有大企业有一些商业实现（如微软的 MSMQ ，IBM 的 Websphere MQ 等），因此，在 2006 年的 6 月，Cisco 、Redhat、iMatix 等联合制定了 AMQP 的公开标准。也就是说AMQP是异步通讯的一个协议。

1.3、介绍几个常说的名词

Server(broker：代理)：接受客户端连接，实现AMQP消息队列和路由功能的进程。

Virtual Host:其实是一个虚拟概念，类似于权限控制组，一个Virtual Host里面可以有若干个Exchange和Queue，但是权限控制的最小粒度是Virtual Host

connection：连接，对于RabbitMQ而言，其实就是一个位于客户端和Broker之间的TCP连接。

channel：信道，仅仅创建了客户端到Broker之间的连接后，客户端还是不能发送消息的。需要为每一个Connection创建Channel，AMQP协议规定只有通过Channel才能执行AMQP的命令。一个Connection可以包含多个Channel。之所以需要Channel，是因为TCP连接的建立和释放都是十分昂贵的，如果一个客户端每一个线程都需要与Broker交互，如果每一个线程都建立一个TCP连接，暂且不考虑TCP连接是否浪费，就算操作系统也无法承受每秒建立如此多的TCP连接。RabbitMQ建议客户端线程之间不要共用Channel，至少要保证共用Channel的线程发送消息必须是串行的，但是建议尽量共用Connection。

Exchange：接受生产者发送的消息，并根据Binding规则将消息路由给服务器中的队列。ExchangeType决定了Exchange路由消息的行为，例如，在RabbitMQ中，ExchangeType有direct、Fanout和Topic三种，不同类型的Exchange路由的行为是不一样的。

Queue： 由Header和Body组成，Header是由生产者添加的各种属性的集合，包括Message是否被持久化、由哪个Message Queue接受、优先级是多少等。而Body是真正需要传输的APP数据

Message Queue：消息队列，用于存储还未被消费者消费的消息

Binding：Binding联系了Exchange与Message Queue。Exchange在与多个Message Queue发生Binding后会生成一张路由表，路由表中存储着Message Queue所需消息的限制条件即Binding Key。当Exchange收到Message时会解析其Header得到Routing Key，Exchange根据Routing Key与Exchange Type将Message路由到Message Queue。Binding Key由Consumer在Binding Exchange与Message Queue时指定，而Routing Key由Producer发送Message时指定，两者的匹配方式由Exchange Type决定。

二、RabbitMQ的使用场景

关于RabbitMQ的几种使用场景，这里都是根据官网https://www.rabbitmq.com/getstarted.html来的，具体的代码实现，这里就不粘， 简单总结一下。

2.1 简单模式

一个生产者、一个消费者，生产者直接将消息发送到队列，消费者消费消息

2.2 工人之间分配模式

一个生产者、两个消费者，生产者将消息直接发送到队列，消费者消费消息

注意：

在消费者代码里没有这个设置的话channel.basicQos(1)，是平均分配， 加上这个设置，就是能者多劳,这种更加符合实际的应用场景；

2.3 订阅模式

一个生产者、多个消费者，生产者将消息发送到Exchange中，消费者通过路由规则接受消息

有三种类型的Exchanges：direct, fanout,topic。 每个实现了不同的路由算法（routing algorithm）。

· Direct exchange:如果 routing key 匹配, 那么Message就会被传递到相应的queue中。其实在queue创建时，它会自动的以queue的名字作为routing key来绑定那个exchange。

·Fanout exchange: 会向响应的queue广播【没有路由规则】。

·Topic exchange: 对key进行模式匹配，比如ab*可以传递到所有ab*的queue。

2.4 RPC模式

这块还在学习中，后续补充......

三、spring整合RabbitMQ

3.1添加依赖

<dependency>
	 <groupId>org.springframework.amqp</groupId>
	 <artifactId>spring-rabbit</artifactId>
         <version>1.4.0.RELEASE</version>
 </dependency>
 <dependency>
	<groupId>com.rabbitmq</groupId>
	<artifactId>amqp-client</artifactId>
	<version>3.4.1</version>
</dependency>

3.2 新增spring-rabbitmq.xml

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:rabbit="http://www.springframework.org/schema/rabbit"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/rabbit
    http://www.springframework.org/schema/rabbit/spring-rabbit-1.0.xsd
     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd" >

    <description>rabbitmq 连接服务配置</description>

   <!--  <context:property-placeholder location="classpath:rabbitMQ.properties" /> -->  

    <!-- 连接配置 -->
    <rabbit:connection-factory id="connectionFactory" host="${mq.host}" username="${mq.username}" password="${mq.password}" port="${mq.port}"  virtual-host="${mq.vhost}"/>

    <rabbit:admin connection-factory="connectionFactory"/>

    <!-- spring template声明-->
    <rabbit:template exchange="test-mq-exchange" id="amqpTemplate"  connection-factory="connectionFactory"  />
	<!-- message-converter="jsonMessageConverter" -->

    <!-- 消息对象json转换类 -->
    <!-- <bean id="jsonMessageConverter" class="org.springframework.amqp.support.converter.Jackson2JsonMessageConverter" /> -->

    <!-- 声明一个Que -->
    <rabbit:queue id="test_queue" name="test_queue" durable="true" auto-delete="false" exclusive="false" />
    <!--
    durable:是否持久化
	exclusive: 仅创建者可以使用的私有队列，断开后自动删除
	auto_delete: 当所有消费客户端连接断开后，是否自动删除队列
     -->  

     <!-- 声明一个Exchange -->
    <rabbit:direct-exchange name="test-mq-exchange" durable="true" auto-delete="false" id="test-mq-exchange">
	    <rabbit:bindings>
	        <rabbit:binding queue="test_queue" key="test_queue"/>
	    </rabbit:bindings>
	</rabbit:direct-exchange>
	<!--
	rabbit:direct-exchange：定义exchange模式为direct，意思就是消息与一个特定的路由键完全匹配，才会转发。
	rabbit:binding：设置消息queue匹配的key
	-->

</beans>

3.3 rabbitMQ.properties内容

mq.host=127.0.0.1
mq.username=root
mq.password=root
mq.port=5672
#虚拟主机
mq.vhost=/test-vhost

3.4接口与实现类

//接口
public interface MQProducer
{
	/**
     * 发送消息到指定队列
     * @param queueKey
     * @param object
     */
    public void sendDataToQueue(String queueKey, Object object);
}

//实现类

@Service
public class MQProducerImpl implements MQProducer
{

    @Autowired
    private AmqpTemplate amqpTemplate;

    private final static Logger LOGGER = Logger.getLogger(MQProducerImpl.class);

    public void sendDataToQueue(String queueKey, Object object)
    {
        try
        {
        	LOGGER.info("=========发送消息开始=============消息："+object.toString());
            amqpTemplate.convertAndSend(queueKey, object);
        }
        catch (Exception e)
        {
            LOGGER.error(e);
        }

    }
}

3.5 队列监听

@Component
public class QueueListenter implements MessageListener
{

    public void onMessage(Message message)
    {
    	String str = "";
        try
        {
        	str = new String(message.getBody(), "UTF-8");
        	System.out.println("=============监听【QueueListenter】消息"+message);
            System.out.print("=====获取消息"+str);

        }catch(Exception e)
        {
            e.printStackTrace();
        }
    }

}

3.6 配置监听器

<!-- 监听器的bean -->

<bean id="queueListenter" class="com.yh.showpic.rabbitmq.listener.QueueListenter"/>

<!-- 配置监听queue -->
<rabbit:listener-container connection-factory="connectionFactory" acknowledge="auto">
    	<rabbit:listener queues="test_queue" ref="queueListenter"/>
</rabbit:listener-container>

3.7 测试类

@RunWith(value = SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:/spring/spring.xml","classpath:/spring/spring-rabbitMQ.xml"})
public class TestQueue
{
    @Autowired
    MQProducer mqProducer;

    private static final String QUEUE_KEY = "test_queue";

    @Test
    public void send()
    {
    	String message = "hello rabbitMQ!";
//        Map<String,Object> msg = new HashMap<String,Object>();
//        msg.put("data","hello,rabbmitmq!");
        mqProducer.sendDataToQueue(QUEUE_KEY,message);
    }
}

后台日志：

[org.springframework.context.support.DefaultLifecycleProcessor] - Starting beans in phase 2147483647
=========发送消息开始=============消息：hello rabbitMQ!
=============监听【QueueListenter】消息(Body:'hello rabbitMQ!'MessageProperties [headers={}, timestamp=null, messageId=null, userId=null, appId=null, clusterId=null, type=null, correlationId=null, replyTo=null, contentType=text/plain, contentEncoding=UTF-8, contentLength=0, deliveryMode=PERSISTENT, expiration=null, priority=0, redelivered=false, receivedExchange=test-mq-exchange, receivedRoutingKey=test_queue, deliveryTag=1, messageCount=0])
=====获取消息hello rabbitMQ![org.springframework.context.support.GenericApplicationContext] - Closing org.springframework.context.support.GenericApplicationContext@349955ab: startup date [Sun Sep 11 17:34:30 CST 2016]; root of context hierarchy

整合成功！

看日志：

(Body:'hello rabbitMQ!'MessageProperties [headers={}, timestamp=null, messageId=null, userId=null, appId=null, clusterId=null, type=null, correlationId=null, replyTo=null, contentType=text/plain, contentEncoding=UTF-8, contentLength=0, deliveryMode=PERSISTENT, expiration=null, priority=0, redelivered=false, receivedExchange=test-mq-exchange, receivedRoutingKey=test_queue, deliveryTag=1, messageCount=0])

知道消息是由Header和Body组成，Header是由生产者添加的各种属性的集合，包括Message是否被持久化、由哪个Message Queue接受、优先级是多少等。而Body是真正需要传输的APP数据。

4、rabbitMQ的客户端配置

根据上面3.2节 spring的整合配置文件之后，还需要配置rabbitMQ 的客户端。配置贴图：

5、后续补充内容

根据上面一章，添加新的queue之后，都需要手动配置客户端，这样显得很麻烦，这里有配置，添加下面配置，客户端我们就不用再关心，重点放在我们的代码上面。如下配置：

<!-- queue 队列声明 -->
<rabbit:queue id="dealDataQueue" name="test.deal.data.queue" durable="true" auto-delete="false" exclusive="false"/>

<!-- exchange queue binging key 绑定 -->
<rabbit:direct-exchange name="xx-exchange" id="xx-exchange" durable="true" auto-delete="false">
        <rabbit:bindings>
                <rabbit:binding queue="dealDataQueue" key="test.deal.data.queue"/>
        </rabbit:bindings>
</rabbit:direct-exchange>

<!--定义 MQ 监听器 bean-->
<bean id="dealDataQueueLitener" class="com.xxx.DealDataListener"/>

<!-- 监听 绑定 queue -->
<rabbit:listener-container connection-factory="rabbitConnectionFactory" acknowledge="auto">
      <!--监听器监听该queue -->
      <rabbit:listener queues="dealDataQueue" ref="dealDataQueueLitener"/>
</rabbit:listener-container>

<!-- config exchange -->
<rabbit:template id="rabbitTemplate" exchange="xx-exchange" connection-factory="rabbitConnectionFactory" />

以上内容都是我个人学习补充，由于能力有限，难免出现错误，如有错误，多谢指正。

参考资料：

1、RabbitMQ官方网站

2、RabbitMQ的几种典型使用场景

3、CSDN专栏