Spring Boot 的自动配置，以rabbitmq为例，请详细说明

Spring Boot 的自动配置特性能够大大简化集成外部服务和组件的配置过程。以 RabbitMQ 为例，Spring Boot 通过 spring-boot-starter-amqp 提供了自动配置支持，开发者只需在应用中添加相关依赖并配置必要的属性，Spring Boot 会自动配置所需的连接工厂、消息队列、交换机、消息模板等。

以下是以 RabbitMQ 为例的详细说明。

1. 引入 RabbitMQ 依赖

要使用 Spring Boot 集成 RabbitMQ，首先需要在项目的 pom.xml 文件中添加 spring-boot-starter-amqp 依赖，这个依赖包含了与 RabbitMQ 交互的所有必要组件。

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

spring-boot-starter-amqp 依赖包含了 Spring AMQP 和 RabbitMQ 的连接组件，自动配置会根据此依赖自动启用 RabbitMQ 相关功能。

2. 配置 RabbitMQ 连接属性

接下来，你需要在 application.properties 或 application.yml 中配置 RabbitMQ 的连接信息。例如：

使用 application.properties

spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
spring.rabbitmq.virtual-host=/
spring.rabbitmq.publisher-confirm-type=simple
spring.rabbitmq.listener.simple.concurrency=3
spring.rabbitmq.listener.simple.max-concurrency=10

• spring.rabbitmq.host：RabbitMQ 服务器的地址，通常是 localhost。
• spring.rabbitmq.port：RabbitMQ 服务器的端口，默认是 5672。
• spring.rabbitmq.username 和 spring.rabbitmq.password：RabbitMQ 的认证信息。
• spring.rabbitmq.virtual-host：虚拟主机，通常是 /。
• spring.rabbitmq.publisher-confirm-type：确认模式，simple 为简单确认。
• spring.rabbitmq.listener.simple.concurrency：并发消费者数量。
• spring.rabbitmq.listener.simple.max-concurrency：最大消费者数量。

 

Spring Boot 会读取这些配置并自动配置连接工厂、消息队列监听器等。

3. 自动配置的原理

Spring Boot 在启动时会通过 spring-boot-autoconfigure 模块自动配置 RabbitMQ 相关的 Bean，主要通过以下几个步骤：

3.1 自动配置连接工厂（ConnectionFactory）

Spring Boot 会根据 spring.rabbitmq.* 配置自动创建一个 ConnectionFactory，它负责与 RabbitMQ 服务器建立连接。通常，Spring Boot 默认使用 CachingConnectionFactory 来实现连接工厂。

@Bean
@Primary
@ConditionalOnMissingBean(ConnectionFactory.class)
public CachingConnectionFactory connectionFactory() {CachingConnectionFactory connectionFactory = new CachingConnectionFactory();connectionFactory.setHost(rabbitProperties.getHost());connectionFactory.setPort(rabbitProperties.getPort());connectionFactory.setUsername(rabbitProperties.getUsername());connectionFactory.setPassword(rabbitProperties.getPassword());connectionFactory.setVirtualHost(rabbitProperties.getVirtualHost());return connectionFactory;
}

• @ConditionalOnMissingBean 表示如果应用上下文中没有 ConnectionFactory 的 Bean，Spring Boot 会创建一个默认的 CachingConnectionFactory。
• 配置的 spring.rabbitmq.* 参数将被注入到这个 ConnectionFactory 中。

3.2 自动配置 RabbitTemplate

RabbitTemplate 是 Spring AMQP 用来发送消息的核心类。Spring Boot 会自动配置一个 RabbitTemplate，它使用 ConnectionFactory 来与 RabbitMQ 服务器进行交互。

@Bean
@ConditionalOnMissingBean(RabbitTemplate.class)
public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {RabbitTemplate template = new RabbitTemplate(connectionFactory);template.setMessageConverter(new Jackson2JsonMessageConverter());return template;
}

• RabbitTemplate 被用来发送消息，Spring Boot 自动创建并配置。
• 默认使用 JSON 消息转换器（Jackson2JsonMessageConverter）将消息转换为 JSON 格式。

3.3 自动配置 RabbitListenerContainerFactory

如果你想使用 @RabbitListener 注解来监听 RabbitMQ 消息队列，Spring Boot 会自动配置 RabbitListenerContainerFactory。

@Bean
@ConditionalOnMissingBean(RabbitListenerContainerFactory.class)
public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(ConnectionFactory connectionFactory, RabbitProperties rabbitProperties) {SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();factory.setConnectionFactory(connectionFactory);factory.setConcurrency(rabbitProperties.getListener().getSimple().getConcurrency());factory.setMaxConcurrency(rabbitProperties.getListener().getSimple().getMaxConcurrency());return factory;
}

• 这个工厂用于创建 RabbitMQ 消息监听容器，容器负责消费队列中的消息。
• setConcurrency 和 setMaxConcurrency 用来配置消息消费者的并发数。

3.4 自动配置消息监听器（@RabbitListener）

Spring Boot 会自动启用对 @RabbitListener 注解的支持。你可以使用 @RabbitListener 注解创建消息监听器，而无需手动配置监听容器。

4. 创建消费者和生产者

4.1 消息生产者（发送消息）

你可以使用 RabbitTemplate 发送消息到 RabbitMQ 队列。

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;@Service
public class MessageProducer {@Autowiredprivate RabbitTemplate rabbitTemplate;public void sendMessage(String message) {rabbitTemplate.convertAndSend("myQueue", message);}
}

• rabbitTemplate.convertAndSend 方法用于将消息发送到指定的队列（myQueue）。
• Spring Boot 会自动为你配置队列、交换机、路由等。

4.2 消息消费者（监听消息）

你可以使用 @RabbitListener 注解来创建消息消费者，监听指定的队列，并在消息到达时处理它。

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Service;@Service
public class MessageConsumer {@RabbitListener(queues = "myQueue")public void receiveMessage(String message) {System.out.println("Received message: " + message);}
}

• @RabbitListener 注解会告诉 Spring Boot 自动创建一个消息监听器并连接到指定的队列。
• 每当有消息进入 myQueue 队列时，receiveMessage 方法就会被调用。

5. 自定义配置

你可以进一步自定义 RabbitMQ 的配置，以下是一些常见的自定义场景：

5.1 配置交换机、队列和绑定

你可以定义自己的交换机、队列和绑定，确保它们符合你的应用需求。例如：

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@Configuration
public class RabbitConfig {@Beanpublic Queue myQueue() {return new Queue("myQueue", true);}@Beanpublic TopicExchange exchange() {return new TopicExchange("myExchange");}@Beanpublic Binding binding(Queue myQueue, TopicExchange exchange) {return BindingBuilder.bind(myQueue).to(exchange).with("myQueue.#");}
}

• Queue 定义了一个消息队列。
• TopicExchange 定义了一个交换机。
• Binding 定义了队列和交换机之间的绑定关系。

5.2 配置消息监听器的并发

你可以通过 application.properties 或 application.yml 来调整消息监听器的并发配置：

spring.rabbitmq.listener.simple.concurrency=5
spring.rabbitmq.listener.simple.max-concurrency=10

这将允许 Spring Boot 动态调整消费者线程的数量，确保队列消息能够高效消费。

总结

Spring Boot 通过自动配置 RabbitMQ 连接、消息发送和消费等相关组件，极大地简化了 RabbitMQ 的集成过程。只需添加 spring-boot-starter-amqp 依赖并在配置文件中指定必要的参数，Spring Boot 就会自动配置所需的所有组件，并根据需求自动启动消息生产者和消费者。你可以通过注解 @RabbitListener 来定义消息监听器，也可以自定义交换机、队列和绑定等配置，从而满足不同的业务需求。

通过源码再次，详细说明

要深入了解 Spring Boot 如何通过自动配置集成 RabbitMQ，我们需要通过源码分析它是如何工作的。Spring Boot 使用了 spring-boot-starter-amqp 来简化 RabbitMQ 的配置。以下是从源代码角度对 Spring Boot 如何自动配置 RabbitMQ 进行详细说明的过程。

1. Spring Boot 启动流程和自动配置

Spring Boot 使用了 @EnableAutoConfiguration 注解和 spring.factories 文件来实现自动配置。在启动时，Spring Boot 会扫描并自动配置与应用上下文相关的配置类。RabbitMQ 的自动配置就是通过这些配置类实现的。

1.1 spring-boot-starter-amqp 依赖

首先，spring-boot-starter-amqp 依赖包含了 Spring AMQP 和 RabbitMQ 的集成依赖，并提供了 RabbitMQ 自动配置的支持。它的 spring.factories 文件列出了与 RabbitMQ 相关的自动配置类。

在 spring-boot-starter-amqp 中，spring.factories 文件会自动引入 RabbitAutoConfiguration 类。你可以在 spring-boot-starter-amqp 依赖中看到这一点：

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

当你引入了这个依赖后，Spring Boot 会自动加载 RabbitMQ 的相关配置。

2. RabbitAutoConfiguration 类

Spring Boot 的 RabbitMQ 自动配置类是 RabbitAutoConfiguration，它位于 org.springframework.boot.autoconfigure.amqp 包中。这个类的作用是基于你的配置自动设置 RabbitMQ 连接、队列、交换机等。

我们来分析一下 RabbitAutoConfiguration 类的源码：

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(CachingConnectionFactory.class)
@ConditionalOnProperty(prefix = "spring.rabbitmq", name = "host")
@EnableConfigurationProperties(RabbitProperties.class)
@Import({ RabbitListenerConfiguration.class, RabbitManagementConfigurer.class })
public class RabbitAutoConfiguration {private static final Logger logger = LoggerFactory.getLogger(RabbitAutoConfiguration.class);private final RabbitProperties properties;public RabbitAutoConfiguration(RabbitProperties properties) {this.properties = properties;}@Bean@ConditionalOnMissingBean(ConnectionFactory.class)public CachingConnectionFactory connectionFactory() {logger.debug("Creating CachingConnectionFactory");CachingConnectionFactory factory = new CachingConnectionFactory();factory.setHost(this.properties.getHost());factory.setPort(this.properties.getPort());factory.setUsername(this.properties.getUsername());factory.setPassword(this.properties.getPassword());factory.setVirtualHost(this.properties.getVirtualHost());return factory;}@Bean@ConditionalOnMissingBean(RabbitTemplate.class)public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());return rabbitTemplate;}@Bean@ConditionalOnMissingBean(SimpleRabbitListenerContainerFactory.class)public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(ConnectionFactory connectionFactory, RabbitProperties rabbitProperties) {SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();factory.setConnectionFactory(connectionFactory);factory.setConcurrency(rabbitProperties.getListener().getSimple().getConcurrency());factory.setMaxConcurrency(rabbitProperties.getListener().getSimple().getMaxConcurrency());return factory;}
}

2.1 @Configuration 和 @EnableConfigurationProperties

• @Configuration(proxyBeanMethods = false)：这是一个配置类，proxyBeanMethods = false 表示这个配置类不会使用代理，也就是说，它只会影响当前类中定义的 bean。
• @EnableConfigurationProperties(RabbitProperties.class)：该注解使得 RabbitProperties 类成为一个配置属性类，允许 Spring Boot 自动加载配置文件中的 spring.rabbitmq.* 属性，并将它们绑定到 RabbitProperties 对象。

2.2 connectionFactory Bean

@Bean
@ConditionalOnMissingBean(ConnectionFactory.class)
public CachingConnectionFactory connectionFactory() {CachingConnectionFactory factory = new CachingConnectionFactory();factory.setHost(this.properties.getHost());factory.setPort(this.properties.getPort());factory.setUsername(this.properties.getUsername());factory.setPassword(this.properties.getPassword());factory.setVirtualHost(this.properties.getVirtualHost());return factory;
}

• @ConditionalOnMissingBean(ConnectionFactory.class)：这表示如果应用上下文中没有 ConnectionFactory 类型的 Bean，Spring Boot 会自动创建一个 CachingConnectionFactory 的实例。CachingConnectionFactory 是 Spring AMQP 提供的一个连接工厂实现，它能缓存到 RabbitMQ 的连接以提高性能。
• factory.setHost 等：这些配置项通过 RabbitProperties 类从 application.properties 或 application.yml 中读取并注入。

2.3 rabbitTemplate Bean

@Bean
@ConditionalOnMissingBean(RabbitTemplate.class)
public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());return rabbitTemplate;
}

• @ConditionalOnMissingBean(RabbitTemplate.class)：如果 RabbitTemplate 已经存在于应用上下文中，Spring Boot 就不会再次创建它。
• RabbitTemplate：它是与 RabbitMQ 交互的核心类，主要用于发送消息。Spring Boot 会自动创建并配置 RabbitTemplate，并将其与上面创建的 ConnectionFactory 关联。

2.4 rabbitListenerContainerFactory Bean

@Bean
@ConditionalOnMissingBean(SimpleRabbitListenerContainerFactory.class)
public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(ConnectionFactory connectionFactory, RabbitProperties rabbitProperties) {SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();factory.setConnectionFactory(connectionFactory);factory.setConcurrency(rabbitProperties.getListener().getSimple().getConcurrency());factory.setMaxConcurrency(rabbitProperties.getListener().getSimple().getMaxConcurrency());return factory;
}

• SimpleRabbitListenerContainerFactory：这是一个用来创建 RabbitMQ 消息监听容器的工厂。该容器负责从 RabbitMQ 中接收并处理消息。
• setConcurrency 和 setMaxConcurrency：这两个方法控制监听器的并发性，指定了消息监听的最小和最大并发数。

3. RabbitListenerConfiguration 和 RabbitManagementConfigurer

RabbitAutoConfiguration 类还通过 @Import 注解引入了 RabbitListenerConfiguration 和 RabbitManagementConfigurer 类。这些类负责配置消息监听器和管理接口等。

java

@Import({ RabbitListenerConfiguration.class, RabbitManagementConfigurer.class })

• RabbitListenerConfiguration：负责配置和启用 @RabbitListener 注解的处理。
• RabbitManagementConfigurer：负责 RabbitMQ 管理的配置，通常是为了启用或配置 RabbitMQ 管理界面。

4. RabbitProperties 类

RabbitProperties 类是用来封装 application.properties 或 application.yml 中与 RabbitMQ 相关的配置项的。它的主要作用是将这些配置绑定到 Java 对象上，方便后续使用。

@ConfigurationProperties(prefix = "spring.rabbitmq")
public class RabbitProperties {private String host = "localhost";private int port = 5672;private String username = "guest";private String password = "guest";private String virtualHost = "/";private Listener listener = new Listener();public static class Listener {private Simple simple = new Simple();public static class Simple {private int concurrency = 1;private int maxConcurrency = 1;}}// getters and setters
}

RabbitProperties 是一个 POJO 类，Spring Boot 会将 application.properties 中以 spring.rabbitmq.* 开头的属性自动映射到这个类的字段中。

5. @RabbitListener 注解支持

Spring Boot 自动配置还会启用 @RabbitListener 注解的支持，这意味着你可以通过注解驱动的方式来创建 RabbitMQ 消息监听器。例如：

@Service
public class MyListener {@RabbitListener(queues = "myQueue")public void handleMessage(String message) {System.out.println("Received message: " + message);}
}

6. 总结

通过 RabbitAutoConfiguration，Spring Boot 自动配置了与 RabbitMQ 交互所需的主要组件：ConnectionFactory、RabbitTemplate、SimpleRabbitListenerContainerFactory 等。这些组件的创建是基于 application.properties 中的配置完成的。通过 Spring Boot 的自动配置，开发者只需要添加必要的依赖和配置，不必手动创建和配置这些复杂的 RabbitMQ 组件。

自动配置总结

• ConnectionFactory：用于连接到 RabbitMQ 服务。
• RabbitTemplate：用于发送消息。
• SimpleRabbitListenerContainerFactory：用于配置消息监听容器。
• RabbitListener 注解：用于处理消息监听。

RabbitAutoConfiguration 源码 1.5.9版本

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//package org.springframework.boot.autoconfigure.amqp;import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.AmqpAdmin;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.connection.RabbitConnectionFactoryBean;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.amqp.rabbit.core.RabbitMessagingTemplate;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.boot.autoconfigure.amqp.RabbitProperties.Retry;
import org.springframework.boot.autoconfigure.amqp.RabbitProperties.Ssl;
import org.springframework.boot.autoconfigure.amqp.RabbitProperties.Template;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.retry.backoff.ExponentialBackOffPolicy;
import org.springframework.retry.policy.SimpleRetryPolicy;
import org.springframework.retry.support.RetryTemplate;@Configuration
@ConditionalOnClass({RabbitTemplate.class, Channel.class})
@EnableConfigurationProperties({RabbitProperties.class})
@Import({RabbitAnnotationDrivenConfiguration.class})
public class RabbitAutoConfiguration {public RabbitAutoConfiguration() {}@Configuration@ConditionalOnClass({RabbitMessagingTemplate.class})@ConditionalOnMissingBean({RabbitMessagingTemplate.class})@Import({RabbitAutoConfiguration.RabbitTemplateConfiguration.class})protected static class MessagingTemplateConfiguration {protected MessagingTemplateConfiguration() {}@Bean@ConditionalOnSingleCandidate(RabbitTemplate.class)public RabbitMessagingTemplate rabbitMessagingTemplate(RabbitTemplate rabbitTemplate) {return new RabbitMessagingTemplate(rabbitTemplate);}}@Configuration@Import({RabbitAutoConfiguration.RabbitConnectionFactoryCreator.class})protected static class RabbitTemplateConfiguration {private final ObjectProvider<MessageConverter> messageConverter;private final RabbitProperties properties;public RabbitTemplateConfiguration(ObjectProvider<MessageConverter> messageConverter, RabbitProperties properties) {this.messageConverter = messageConverter;this.properties = properties;}@Bean@ConditionalOnSingleCandidate(ConnectionFactory.class)@ConditionalOnMissingBean({RabbitTemplate.class})public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);MessageConverter messageConverter = (MessageConverter)this.messageConverter.getIfUnique();if (messageConverter != null) {rabbitTemplate.setMessageConverter(messageConverter);}rabbitTemplate.setMandatory(this.determineMandatoryFlag());Template templateProperties = this.properties.getTemplate();Retry retryProperties = templateProperties.getRetry();if (retryProperties.isEnabled()) {rabbitTemplate.setRetryTemplate(this.createRetryTemplate(retryProperties));}if (templateProperties.getReceiveTimeout() != null) {rabbitTemplate.setReceiveTimeout(templateProperties.getReceiveTimeout());}if (templateProperties.getReplyTimeout() != null) {rabbitTemplate.setReplyTimeout(templateProperties.getReplyTimeout());}return rabbitTemplate;}private boolean determineMandatoryFlag() {Boolean mandatory = this.properties.getTemplate().getMandatory();return mandatory != null ? mandatory : this.properties.isPublisherReturns();}private RetryTemplate createRetryTemplate(Retry properties) {RetryTemplate template = new RetryTemplate();SimpleRetryPolicy policy = new SimpleRetryPolicy();policy.setMaxAttempts(properties.getMaxAttempts());template.setRetryPolicy(policy);ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();backOffPolicy.setInitialInterval(properties.getInitialInterval());backOffPolicy.setMultiplier(properties.getMultiplier());backOffPolicy.setMaxInterval(properties.getMaxInterval());template.setBackOffPolicy(backOffPolicy);return template;}@Bean@ConditionalOnSingleCandidate(ConnectionFactory.class)@ConditionalOnProperty(prefix = "spring.rabbitmq",name = {"dynamic"},matchIfMissing = true)@ConditionalOnMissingBean({AmqpAdmin.class})public AmqpAdmin amqpAdmin(ConnectionFactory connectionFactory) {return new RabbitAdmin(connectionFactory);}}@Configuration@ConditionalOnMissingBean({ConnectionFactory.class})protected static class RabbitConnectionFactoryCreator {protected RabbitConnectionFactoryCreator() {}@Beanpublic CachingConnectionFactory rabbitConnectionFactory(RabbitProperties config) throws Exception {RabbitConnectionFactoryBean factory = new RabbitConnectionFactoryBean();if (config.determineHost() != null) {factory.setHost(config.determineHost());}factory.setPort(config.determinePort());if (config.determineUsername() != null) {factory.setUsername(config.determineUsername());}if (config.determinePassword() != null) {factory.setPassword(config.determinePassword());}if (config.determineVirtualHost() != null) {factory.setVirtualHost(config.determineVirtualHost());}if (config.getRequestedHeartbeat() != null) {factory.setRequestedHeartbeat(config.getRequestedHeartbeat());}Ssl ssl = config.getSsl();if (ssl.isEnabled()) {factory.setUseSSL(true);if (ssl.getAlgorithm() != null) {factory.setSslAlgorithm(ssl.getAlgorithm());}factory.setKeyStore(ssl.getKeyStore());factory.setKeyStorePassphrase(ssl.getKeyStorePassword());factory.setTrustStore(ssl.getTrustStore());factory.setTrustStorePassphrase(ssl.getTrustStorePassword());}if (config.getConnectionTimeout() != null) {factory.setConnectionTimeout(config.getConnectionTimeout());}factory.afterPropertiesSet();CachingConnectionFactory connectionFactory = new CachingConnectionFactory((com.rabbitmq.client.ConnectionFactory)factory.getObject());connectionFactory.setAddresses(config.determineAddresses());connectionFactory.setPublisherConfirms(config.isPublisherConfirms());connectionFactory.setPublisherReturns(config.isPublisherReturns());if (config.getCache().getChannel().getSize() != null) {connectionFactory.setChannelCacheSize(config.getCache().getChannel().getSize());}if (config.getCache().getConnection().getMode() != null) {connectionFactory.setCacheMode(config.getCache().getConnection().getMode());}if (config.getCache().getConnection().getSize() != null) {connectionFactory.setConnectionCacheSize(config.getCache().getConnection().getSize());}if (config.getCache().getChannel().getCheckoutTimeout() != null) {connectionFactory.setChannelCheckoutTimeout(config.getCache().getChannel().getCheckoutTimeout());}return connectionFactory;}}
}