随便谈谈RabbitMQ与springBoot进行集成。

先说说题外话，本来只想找到一个springBoot快速集成RabbitMQ的例子，用起来就行的。但是百度搜了一大通， 各有各的玩法，但是就是没找到一个自己心仪的方式。最终发现，稍微看看springBoot的jar包，顿时觉得清晰好多。

顺便说明一下，这个文章全是我自己总结的，目前是不同于网络上各种转载文的。旨在给有兴趣的朋友共同分享。

关于RabbitMQ就不做介绍了。几种消息传递模式官网自有介绍。这里只关注两个点：
1、如何主动发送及消费消息。
2、如何注册监听自动消费发过来的消息。

首先针对第一个问题：
springBoot已经有了集成rabbitMQ 的 starter

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
 </dependency> 

加入这个引用后，就可以在springBoot的配置文件中直接配置rabbitMQ的属性，(以spring.rabbitmq开头)然后在自己的方法中可以注入 RabbitTemplate ，用这个template进行发消息 以及 收消息 的操作 。可以设置exchange ,routekey，queue什么的，然后一大堆的send receive方法可以调用。
是不是觉得有点太简单了？这用法比百度搜到的大部分示例都简单，甚至都不用上示例代码。那下面就一起来看看是怎么回事呗。

可以看到 引入了maven依赖后，springBoot的自动配置模块就已经引入进来了，正是在这里面封装了springBoot对RabbitMQ的配置。在spring-boot-autoconfigure模块中有RabbitMQ 的自定义配置加载类

这个类在META-INF下的spring.factories文件中已经配置成了在springBoot启动时就会自动进行配置。这是springBoot的自动配置机制。

然后在这个配置类的代码头部可以看到配置的要求

同时，这个配置类往spring容器里注入了几个Bean。

其中，这个RabbitTemplate就是可以用来操作RabbitMQ的一个重要的工具类。
这样，在自己的代码中，就可以直接用@Resource或者@Autowire引用这个类来发送及接受消息了。

而RabbitProperties就是rabbit的相关配置的处理类。

所以，只要在application.properties里配置spring.rabbitmq开头的几个属性，就会自动配置到这些类里。
至于spring.rabbitmq下可选的配置属性， 在spring-boot-autoconfigure包下的/META-INF/spring-configuration-metadata.json 文件中有详细的定义。用IDEA就会自动弹出所有可选的配置项。eclipse貌似不行。–其实这些注释都是通过RabbitProperties来注入的，看看这个类的属性也能知道要配些什么东西。

分析到这里，通过SpringBoot主动发送和接受消息的引入方式就已经知道了。

然后针对第二个问题：
继续看看怎么用springBoot的方式注册监听，自动消费发过来的消息。
还是在那个 自动注册类 RabbitAutoConfiguration里，可以看到头部还引用了一个配置类 RabbitAnnotationDrivenConfiguration 从名字就看出这是Rabbit的注释驱动配置类，一看就是springBoot的风格。还是看头部的声明

这个配置需要有EnableRabbit注释才会启动配置。然后，看看这个EnableRabbit 注释前面的注释内容就很一目了然了

---

org.springframework.amqp.rabbit.annotation.EnableRabbit

Enable Rabbit listener annotated endpoints that are created under the
cover by a RabbitListenerContainerFactory. To be used on
Configuration classes as follows: @Configuration @EnableRabbit
public class AppConfig {
@Bean
public SimpleRabbitListenerContainerFactory myRabbitListenerContainerFactory() {
SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
factory.setConnectionFactory(connectionFactory());
factory.setMaxConcurrentConsumers(5);
return factory;
}
// other @Bean definitions } The RabbitListenerContainerFactory is responsible to create the listener container responsible for a
particular endpoint. Typical implementations, as the
SimpleRabbitListenerContainerFactory used in the sample above,
provides the necessary configuration options that are supported by
the underlying MessageListenerContainer.

@EnableRabbit enables detection of RabbitListener annotations on any
Spring-managed bean in the container. For example, given a class
MyService: package com.acme.foo;

public class MyService {
@RabbitListener(containerFactory=”myRabbitListenerContainerFactory”,
queues=”myQueue”)
public void process(String msg) {
// process incoming message
} } The container factory to use is identified by the containerFactory attribute defining the name of the
RabbitListenerContainerFactory bean to use. When none is set a
RabbitListenerContainerFactory bean with name
rabbitListenerContainerFactory is assumed to be present. the
following configuration would ensure that every time a
org.springframework.amqp.core.Message is received on the
org.springframework.amqp.core.Queue named “myQueue”,
MyService.process() is called with the content of the message:
@Configuration @EnableRabbit public class AppConfig {
@Bean
public MyService myService() {
return new MyService();
}

 // Rabbit infrastructure setup  } Alternatively, if MyService were annotated with  @Component, the following configuration would

ensure that its @RabbitListener annotated method is invoked with a
matching incoming message: @Configuration @EnableRabbit
@ComponentScan(basePackages=”com.acme.foo”) public class AppConfig {
} Note that the created containers are not registered against the
application context but can be easily located for management purposes
using the RabbitListenerEndpointRegistry.

Annotated methods can use flexible signature; in particular, it is
possible to use the Message abstraction and related annotations, see
RabbitListener Javadoc for more details. For instance, the following
would inject the content of the message and a a custom “myCounter”
AMQP header: @RabbitListener(containerFactory =
“myRabbitListenerContainerFactory”, queues = “myQueue”) public void
process(String msg, @Header(“myCounter”) int counter) {
// process incoming message } These features are abstracted by the MessageHandlerMethodFactory that is responsible to build the
necessary invoker to process the annotated method. By default,
DefaultMessageHandlerMethodFactory is used. When more control is
desired, a @Configuration class may implement
RabbitListenerConfigurer. This allows access to the underlying
RabbitListenerEndpointRegistrar instance. The following example
demonstrates how to specify an explicit default
RabbitListenerContainerFactory @Configuration
@EnableRabbit public class AppConfig implements
RabbitListenerConfigurer {
@Override
public void configureRabbitListeners(RabbitListenerEndpointRegistrar registrar) {
registrar.setContainerFactory(myRabbitListenerContainerFactory());
}

 @Bean
 public RabbitListenerContainerFactory myRabbitListenerContainerFactory() {
     // factory settings
 }

 @Bean
 public MyService myService() {
     return new MyService();
 }  }  } For reference, the example above can be compared to the following Spring  XML configuration:   <beans>
 <rabbit:annotation-driven container-factory="myRabbitListenerContainerFactory"/>

 <bean id="myRabbitListenerContainerFactory"
       class="org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory">
       // factory settings
 </bean>

 <bean id="myService" class="com.acme.foo.MyService"/>  </beans> It is also possible to specify a custom RabbitListenerEndpointRegistry

in case you need more control on the way the containers are created
and managed. The example below also demonstrates how to customize the
RabbitHandlerMethodFactory to use with a custom Validator so that
payloads annotated with Validated are first validated against a
custom Validator. @Configuration @EnableRabbit public
class AppConfig implements RabbitListenerConfigurer {
@Override
public void configureRabbitListeners(RabbitListenerEndpointRegistrar registrar) {
registrar.setEndpointRegistry(myRabbitListenerEndpointRegistry());
registrar.setMessageHandlerMethodFactory(myMessageHandlerMethodFactory);
}

 @Bean
 public RabbitListenerEndpointRegistry myRabbitListenerEndpointRegistry() {
     // registry configuration
 }

 @Bean
 public RabbitHandlerMethodFactory myMessageHandlerMethodFactory() {
    DefaultRabbitHandlerMethodFactory factory = new DefaultRabbitHandlerMethodFactory();
    factory.setValidator(new MyValidator());
    return factory;
 }

 @Bean
 public MyService myService() {
     return new MyService();
 }  }  } For reference, the example above can be compared to the following Spring  XML configuration:   <beans>
 <rabbit:annotation-driven registry="myRabbitListenerEndpointRegistry"
     handler-method-factory="myRabbitHandlerMethodFactory"/&gt;

 <bean id="myRabbitListenerEndpointRegistry"
       class="org.springframework.amqp.rabbit.config.RabbitListenerEndpointRegistry">
       // registry configuration
 </bean>

 <bean id="myRabbitHandlerMethodFactory"
       class="org.springframework.amqp.rabbit.config.DefaultRabbitHandlerMethodFactory">
     <property name="validator" ref="myValidator"/>
 </bean>

 <bean id="myService" class="com.acme.foo.MyService"/>  </beans> Implementing RabbitListenerConfigurer  also allows for fine-grained

control over endpoints registration via the
RabbitListenerEndpointRegistrar. For example, the following
configures an extra endpoint: @Configuration @EnableRabbit public
class AppConfig implements RabbitListenerConfigurer {
@Override
public void configureRabbitListeners(RabbitListenerEndpointRegistrar registrar) {
SimpleRabbitListenerEndpoint myEndpoint = new SimpleRabbitListenerEndpoint();
// … configure the endpoint
registrar.registerEndpoint(endpoint, anotherRabbitListenerContainerFactory());
}

 @Bean
 public MyService myService() {
     return new MyService();
 }

 @Bean
 public RabbitListenerContainerFactory anotherRabbitListenerContainerFactory() {
     // ...
 }

 // Rabbit infrastructure setup  }  } Note that all beans implementing RabbitListenerConfigurer  will be detected and invoked in

a similar fashion. The example above can be translated in a regular
bean definition registered in the context in case you use the XML
configuration.

Since:
1.4 Author: Stephane Nicoll See Also: RabbitListener RabbitListenerAnnotationBeanPostProcessor
org.springframework.amqp.rabbit.listener.RabbitListenerEndpointRegistrar
org.springframework.amqp.rabbit.listener.RabbitListenerEndpointRegistry

---

里面很多详细的配置，可以逐步的设置默认的处理流程。有兴趣可以再继续深入跟踪下去。
(网上看到有一个教程，说对ConnectionFactory，因为没有默认设置来支持消息回调 connectionFactory.setPublisherConfirms(true);
而大费周章，摈弃springBoot的自动配置，自己从头注入。虽然没有动手试过，但是看着些说明，springBoot都是有很优雅的方式支持设置的。)

所以最后，针对第二个问题，结果也就出来了。
最简单的用法就是按注释里说的分三步
先定义一个SimpleRabbitListenerContainerFactory

 @Configuration
 @EnableRabbit
 public class AppConfig {
     @Bean
     public SimpleRabbitListenerContainerFactory myRabbitListenerContainerFactory() {
       SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
       factory.setConnectionFactory(connectionFactory());
       factory.setMaxConcurrentConsumers(5);
       return factory;
     }
     // other @Bean definitions
 }

然后就可以定义自己的service监听这个连接发过来的消息了。

 package com.acme.foo;

 public class MyService {
     @RabbitListener(containerFactory="myRabbitListenerContainerFactory", queues="myQueue")
     public void process(String msg) {
         // process incoming message
     }
 }

然后把这个MyService注入到spring容器里

@Configuration
 @EnableRabbit
 public class AppConfig {
     @Bean
     public MyService myService() {
         return new MyService();
     }

     // Rabbit infrastructure setup
 }