spring集成rabbitMQ

spring集成rabbitMQ

1.依赖rabbitMQ相关jar包:

<!-- RabbitMQ -->
<dependency>
<groupId>com.rabbitmq</groupId>
<artifactId>amqp-client</artifactId>
<version>3.5.1</version>
</dependency>
<dependency>
<groupId>org.springframework.amqp</groupId>
<artifactId>spring-rabbit</artifactId>
<version>1.4.5.RELEASE</version>
</dependency>

2.rabbitMQ参数配置:

2.1使用rabbitmq.properties

mq.host=127.0.0.1
mq.username=queue
mq.password=1234
mq.port=8001

2.2修改 applicationContext.xml 文件，引入我们创建的 properties 文件

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

#或者
<util:properties id="appConfig" location="classpath:application.properties"></util:properties>

3.连接
RabbitMQ 服务器

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

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

4. 在 applicationContext.xml 中声明一个交换机。

<rabbit:top-exchange> 标签的 name 属性就是在 RabbitMQ 服务器配置交换机的
name 值。

<rabbit:binding> 标签的 queue 属性是下面 <queue> 标签的 id
属性。

<rabbit:binding> 标签的 pattern 属性是在 RabbitMQ 服务器配置交换机与队列绑定时的
Routing key 值（路由）。

<rabbit:topic-exchange name="test_mq_exchange" durable="true" auto-delete="false">
<rabbit:bindings>
<rabbit:binding queue="test_queue" pattern="test_mq_patt"/>
</rabbit:bindings>
</rabbit:topic-exchange>

交换机的四种模式：
direct：转发消息到 routigKey 指定的队列。
topic：按规则转发消息（最灵活）。
headers：忽略routingKey的一种路由方式,较少使用
fanout：转发消息到所有绑定队列

交换器的属性：
持久性：如果启用，交换器将会在server重启前都有效。
自动删除：如果启用，那么交换器将会在其绑定的队列都被删除掉之后自动删除掉自身。
惰性：如果没有声明交换器，那么在执行到使用的时候会导致异常，并不会主动声明。

如果没有队列绑定在交换机上，则发送到该交换机上的消息会丢失。

 

一个交换机可以绑定多个队列，一个队列可以被多个交换机绑定。

 

topic 类型交换器通过模式匹配分析消息的 routing-key 属性。它将 routing-key 和 binding-key 的字符串切分成单词。这些单词之间用点隔开。它同样也会识别两个通配符：#匹配0个或者多个单词，*匹配一个单词。例如，binding key：*.stock.#匹配 routing key：usd.stcok 和 eur.stock.db，但是不匹配
stock.nana。

 

因为交换器是命名实体，声明一个已经存在的交换器，但是试图赋予不同类型是会导致错误。客户端需要删除这个已经存在的交换器，然后重新声明并且赋予新的类型。

5.声明一个 RabbitMQ Template(与交换机关联)

<rabbit:template id="amqpTemplate" exchange="test_mq_exchange" connection-factory="connectionFactory"  />

6. 在 applicationContext.xml 中声明一个队列。

<rabbit:queue> 标签的 name 属性就是在 RabbitMQ 服务器中配置 Queue 的 name。

<rabbit:queue>
标签的 id 属性是上面 <rabbit:binding> 标签的 queue 属性。

<rabbit:queue id="test_queue" name="test_mq_testQueue" durable="true" auto-delete="false" exclusive="false" />

durable：是否持久化
exclusive：仅创建者可以使用的私有队列，断开后自动删除
auto-delete：当所有消费端连接断开后，是否自动删除队列

7.
创建生产者端

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
* @Description: 消息队列发送者
* @Author:
* @CreateTime:
*/
@Service
public class Producer {

@Autowired
private AmqpTemplate amqpTemplate;

public void sendQueue(String exchange_key, String queue_key, Object object) {
// convertAndSend 将Java对象转换为消息发送至匹配key的交换机中Exchange
amqpTemplate.convertAndSend(exchange_key, queue_key, object);
}
}

8.
在 applicationContext.xml 中配置监听及消费者端

<!-- 消费者 -->
<bean name="rabbitmqService" class="com.enh.mq.RabbitmqService"></bean>

<!-- 配置监听 -->
<rabbit:listener-container connection-factory="connectionFactory" acknowledge="auto">
　　<!--
　　　　queues 监听队列，多个用逗号分隔
　　　　ref 监听器
　　-->
　　<rabbit:listener queues="test_queue" ref="rabbitmqService"/>
</rabbit:listener-container>

消费者 Java 代码：

import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageListener;

public class RabbitmqService implements MessageListener {
public void onMessage(Message message) {
System.out.println("消息消费者 = " + message.toString());
}
}

总结,如下:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:rabbit="http://www.springframework.org/schema/rabbit"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation=" http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd http://www.springframework.org/schema/rabbit http://www.springframework.org/schema/rabbit/spring-rabbit-1.0.xsd">

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

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

<!-- 消息队列客户端 -->
<rabbit:template id="amqpTemplate" exchange="test_mq_exchange" connection-factory="connectionFactory"  />

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

<!-- 交换机定义 -->
<!--
交换机：一个交换机可以绑定多个队列，一个队列也可以绑定到多个交换机上。
如果没有队列绑定到交换机上，则发送到该交换机上的信息则会丢失。

direct模式:消息与一个特定的路由器完全匹配，才会转发
topic模式:按规则转发消息，最灵活
-->
<rabbit:topic-exchange name="test_mq_exchange" durable="true" auto-delete="false">
<rabbit:bindings>
<!-- 设置消息Queue匹配的pattern (direct模式为key) -->
<rabbit:binding queue="test_queue" pattern="test_mq_patt"/>
</rabbit:bindings>
</rabbit:topic-exchange>

<bean name="rabbitmqService" class="com.enh.mq.RabbitmqService"></bean>

<!-- 配置监听 消费者 -->
<rabbit:listener-container connection-factory="connectionFactory" acknowledge="auto">
<!--
queues 监听队列，多个用逗号分隔
ref 监听器 -->
<rabbit:listener queues="test_queue" ref="rabbitmqService"/>
</rabbit:listener-container>
</beans>

9. 如何使用 RabbitMQ 发送一个消息

@Autowired
private Producer producer;
@Value("#{appConfig['mq.queue']}")
private String queueId;

/**
* @Description: 消息队列
* @Author:
* @CreateTime:
*/
@ResponseBody
@RequestMapping("/sendQueue")
public String testQueue() {
try {
Map<String, Object> map = new HashMap<String, Object>();
map.put("data", "hello rabbitmq");
// 注意：第二个属性是 Queue 与 交换机绑定的路由
producer.sendQueue(queueId + "_exchange", queueId + "_patt", map);
} catch (Exception e) {
e.printStackTrace();
}
return "发送完毕";
}