Polish "Add support for configuring SimpleMessageListenerContainer"

See spring-projectsgh-47716

Author: snicoll

module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/AbstractJmsListenerContainerFactoryConfigurer.java

@@ -24,16 +24,28 @@
 import org.springframework.boot.context.properties.PropertyMapper;
 import org.springframework.boot.jms.autoconfigure.JmsProperties.Listener.Session;
 import org.springframework.jms.config.AbstractJmsListenerContainerFactory;
+import org.springframework.jms.config.JmsListenerContainerFactory;
 import org.springframework.jms.support.converter.MessageConverter;
 import org.springframework.jms.support.destination.DestinationResolver;
 import org.springframework.util.Assert;
 
 /**
- * Configures {@link AbstractJmsListenerContainerFactory} with sensible defaults.
+ * Configure common {@link JmsListenerContainerFactory} settings with sensible defaults.
+ * <p>
+ * This includes:
+ * <li>A {@link DestinationResolver} is such a component is present.</li>
+ * <li>A {@link MessageConverter} is such a component is present.</li>
+ * <li>An {@link ExceptionListener} is such a component is present.</li>
+ * <li>An {@link ObservationRegistry} is such a component is present.</li>
+ * <li>Configuration properties of the {@code spring.jms} namespace that are common to all
+ * implementations.</li>
  *
  * @param <T> the connection factory type.
+ * @author Stephane Nicoll
+ * @author Eddú Meléndez
  * @author Vedran Pavic
- * @since 4.0.0
+ * @author Lasse Wulff
+ * @since 4.1.0
  */
 public abstract class AbstractJmsListenerContainerFactoryConfigurer<T extends AbstractJmsListenerContainerFactory<?>> {
 
@@ -90,6 +102,15 @@ void setObservationRegistry(@Nullable ObservationRegistry observationRegistry) {
 		this.observationRegistry = observationRegistry;
 	}
 
+	/**
+	 * Return the {@link JmsProperties}.
+	 * @return the jms properties
+	 */
+	protected JmsProperties getJmsProperties() {
+		Assert.state(this.jmsProperties != null, "'jmsProperties' must not be null");
+		return this.jmsProperties;
+	}
+
 	/**
 	 * Configure the specified jms listener container factory. The factory can be further
 	 * tuned and default settings can be overridden.
@@ -100,32 +121,21 @@ void setObservationRegistry(@Nullable ObservationRegistry observationRegistry) {
 	public void configure(T factory, ConnectionFactory connectionFactory) {
 		Assert.notNull(factory, "'factory' must not be null");
 		Assert.notNull(connectionFactory, "'connectionFactory' must not be null");
-		Assert.state(this.jmsProperties != null, "'jmsProperties' must not be null");
-		JmsProperties.Listener listenerProperties = this.jmsProperties.getListener();
+		JmsProperties properties = getJmsProperties();
+		JmsProperties.Listener listenerProperties = properties.getListener();
 		Session sessionProperties = listenerProperties.getSession();
 		factory.setConnectionFactory(connectionFactory);
 		PropertyMapper map = PropertyMapper.get();
-		map.from(this.jmsProperties::isPubSubDomain).to(factory::setPubSubDomain);
-		map.from(this.jmsProperties::isSubscriptionDurable).to(factory::setSubscriptionDurable);
-		map.from(this.jmsProperties::getClientId).to(factory::setClientId);
+		map.from(properties::isPubSubDomain).to(factory::setPubSubDomain);
+		map.from(properties::isSubscriptionDurable).to(factory::setSubscriptionDurable);
+		map.from(properties::getClientId).to(factory::setClientId);
 		map.from(this.destinationResolver).to(factory::setDestinationResolver);
 		map.from(this.messageConverter).to(factory::setMessageConverter);
 		map.from(this.exceptionListener).to(factory::setExceptionListener);
 		map.from(sessionProperties.getAcknowledgeMode()::getMode).to(factory::setSessionAcknowledgeMode);
 		map.from(this.observationRegistry).to(factory::setObservationRegistry);
 		map.from(sessionProperties::getTransacted).to(factory::setSessionTransacted);
 		map.from(listenerProperties::isAutoStartup).to(factory::setAutoStartup);
-		configure(factory, connectionFactory, this.jmsProperties);
 	}
 
-	/**
-	 * Configures the given {@code factory} using the given {@code connectionFactory} and
-	 * {@code jmsProperties}.
-	 * @param factory the {@link AbstractJmsListenerContainerFactory} instance to
-	 * configure
-	 * @param connectionFactory the {@link ConnectionFactory} to use
-	 * @param jmsProperties the {@link JmsProperties} to use
-	 */
-	protected abstract void configure(T factory, ConnectionFactory connectionFactory, JmsProperties jmsProperties);
-
 }

module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/DefaultJmsListenerContainerFactoryConfigurer.java

@@ -27,8 +27,8 @@
 import org.springframework.transaction.jta.JtaTransactionManager;
 
 /**
- * Configures {@link DefaultJmsListenerContainerFactory} with sensible defaults tuned
- * using configuration properties.
+ * Configure {@link DefaultJmsListenerContainerFactory} with sensible defaults tuned using
+ * configuration properties.
  * <p>
  * Can be injected into application code and used to define a custom
  * {@code DefaultJmsListenerContainerFactory} whose configuration is based upon that
@@ -39,6 +39,7 @@
  * @author Vedran Pavic
  * @author Lasse Wulff
  * @since 4.0.0
+ * @see SimpleJmsListenerContainerFactoryConfigurer
  */
 public final class DefaultJmsListenerContainerFactoryConfigurer
 		extends AbstractJmsListenerContainerFactoryConfigurer<DefaultJmsListenerContainerFactory> {
@@ -55,10 +56,10 @@ void setTransactionManager(@Nullable JtaTransactionManager transactionManager) {
 	}
 
 	@Override
-	protected void configure(DefaultJmsListenerContainerFactory factory, ConnectionFactory connectionFactory,
-			JmsProperties jmsProperties) {
+	public void configure(DefaultJmsListenerContainerFactory factory, ConnectionFactory connectionFactory) {
+		super.configure(factory, connectionFactory);
 		PropertyMapper map = PropertyMapper.get();
-		JmsProperties.Listener listenerProperties = jmsProperties.getListener();
+		JmsProperties.Listener listenerProperties = getJmsProperties().getListener();
 		Session sessionProperties = listenerProperties.getSession();
 		map.from(this.transactionManager).to(factory::setTransactionManager);
 		if (this.transactionManager == null && sessionProperties.getTransacted() == null) {

module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/SimpleJmsListenerContainerFactoryConfigurer.java

@@ -16,22 +16,30 @@
 
 package org.springframework.boot.jms.autoconfigure;
 
-import jakarta.jms.ConnectionFactory;
-
 import org.springframework.jms.config.SimpleJmsListenerContainerFactory;
+import org.springframework.jms.listener.DefaultMessageListenerContainer;
+import org.springframework.jms.listener.SimpleMessageListenerContainer;
 
 /**
- * Configures {@link SimpleJmsListenerContainerFactory} with sensible defaults.
+ * Configure {@link SimpleJmsListenerContainerFactory} with sensible defaults. In contrast
+ * to {@link DefaultMessageListenerContainer} that uses a pull-based mechanism (polling)
+ * to process messages, the {@link SimpleMessageListenerContainer} instances created by
+ * this factory use a push-based mechanism that's very close to the spirit of the
+ * standalone JMS specification.
+ * <p>
+ * As such, concurrency-related configuration properties from the {@code spring.jms}
+ * namespace are not taken into account by this implementation.
+ * <p>
+ * Can be injected into application code and used to define a custom
+ * {@code SimpleJmsListenerContainerFactory} whose configuration is based upon that
+ * produced by auto-configuration.
  *
  * @author Vedran Pavic
+ * @author Stephane Nicoll
  * @since 4.0.0
+ * @see DefaultJmsListenerContainerFactoryConfigurer
  */
 public final class SimpleJmsListenerContainerFactoryConfigurer
 		extends AbstractJmsListenerContainerFactoryConfigurer<SimpleJmsListenerContainerFactory> {
 
-	@Override
-	protected void configure(SimpleJmsListenerContainerFactory factory, ConnectionFactory connectionFactory,
-			JmsProperties jmsProperties) {
-	}
-
 }

module/spring-boot-jms/src/test/java/org/springframework/boot/jms/autoconfigure/JmsAutoConfigurationTests.java

@@ -45,6 +45,7 @@
 import org.springframework.jms.core.JmsMessagingTemplate;
 import org.springframework.jms.core.JmsTemplate;
 import org.springframework.jms.listener.DefaultMessageListenerContainer;
+import org.springframework.jms.listener.SimpleMessageListenerContainer;
 import org.springframework.jms.support.converter.MessageConverter;
 import org.springframework.jms.support.destination.DestinationResolver;
 import org.springframework.transaction.jta.JtaTransactionManager;
@@ -168,20 +169,38 @@ void testJmsListenerContainerFactoryWithCustomSettings() {
 					"spring.jms.listener.receiveTimeout=2s", "spring.jms.listener.maxConcurrency=10",
 					"spring.jms.subscription-durable=true", "spring.jms.client-id=exampleId",
 					"spring.jms.listener.max-messages-per-task=5")
-			.run(this::testJmsListenerContainerFactoryWithCustomSettings);
+			.run((context) -> {
+				DefaultMessageListenerContainer container = getContainer(context, "jmsListenerContainerFactory");
+				assertThat(container.isAutoStartup()).isFalse();
+				assertThat(container.getSessionAcknowledgeMode()).isEqualTo(Session.CLIENT_ACKNOWLEDGE);
+				assertThat(container.isSessionTransacted()).isFalse();
+				assertThat(container.getConcurrentConsumers()).isEqualTo(2);
+				assertThat(container.getMaxConcurrentConsumers()).isEqualTo(10);
+				assertThat(container).hasFieldOrPropertyWithValue("receiveTimeout", 2000L);
+				assertThat(container).hasFieldOrPropertyWithValue("maxMessagesPerTask", 5);
+				assertThat(container.isSubscriptionDurable()).isTrue();
+				assertThat(container.getClientId()).isEqualTo("exampleId");
+			});
 	}
 
-	private void testJmsListenerContainerFactoryWithCustomSettings(AssertableApplicationContext loaded) {
-		DefaultMessageListenerContainer container = getContainer(loaded, "jmsListenerContainerFactory");
-		assertThat(container.isAutoStartup()).isFalse();
-		assertThat(container.getSessionAcknowledgeMode()).isEqualTo(Session.CLIENT_ACKNOWLEDGE);
-		assertThat(container.isSessionTransacted()).isFalse();
-		assertThat(container.getConcurrentConsumers()).isEqualTo(2);
-		assertThat(container.getMaxConcurrentConsumers()).isEqualTo(10);
-		assertThat(container).hasFieldOrPropertyWithValue("receiveTimeout", 2000L);
-		assertThat(container).hasFieldOrPropertyWithValue("maxMessagesPerTask", 5);
-		assertThat(container.isSubscriptionDurable()).isTrue();
-		assertThat(container.getClientId()).isEqualTo("exampleId");
+	@Test
+	void testManualJmsListenerContainerFactoryWithCustomSettings() {
+		this.contextRunner.withUserConfiguration(TestConfiguration6.class, EnableJmsConfiguration.class)
+			.withPropertyValues("spring.jms.listener.autoStartup=false",
+					"spring.jms.listener.session.acknowledgeMode=client",
+					"spring.jms.listener.session.transacted=false", "spring.jms.subscription-durable=true",
+					"spring.jms.client-id=exampleId")
+			.run((context) -> {
+				SimpleJmsListenerContainerFactory containerFactory = context.getBean("jmsListenerContainerFactory",
+						SimpleJmsListenerContainerFactory.class);
+				SimpleMessageListenerContainer container = containerFactory
+					.createListenerContainer(mock(JmsListenerEndpoint.class));
+				assertThat(container.isAutoStartup()).isFalse();
+				assertThat(container.getSessionAcknowledgeMode()).isEqualTo(Session.CLIENT_ACKNOWLEDGE);
+				assertThat(container.isSessionTransacted()).isFalse();
+				assertThat(container.isSubscriptionDurable()).isTrue();
+				assertThat(container.getClientId()).isEqualTo("exampleId");
+			});
 	}
 
 	@Test