From a96b3ef1011588000a7cd99d8c6459e556073f7a Mon Sep 17 00:00:00 2001 From: bono007 Date: Sun, 20 Jun 2021 18:30:30 -0500 Subject: [PATCH 1/2] Add Rabbit connection factory configurers See gh-26982 --- .../AbstractConnectionFactoryConfigurer.java | 61 ++++++++++ .../CachingConnectionFactoryConfigurer.java | 38 +++++++ .../amqp/RabbitAutoConfiguration.java | 94 ++++++---------- ...RabbitConnectionFactoryBeanConfigurer.java | 104 ++++++++++++++++++ 4 files changed, 237 insertions(+), 60 deletions(-) create mode 100644 spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/AbstractConnectionFactoryConfigurer.java create mode 100644 spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/CachingConnectionFactoryConfigurer.java create mode 100644 spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/RabbitConnectionFactoryBeanConfigurer.java diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/AbstractConnectionFactoryConfigurer.java b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/AbstractConnectionFactoryConfigurer.java new file mode 100644 index 00000000000..3ece213986e --- /dev/null +++ b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/AbstractConnectionFactoryConfigurer.java @@ -0,0 +1,61 @@ +package org.springframework.boot.autoconfigure.amqp; + +import org.springframework.amqp.rabbit.connection.AbstractConnectionFactory; +import org.springframework.amqp.rabbit.connection.ConnectionNameStrategy; +import org.springframework.boot.context.properties.PropertyMapper; +import org.springframework.util.Assert; + +/** + * Configures {@link AbstractConnectionFactory Rabbit ConnectionFactory} with sensible + * defaults. + * + * @param the connection factory type. + * @author Chris Bono + * @since 2.6.0 + */ +public abstract class AbstractConnectionFactoryConfigurer { + + private RabbitProperties rabbitProperties; + + private ConnectionNameStrategy connectionNameStrategy; + + public RabbitProperties getRabbitProperties() { + return rabbitProperties; + } + + public void setRabbitProperties(RabbitProperties rabbitProperties) { + this.rabbitProperties = rabbitProperties; + } + + public ConnectionNameStrategy getConnectionNameStrategy() { + return connectionNameStrategy; + } + + public void setConnectionNameStrategy(ConnectionNameStrategy connectionNameStrategy) { + this.connectionNameStrategy = connectionNameStrategy; + } + + /** + * Configure the specified Rabbit connection factory - delegating to + * {@link #configureSpecific} for the connection factory implementation specific + * settings. The factory can be further tuned and default settings can be overridden. + * @param connectionFactory the connection factory instance to configure + */ + public void configure(T connectionFactory) { + Assert.notNull(connectionFactory, "ConnectionFactory must not be null"); + PropertyMapper map = PropertyMapper.get(); + map.from(this.rabbitProperties::determineAddresses).to(connectionFactory::setAddresses); + map.from(this.rabbitProperties::getAddressShuffleMode).whenNonNull() + .to(connectionFactory::setAddressShuffleMode); + map.from(connectionNameStrategy).whenNonNull().to(connectionFactory::setConnectionNameStrategy); + configureSpecific(connectionFactory); + } + + /** + * Configure the specified Rabbit connection factory with implementation specific + * settings. + * @param connectionFactory the connection factory instance to configure + */ + protected abstract void configureSpecific(T connectionFactory); + +} diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/CachingConnectionFactoryConfigurer.java b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/CachingConnectionFactoryConfigurer.java new file mode 100644 index 00000000000..455508210d9 --- /dev/null +++ b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/CachingConnectionFactoryConfigurer.java @@ -0,0 +1,38 @@ +package org.springframework.boot.autoconfigure.amqp; + +import java.time.Duration; + +import org.springframework.amqp.rabbit.connection.CachingConnectionFactory; +import org.springframework.boot.context.properties.PropertyMapper; + +/** + * Configures {@link CachingConnectionFactory Rabbit CachingConnectionFactory} with + * sensible defaults. + * + * @author Chris Bono + * @since 2.6.0 + */ +public class CachingConnectionFactoryConfigurer extends AbstractConnectionFactoryConfigurer { + + /** + * Configure the specified Rabbit caching connection factory with implementation + * specific settings. + * @param connectionFactory the {@link CachingConnectionFactory} instance to configure + */ + @Override + public void configureSpecific(CachingConnectionFactory connectionFactory) { + PropertyMapper map = PropertyMapper.get(); + RabbitProperties rabbitProperties = getRabbitProperties(); + map.from(rabbitProperties::isPublisherReturns).to(connectionFactory::setPublisherReturns); + map.from(rabbitProperties::getPublisherConfirmType).whenNonNull() + .to(connectionFactory::setPublisherConfirmType); + RabbitProperties.Cache.Channel channel = rabbitProperties.getCache().getChannel(); + map.from(channel::getSize).whenNonNull().to(connectionFactory::setChannelCacheSize); + map.from(channel::getCheckoutTimeout).whenNonNull().as(Duration::toMillis) + .to(connectionFactory::setChannelCheckoutTimeout); + RabbitProperties.Cache.Connection connection = rabbitProperties.getCache().getConnection(); + map.from(connection::getMode).whenNonNull().to(connectionFactory::setCacheMode); + map.from(connection::getSize).whenNonNull().to(connectionFactory::setConnectionCacheSize); + } + +} diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/RabbitAutoConfiguration.java b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/RabbitAutoConfiguration.java index 3c09a5b2fdf..bb76ce7014b 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/RabbitAutoConfiguration.java +++ b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/RabbitAutoConfiguration.java @@ -16,7 +16,6 @@ package org.springframework.boot.autoconfigure.amqp; -import java.time.Duration; import java.util.stream.Collectors; import com.rabbitmq.client.Channel; @@ -40,7 +39,6 @@ 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.boot.context.properties.PropertyMapper; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Import; @@ -84,6 +82,7 @@ import org.springframework.core.io.ResourceLoader; * @author Gary Russell * @author Phillip Webb * @author Artsiom Yudovin + * @author Chris Bono * @since 1.0.0 */ @Configuration(proxyBeanMethods = false) @@ -93,73 +92,48 @@ import org.springframework.core.io.ResourceLoader; public class RabbitAutoConfiguration { @Configuration(proxyBeanMethods = false) - @ConditionalOnMissingBean(ConnectionFactory.class) protected static class RabbitConnectionFactoryCreator { @Bean - public CachingConnectionFactory rabbitConnectionFactory(RabbitProperties properties, + @ConditionalOnMissingBean + RabbitConnectionFactoryBeanConfigurer rabbitConnectionFactoryBeanConfigurer(RabbitProperties properties, ResourceLoader resourceLoader, ObjectProvider credentialsProvider, - ObjectProvider credentialsRefreshService, - ObjectProvider connectionNameStrategy, + ObjectProvider credentialsRefreshService) { + RabbitConnectionFactoryBeanConfigurer configurer = new RabbitConnectionFactoryBeanConfigurer(); + configurer.setRabbitProperties(properties); + configurer.setResourceLoader(resourceLoader); + configurer.setCredentialsProvider(credentialsProvider.getIfUnique()); + configurer.setCredentialsRefreshService(credentialsRefreshService.getIfUnique()); + return configurer; + } + + @Bean + @ConditionalOnMissingBean + CachingConnectionFactoryConfigurer rabbitConnectionFactoryConfigurer(RabbitProperties rabbitProperties, + ObjectProvider connectionNameStrategy) { + CachingConnectionFactoryConfigurer configurer = new CachingConnectionFactoryConfigurer(); + configurer.setRabbitProperties(rabbitProperties); + configurer.setConnectionNameStrategy(connectionNameStrategy.getIfUnique()); + return configurer; + } + + @Bean + @ConditionalOnMissingBean(ConnectionFactory.class) + CachingConnectionFactory rabbitConnectionFactory( + RabbitConnectionFactoryBeanConfigurer rabbitConnectionFactoryBeanConfigurer, + CachingConnectionFactoryConfigurer rabbitCachingConnectionFactoryConfigurer, ObjectProvider connectionFactoryCustomizers) throws Exception { - com.rabbitmq.client.ConnectionFactory connectionFactory = getRabbitConnectionFactoryBean(properties, - resourceLoader, credentialsProvider, credentialsRefreshService).getObject(); + + RabbitConnectionFactoryBean connectionFactoryBean = new RabbitConnectionFactoryBean(); + rabbitConnectionFactoryBeanConfigurer.configure(connectionFactoryBean); + connectionFactoryBean.afterPropertiesSet(); + com.rabbitmq.client.ConnectionFactory connectionFactory = connectionFactoryBean.getObject(); connectionFactoryCustomizers.orderedStream() .forEach((customizer) -> customizer.customize(connectionFactory)); + CachingConnectionFactory factory = new CachingConnectionFactory(connectionFactory); - PropertyMapper map = PropertyMapper.get(); - map.from(properties::determineAddresses).to(factory::setAddresses); - map.from(properties::getAddressShuffleMode).whenNonNull().to(factory::setAddressShuffleMode); - map.from(properties::isPublisherReturns).to(factory::setPublisherReturns); - map.from(properties::getPublisherConfirmType).whenNonNull().to(factory::setPublisherConfirmType); - RabbitProperties.Cache.Channel channel = properties.getCache().getChannel(); - map.from(channel::getSize).whenNonNull().to(factory::setChannelCacheSize); - map.from(channel::getCheckoutTimeout).whenNonNull().as(Duration::toMillis) - .to(factory::setChannelCheckoutTimeout); - RabbitProperties.Cache.Connection connection = properties.getCache().getConnection(); - map.from(connection::getMode).whenNonNull().to(factory::setCacheMode); - map.from(connection::getSize).whenNonNull().to(factory::setConnectionCacheSize); - map.from(connectionNameStrategy::getIfUnique).whenNonNull().to(factory::setConnectionNameStrategy); - return factory; - } + rabbitCachingConnectionFactoryConfigurer.configure(factory); - private RabbitConnectionFactoryBean getRabbitConnectionFactoryBean(RabbitProperties properties, - ResourceLoader resourceLoader, ObjectProvider credentialsProvider, - ObjectProvider credentialsRefreshService) { - RabbitConnectionFactoryBean factory = new RabbitConnectionFactoryBean(); - factory.setResourceLoader(resourceLoader); - PropertyMapper map = PropertyMapper.get(); - map.from(properties::determineHost).whenNonNull().to(factory::setHost); - map.from(properties::determinePort).to(factory::setPort); - map.from(properties::determineUsername).whenNonNull().to(factory::setUsername); - map.from(properties::determinePassword).whenNonNull().to(factory::setPassword); - map.from(properties::determineVirtualHost).whenNonNull().to(factory::setVirtualHost); - map.from(properties::getRequestedHeartbeat).whenNonNull().asInt(Duration::getSeconds) - .to(factory::setRequestedHeartbeat); - map.from(properties::getRequestedChannelMax).to(factory::setRequestedChannelMax); - RabbitProperties.Ssl ssl = properties.getSsl(); - if (ssl.determineEnabled()) { - factory.setUseSSL(true); - map.from(ssl::getAlgorithm).whenNonNull().to(factory::setSslAlgorithm); - map.from(ssl::getKeyStoreType).to(factory::setKeyStoreType); - map.from(ssl::getKeyStore).to(factory::setKeyStore); - map.from(ssl::getKeyStorePassword).to(factory::setKeyStorePassphrase); - map.from(ssl::getKeyStoreAlgorithm).whenNonNull().to(factory::setKeyStoreAlgorithm); - map.from(ssl::getTrustStoreType).to(factory::setTrustStoreType); - map.from(ssl::getTrustStore).to(factory::setTrustStore); - map.from(ssl::getTrustStorePassword).to(factory::setTrustStorePassphrase); - map.from(ssl::getTrustStoreAlgorithm).whenNonNull().to(factory::setTrustStoreAlgorithm); - map.from(ssl::isValidateServerCertificate) - .to((validate) -> factory.setSkipServerCertificateValidation(!validate)); - map.from(ssl::getVerifyHostname).to(factory::setEnableHostnameVerification); - } - map.from(properties::getConnectionTimeout).whenNonNull().asInt(Duration::toMillis) - .to(factory::setConnectionTimeout); - map.from(properties::getChannelRpcTimeout).whenNonNull().asInt(Duration::toMillis) - .to(factory::setChannelRpcTimeout); - map.from(credentialsProvider::getIfUnique).whenNonNull().to(factory::setCredentialsProvider); - map.from(credentialsRefreshService::getIfUnique).whenNonNull().to(factory::setCredentialsRefreshService); - factory.afterPropertiesSet(); return factory; } diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/RabbitConnectionFactoryBeanConfigurer.java b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/RabbitConnectionFactoryBeanConfigurer.java new file mode 100644 index 00000000000..568a5094b65 --- /dev/null +++ b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/RabbitConnectionFactoryBeanConfigurer.java @@ -0,0 +1,104 @@ +package org.springframework.boot.autoconfigure.amqp; + +import java.time.Duration; + +import com.rabbitmq.client.impl.CredentialsProvider; +import com.rabbitmq.client.impl.CredentialsRefreshService; + +import org.springframework.amqp.rabbit.connection.RabbitConnectionFactoryBean; +import org.springframework.boot.context.properties.PropertyMapper; +import org.springframework.core.io.ResourceLoader; +import org.springframework.util.Assert; + +/** + * Configures {@link RabbitConnectionFactoryBean} with sensible defaults. + * + * @author Chris Bono + * @since 2.6.0 + */ +public class RabbitConnectionFactoryBeanConfigurer { + + private RabbitProperties rabbitProperties; + + private ResourceLoader resourceLoader; + + private CredentialsProvider credentialsProvider; + + private CredentialsRefreshService credentialsRefreshService; + + public RabbitProperties getRabbitProperties() { + return rabbitProperties; + } + + public void setRabbitProperties(RabbitProperties rabbitProperties) { + this.rabbitProperties = rabbitProperties; + } + + public ResourceLoader getResourceLoader() { + return resourceLoader; + } + + public void setResourceLoader(ResourceLoader resourceLoader) { + this.resourceLoader = resourceLoader; + } + + public CredentialsProvider getCredentialsProvider() { + return credentialsProvider; + } + + public void setCredentialsProvider(CredentialsProvider credentialsProvider) { + this.credentialsProvider = credentialsProvider; + } + + public CredentialsRefreshService getCredentialsRefreshService() { + return credentialsRefreshService; + } + + public void setCredentialsRefreshService(CredentialsRefreshService credentialsRefreshService) { + this.credentialsRefreshService = credentialsRefreshService; + } + + /** + * Configure the specified rabbit connection factory bean. The factory bean can be + * further tuned and default settings can be overridden. It is the repsonsiblity of + * the caller to invoke {@link RabbitConnectionFactoryBean#afterPropertiesSet()} + * though. + * @param factory the {@link RabbitConnectionFactoryBean} instance to configure + */ + public void configure(RabbitConnectionFactoryBean factory) { + Assert.notNull(factory, "RabbitConnectionFactoryBean must not be null"); + factory.setResourceLoader(resourceLoader); + PropertyMapper map = PropertyMapper.get(); + map.from(this.rabbitProperties::determineHost).whenNonNull().to(factory::setHost); + map.from(this.rabbitProperties::determinePort).to(factory::setPort); + map.from(this.rabbitProperties::determineUsername).whenNonNull().to(factory::setUsername); + map.from(this.rabbitProperties::determinePassword).whenNonNull().to(factory::setPassword); + map.from(this.rabbitProperties::determineVirtualHost).whenNonNull().to(factory::setVirtualHost); + map.from(this.rabbitProperties::getRequestedHeartbeat).whenNonNull().asInt(Duration::getSeconds) + .to(factory::setRequestedHeartbeat); + map.from(this.rabbitProperties::getRequestedChannelMax).to(factory::setRequestedChannelMax); + RabbitProperties.Ssl ssl = this.rabbitProperties.getSsl(); + if (ssl.determineEnabled()) { + factory.setUseSSL(true); + map.from(ssl::getAlgorithm).whenNonNull().to(factory::setSslAlgorithm); + map.from(ssl::getKeyStoreType).to(factory::setKeyStoreType); + map.from(ssl::getKeyStore).to(factory::setKeyStore); + map.from(ssl::getKeyStorePassword).to(factory::setKeyStorePassphrase); + map.from(ssl::getKeyStoreAlgorithm).whenNonNull().to(factory::setKeyStoreAlgorithm); + map.from(ssl::getTrustStoreType).to(factory::setTrustStoreType); + map.from(ssl::getTrustStore).to(factory::setTrustStore); + map.from(ssl::getTrustStorePassword).to(factory::setTrustStorePassphrase); + map.from(ssl::getTrustStoreAlgorithm).whenNonNull().to(factory::setTrustStoreAlgorithm); + map.from(ssl::isValidateServerCertificate) + .to((validate) -> factory.setSkipServerCertificateValidation(!validate)); + map.from(ssl::getVerifyHostname).to(factory::setEnableHostnameVerification); + } + map.from(this.rabbitProperties::getConnectionTimeout).whenNonNull().asInt(Duration::toMillis) + .to(factory::setConnectionTimeout); + map.from(this.rabbitProperties::getChannelRpcTimeout).whenNonNull().asInt(Duration::toMillis) + .to(factory::setChannelRpcTimeout); + map.from(credentialsProvider).whenNonNull().to(factory::setCredentialsProvider); + map.from(credentialsRefreshService).whenNonNull().to(factory::setCredentialsRefreshService); + } + +} From 2c8658c24f9215c22b3f39fdd9ade520b4875d22 Mon Sep 17 00:00:00 2001 From: Andy Wilkinson Date: Tue, 13 Jul 2021 17:15:04 +0100 Subject: [PATCH 2/2] Polish "Add Rabbit connection factory configurers" See gh-26982 --- .../AbstractConnectionFactoryConfigurer.java | 54 +++++++++++-------- .../CachingConnectionFactoryConfigurer.java | 31 +++++++---- .../amqp/RabbitAutoConfiguration.java | 8 ++- ...RabbitConnectionFactoryBeanConfigurer.java | 49 ++++++++--------- 4 files changed, 81 insertions(+), 61 deletions(-) diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/AbstractConnectionFactoryConfigurer.java b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/AbstractConnectionFactoryConfigurer.java index 3ece213986e..55ce5e0d2c9 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/AbstractConnectionFactoryConfigurer.java +++ b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/AbstractConnectionFactoryConfigurer.java @@ -1,3 +1,19 @@ +/* + * Copyright 2012-2021 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + package org.springframework.boot.autoconfigure.amqp; import org.springframework.amqp.rabbit.connection.AbstractConnectionFactory; @@ -15,47 +31,43 @@ import org.springframework.util.Assert; */ public abstract class AbstractConnectionFactoryConfigurer { - private RabbitProperties rabbitProperties; + private final RabbitProperties rabbitProperties; private ConnectionNameStrategy connectionNameStrategy; - public RabbitProperties getRabbitProperties() { - return rabbitProperties; - } - - public void setRabbitProperties(RabbitProperties rabbitProperties) { - this.rabbitProperties = rabbitProperties; + protected AbstractConnectionFactoryConfigurer(RabbitProperties properties) { + Assert.notNull(properties, "RabbitProperties must not be null"); + this.rabbitProperties = properties; } - public ConnectionNameStrategy getConnectionNameStrategy() { - return connectionNameStrategy; + protected final ConnectionNameStrategy getConnectionNameStrategy() { + return this.connectionNameStrategy; } - public void setConnectionNameStrategy(ConnectionNameStrategy connectionNameStrategy) { + protected final void setConnectionNameStrategy(ConnectionNameStrategy connectionNameStrategy) { this.connectionNameStrategy = connectionNameStrategy; } /** - * Configure the specified Rabbit connection factory - delegating to - * {@link #configureSpecific} for the connection factory implementation specific - * settings. The factory can be further tuned and default settings can be overridden. - * @param connectionFactory the connection factory instance to configure + * Configures the given {@code connectionFactory} with sensible defaults. + * @param connectionFactory connection factory to configure */ - public void configure(T connectionFactory) { + public final void configure(T connectionFactory) { Assert.notNull(connectionFactory, "ConnectionFactory must not be null"); PropertyMapper map = PropertyMapper.get(); map.from(this.rabbitProperties::determineAddresses).to(connectionFactory::setAddresses); map.from(this.rabbitProperties::getAddressShuffleMode).whenNonNull() .to(connectionFactory::setAddressShuffleMode); - map.from(connectionNameStrategy).whenNonNull().to(connectionFactory::setConnectionNameStrategy); - configureSpecific(connectionFactory); + map.from(this.connectionNameStrategy).whenNonNull().to(connectionFactory::setConnectionNameStrategy); + configure(connectionFactory, this.rabbitProperties); } /** - * Configure the specified Rabbit connection factory with implementation specific - * settings. - * @param connectionFactory the connection factory instance to configure + * Configures the given {@code connectionFactory} using the given + * {@code rabbitProperties}. + * @param connectionFactory connection factory to configure + * @param rabbitProperties properties to use for the configuration */ - protected abstract void configureSpecific(T connectionFactory); + protected abstract void configure(T connectionFactory, RabbitProperties rabbitProperties); } diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/CachingConnectionFactoryConfigurer.java b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/CachingConnectionFactoryConfigurer.java index 455508210d9..1c8ecdcca7c 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/CachingConnectionFactoryConfigurer.java +++ b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/CachingConnectionFactoryConfigurer.java @@ -1,3 +1,19 @@ +/* + * Copyright 2012-2021 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + package org.springframework.boot.autoconfigure.amqp; import java.time.Duration; @@ -6,23 +22,20 @@ import org.springframework.amqp.rabbit.connection.CachingConnectionFactory; import org.springframework.boot.context.properties.PropertyMapper; /** - * Configures {@link CachingConnectionFactory Rabbit CachingConnectionFactory} with - * sensible defaults. + * Configures Rabbit {@link CachingConnectionFactory} with sensible defaults. * * @author Chris Bono * @since 2.6.0 */ public class CachingConnectionFactoryConfigurer extends AbstractConnectionFactoryConfigurer { - /** - * Configure the specified Rabbit caching connection factory with implementation - * specific settings. - * @param connectionFactory the {@link CachingConnectionFactory} instance to configure - */ + public CachingConnectionFactoryConfigurer(RabbitProperties properties) { + super(properties); + } + @Override - public void configureSpecific(CachingConnectionFactory connectionFactory) { + public void configure(CachingConnectionFactory connectionFactory, RabbitProperties rabbitProperties) { PropertyMapper map = PropertyMapper.get(); - RabbitProperties rabbitProperties = getRabbitProperties(); map.from(rabbitProperties::isPublisherReturns).to(connectionFactory::setPublisherReturns); map.from(rabbitProperties::getPublisherConfirmType).whenNonNull() .to(connectionFactory::setPublisherConfirmType); diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/RabbitAutoConfiguration.java b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/RabbitAutoConfiguration.java index bb76ce7014b..6a8740b24d9 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/RabbitAutoConfiguration.java +++ b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/RabbitAutoConfiguration.java @@ -99,9 +99,8 @@ public class RabbitAutoConfiguration { RabbitConnectionFactoryBeanConfigurer rabbitConnectionFactoryBeanConfigurer(RabbitProperties properties, ResourceLoader resourceLoader, ObjectProvider credentialsProvider, ObjectProvider credentialsRefreshService) { - RabbitConnectionFactoryBeanConfigurer configurer = new RabbitConnectionFactoryBeanConfigurer(); - configurer.setRabbitProperties(properties); - configurer.setResourceLoader(resourceLoader); + RabbitConnectionFactoryBeanConfigurer configurer = new RabbitConnectionFactoryBeanConfigurer(resourceLoader, + properties); configurer.setCredentialsProvider(credentialsProvider.getIfUnique()); configurer.setCredentialsRefreshService(credentialsRefreshService.getIfUnique()); return configurer; @@ -111,8 +110,7 @@ public class RabbitAutoConfiguration { @ConditionalOnMissingBean CachingConnectionFactoryConfigurer rabbitConnectionFactoryConfigurer(RabbitProperties rabbitProperties, ObjectProvider connectionNameStrategy) { - CachingConnectionFactoryConfigurer configurer = new CachingConnectionFactoryConfigurer(); - configurer.setRabbitProperties(rabbitProperties); + CachingConnectionFactoryConfigurer configurer = new CachingConnectionFactoryConfigurer(rabbitProperties); configurer.setConnectionNameStrategy(connectionNameStrategy.getIfUnique()); return configurer; } diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/RabbitConnectionFactoryBeanConfigurer.java b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/RabbitConnectionFactoryBeanConfigurer.java index 568a5094b65..8ec5ee0a2f5 100644 --- a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/RabbitConnectionFactoryBeanConfigurer.java +++ b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/amqp/RabbitConnectionFactoryBeanConfigurer.java @@ -1,3 +1,19 @@ +/* + * Copyright 2012-2020 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + package org.springframework.boot.autoconfigure.amqp; import java.time.Duration; @@ -18,42 +34,23 @@ import org.springframework.util.Assert; */ public class RabbitConnectionFactoryBeanConfigurer { - private RabbitProperties rabbitProperties; + private final RabbitProperties rabbitProperties; - private ResourceLoader resourceLoader; + private final ResourceLoader resourceLoader; private CredentialsProvider credentialsProvider; private CredentialsRefreshService credentialsRefreshService; - public RabbitProperties getRabbitProperties() { - return rabbitProperties; - } - - public void setRabbitProperties(RabbitProperties rabbitProperties) { - this.rabbitProperties = rabbitProperties; - } - - public ResourceLoader getResourceLoader() { - return resourceLoader; - } - - public void setResourceLoader(ResourceLoader resourceLoader) { + public RabbitConnectionFactoryBeanConfigurer(ResourceLoader resourceLoader, RabbitProperties properties) { this.resourceLoader = resourceLoader; - } - - public CredentialsProvider getCredentialsProvider() { - return credentialsProvider; + this.rabbitProperties = properties; } public void setCredentialsProvider(CredentialsProvider credentialsProvider) { this.credentialsProvider = credentialsProvider; } - public CredentialsRefreshService getCredentialsRefreshService() { - return credentialsRefreshService; - } - public void setCredentialsRefreshService(CredentialsRefreshService credentialsRefreshService) { this.credentialsRefreshService = credentialsRefreshService; } @@ -67,7 +64,7 @@ public class RabbitConnectionFactoryBeanConfigurer { */ public void configure(RabbitConnectionFactoryBean factory) { Assert.notNull(factory, "RabbitConnectionFactoryBean must not be null"); - factory.setResourceLoader(resourceLoader); + factory.setResourceLoader(this.resourceLoader); PropertyMapper map = PropertyMapper.get(); map.from(this.rabbitProperties::determineHost).whenNonNull().to(factory::setHost); map.from(this.rabbitProperties::determinePort).to(factory::setPort); @@ -97,8 +94,8 @@ public class RabbitConnectionFactoryBeanConfigurer { .to(factory::setConnectionTimeout); map.from(this.rabbitProperties::getChannelRpcTimeout).whenNonNull().asInt(Duration::toMillis) .to(factory::setChannelRpcTimeout); - map.from(credentialsProvider).whenNonNull().to(factory::setCredentialsProvider); - map.from(credentialsRefreshService).whenNonNull().to(factory::setCredentialsRefreshService); + map.from(this.credentialsProvider).whenNonNull().to(factory::setCredentialsProvider); + map.from(this.credentialsRefreshService).whenNonNull().to(factory::setCredentialsRefreshService); } }