先說說題外話，本來只想找到一個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
 }