From 2c8658c24f9215c22b3f39fdd9ade520b4875d22 Mon Sep 17 00:00:00 2001 From: Andy Wilkinson Date: Tue, 13 Jul 2021 17:15:04 +0100 Subject: [PATCH] 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; + protected AbstractConnectionFactoryConfigurer(RabbitProperties properties) { + Assert.notNull(properties, "RabbitProperties must not be null"); + this.rabbitProperties = properties; } - public void setRabbitProperties(RabbitProperties rabbitProperties) { - this.rabbitProperties = rabbitProperties; + protected final ConnectionNameStrategy getConnectionNameStrategy() { + return this.connectionNameStrategy; } - public ConnectionNameStrategy getConnectionNameStrategy() { - return 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); } }