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 {
@Autowired
private 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 {
@Bean
public Queue myQueue() {
return new Queue("myQueue", true);
}
@Bean
public TopicExchange exchange() {
return new TopicExchange("myExchange");
}
@Bean
public 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() {
}
@Bean
public 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;
}
}
}
