rabbitmq springboot 配置篇

属性文件：org.springframework.boot.autoconfigure.amqp.RabbitProperties

 

★Config:
# base
spring.rabbitmq.host: 服务Host
spring.rabbitmq.port: 服务端口
spring.rabbitmq.username: 用户名
spring.rabbitmq.password: 密码
spring.rabbitmq.virtual-host:  RabbitMQ的虚拟主机
spring.rabbitmq.addresses: 指定client连接到的server的地址，多个以逗号分隔(优先取addresses，然后再取host)
spring.rabbitmq.requested-heartbeat: 指定心跳超时，单位秒，0为不指定；默认60s
spring.rabbitmq.publisher-confirms:  开启Publisher Confirm机制
spring.rabbitmq.publisher-returns: 开启publisher Return机制
spring.rabbitmq.connection-timeout: 连接超时，单位毫秒，0表示无穷大，不超时
spring.rabbitmq.parsed-addresses:

# ssl
spring.rabbitmq.ssl.enabled: 是否支持ssl
spring.rabbitmq.ssl.key-store: 指定持有SSL certificate的key store的路径
spring.rabbitmq.ssl.key-store-password: 指定访问key store的密码
spring.rabbitmq.ssl.trust-store: 指定持有SSL certificates的Trust store
spring.rabbitmq.ssl.trust-store-password: 指定访问trust store的密码
spring.rabbitmq.ssl.algorithm: ssl使用的算法，例如，TLSv1.1

# cache
spring.rabbitmq.cache.channel.size: 缓存中保持的channel数量

spring.rabbitmq.cache.channel.checkout-timeout: 当缓存数量被设置时，从缓存中获取一个channel的超时时间，单位毫秒；如果为0，则总是创建一个新channel

channel不是线程安全的，线程并发的去访问同一个channel会出问题。这里有几种处理方式：

1 全局公用一个channel且使用全局锁,让操作channel排队.这种明显性能是不行的；
2 一个线程对应创建一个新的channel，但是要处理好一个连接能支撑的最大channel数量；
3 一个线程对应一个channel,但是是从channel池子拿的,不是每次都创建新的.一旦一个线程完成了一个channel的使用，它将返回到池中，从而使该channel可用于另一个线程。

量不大的话,使用第二种方式就可以了。量大的话，建议使用第三种方式，毕竟创建和销毁channel也是耗时耗资源的.在spring amqp中，提供了一个缓存channel的方案。可以在创建CachingConnectionFactory时指定缓存的模式。

connectionFactory.setCacheMode(CachingConnectionFactory.CacheMode.CHANNEL);
connectionFactory.setChannelCacheSize(25);

上面的两行代码,表示channel共用唯一的一个连接,且缓存了25个channel,注意这里的25个并不是说，这个连接里只能最多创建25个channel,而是说最多缓存25个channel。
举个例子，假设并发发送100条消息，在CachingConnectionFactory.CacheMode.CHANNEL模式下，瞬间会创建100个channel的，然后往缓存里放25个channel，当流量下去了，刚刚创建的多余的channel会自动关闭掉的，缓存里只保留25个。
使用这种方式的话，要注意缓存的channel数量，不能太小，不然流量一大,仍然会造成频繁关闭channel的情况。当然我们也不能说有多少并发，就创建多少个channel，还是要限制一下，这个时候可以使用：

connectionFactory.setChannelCheckoutTimeout(1000);

当ChannelCheckoutTimeout的值大于0的时候，ChannelCacheSize的值就是最大的channel数量了，一旦从缓存中获取不到channel，等待ChannelCheckoutTimeout毫秒后,如果还是获取不到的，就会抛AmqpTimeoutException了。
链接：https://juejin.cn/post/6844904015508029453

spring.rabbitmq.cache.connection.size: 缓存的连接数，只有是CONNECTION模式时生效
spring.rabbitmq.cache.connection.mode: 连接工厂缓存模式：CHANNEL 和 CONNECTION

# listener
spring.rabbitmq.listener.simple.auto-startup: 是否启动时自动启动容器

使用情景1:
rabbitMQ配置动态启动，rabbitMQ代理不正常时可以不启动项目中MQ的监听，主要解决，项目和MQ的启动顺序的问题。
使用情景2:
当启动程序时，并且MQ队列中有消息，这些消息的消费就会在应用程序完全启动之前开始，但是启动程序要初始化一些程序要用的数据，在没有初始化完成时消费这些消息会报错，所以希望在程序初始化完成后，再启动RabbitMQ的监听容器。

 可以通过控制层，测试去启动，生成环境是通过一个线程，一个去查看rabbit的代理服务器是否正常，正常的时候就开启rabbit的监听。
package com.example.demo.main;
 
import java.util.Set;
import javax.annotation.Resource;
import org.springframework.amqp.rabbit.listener.RabbitListenerEndpointRegistry;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
 
@RestController
@RequestMapping("rabbitmq/listener")
public class RabbitMQController {
 
    @Resource
    private RabbitListenerEndpointRegistry rabbitListenerEndpointRegistry;
 
    @RequestMapping("stop")
    public String stop(){
        rabbitListenerEndpointRegistry.stop();
        System.out.println("停止MQ监听");
        return "success";
    }
 
    @RequestMapping("start")
    public String start(){
        rabbitListenerEndpointRegistry.start();
        System.out.println("启动MQ监听");
        return "success";
    }
 
    @RequestMapping("setup")
    public String setup(int consumer, int maxConsumer){
        Set<String> containerIds = rabbitListenerEndpointRegistry.getListenerContainerIds();
        SimpleMessageListenerContainer container = null;
        for(String id : containerIds){
            container = (SimpleMessageListenerContainer) rabbitListenerEndpointRegistry.getListenerContainer(id);
            if(container != null){
                container.setConcurrentConsumers(consumer);
                container.setMaxConcurrentConsumers(maxConsumer);
            }
        }
        System.out.println("设置");
        return "success";
    }
}

 

spring.rabbitmq.listener.simple.acknowledge-mode: 表示消息确认方式，其有三种配置方式，分别是none、manual和auto；默认auto
spring.rabbitmq.listener.simple.concurrency: 最小的消费者数量

 

 

 

 

参考: https://www.cnblogs.com/liukunjava/p/13163951.html

 

spring.rabbitmq.listener.simple.max-concurrency: 最大的消费者数量

spring.rabbitmq.listener.simple.prefetch: 指定一个请求能处理多少个消息，如果有事务的话，必须大于等于transaction数量.

每个customer会在MQ预取一些消息放入内存的LinkedBlockingQueue中，这个值越高，消息传递的越快，但非顺序处理消息的风险更高。如果ack模式为none，则忽略。如有必要，将增加此值以匹配txSize或messagePerAck。从2.0开始默认为250；设置为1将还原为以前的行为。

prefetch默认值以前是1，这可能会导致高效使用者的利用率不足。从spring-amqp 2.0版开始，默认的prefetch值是250，这将使消费者在大多数常见场景中保持忙碌，从而提高吞吐量。

不过在有些情况下，尤其是处理速度比较慢的大消息，消息可能在内存中大量堆积，消耗大量内存；以及对于一些严格要求顺序的消息，prefetch的值应当设置为1。

对于低容量消息和多个消费者的情况（也包括单listener容器的concurrency配置）希望在多个使用者之间实现更均匀的消息分布，建议在手动ack下并设置prefetch=1。

 

spring.rabbitmq.listener.simple.transaction-size: 指定一个事务处理的消息数量，最好是小于等于prefetch的数量.
spring.rabbitmq.listener.simple.default-requeue-rejected: 决定被拒绝的消息是否重新入队；默认是true（与参数acknowledge-mode有关系）
spring.rabbitmq.listener.simple.idle-event-interval: 多少长时间发布空闲容器时间，单位毫秒

spring.rabbitmq.listener.simple.retry.enabled: 监听重试是否可用
spring.rabbitmq.listener.simple.retry.max-attempts: 最大重试次数
spring.rabbitmq.listener.simple.retry.initial-interval: 第一次和第二次尝试发布或传递消息之间的间隔
spring.rabbitmq.listener.simple.retry.multiplier: 应用于上一重试间隔的乘数
spring.rabbitmq.listener.simple.retry.max-interval: 最大重试时间间隔
spring.rabbitmq.listener.simple.retry.stateless: 重试是有状态or无状态

# template
spring.rabbitmq.template.mandatory: 启用强制信息；默认false
spring.rabbitmq.template.receive-timeout: receive() 操作的超时时间
spring.rabbitmq.template.reply-timeout: sendAndReceive() 操作的超时时间
spring.rabbitmq.template.retry.enabled: 发送重试是否可用
spring.rabbitmq.template.retry.max-attempts: 最大重试次数
spring.rabbitmq.template.retry.initial-interval: 第一次和第二次尝试发布或传递消息之间的间隔
spring.rabbitmq.template.retry.multiplier: 应用于上一重试间隔的乘数
spring.rabbitmq.template.retry.max-interval: 最大重试时间间隔