Reduce factory method complexity

- proposed new model for non-null property propagation

* Polishing - PR comments; extract to utility and provide chaining.

* Javadocs for INSTANCE.

* Fix Javadocs (checkstyle)

* Configure direct containers the same way.

* Returning this is more efficient than INSTANCE.

Author: garyrussell

spring-amqp/src/main/java/org/springframework/amqp/utils/JavaUtils.java

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2019 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
+ *
+ *      http://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.amqp.utils;
+
+import java.util.function.Consumer;
+
+/**
+ * Chained utility methods to simplify some Java repetitive code. Obtain a reference to
+ * the singleton {@link #INSTANCE} and then chain calls to the utility methods.
+ *
+ * @author Gary Russell
+ * @since 2.1.4
+ *
+ */
+public final class JavaUtils {
+
+	/**
+	 * The singleton instance of this utility class.
+	 */
+	public static final JavaUtils INSTANCE = new JavaUtils();
+
+	private JavaUtils() {
+		super();
+	}
+
+	/**
+	 * Invoke {@link Consumer#accept(Object)} with the value if the condition is true.
+	 * @param condition the condition.
+	 * @param value the value.
+	 * @param consumer the consumer.
+	 * @param <T> the value type.
+	 * @return this.
+	 */
+	public <T> JavaUtils acceptIfCondition(boolean condition, T value, Consumer<T> consumer) {
+		if (condition) {
+			consumer.accept(value);
+		}
+		return this;
+	}
+
+	/**
+	 * Invoke {@link Consumer#accept(Object)} with the value if it is not null.
+	 * @param value the value.
+	 * @param consumer the consumer.
+	 * @param <T> the value type.
+	 * @return this.
+	 */
+	public <T> JavaUtils acceptIfNotNull(T value, Consumer<T> consumer) {
+		if (value != null) {
+			consumer.accept(value);
+		}
+		return this;
+	}
+
+}

spring-rabbit/src/main/java/org/springframework/amqp/rabbit/config/DirectRabbitListenerContainerFactory.java

@@ -18,6 +18,7 @@
 
 import org.springframework.amqp.rabbit.listener.DirectMessageListenerContainer;
 import org.springframework.amqp.rabbit.listener.RabbitListenerEndpoint;
+import org.springframework.amqp.utils.JavaUtils;
 import org.springframework.scheduling.TaskScheduler;
 
 /**
@@ -104,12 +105,10 @@ protected DirectMessageListenerContainer createContainerInstance() {
 	protected void initializeContainer(DirectMessageListenerContainer instance, RabbitListenerEndpoint endpoint) {
 		super.initializeContainer(instance, endpoint);
 
-		if (this.taskScheduler != null) {
-			instance.setTaskScheduler(this.taskScheduler);
-		}
-		if (this.monitorInterval != null) {
-			instance.setMonitorInterval(this.monitorInterval);
-		}
+		JavaUtils javaUtils = JavaUtils.INSTANCE.acceptIfNotNull(this.taskScheduler, instance::setTaskScheduler)
+			.acceptIfNotNull(this.monitorInterval, instance::setMonitorInterval)
+			.acceptIfNotNull(this.messagesPerAck, instance::setMessagesPerAck)
+			.acceptIfNotNull(this.ackTimeout, instance::setAckTimeout);
 		if (endpoint != null && endpoint.getConcurrency() != null) {
 			try {
 				instance.setConsumersPerQueue(Integer.parseInt(endpoint.getConcurrency()));
@@ -118,14 +117,8 @@ protected void initializeContainer(DirectMessageListenerContainer instance, Rabb
 				throw new IllegalStateException("Failed to parse concurrency: " + e.getMessage(), e);
 			}
 		}
-		else if (this.consumersPerQueue != null) {
-			instance.setConsumersPerQueue(this.consumersPerQueue);
-		}
-		if (this.messagesPerAck != null) {
-			instance.setMessagesPerAck(this.messagesPerAck);
-		}
-		if (this.ackTimeout != null) {
-			instance.setAckTimeout(this.ackTimeout);
+		else {
+			javaUtils.acceptIfNotNull(this.consumersPerQueue, instance::setConsumersPerQueue);
 		}
 	}
 

spring-rabbit/src/main/java/org/springframework/amqp/rabbit/config/SimpleRabbitListenerContainerFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2014-2018 the original author or authors.
+ * Copyright 2014-2019 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.
@@ -18,6 +18,7 @@
 
 import org.springframework.amqp.rabbit.listener.RabbitListenerEndpoint;
 import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
+import org.springframework.amqp.utils.JavaUtils;
 
 /**
  * A {@link org.springframework.amqp.rabbit.listener.RabbitListenerContainerFactory}
@@ -134,44 +135,28 @@ protected SimpleMessageListenerContainer createContainerInstance() {
 		return new SimpleMessageListenerContainer();
 	}
 
-	@Override // NOSONAR complexity = mostly null checks
+	@Override
 	protected void initializeContainer(SimpleMessageListenerContainer instance, RabbitListenerEndpoint endpoint) {
 		super.initializeContainer(instance, endpoint);
 
-		if (this.txSize != null) {
-			instance.setTxSize(this.txSize);
-		}
+		JavaUtils javaUtils = JavaUtils.INSTANCE
+			.acceptIfNotNull(this.txSize, instance::setTxSize);
 		String concurrency = null;
 		if (endpoint != null) {
 			concurrency = endpoint.getConcurrency();
-			if (concurrency != null) {
-				instance.setConcurrency(concurrency);
-			}
-		}
-		if (concurrency == null && this.concurrentConsumers != null) {
-			instance.setConcurrentConsumers(this.concurrentConsumers);
-		}
-		if ((concurrency == null || !(concurrency.contains("-"))) && this.maxConcurrentConsumers != null) {
-			instance.setMaxConcurrentConsumers(this.maxConcurrentConsumers);
-		}
-		if (this.startConsumerMinInterval != null) {
-			instance.setStartConsumerMinInterval(this.startConsumerMinInterval);
-		}
-		if (this.stopConsumerMinInterval != null) {
-			instance.setStopConsumerMinInterval(this.stopConsumerMinInterval);
-		}
-		if (this.consecutiveActiveTrigger != null) {
-			instance.setConsecutiveActiveTrigger(this.consecutiveActiveTrigger);
-		}
-		if (this.consecutiveIdleTrigger != null) {
-			instance.setConsecutiveIdleTrigger(this.consecutiveIdleTrigger);
-		}
-		if (this.receiveTimeout != null) {
-			instance.setReceiveTimeout(this.receiveTimeout);
-		}
-		if (this.deBatchingEnabled != null) {
-			instance.setDeBatchingEnabled(this.deBatchingEnabled);
+			javaUtils.acceptIfNotNull(concurrency, instance::setConcurrency);
 		}
+		javaUtils
+			.acceptIfCondition(concurrency == null && this.concurrentConsumers != null, this.concurrentConsumers,
+				instance::setConcurrentConsumers)
+			.acceptIfCondition((concurrency == null || !(concurrency.contains("-"))) && this.maxConcurrentConsumers != null,
+				this.maxConcurrentConsumers, instance::setMaxConcurrentConsumers)
+			.acceptIfNotNull(this.startConsumerMinInterval, instance::setStartConsumerMinInterval)
+			.acceptIfNotNull(this.stopConsumerMinInterval, instance::setStopConsumerMinInterval)
+			.acceptIfNotNull(this.consecutiveActiveTrigger, instance::setConsecutiveActiveTrigger)
+			.acceptIfNotNull(this.consecutiveIdleTrigger, instance::setConsecutiveIdleTrigger)
+			.acceptIfNotNull(this.receiveTimeout, instance::setReceiveTimeout)
+			.acceptIfNotNull(this.deBatchingEnabled, instance::setDeBatchingEnabled);
 	}
 
 }