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 {

    @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;
        }
    }
}