RabbitMQ-从基础到实战（6）— 与Spring集成

转载请注明出处

0.目录

1.简介

2.Spring AMQP

3.main方法集成

amqp-client

<dependency>
<groupId>org.springframework.amqp</groupId>
<artifactId>spring-rabbit</artifactId>
<version>1.7.1.RELEASE</version>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.2.1</version>
</dependency>

1 package com.liyang.ticktock.rabbitmq;
2
3 import org.springframework.amqp.core.BindingBuilder;
4 import org.springframework.amqp.core.Queue;
5 import org.springframework.amqp.core.TopicExchange;
6 import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
7 import org.springframework.amqp.rabbit.connection.ConnectionFactory;
8 import org.springframework.amqp.rabbit.core.RabbitAdmin;
9 import org.springframework.amqp.rabbit.core.RabbitTemplate;
10 import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
11 import org.springframework.amqp.rabbit.listener.adapter.MessageListenerAdapter;
12
13
14 public class App
15 {
16     public static void main( String[] args ) throws InterruptedException
17     {
18         //获取一个连接工厂，用户默认是guest/guest（只能使用部署在本机的RabbitMQ）
19         //是Spring实现的对com.rabbitmq.client.Connection的包装
20         ConnectionFactory cf = new CachingConnectionFactory("localhost");
21
22         //对AMQP 0-9-1的实现
23         RabbitAdmin admin = new RabbitAdmin(cf);
24         //声明一个队列
25         Queue queue = new Queue("myQueue");
26         admin.declareQueue(queue);
27         //声明一个exchange
28         TopicExchange exchange = new TopicExchange("myExchange");
29         admin.declareExchange(exchange);
30         //绑定队列到exchange，加上routingKey foo.*
31         admin.declareBinding(BindingBuilder.bind(queue).to(exchange).with("foo.*"));
32
33         //监听容器
34         SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(cf);
35         //监听者对象
36         Object listener = new Object() {
37             @SuppressWarnings("unused")
38             public void handleMessage(String foo) {
39                 System.out.println(foo);
40             }
41         };
42         //通过这个适配器代理listener
43         MessageListenerAdapter adapter = new MessageListenerAdapter(listener);
44         //把适配器（listener）设置给Container
45         container.setMessageListener(adapter);
46         //设置该容器监听的队列名，可以传多个，public void setQueueNames(String... queueName) {
47         container.setQueueNames("myQueue");
48         //开始监听
49         container.start();
50
51         //发送模版，设置上连接工厂
52         RabbitTemplate template = new RabbitTemplate(cf);
53         //发送消息
54         template.convertAndSend("myExchange", "foo.bar", "Hello, world!");
55
56         Thread.sleep(1000);
57         container.stop();
58     }
59 }

4.传统Spring方式集成

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.3.7.RELEASE</version>
</dependency>

<?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:rabbit="http://www.springframework.org/schema/rabbit"
xsi:schemaLocation="http://www.springframework.org/schema/beans  http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd http://www.springframework.org/schema/rabbit http://www.springframework.org/schema/rabbit/spring-rabbit-1.6.xsd ">

<context:annotation-config/>
<context:component-scan base-package="com.liyang.ticktock.rabbitmq.listener"/>

<!-- 配置ConnectionFactory -->
<rabbit:connection-factory id="connectionFactory"
host="127.0.0.1" username="guest" password="guest" port="5672" />

<!-- 等同new一个RabbitAdmin -->
<rabbit:admin connection-factory="connectionFactory" />

<!-- 声明一个队列 -->
<rabbit:queue name="myQueue" />

<!-- 声明一个topic类型的exchange，并把上面声明的队列绑定在上面，routingKey="foo.*" -->
<rabbit:topic-exchange name="myExchange">
<rabbit:bindings>
<rabbit:binding queue="myQueue" pattern="foo.*" />
<!-- 这里还可以继续绑定其他队列 -->
</rabbit:bindings>
</rabbit:topic-exchange>

<!-- 声明一个rabbitTemplate，指定连接信息，发送消息到myExchange上，routingKey在程序中设置，此处的配置在程序中可以用set修改 -->
<rabbit:template id="amqpTemplate" connection-factory="connectionFactory"
exchange="myExchange"/>

<!-- 配置监听容器，指定消息处理类，处理方法，还可以配置自动确认等-->
<rabbit:listener-container connection-factory="connectionFactory">
<rabbit:listener ref="myListener" method="listen" queue-names="myQueue" />
<!-- 可以继续注册监听 -->
</rabbit:listener-container>

</beans>

1 package com.liyang.ticktock.rabbitmq.listener;
2
3 import org.slf4j.Logger;
4 import org.slf4j.LoggerFactory;
5 import org.springframework.stereotype.Component;
6
7 @Component
8 public class MyListener {
9     Logger logger = LoggerFactory.getLogger(MyListener.class);
10
11     public void listen(String message){
12         logger.debug("received:"+message);
13     }
14
15 }

1 public static void main(String[] args) throws InterruptedException {
2     //启动Spring环境
3     AbstractApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
4     //假装是Autowired的
5     RabbitTemplate template = ctx.getBean(RabbitTemplate.class);
6     //设置routingKey
7     template.setRoutingKey("foo.bar");
8     //发送，exchange，routingKey什么的都配好了
9     template.convertAndSend("Hello, world!");
10
11     //关掉环境
12     Thread.sleep(1000);
13     ctx.destroy();
14 }

5.采用Spring Boot集成

6.结束语