一、rabbitMQ简介

1.1、rabbitMQ的优点(适用范围)
1. 基于erlang语言开发具有高可用高并发的优点,适合集群服务器。
2. 健壮、稳定、易用、跨平台、支持多种语言、文档齐全。
3. 有消息确认机制和持久化机制,可靠性高。
4. 开源
其他MQ的优势:
1. Apache ActiveMQ曝光率最高,但是可能会丢消息。
2. ZeroMQ延迟很低、支持灵活拓扑,但是不支持消息持久化和崩溃恢复。

1.2、几个概念说明
producer&Consumer
producer指的是消息生产者,consumer消息的消费者。
Queue
消息队列,提供了FIFO的处理机制,具有缓存消息的能力。rabbitmq中,队列消息可以设置为持久化,临时或者自动删除。
设置为持久化的队列,queue中的消息会在server本地硬盘存储一份,防止系统crash,数据丢失
设置为临时队列,queue中的数据在系统重启之后就会丢失
设置为自动删除的队列,当不存在用户连接到server,队列中的数据会被自动删除Exchange

Exchange类似于数据通信网络中的交换机,提供消息路由策略。rabbitmq中,producer不是通过信道直接将消息发送给queue,而是先发送给Exchange。一个Exchange可以和多个Queue进行绑定,producer在传递消息的时候,会传递一个ROUTING_KEY,Exchange会根据这个ROUTING_KEY按照特定的路由算法,将消息路由给指定的queue。和Queue一样,Exchange也可设置为持久化,临时或者自动删除。
Exchange有4种类型:direct(默认),fanout, topic, 和headers,不同类型的Exchange转发消息的策略有所区别:
Direct
直接交换器,工作方式类似于单播,Exchange会将消息发送完全匹配ROUTING_KEY的Queue
fanout
广播是式交换器,不管消息的ROUTING_KEY设置为什么,Exchange都会将消息转发给所有绑定的Queue。
topic
主题交换器,工作方式类似于组播,Exchange会将消息转发和ROUTING_KEY匹配模式相同的所有队列,比如,ROUTING_KEY为user.stock的Message会转发给绑定匹配模式为 * .stock,user.stock, * . * 和#.user.stock.#的队列。( * 表是匹配一个任意词组,#表示匹配0个或多个词组)
headers
消息体的header匹配(ignore)
Binding
所谓绑定就是将一个特定的 Exchange 和一个特定的 Queue 绑定起来。Exchange 和Queue的绑定可以是多对多的关系。
virtual host
在rabbitmq server上可以创建多个虚拟的message broker,又叫做virtual hosts (vhosts)。每一个vhost本质上是一个mini-rabbitmq server,分别管理各自的exchange,和bindings。vhost相当于物理的server,可以为不同app提供边界隔离,使得应用安全的运行在不同的vhost实例上,相互之间不会干扰。producer和consumer连接rabbit server需要指定一个vhost。

1.3、消息队列的使用过程
1. 客户端连接到消息队列服务器,打开一个channel。
2. 客户端声明一个exchange,并设置相关属性。
3. 客户端声明一个queue,并设置相关属性。
4. 客户端使用routing key,在exchange和queue之间建立好绑定关系。
5. 客户端投递消息到exchange。
6. exchange接收到消息后,就根据消息的key和已经设置的binding,进行消息路由,将消息投递到一个或多个队列里

二、环境配置与安装

1、Erlang环境安装
RabbitMQ是基于Erlang的,所以首先必须配置Erlang环境。
从Erlang的官网 http://www.erlang.org/download.html 下载最新的erlang安装包,我下载的版本是 otp_src_R14B03.tar.gz 。然后:

  1. $ tar xvzf otp_src_R14B03.tar.gz
  2. $ cd otp_src_R14B03
  3. $ ./configure

编译后的输出
如下图:

注:
可能会报错 configure: error: No curses library functions found
configure: error: /bin/sh '/home/liyixiang/erlang/configure' failed for erts

原因是缺少ncurses包

解决:在ubuntu系统下

  1. apt-cache search ncurses
  2. apt-get install libncurses5-dev

然后重新执行

  1. ./configure

提示没有wxWidgets和fop、ssh、odbc、ssl,但是问题不大。继续:

  1. make

然后:

  1. sudo make install

配置erlang环境变量 
修改/etc/profile文件,增加下面的环境变量:(vim profile i插入 编辑完毕ESC退出 wq!强制修改)

  1. #set erlang environment
  2. export PATH=$PATH:/usr/erlang/bin:$PATH
  3. source profile使得文件生效

下面是我的

2、RabbitMQ-Server安装

安装完Erlang,开始安装RabbitMQ-Server。安装方法有三种,这里笔者三者都试过了,就只有以下这个方法成功了。

直接使用:

  1. apt-get  install rabbitmq-server

安装完成后会自动打开:

使用命令查看rabbitmq运行状态:

  1. rabbitmqctl status

停止

  1. rabbitmqctl stop

开启

  1. rabbitmq-server start

3、rabbitmq web管理页面插件安装

输入以下命令

  1. <pre code_snippet_id="1560509" snippet_file_name="blog_20160120_11_8615485" name="code" class="plain">cd /usr/lib/rabbitmq/bin/
  2. rabbitmq-plugins enable rabbitmq_management</pre>

这里笔者一直安装不成功。

 

如果安装成功打开浏览器,输入 http://[server-name]:15672/ 如 http://localhost:15672/ ,会要求输入用户名和密码,用默认的guest/guest即可(guest/guest用户只能从localhost地址登录,如果要配置远程登录,必须另创建用户)。
如果要从远程登录怎么做呢?处于安全考虑,guest这个默认的用户只能通过http://localhost:15672来登录,其他的IP无法直接用这个guest帐号。这里我们可以通过配置文件来实现从远程登录管理界面,只要编辑/etc/rabbitmq/rabbitmq.config文件(没有就新增),添加以下配置就可以了。

4、添加用户

  1. vim /etc/rabbitmq/rabbitmq.config

然后添加

  1. [
  2. {rabbit, [{tcp_listeners, [5672]}, {loopback_users, ["asdf"]}]}
  3. ].

注意上面有个点号

现在添加了一个新授权用户asdf,可以远程使用这个用户名。记得要先用命令添加这个命令才行:

  1. cd /usr/lib/rabbitmq/bin/

#用户名与密码

  1. sudo rabbitmqctl add_user asdf 123456

用户设置为administrator才能远程访问

  1. sudo rabbitmqctl set_user_tags asdf administrator
  2. sudo rabbitmqctl set_permissions -p / asdf ".*" ".*" ".*"

其实也可以通过管理平台页面直接添加用户和密码等信息。如果还不能远程访问或远程登录检查是不是5672, 15672端口没有开放!!!!!!

5、开放端口

  1. ufw allow 5672
 

三、简单Java实例

下面来演示一个使用java的简单实例:
1、首先是消息生产者和提供者的基类
  1. package com.lin;
  2. import java.io.IOException;
  3. import com.rabbitmq.client.Channel;
  4. import com.rabbitmq.client.Connection;
  5. import com.rabbitmq.client.ConnectionFactory;
  6. /**
  7. *
  8. * 功能概要: EndPoint类型的队列
  9. *
  10. * @author linbingwen
  11. * @since  2016年1月11日
  12. */
  13. public abstract class EndPoint{
  14. protected Channel channel;
  15. protected Connection connection;
  16. protected String endPointName;
  17. public EndPoint(String endpointName) throws IOException{
  18. this.endPointName = endpointName;
  19. //Create a connection factory
  20. ConnectionFactory factory = new ConnectionFactory();
  21. //hostname of your rabbitmq server
  22. factory.setHost("10.75.4.25");
  23. factory.setPort(5672);
  24. factory.setUsername("asdf");
  25. factory.setPassword("123456");
  26. //getting a connection
  27. connection = factory.newConnection();
  28. //creating a channel
  29. channel = connection.createChannel();
  30. //declaring a queue for this channel. If queue does not exist,
  31. //it will be created on the server.
  32. channel.queueDeclare(endpointName, false, false, false, null);
  33. }
  34. /**
  35. * 关闭channel和connection。并非必须,因为隐含是自动调用的。
  36. * @throws IOException
  37. */
  38. public void close() throws IOException{
  39. this.channel.close();
  40. this.connection.close();
  41. }
  42. }

2、消息提供者

  1. package com.lin.producer;
  2. import java.io.IOException;
  3. import java.io.Serializable;
  4. import org.apache.commons.lang.SerializationUtils;
  5. import com.lin.EndPoint;
  6. /**
  7. *
  8. * 功能概要:消息生产者
  9. *
  10. * @author linbingwen
  11. * @since  2016年1月11日
  12. */
  13. public class Producer extends EndPoint{
  14. public Producer(String endPointName) throws IOException{
  15. super(endPointName);
  16. }
  17. public void sendMessage(Serializable object) throws IOException {
  18. channel.basicPublish("",endPointName, null, SerializationUtils.serialize(object));
  19. }
  20. }

3、消息消费者

  1. package com.lin.consumer;
  2. import java.io.IOException;
  3. import java.util.HashMap;
  4. import java.util.Map;
  5. import org.apache.commons.lang.SerializationUtils;
  6. import com.lin.EndPoint;
  7. import com.rabbitmq.client.AMQP.BasicProperties;
  8. import com.rabbitmq.client.Consumer;
  9. import com.rabbitmq.client.Envelope;
  10. import com.rabbitmq.client.ShutdownSignalException;
  11. /**
  12. *
  13. * 功能概要:读取队列的程序端,实现了Runnable接口
  14. *
  15. * @author linbingwen
  16. * @since  2016年1月11日
  17. */
  18. public class QueueConsumer extends EndPoint implements Runnable, Consumer{
  19. public QueueConsumer(String endPointName) throws IOException{
  20. super(endPointName);
  21. }
  22. public void run() {
  23. try {
  24. //start consuming messages. Auto acknowledge messages.
  25. channel.basicConsume(endPointName, true,this);
  26. } catch (IOException e) {
  27. e.printStackTrace();
  28. }
  29. }
  30. /**
  31. * Called when consumer is registered.
  32. */
  33. public void handleConsumeOk(String consumerTag) {
  34. System.out.println("Consumer "+consumerTag +" registered");
  35. }
  36. /**
  37. * Called when new message is available.
  38. */
  39. public void handleDelivery(String consumerTag, Envelope env,
  40. BasicProperties props, byte[] body) throws IOException {
  41. Map map = (HashMap)SerializationUtils.deserialize(body);
  42. System.out.println("Message Number "+ map.get("message number") + " received.");
  43. }
  44. public void handleCancel(String consumerTag) {}
  45. public void handleCancelOk(String consumerTag) {}
  46. public void handleRecoverOk(String consumerTag) {}
  47. public void handleShutdownSignal(String consumerTag, ShutdownSignalException arg1) {}
  48. }

4、测试

  1. package com.lin.test;
  2. import java.io.IOException;
  3. import java.sql.SQLException;
  4. import java.util.HashMap;
  5. import com.lin.consumer.QueueConsumer;
  6. import com.lin.producer.Producer;
  7. public class Test {
  8. public Test() throws Exception{
  9. QueueConsumer consumer = new QueueConsumer("queue");
  10. Thread consumerThread = new Thread(consumer);
  11. consumerThread.start();
  12. Producer producer = new Producer("queue");
  13. for (int i = 0; i < 1000000; i++) {
  14. HashMap message = new HashMap();
  15. message.put("message number", i);
  16. producer.sendMessage(message);
  17. System.out.println("Message Number "+ i +" sent.");
  18. }
  19. }
  20. /**
  21. * @param args
  22. * @throws SQLException
  23. * @throws IOException
  24. */
  25. public static void main(String[] args) throws Exception{
  26. new Test();
  27. }
  28. }

其中引入的jar包:

  1. <!-- rabbitmq客户端 -->
  2. <dependencies>
  3. <dependency>
  4. <groupId>com.rabbitmq</groupId>
  5. <artifactId>amqp-client</artifactId>
  6. <version>3.0.4</version>
  7. </dependency>
  8. <dependency>
  9. <groupId>commons-lang</groupId>
  10. <artifactId>commons-lang</artifactId>
  11. <version>2.6</version>
  12. </dependency>
  13. <dependency>
  14. <groupId>org.apache.commons</groupId>
  15. <artifactId>commons-lang3</artifactId>
  16. <version>3.1</version>
  17. </dependency>
  18. </dependencies>

测试结果:

在提供消息
在消费消息

然后同时打开rabbitmq的服务端,输入如下:
  1. rabbitmqctl list_queues

这个命令是用来查看服务端中有多处个消息队列的。

可以看到有个名为queue的消息队列(更好的方法是安装好web监控插件,笔者一直安装失败,所以这里就不展示了)
 
 

四、Rbbitmq与Spring结合使用

首先建立一个maven工程,整个项目的结构如下:
下面将具体来讲讲整个过程
1、jar包的引入
pom.xml配置即可,如下:
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3. <modelVersion>4.0.0</modelVersion>
  4. <groupId>com.lin</groupId>
  5. <artifactId>rabbit_c2</artifactId>
  6. <version>0.0.1-SNAPSHOT</version>
  7. <properties>
  8. <!-- spring版本号 -->
  9. <spring.version>3.2.8.RELEASE</spring.version>
  10. <!-- log4j日志文件管理包版本 -->
  11. <slf4j.version>1.6.6</slf4j.version>
  12. <log4j.version>1.2.12</log4j.version>
  13. <!-- junit版本号 -->
  14. <junit.version>4.10</junit.version>
  15. </properties>
  16. <dependencies>
  17. <!-- 添加Spring依赖 -->
  18. <dependency>
  19. <groupId>org.springframework</groupId>
  20. <artifactId>spring-core</artifactId>
  21. <version>${spring.version}</version>
  22. </dependency>
  23. <dependency>
  24. <groupId>org.springframework</groupId>
  25. <artifactId>spring-webmvc</artifactId>
  26. <version>${spring.version}</version>
  27. </dependency>
  28. <dependency>
  29. <groupId>org.springframework</groupId>
  30. <artifactId>spring-context</artifactId>
  31. <version>${spring.version}</version>
  32. </dependency>
  33. <dependency>
  34. <groupId>org.springframework</groupId>
  35. <artifactId>spring-context-support</artifactId>
  36. <version>${spring.version}</version>
  37. </dependency>
  38. <dependency>
  39. <groupId>org.springframework</groupId>
  40. <artifactId>spring-aop</artifactId>
  41. <version>${spring.version}</version>
  42. </dependency>
  43. <dependency>
  44. <groupId>org.springframework</groupId>
  45. <artifactId>spring-aspects</artifactId>
  46. <version>${spring.version}</version>
  47. </dependency>
  48. <dependency>
  49. <groupId>org.springframework</groupId>
  50. <artifactId>spring-tx</artifactId>
  51. <version>${spring.version}</version>
  52. </dependency>
  53. <dependency>
  54. <groupId>org.springframework</groupId>
  55. <artifactId>spring-jdbc</artifactId>
  56. <version>${spring.version}</version>
  57. </dependency>
  58. <dependency>
  59. <groupId>org.springframework</groupId>
  60. <artifactId>spring-web</artifactId>
  61. <version>${spring.version}</version>
  62. </dependency>
  63. <!--单元测试依赖 -->
  64. <dependency>
  65. <groupId>junit</groupId>
  66. <artifactId>junit</artifactId>
  67. <version>${junit.version}</version>
  68. <scope>test</scope>
  69. </dependency>
  70. <!-- 日志文件管理包 -->
  71. <!-- log start -->
  72. <dependency>
  73. <groupId>log4j</groupId>
  74. <artifactId>log4j</artifactId>
  75. <version>${log4j.version}</version>
  76. </dependency>
  77. <dependency>
  78. <groupId>org.slf4j</groupId>
  79. <artifactId>slf4j-api</artifactId>
  80. <version>${slf4j.version}</version>
  81. </dependency>
  82. <dependency>
  83. <groupId>org.slf4j</groupId>
  84. <artifactId>slf4j-log4j12</artifactId>
  85. <version>${slf4j.version}</version>
  86. </dependency>
  87. <!-- log end -->
  88. <!--spring单元测试依赖 -->
  89. <dependency>
  90. <groupId>org.springframework</groupId>
  91. <artifactId>spring-test</artifactId>
  92. <version>${spring.version}</version>
  93. <scope>test</scope>
  94. </dependency>
  95. <!--rabbitmq依赖 -->
  96. <dependency>
  97. <groupId>org.springframework.amqp</groupId>
  98. <artifactId>spring-rabbit</artifactId>
  99. <version>1.3.5.RELEASE</version>
  100. </dependency>
  101. <dependency>
  102. <groupId>javax.validation</groupId>
  103. <artifactId>validation-api</artifactId>
  104. <version>1.1.0.Final</version>
  105. </dependency>
  106. <dependency>
  107. <groupId>org.hibernate</groupId>
  108. <artifactId>hibernate-validator</artifactId>
  109. <version>5.0.1.Final</version>
  110. </dependency>
  111. </dependencies>
  112. <build>
  113. <resources>
  114. <resource>
  115. <directory>src/main/resources</directory>
  116. <targetPath>${basedir}/target/classes</targetPath>
  117. <includes>
  118. <include>**/*.properties</include>
  119. <include>**/*.xml</include>
  120. </includes>
  121. <filtering>true</filtering>
  122. </resource>
  123. <resource>
  124. <directory>src/main/resources</directory>
  125. <targetPath>${basedir}/target/resources</targetPath>
  126. <includes>
  127. <include>**/*.properties</include>
  128. <include>**/*.xml</include>
  129. </includes>
  130. <filtering>true</filtering>
  131. </resource>
  132. </resources>
  133. <plugins>
  134. <plugin>
  135. <groupId>org.apache.maven.plugins</groupId>
  136. <artifactId>maven-compiler-plugin</artifactId>
  137. <configuration>
  138. <source>1.6</source>
  139. <target>1.6</target>
  140. <encoding>UTF-8</encoding>
  141. </configuration>
  142. </plugin>
  143. <plugin>
  144. <groupId>org.apache.maven.plugins</groupId>
  145. <artifactId>maven-war-plugin</artifactId>
  146. <version>2.1.1</version>
  147. <configuration>
  148. <warSourceExcludes>${warExcludes}</warSourceExcludes>
  149. </configuration>
  150. </plugin>
  151. <plugin>
  152. <groupId>org.apache.maven.plugins</groupId>
  153. <artifactId>maven-surefire-plugin</artifactId>
  154. <version>2.4.3</version>
  155. <configuration>
  156. <testFailureIgnore>true</testFailureIgnore>
  157. </configuration>
  158. </plugin>
  159. <plugin>
  160. <inherited>true</inherited>
  161. <groupId>org.apache.maven.plugins</groupId>
  162. <artifactId>maven-source-plugin</artifactId>
  163. <executions>
  164. <execution>
  165. <id>attach-sources</id>
  166. <goals>
  167. <goal>jar</goal>
  168. </goals>
  169. </execution>
  170. </executions>
  171. </plugin>
  172. <plugin>
  173. <groupId>org.apache.maven.plugins</groupId>
  174. <artifactId>maven-resources-plugin</artifactId>
  175. <configuration>
  176. <encoding>UTF-8</encoding>
  177. </configuration>
  178. </plugin>
  179. </plugins>
  180. </build>
  181. </project>

2、消息生产者

  1. package com.lin.producer;
  2. import javax.annotation.Resource;
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  5. import org.springframework.amqp.core.AmqpTemplate;
  6. import org.springframework.stereotype.Service;
  7. /**
  8. * 功能概要:消息产生,提交到队列中去
  9. *
  10. * @author linbingwen
  11. * @since  2016年1月15日
  12. */
  13. @Service
  14. public class MessageProducer {
  15. private Logger logger = LoggerFactory.getLogger(MessageProducer.class);
  16. @Resource
  17. private AmqpTemplate amqpTemplate;
  18. public void sendMessage(Object message){
  19. logger.info("to send message:{}",message);
  20. amqpTemplate.convertAndSend("queueTestKey",message);
  21. }
  22. }

3、消息消费者

  1. package com.lin.consumer;
  2. import org.slf4j.Logger;
  3. import org.slf4j.LoggerFactory;
  4. import org.springframework.amqp.core.Message;
  5. import org.springframework.amqp.core.MessageListener;
  6. /**
  7. * 功能概要:消费接收
  8. *
  9. * @author linbingwen
  10. * @since  2016年1月15日
  11. */
  12. public class MessageConsumer implements MessageListener {
  13. private Logger logger = LoggerFactory.getLogger(MessageConsumer.class);
  14. @Override
  15. public void onMessage(Message message) {
  16. logger.info("receive message:{}",message);
  17. }
  18. }

4、rabbitMq.xml配置信息

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rabbit="http://www.springframework.org/schema/rabbit"
  4. xsi:schemaLocation="http://www.springframework.org/schema/beans
  5. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  6. http://www.springframework.org/schema/beans
  7. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  8. http://www.springframework.org/schema/rabbit
  9. http://www.springframework.org/schema/rabbit/spring-rabbit-1.0.xsd">
  10. <!--配置connection-factory,指定连接rabbit server参数 -->
  11. <rabbit:connection-factory id="connectionFactory"
  12. username="asdf" password="123456" host="10.75.4.25" port="5672" />
  13. <!--定义rabbit template用于数据的接收和发送 -->
  14. <rabbit:template id="amqpTemplate"  connection-factory="connectionFactory"
  15. exchange="exchangeTest" />
  16. <!--通过指定下面的admin信息,当前producer中的exchange和queue会在rabbitmq服务器上自动生成 -->
  17. <rabbit:admin connection-factory="connectionFactory" />
  18. <!--定义queue -->
  19. <rabbit:queue name="queueTest" durable="true" auto-delete="false" exclusive="false" />
  20. <!-- 定义direct exchange,绑定queueTest -->
  21. <rabbit:direct-exchange name="exchangeTest" durable="true" auto-delete="false">
  22. <rabbit:bindings>
  23. <rabbit:binding queue="queueTest" key="queueTestKey"></rabbit:binding>
  24. </rabbit:bindings>
  25. </rabbit:direct-exchange>
  26. <!-- 消息接收者 -->
  27. <bean id="messageReceiver" class="com.lin.consumer.MessageConsumer"></bean>
  28. <!-- queue litener  观察 监听模式 当有消息到达时会通知监听在对应的队列上的监听对象-->
  29. <rabbit:listener-container connection-factory="connectionFactory">
  30. <rabbit:listener queues="queueTest" ref="messageReceiver"/>
  31. </rabbit:listener-container>
  32. </beans>

5、spring集成rabbiqMq。application.xml内容如下:

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
  4. xmlns:p="http://www.springframework.org/schema/p"
  5. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
  6. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd">
  7. <import resource="classpath*:rabbitmq.xml" />
  8. <!-- 扫描指定package下所有带有如@controller,@services,@resource,@ods并把所注释的注册为Spring Beans -->
  9. <context:component-scan base-package="com.lin.consumer,com.lin.producer" />
  10. <!-- 激活annotation功能 -->
  11. <context:annotation-config />
  12. <!-- 激活annotation功能 -->
  13. <context:spring-configured />
  14. </beans>

6、最后,为了方便,打印了日志,log4j.properties配置如下

  1. log4j.rootLogger=DEBUG,Console,Stdout
  2. #Console
  3. log4j.appender.Console=org.apache.log4j.ConsoleAppender
  4. log4j.appender.Console.layout=org.apache.log4j.PatternLayout
  5. log4j.appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n
  6. log4j.logger.java.sql.ResultSet=INFO
  7. log4j.logger.org.apache=INFO
  8. log4j.logger.java.sql.Connection=DEBUG
  9. log4j.logger.java.sql.Statement=DEBUG
  10. log4j.logger.java.sql.PreparedStatement=DEBUG
  11. log4j.appender.Stdout = org.apache.log4j.DailyRollingFileAppender
  12. log4j.appender.Stdout.File = E://logs/log.log
  13. log4j.appender.Stdout.Append = true
  14. log4j.appender.Stdout.Threshold = DEBUG
  15. log4j.appender.Stdout.layout = org.apache.log4j.PatternLayout
  16. log4j.appender.Stdout.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss}  [ %t:%r ] - [ %p ]  %m%n
 

接着运行整个工程即可:

下面是运行的结果:
 
一会发一会收:因为在同一工程,所以发消息和接消息是交替出现的
 
我们出可以去rabbitMq 服务器上看:
可以看到,我们配置的队列已存在了:
到此,整个工程结束。

工程免费下载地址:http://download.csdn.net/detail/evankaka/9412001

本文转自:http://blog.csdn.net/evankaka/article/details/50495437

170613、Spring整合RabbitMQ实例的更多相关文章

  1. RabbitMQ学习总结(7)——Spring整合RabbitMQ实例

    1.RabbitMQ简介 RabbitMQ是流行的开源消息队列系统,用erlang语言开发.RabbitMQ是AMQP(高级消息队列协议)的标准实现.  官网:http://www.rabbitmq. ...

  2. SpringMVC系列(十五)Spring MVC与Spring整合时实例被创建两次的解决方案以及Spring 的 IOC 容器和 SpringMVC 的 IOC 容器的关系

    一.Spring MVC与Spring整合时实例被创建两次的解决方案 1.问题产生的原因 Spring MVC的配置文件和Spring的配置文件里面都使用了扫描注解<context:compon ...

  3. RabbitMQ入门到进阶(Spring整合RabbitMQ&SpringBoot整合RabbitMQ)

    1.MQ简介 MQ 全称为 Message Queue,是在消息的传输过程中保存消息的容器.多用于分布式系统 之间进行通信. 2.为什么要用 MQ 1.流量消峰 没使用MQ 使用了MQ 2.应用解耦 ...

  4. spring整合RabbitMQ

    今天就来康康spring怎么整合RabbitMQ 注意一点,在发送消息的时候对template进行配置mandatory=true保证监听有效 生产端还可以配置其他属性,比如发送重试,超时时间.次数. ...

  5. rabbitMQ教程(三) spring整合rabbitMQ代码实例

    一.开启rabbitMQ服务,导入MQ jar包和gson jar包(MQ默认的是jackson,但是效率不如Gson,所以我们用gson) 二.发送端配置,在spring配置文件中配置 <?x ...

  6. rabbitMQ教程(四) spring整合rabbitMQ代码实例

    一.开启rabbitMQ服务,导入MQ jar包和gson jar包(MQ默认的是jackson,但是效率不如Gson,所以我们用gson) 二.发送端配置,在spring配置文件中配置 <?x ...

  7. activiti自己定义流程之Spring整合activiti-modeler实例(一):环境搭建

    项目中须要整合activiti-modeler自己定义流程,找了非常多资料后,最终成功的跳转到activiti-modeler流程设计界面.下面是记录: 一.整合基础:eclipse4.4.1.tom ...

  8. Spring 整合Mybatis实例

    演示样例下载地址:http://download.csdn.net/detail/geloin/4506640 本文基于Spring 注解,让Spring跑起来.本文使用Mysql数据库. (1) 导 ...

  9. activiti自己定义流程之Spring整合activiti-modeler实例(七):任务列表展示

    1.通过上一节的操作,能够知道流程启动以后会同一时候生成一个流程实例和用户任务.这个用户任务保存在act_ru_task和act_hi_task表中,从表明能够看出ru是runtime,hi是hist ...

随机推荐

  1. 释放Ubuntu/Linux系统cache,增加可用内存空间

    某台式机Ubuntu内存共3G,但free的内存只有200M,无法满足scala的jvm需求. 注意用top命令查看才能看到真正的free内存.下面是查看真正内存使用量的另一种命令. watch -n ...

  2. USB2.0学习笔记连载(二):USB基础知识简介

    USB接口分为USB A型.USB B型.USBmini型.USBmicro型.USB3.0其中每种都有相应的插座和插头. 图1 图2 上图是USBA型接口,图1为插座,图2为插头.插座指向下行方向, ...

  3. PHP高手修炼50法——勤快篇

    .把PHP当成一门新的语言学习: .看<PHP与mysql5?web?开发技术详解>和<PHP高级程序设计:模式.框架与测试>: .不要被VC.BCB.BC.MC.TC等词汇所 ...

  4. 解决只有单引号的Json格式转换成bean问题

    objectMapper.configure(Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);单引号类似Json格式:{id:124463277,code:null ...

  5. openstack热迁移和冷迁移

    转自: http://www.cnblogs.com/pycode/p/6494848.html 迁移类型: *非在线迁移 (有时也称之为‘迁移’).也就是在迁移到另外的计算节点时的这段时间虚拟机实例 ...

  6. JavaScript-事件冒泡简介及应用

    一.什么是事件冒泡 在一个对象上触发某类事件(比如单击onclick事件),如果此对象定义了此事件的处理程序,那么此事件就会调用这个处理程序,如果没有定义此事件处理程序或者事件返回true,那么这个事 ...

  7. 支付宝 报错 rsa_private read error : private key is NULL解决方法

    原因:  真机调试IOS支付宝功能GDB出现 rsa_private read error : private key is NULL提示 调试iOS 支付宝SDK的时候,执行demo.把 Partn ...

  8. CSS之少用继承,多用组合

    下面是一段普通的代码: css: .box{ border:1px solid #ccc; font-size:12px; background:#f1f1f1; padding:10px; } ht ...

  9. 在你开发完brew应用之后 ,你又如果将brew应用由编译成可以部署到brew真机上的程序包呢

    参考自:http://blog.csdn.net/feimor/article/details/6239281 一.准备工作(安装工具) 先安装Visual C++ 6.0,再安装BREW SDK v ...

  10. linq select

    var categoryIdArray = MusicCategoryRelationBLL.GetModel(music.Id); music.MusicCategoryIds = string.E ...