持久化

Queue :

durable : 为true，声明 queue 是持久化的，当RabbitMQ崩溃重启后 queue 仍然存在；
exclusive：为true，声明该 queue 为排他队列，如果一个队列被声明为排他队列，该队列仅对首次声明它的连接可见，并在连接断开时自动删除该 queue，也就是当 connection 断开后，该 queue 就会被删除；
autoDelete ：为true，当所有订阅了该 queue 的 consumer 从RabbitMQ断开后就会删除该queue，或者是当 connection 断开后，该 queue 就会被删除，与 exclusive 不同的是，如果一开始就没有 consumer 连接到该 queue，那么该 queue 将不会被删除；

durable属性和auto-delete属性可以同时生效；
durable属性和exclusive属性会有性质上的冲突，两者同时设置时，仅exclusive属性生效；
auto_delete属性和exclusive属性可以同时生效；
参考： https://yq.aliyun.com/articles/42205

集群部署

https://www.cnblogs.com/vipstone/p/9362388.html

Qos prefetch

prefetch并不是说设置得越大越好。过大可能导致consumer处理不过来，一直在本地缓存的BlockingQueue里呆太久，这样消息在客户端的延迟就大大增加；而对于多个consumer的情况，则会分配不均匀，导致有些consumer一直在忙，有些则非常空闲。
然而设置的过小，又会令到consumer不能充分工作，因为我们总想它100％的时间都是处于繁忙状态，而这时可能会在处理完一条消息后，BlockingQueue为空，因为新的消息还未来得及到达，所以consumer就处于空闲状态了。

 <!-- queue litener 观察 监听模式 当有消息到达时会通知监听在对应的队列上的监听对象
        concurrency="2" 消费者数量
        max-concurrency= 10 并发量，每个消费者每次消费的并发量
        prefetch="3"  spring-amqp中的prefetch默认值是1  每个消费者每次缓存的消息数 消费时从这个本地缓存中取出一个个消费
     -->
    <rabbit:listener-container connection-factory="cofirm_connectionFactory" acknowledge="manual" concurrency="1" prefetch="3">
        <!-- queues：监听的队列，多个的话用逗号（,）分隔 ref：监听器 -->
        <!--rabbit:listener  exclusive="true" 每个消费者对应的listener有个Exclusive参数，默认为false, 如果设置为true，concurrency就必须设置为1，即只能单个消费者消费队列里的消息，适用于必须严格执行消息队列的消费顺序（先进先出） -->
        <rabbit:listener queues="confirm_queue" exclusive="true" ref="manualMessageReceiver"/>

        <!--<rabbit:listener queues="confirm_queue" ref="manualMessageReceiver2"/>-->
    </rabbit:listener-container>
    <!--
    prefetch="10"  消息预取数目为每次接收10条。

    可以指定noAck参数，当noAck=false时，RabbitMQ会等待消费者显式发回ack信号后才从内存（或磁盘，如果是持久化消息的话）中移去消息。否则，RabbitMQ会在队列中消息被消费后立即删除它
    false表示consumer在成功消费过后必须要手动回复一下服务器，如果不回复，服务器就将认为此条消息消费失败，继续分发给其他consumer
    acknowledge="manual":意为表示该消费者的ack方式为手动 ；acknowledge="auto"表示自动。
    -->

    <!-- queue litener 观察 监听模式 当有消息到达时会通知监听在对应的队列上的监听对象
        concurrency="2" 消费者数量
        max-concurrency= 10 并发量，每个消费者每次消费的并发量
        prefetch="3"  spring-amqp中的prefetch默认值是1  每个消费者每次缓存的消息数 消费时从这个本地缓存中取出一个个消费
     -->
    <rabbit:listener-container connection-factory="cofirm_connectionFactory" acknowledge="manual" concurrency="2" prefetch="3">
        <!-- queues：监听的队列，多个的话用逗号（,）分隔 ref：监听器 -->
        <!--rabbit:listener  exclusive="true" 每个消费者对应的listener有个Exclusive参数，默认为false, 如果设置为true，concurrency就必须设置为1，即只能单个消费者消费队列里的消息，适用于必须严格执行消息队列的消费顺序（先进先出） -->
        <rabbit:listener queues="confirm_queue" ref="manualMessageReceiver2"/>
    </rabbit:listener-container>

RabbitMQ之Qos prefetch
RabbitMq qos prefetch 消息堵塞问题
 RabbitMQ消费者的几个参数concurrency prefetch Exclusive

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

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">

    <!--配置connection-factory，指定连接rabbit server参数 -->
    <rabbit:connection-factory id="connectionFactory" host="192.168.1.7" port="5672"
           username="admin" password="admin" virtual-host="admin" />

    <!--
    publisher-confirms="true" 开启发送确认机制
    publisher-returns="true" 开启结果返回机制
    channel-cache-size="5" 缓存中要维护的通道数
    -->




    <!--通过指定下面的admin信息，当前producer中的exchange和queue会在rabbitmq服务器上自动生成
    rabbit-admin 标签如不声明,则 rabbit:queue 与 rabbit:direct-exchange 标签中必须添加 auto-declare 属性为true ,
    表示如果队列或路由不存在则自动声明，如不声明rabbit-admin，也不添加auto-declare属性则启动时会报声明队列错误，或队列不存在。

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




    <!--定义queue
    durable 持久化 重启是否重建队列、交换器

    auto-delete 最后一个消费者取消订阅，队列自动删除
    exclusive 默认true  私有队列，限制队列只有一个消费者  一般两者结合使用    临时排他匿名的队列

    auto-declare="true"
    -->
    <rabbit:queue name="queueTest" durable="true" auto-delete="false" exclusive="false" declared-by="connectAdmin" />

    <!-- fanout exchange 广播模式
     所有跟交换机绑定的队列都会收到消息  忽略route_key
     -->
    <!--<rabbit:fanout-exchange name="fanoutExchangeTest">
        <rabbit:bindings>
            <rabbit:binding queue="queueTest" ></rabbit:binding>
        </rabbit:bindings>
    </rabbit:fanout-exchange>-->

    <!-- 定义direct exchange 路由模式
     路由模式通过指定key来确认消息路由到那个队列
     -->
    <rabbit:direct-exchange name="exchangeTest" durable="true" auto-delete="false" declared-by="connectAdmin">
        <rabbit:bindings>
            <rabbit:binding queue="queueTest" key="queueTestKey"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:direct-exchange>

    <!--定义rabbit template用于数据的接收和发送
     rabbit:template 标签中的routing-key、exchange也可以不在XML中配置，在类中发送消息时可以作为参数代入。则XML中只需要配置一个rabbit:template标签即可
     -->
    <rabbit:template id="amqpTemplate" connection-factory="connectionFactory" exchange="exchangeTest" />
    <!--
    routing-key="queueTestKey"
    encoding="UTF-8"
    message-converter="jsonMessageConverter"

        当mandatory标志位设置为true时，如果exchange根据自身类型和消息routeKey无法找到一个符合条件的queue，
        那么会调用basic.return方法将消息返回给生产者（Basic.Return + Content-Header + Content-Body）；
        当mandatory设置为false时，出现上述情形broker会直接将消息扔掉。  return 在前  confirm在后
    mandatory="true"

        当immediate标志位设置为true时，如果exchange在将消息路由到queue(s)时发现对于的queue上没有消费者，那么这条消息不会放入队列中。
        当与消息routeKey关联的所有queue（一个或者多个）都没有消费者时，该消息会通过basic.return方法返还给生产者。
        注意：在RabbitMQ3.0以后的版本里，去掉了immediate参数的支持，发送带immediate=true标记的publish会返回错误
        immediate标记会影响镜像队列性能，增加代码复杂性，并建议采用“TTL”和“DLX”等方式替代。
    immediate="true"

    return-callback="MyReturnCallback"
    confirm-callback="confirmcallback"

    -->

    <!-- 消息对象json转换类 -->
    <!--<bean id="jsonMessageConverter" class="org.springframework.amqp.support.converter.Jackson2JsonMessageConverter" />-->





    <!-- 消息接收者 -->
    <bean id="messageReceiver" class="me.shijunjie.consumer.MessageConsumer"></bean>

    <!-- queue litener 观察 监听模式 当有消息到达时会通知监听在对应的队列上的监听对象
        prefetch="1" 为每次获取一个请求
        receive-timeout="2000" 消费者接收消息超时时长，receive-timeout 单位为毫秒
     -->
    <rabbit:listener-container connection-factory="connectionFactory"  acknowledge="auto" >
        <rabbit:listener queues="queueTest" ref="messageReceiver" />
    </rabbit:listener-container>
    <!--
    prefetch="10"  消息预取数目为每次接收10条。

    可以指定noAck参数，当noAck=false时，RabbitMQ会等待消费者显式发回ack信号后才从内存（或磁盘，如果是持久化消息的话）中移去消息。否则，RabbitMQ会在队列中消息被消费后立即删除它
    false表示consumer在成功消费过后必须要手动回复一下服务器，如果不回复，服务器就将认为此条消息消费失败，继续分发给其他consumer
    acknowledge="manual":意为表示该消费者的ack方式为手动 ；acknowledge="auto"表示自动。
    -->


















    <!--定义queue -->
    <rabbit:queue name="queueChris" durable="true"
        auto-delete="false" exclusive="false" declared-by="connectAdmin" />

    <!-- 定义direct exchange，绑定queueTest -->
    <rabbit:direct-exchange name="exchangeTest"
        durable="true" auto-delete="false" declared-by="connectAdmin">
        <rabbit:bindings>
            <rabbit:binding queue="queueChris" key="queueTestChris"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:direct-exchange>

    <!-- 消息接收者 -->
    <bean id="receiverChris" class="me.shijunjie.consumer.ChrisConsumer"></bean>

    <!-- queue litener 观察 监听模式 当有消息到达时会通知监听在对应的队列上的监听对象 -->
    <rabbit:listener-container
        connection-factory="connectionFactory">
        <rabbit:listener queues="queueChris" ref="receiverChris" />
    </rabbit:listener-container>










    <!-- 分隔线 -->
    <!--配置connection-factory，指定连接rabbit server参数 -->
    <rabbit:connection-factory id="connectionFactory2" virtual-host="admin"
        username="admin" password="admin" host="192.168.1.7" port="5672" />

    <!--通过指定下面的admin信息，当前producer中的exchange和queue会在rabbitmq服务器上自动生成 -->
    <rabbit:admin id="connectAdmin2" connection-factory="connectionFactory2" />

    <!--定义queue -->
    <rabbit:queue name="queueShijj" durable="true"
        auto-delete="false" exclusive="false" declared-by="connectAdmin2" />

    <!-- 定义topic-exchange  通配符模式

     将路由键和某模式进行匹配  # 匹配一个或多个词  * 只匹配一个词
     -->
    <rabbit:topic-exchange name="exchangeTest2"
        durable="true" auto-delete="false" declared-by="connectAdmin2">
        <rabbit:bindings>
            <rabbit:binding queue="queueShijj" pattern="shijj.#"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:topic-exchange>

    <!--定义rabbit template用于数据的接收和发送 -->
    <rabbit:template id="amqpTemplate2" connection-factory="connectionFactory2"
        exchange="exchangeTest2" />

    <!-- 消息接收者 -->
    <bean id="recieverShijj" class="me.shijunjie.consumer.ShijjConsumer"></bean>

    <!-- queue litener 观察 监听模式 当有消息到达时会通知监听在对应的队列上的监听对象 -->
    <rabbit:listener-container
        connection-factory="connectionFactory2">
        <rabbit:listener queues="queueShijj" ref="recieverShijj" />
    </rabbit:listener-container>
</beans>

https://blog.csdn.net/chang_ge/article/details/82976820
https://blog.csdn.net/qq_37936542/article/details/80111555
https://blog.csdn.net/LeiXiaoTao_Java/article/details/78952930

有专栏 Headers交换类型（java）
Java使用RabbitMQ要点知识

延时消息

 delayMsgTemplate.convertAndSend( message, new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                //为每个消息设置expiration，此时消息之间过期时间不同。
                // 如果两者都设置(x-message-ttl)，过期时间取两者最小。 ms单位   1000ms = 1s
                message.getMessageProperties().setExpiration(String.valueOf(60000));
                return message;
            }
        });


或

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

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">

    <!--配置connection-factory，指定连接rabbit server参数 -->
    <rabbit:connection-factory id="connectionFactory" host="192.168.1.7" port="5672"
           username="admin" password="admin" virtual-host="admin" />


    <!--<rabbit:connection-factory id="connectionFactory" host="192.168.1.7" port="5672"
                               username="guest" password="guest" virtual-host="/"/>-->
    <!--
    publisher-confirms="true" 开启发送确认机制
    publisher-returns="true" 开启结果返回机制
    channel-cache-size="5" 缓存中要维护的通道数
    -->

    <!--通过指定下面的admin信息，当前producer中的exchange和queue会在rabbitmq服务器上自动生成
    rabbit-admin 标签如不声明,则 rabbit:queue 与 rabbit:direct-exchange 标签中必须添加 auto-declare 属性为true ,
    表示如果队列或路由不存在则自动声明，如不声明rabbit-admin，也不添加auto-declare属性则启动时会报声明队列错误，或队列不存在。

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


    <!-- 延时队列交换机 -->
    <rabbit:direct-exchange id="exchange_delay_buffer" name="exchange_delay_buffer"
                            durable="false" auto-delete="false" declared-by="connectAdmin">
        <rabbit:bindings>
            <rabbit:binding queue="queue_delay_buffer" key="delay"/>
        </rabbit:bindings>
    </rabbit:direct-exchange>
    <!-- 延时队列 -->
    <rabbit:queue name="queue_delay_buffer" durable="false" declared-by="connectAdmin" >
        <rabbit:queue-arguments>
            <!--  队列过期时间  整个队列具有统一过期时间  ms单位   1000ms = 1s -->
            <entry key="x-message-ttl" value="60000" value-type="java.lang.Long" />

            <!--为每个消息设置expiration，此时消息之间过期时间不同   注意：如果两者都设置，过期时间取两者最小。    -->
            <!--<entry key="x-expires" 这个在代码中设置为每条消息 value="30000"  />-->

            <entry key="x-dead-letter-exchange" value="exchange_delay_process"/>
            <entry key="x-dead-letter-routing-key" value="delay"/>

        </rabbit:queue-arguments>
    </rabbit:queue>

    <!-- 死信队列交换机  延时消息到期后通过此交换机发送消息 -->
    <rabbit:direct-exchange id="exchange_delay_process" name="exchange_delay_process" durable="false"
                            auto-delete="false" declared-by="connectAdmin" >
        <rabbit:bindings>
            <rabbit:binding queue="queue_delay_process" key="delay"/>
            <!--  binding key 相同为 【delay】exchange转发消息到多个队列 -->
            <!--<rabbit:binding queue="queue_delay_done_two" key="delay" />-->
        </rabbit:bindings>
    </rabbit:direct-exchange>
    <!-- 死信队列 -->
    <rabbit:queue name="queue_delay_process" durable="false" declared-by="connectAdmin" />

    <rabbit:template id="delayMsgTemplate" connection-factory="connectionFactory" exchange="exchange_delay_buffer"/>

    <bean id="delayMessageConsumer" class="me.shijunjie.consumer.DelayMessageConsumer"></bean>

    <!-- 消息接收者 -->
    <rabbit:listener-container connection-factory="connectionFactory" channel-transacted="false">
        <rabbit:listener queues="queue_delay_process" ref="delayMessageConsumer"/>
    </rabbit:listener-container>




</beans>

RabbitMQ 延时消息队列 spring实现
 使用RabbitMQ实现延迟任务

springboot和rabbitmq整合实现普通任务和延时任务

confirm

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

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">

    <!--配置connection-factory，指定连接rabbit server参数 -->
    <rabbit:connection-factory id="cofirm_connectionFactory" host="192.168.1.7" port="5672"
                               username="admin" password="admin" virtual-host="admin"
                               publisher-confirms="true"
                               publisher-returns="true"
                               channel-cache-size="25" cache-mode="CHANNEL"
    />

    <!--
    publisher-confirms="true" 开启发送确认机制
    publisher-returns="true" 开启结果返回机制
    channel-cache-size="5" 缓存中要维护的通道数
    -->
    <!--
    https://blog.csdn.net/LeiXiaoTao_Java/article/details/78924863
    -->

    <!--通过指定下面的admin信息，当前producer中的exchange和queue会在rabbitmq服务器上自动生成
    rabbit-admin 标签如不声明,则 rabbit:queue 与 rabbit:direct-exchange 标签中必须添加 auto-declare 属性为true ,
    表示如果队列或路由不存在则自动声明，如不声明rabbit-admin，也不添加auto-declare属性则启动时会报声明队列错误，或队列不存在。

    -->
    <rabbit:admin id="connectAdmin" connection-factory="cofirm_connectionFactory"/>




    <!--
        <bean id="retryTemplate" class="org.springframework.retry.support.RetryTemplate">
           <property name="backOffPolicy">
               <bean class="org.springframework.retry.backoff.ExponentialBackOffPolicy">
                   <property name="initialInterval" value="200" />
                   <property name="maxInterval" value="30000" />
               </bean>
           </property>
           <property name="retryPolicy">
               <bean class="org.springframework.retry.policy.SimpleRetryPolicy">
                   <property name="maxAttempts" value="5"/>
               </bean>
           </property>
        </bean>
    -->

    <!--定义rabbit template用于数据的接收和发送
     rabbit:template 标签中的routing-key、exchange也可以不在XML中配置，在类中发送消息时可以作为参数代入。则XML中只需要配置一个rabbit:template标签即可
     -->
    <rabbit:template id="confirm_amqp_template" connection-factory="cofirm_connectionFactory"
                     exchange="confirm_exchange"
                     routing-key="confirm_key"
                     encoding="UTF-8"
                     mandatory="true"
                     return-callback="sendReturnCallback"
                     confirm-callback="confirmCallback"


    />

    <!--
    routing-key="queueTestKey"
    encoding="UTF-8"
    message-converter="jsonMessageConverter"
    retry-template="retryTemplate"

        当mandatory标志位设置为true时，如果exchange根据自身类型和消息routeKey无法找到一个符合条件的queue，
        那么会调用basic.return方法将消息返回给生产者（Basic.Return + Content-Header + Content-Body）；
        当mandatory设置为false时，出现上述情形broker会直接将消息扔掉。  return 在前  confirm在后
    mandatory="true"

        当immediate标志位设置为true时，如果exchange在将消息路由到queue(s)时发现对于的queue上没有消费者，那么这条消息不会放入队列中。
        当与消息routeKey关联的所有queue（一个或者多个）都没有消费者时，该消息会通过basic.return方法返还给生产者。
        注意：在RabbitMQ3.0以后的版本里，去掉了immediate参数的支持，发送带immediate=true标记的publish会返回错误
        immediate标记会影响镜像队列性能，增加代码复杂性，并建议采用“TTL”和“DLX”等方式替代。
    immediate="true"

    return-callback="MyReturnCallback"
    confirm-callback="confirmcallback"

    -->

    <bean id="sendReturnCallback" class="me.shijunjie.producer.SendmsgReturnCallback"/>
    <bean id="confirmCallback" class="me.shijunjie.producer.SendmsgConfirmCallback"/>
    <!-- 消息对象json转换类 -->
    <!--<bean id="jsonMessageConverter" class="org.springframework.amqp.support.converter.Jackson2JsonMessageConverter"/>-->



    <!--定义queue
    durable 持久化 重启是否重建队列、交换器

    auto-delete 最后一个消费者取消订阅，队列自动删除
    exclusive 默认true  私有队列，限制队列只有一个消费者  一般两者结合使用

    auto-declare="true"
    -->
    <rabbit:queue name="confirm_queue" durable="true" auto-delete="false" exclusive="false" declared-by="connectAdmin"/>

    <!-- fanout exchange 广播模式
     所有跟交换机绑定的队列都会收到消息  忽略route_key
     -->
    <!--<rabbit:fanout-exchange name="fanoutExchangeTest">
        <rabbit:bindings>
            <rabbit:binding queue="queueTest" ></rabbit:binding>
        </rabbit:bindings>
    </rabbit:fanout-exchange>-->

    <!-- 定义direct exchange 路由模式
     路由模式通过指定key来确认消息路由到那个队列
     -->
    <rabbit:direct-exchange name="confirm_exchange" durable="true" auto-delete="false" declared-by="connectAdmin">
        <rabbit:bindings>
            <rabbit:binding queue="confirm_queue" key="confirm_key"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:direct-exchange>

<!--
    &lt;!&ndash; 消息接收者 &ndash;&gt;
    <bean id="autoMessageReceiver" class="me.shijunjie.consumer.MessageConsumer"></bean>
    &lt;!&ndash; queue litener 观察 监听模式 当有消息到达时会通知监听在对应的队列上的监听对象&ndash;&gt;
    <rabbit:listener-container connection-factory="cofirm_connectionFactory" acknowledge="auto">
        &lt;!&ndash; queues：监听的队列，多个的话用逗号（,）分隔 ref：监听器 &ndash;&gt;
        <rabbit:listener queues="confirm_queue" ref="autoMessageReceiver"/>
    </rabbit:listener-container>-->



    <!-- 手动确认的消息接收者 -->
    <bean id="manualMessageReceiver" class="me.shijunjie.consumer.ManualMessageConsumer"></bean>
    <!-- queue litener 观察 监听模式 当有消息到达时会通知监听在对应的队列上的监听对象
     -->
    <rabbit:listener-container connection-factory="cofirm_connectionFactory" acknowledge="manual">
        <!-- queues：监听的队列，多个的话用逗号（,）分隔 ref：监听器 -->
        <rabbit:listener queues="confirm_queue" ref="manualMessageReceiver"/>
    </rabbit:listener-container>
    <!--
    prefetch="10"  消息预取数目为每次接收10条。

    可以指定noAck参数，当noAck=false时，RabbitMQ会等待消费者显式发回ack信号后才从内存（或磁盘，如果是持久化消息的话）中移去消息。否则，RabbitMQ会在队列中消息被消费后立即删除它
    false表示consumer在成功消费过后必须要手动回复一下服务器，如果不回复，服务器就将认为此条消息消费失败，继续分发给其他consumer
    acknowledge="manual":意为表示该消费者的ack方式为手动 ；acknowledge="auto"表示自动。
    -->


</beans>

rpc

说明：
　　消息头里有个字段reply_to 消息的生产者可通过该字段来指定队列名称并阻塞监听此队列等待应答，一般这个队列叫做回调队列，然后接收消息的rpc的服务器能够检查reply_to字段，并创建包含应答内容的新消息并以此队列名称做为路由键。虽然没有指定交换器，但rabbitmq已经知道目地的是应答（回调）队列。
　　存放返回结果的队列叫做回调队列，客户端发送消息之后阻塞监听该队列返回的消息。我们可以使用随机队列命名，也可以指定队列的名称，同时，我们可以一个消息建立一个随机队列，但是通常考虑资源使用的情况，我们一般一个消费者建立一个指定的回调队列。
　　声明没有名字的队列时，rabbitmq会随机指定一个唯一的队列名，同时声明队列时指定exclusive参数，确保只有你可以队列的消息，这就声明了一个临时（auto-delete）、匿名、排他（exclusive）的队列，并将队列名称设置到消息的reply_to头中

springboot集成rabbitmq实战RPC远程调用，同步返回结果

spring-boot & spring 实现 rabbitMq rpc模式的消息发送与接收
 spring集成rabbitmq实现rpc
RabbitMQ学习笔记九：RabbitMQ实现RPC（远程过程调用）
springBoot+ RabbitMQ(同步RPC,异步RPC)
中间件系列八 RabbitMQ之实现RPC模式
 spring对rabbitmq RPC的支持

https://blog.csdn.net/chenxyt/article/details/79347602
远程过程调用(RPC)

springmvc 集成rabbitmq，实现RPC通信方式

Spring-rabbitmq 实现RPC 风格调用实例

RabbitMQ中RPC的实现及其通信机制