From 98d843214b4b0e88a531181ae2cfdc5d7732ca85 Mon Sep 17 00:00:00 2001 From: Vedran Pavic Date: Thu, 27 Feb 2025 15:23:04 +0100 Subject: [PATCH 1/2] Add support for configuring SimpleMessageListenerContainer This commit introduces a `SimpleJmsListenerContainerFactoryConfigurer` that can be used to conveniently apply settings provided by JMS auto-configuration to `SimpleJmsListenerContainerFactory` instances. See gh-47716 Signed-off-by: Vedran Pavic --- .../reference/pages/messaging/jms.adoc | 5 + ...JmsListenerContainerFactoryConfigurer.java | 131 ++++++++++++++++++ ...JmsListenerContainerFactoryConfigurer.java | 93 ++----------- .../JmsAnnotationDrivenConfiguration.java | 16 ++- ...JmsListenerContainerFactoryConfigurer.java | 37 +++++ .../JmsAutoConfigurationTests.java | 6 +- 6 files changed, 200 insertions(+), 88 deletions(-) create mode 100644 module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/AbstractJmsListenerContainerFactoryConfigurer.java create mode 100644 module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/SimpleJmsListenerContainerFactoryConfigurer.java diff --git a/documentation/spring-boot-docs/src/docs/antora/modules/reference/pages/messaging/jms.adoc b/documentation/spring-boot-docs/src/docs/antora/modules/reference/pages/messaging/jms.adoc index 2e64c157108..7253d001b4b 100644 --- a/documentation/spring-boot-docs/src/docs/antora/modules/reference/pages/messaging/jms.adoc +++ b/documentation/spring-boot-docs/src/docs/antora/modules/reference/pages/messaging/jms.adoc @@ -191,3 +191,8 @@ NOTE: In the example above, the customization uses javadoc:org.springframework.b Then you can use the factory in any javadoc:org.springframework.jms.annotation.JmsListener[format=annotation]-annotated method as follows: include-code::custom/MyBean[] + +Analogous to `DefaultJmsListenerContainerFactoryConfigurer`, Spring Boot also provides a javadoc:org.springframework.boot.jms.autoconfigure.SimpleJmsListenerContainerFactoryConfigurer[] that you can use to initialize a javadoc:org.springframework.jms.config.SimpleJmsListenerContainerFactory[] and apply the related settings that auto-configuration provides. + +TIP: In contrast to javadoc:org.springframework.jms.listener.DefaultMessageListenerContainer[] that uses a pull-based mechanism (polling) to process messages, javadoc:org.springframework.jms.listener.SimpleMessageListenerContainer[] uses a push-based mechanism that's very close to the spirit of the standalone JMS specification. +To learn more about the differences between the two listener containers, consult their respective javadocs and {url-spring-framework-docs}/integration/jms/using.html#jms-mdp[Spring Framework reference documentation]. diff --git a/module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/AbstractJmsListenerContainerFactoryConfigurer.java b/module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/AbstractJmsListenerContainerFactoryConfigurer.java new file mode 100644 index 00000000000..d06fed4c7cb --- /dev/null +++ b/module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/AbstractJmsListenerContainerFactoryConfigurer.java @@ -0,0 +1,131 @@ +/* + * Copyright 2012-present 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.jms.autoconfigure; + +import io.micrometer.observation.ObservationRegistry; +import jakarta.jms.ConnectionFactory; +import jakarta.jms.ExceptionListener; +import org.jspecify.annotations.Nullable; + +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.support.converter.MessageConverter; +import org.springframework.jms.support.destination.DestinationResolver; +import org.springframework.util.Assert; + +/** + * Configures {@link AbstractJmsListenerContainerFactory} with sensible defaults. + * + * @param the connection factory type. + * @author Vedran Pavic + * @since 4.0.0 + */ +public abstract class AbstractJmsListenerContainerFactoryConfigurer> { + + private @Nullable DestinationResolver destinationResolver; + + private @Nullable MessageConverter messageConverter; + + private @Nullable ExceptionListener exceptionListener; + + private @Nullable ObservationRegistry observationRegistry; + + private @Nullable JmsProperties jmsProperties; + + /** + * Set the {@link DestinationResolver} to use or {@code null} if no destination + * resolver should be associated with the factory by default. + * @param destinationResolver the {@link DestinationResolver} + */ + void setDestinationResolver(@Nullable DestinationResolver destinationResolver) { + this.destinationResolver = destinationResolver; + } + + /** + * Set the {@link MessageConverter} to use or {@code null} if the out-of-the-box + * converter should be used. + * @param messageConverter the {@link MessageConverter} + */ + void setMessageConverter(@Nullable MessageConverter messageConverter) { + this.messageConverter = messageConverter; + } + + /** + * Set the {@link ExceptionListener} to use or {@code null} if no exception listener + * should be associated by default. + * @param exceptionListener the {@link ExceptionListener} + */ + void setExceptionListener(@Nullable ExceptionListener exceptionListener) { + this.exceptionListener = exceptionListener; + } + + /** + * Set the {@link JmsProperties} to use. + * @param jmsProperties the {@link JmsProperties} + */ + void setJmsProperties(@Nullable JmsProperties jmsProperties) { + this.jmsProperties = jmsProperties; + } + + /** + * Set the {@link ObservationRegistry} to use. + * @param observationRegistry the {@link ObservationRegistry} + */ + void setObservationRegistry(@Nullable ObservationRegistry observationRegistry) { + this.observationRegistry = observationRegistry; + } + + /** + * Configure the specified jms listener container factory. The factory can be further + * tuned and default settings can be overridden. + * @param factory the {@link AbstractJmsListenerContainerFactory} instance to + * configure + * @param connectionFactory the {@link ConnectionFactory} to use + */ + 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(); + 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(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); + +} diff --git a/module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/DefaultJmsListenerContainerFactoryConfigurer.java b/module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/DefaultJmsListenerContainerFactoryConfigurer.java index 27eaf8fddce..7f9ec6e9e44 100644 --- a/module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/DefaultJmsListenerContainerFactoryConfigurer.java +++ b/module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/DefaultJmsListenerContainerFactoryConfigurer.java @@ -18,22 +18,17 @@ package org.springframework.boot.jms.autoconfigure; import java.time.Duration; -import io.micrometer.observation.ObservationRegistry; import jakarta.jms.ConnectionFactory; -import jakarta.jms.ExceptionListener; import org.jspecify.annotations.Nullable; import org.springframework.boot.context.properties.PropertyMapper; import org.springframework.boot.jms.autoconfigure.JmsProperties.Listener.Session; import org.springframework.jms.config.DefaultJmsListenerContainerFactory; -import org.springframework.jms.support.converter.MessageConverter; -import org.springframework.jms.support.destination.DestinationResolver; import org.springframework.transaction.jta.JtaTransactionManager; -import org.springframework.util.Assert; /** - * Configure {@link DefaultJmsListenerContainerFactory} with sensible defaults tuned using - * configuration properties. + * Configures {@link DefaultJmsListenerContainerFactory} with sensible defaults tuned + * using configuration properties. *

* Can be injected into application code and used to define a custom * {@code DefaultJmsListenerContainerFactory} whose configuration is based upon that @@ -45,47 +40,11 @@ import org.springframework.util.Assert; * @author Lasse Wulff * @since 4.0.0 */ -public final class DefaultJmsListenerContainerFactoryConfigurer { - - private @Nullable DestinationResolver destinationResolver; - - private @Nullable MessageConverter messageConverter; - - private @Nullable ExceptionListener exceptionListener; +public final class DefaultJmsListenerContainerFactoryConfigurer + extends AbstractJmsListenerContainerFactoryConfigurer { private @Nullable JtaTransactionManager transactionManager; - private @Nullable JmsProperties jmsProperties; - - private @Nullable ObservationRegistry observationRegistry; - - /** - * Set the {@link DestinationResolver} to use or {@code null} if no destination - * resolver should be associated with the factory by default. - * @param destinationResolver the {@link DestinationResolver} - */ - void setDestinationResolver(@Nullable DestinationResolver destinationResolver) { - this.destinationResolver = destinationResolver; - } - - /** - * Set the {@link MessageConverter} to use or {@code null} if the out-of-the-box - * converter should be used. - * @param messageConverter the {@link MessageConverter} - */ - void setMessageConverter(@Nullable MessageConverter messageConverter) { - this.messageConverter = messageConverter; - } - - /** - * Set the {@link ExceptionListener} to use or {@code null} if no exception listener - * should be associated by default. - * @param exceptionListener the {@link ExceptionListener} - */ - void setExceptionListener(@Nullable ExceptionListener exceptionListener) { - this.exceptionListener = exceptionListener; - } - /** * Set the {@link JtaTransactionManager} to use or {@code null} if the JTA support * should not be used. @@ -95,50 +54,16 @@ public final class DefaultJmsListenerContainerFactoryConfigurer { this.transactionManager = transactionManager; } - /** - * Set the {@link JmsProperties} to use. - * @param jmsProperties the {@link JmsProperties} - */ - void setJmsProperties(@Nullable JmsProperties jmsProperties) { - this.jmsProperties = jmsProperties; - } - - /** - * Set the {@link ObservationRegistry} to use. - * @param observationRegistry the {@link ObservationRegistry} - */ - void setObservationRegistry(@Nullable ObservationRegistry observationRegistry) { - this.observationRegistry = observationRegistry; - } - - /** - * Configure the specified jms listener container factory. The factory can be further - * tuned and default settings can be overridden. - * @param factory the {@link DefaultJmsListenerContainerFactory} instance to configure - * @param connectionFactory the {@link ConnectionFactory} to use - */ - public void configure(DefaultJmsListenerContainerFactory 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(); - Session sessionProperties = listenerProperties.getSession(); - factory.setConnectionFactory(connectionFactory); + @Override + protected void configure(DefaultJmsListenerContainerFactory factory, ConnectionFactory connectionFactory, + JmsProperties jmsProperties) { 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); + JmsProperties.Listener listenerProperties = jmsProperties.getListener(); + Session sessionProperties = listenerProperties.getSession(); map.from(this.transactionManager).to(factory::setTransactionManager); - 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); if (this.transactionManager == null && sessionProperties.getTransacted() == null) { factory.setSessionTransacted(true); } - map.from(this.observationRegistry).to(factory::setObservationRegistry); - map.from(sessionProperties::getTransacted).to(factory::setSessionTransacted); - map.from(listenerProperties::isAutoStartup).to(factory::setAutoStartup); map.from(listenerProperties::formatConcurrency).to(factory::setConcurrency); map.from(listenerProperties::getReceiveTimeout).as(Duration::toMillis).to(factory::setReceiveTimeout); map.from(listenerProperties::getMaxMessagesPerTask).to(factory::setMaxMessagesPerTask); diff --git a/module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/JmsAnnotationDrivenConfiguration.java b/module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/JmsAnnotationDrivenConfiguration.java index d0587784796..540bb75a78d 100644 --- a/module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/JmsAnnotationDrivenConfiguration.java +++ b/module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/JmsAnnotationDrivenConfiguration.java @@ -42,6 +42,7 @@ import org.springframework.transaction.jta.JtaTransactionManager; * @author Phillip Webb * @author Stephane Nicoll * @author Eddú Meléndez + * @author Vedran Pavic */ @Configuration(proxyBeanMethods = false) @ConditionalOnClass(EnableJms.class) @@ -73,8 +74,7 @@ class JmsAnnotationDrivenConfiguration { @Bean @ConditionalOnMissingBean - @SuppressWarnings("removal") - DefaultJmsListenerContainerFactoryConfigurer jmsListenerContainerFactoryConfigurer() { + DefaultJmsListenerContainerFactoryConfigurer defaultJmsListenerContainerFactoryConfigurer() { DefaultJmsListenerContainerFactoryConfigurer configurer = new DefaultJmsListenerContainerFactoryConfigurer(); configurer.setDestinationResolver(this.destinationResolver.getIfUnique()); configurer.setTransactionManager(this.transactionManager.getIfUnique()); @@ -85,6 +85,18 @@ class JmsAnnotationDrivenConfiguration { return configurer; } + @Bean + @ConditionalOnMissingBean + SimpleJmsListenerContainerFactoryConfigurer simpleJmsListenerContainerFactoryConfigurer() { + SimpleJmsListenerContainerFactoryConfigurer configurer = new SimpleJmsListenerContainerFactoryConfigurer(); + configurer.setDestinationResolver(this.destinationResolver.getIfUnique()); + configurer.setMessageConverter(this.messageConverter.getIfUnique()); + configurer.setExceptionListener(this.exceptionListener.getIfUnique()); + configurer.setObservationRegistry(this.observationRegistry.getIfUnique()); + configurer.setJmsProperties(this.properties); + return configurer; + } + @Bean @ConditionalOnSingleCandidate(ConnectionFactory.class) @ConditionalOnMissingBean(name = "jmsListenerContainerFactory") diff --git a/module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/SimpleJmsListenerContainerFactoryConfigurer.java b/module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/SimpleJmsListenerContainerFactoryConfigurer.java new file mode 100644 index 00000000000..c13f6c05e14 --- /dev/null +++ b/module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/SimpleJmsListenerContainerFactoryConfigurer.java @@ -0,0 +1,37 @@ +/* + * Copyright 2012-present 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.jms.autoconfigure; + +import jakarta.jms.ConnectionFactory; + +import org.springframework.jms.config.SimpleJmsListenerContainerFactory; + +/** + * Configures {@link SimpleJmsListenerContainerFactory} with sensible defaults. + * + * @author Vedran Pavic + * @since 4.0.0 + */ +public final class SimpleJmsListenerContainerFactoryConfigurer + extends AbstractJmsListenerContainerFactoryConfigurer { + + @Override + protected void configure(SimpleJmsListenerContainerFactory factory, ConnectionFactory connectionFactory, + JmsProperties jmsProperties) { + } + +} diff --git a/module/spring-boot-jms/src/test/java/org/springframework/boot/jms/autoconfigure/JmsAutoConfigurationTests.java b/module/spring-boot-jms/src/test/java/org/springframework/boot/jms/autoconfigure/JmsAutoConfigurationTests.java index c089a7000f0..a140e67252e 100644 --- a/module/spring-boot-jms/src/test/java/org/springframework/boot/jms/autoconfigure/JmsAutoConfigurationTests.java +++ b/module/spring-boot-jms/src/test/java/org/springframework/boot/jms/autoconfigure/JmsAutoConfigurationTests.java @@ -75,6 +75,7 @@ class JmsAutoConfigurationTests { .doesNotHaveBean(JmsMessagingTemplate.class) .doesNotHaveBean(JmsClient.class) .doesNotHaveBean(DefaultJmsListenerContainerFactoryConfigurer.class) + .doesNotHaveBean(SimpleJmsListenerContainerFactoryConfigurer.class) .doesNotHaveBean(DefaultJmsListenerContainerFactory.class)); } @@ -495,9 +496,10 @@ class JmsAutoConfigurationTests { static class TestConfiguration6 { @Bean - JmsListenerContainerFactory jmsListenerContainerFactory(ConnectionFactory connectionFactory) { + JmsListenerContainerFactory jmsListenerContainerFactory( + SimpleJmsListenerContainerFactoryConfigurer configurer, ConnectionFactory connectionFactory) { SimpleJmsListenerContainerFactory factory = new SimpleJmsListenerContainerFactory(); - factory.setConnectionFactory(connectionFactory); + configurer.configure(factory, connectionFactory); return factory; } From 30a56c2de9e4b1c941c731a8bae20fcbcba40094 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?St=C3=A9phane=20Nicoll?= Date: Mon, 17 Nov 2025 13:47:52 +0100 Subject: [PATCH 2/2] Polish "Add support for configuring SimpleMessageListenerContainer" See gh-47716 --- ...JmsListenerContainerFactoryConfigurer.java | 46 +++++++++++-------- ...JmsListenerContainerFactoryConfigurer.java | 11 +++-- ...JmsListenerContainerFactoryConfigurer.java | 24 ++++++---- .../JmsAutoConfigurationTests.java | 43 ++++++++++++----- 4 files changed, 81 insertions(+), 43 deletions(-) diff --git a/module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/AbstractJmsListenerContainerFactoryConfigurer.java b/module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/AbstractJmsListenerContainerFactoryConfigurer.java index d06fed4c7cb..b99fa99326c 100644 --- a/module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/AbstractJmsListenerContainerFactoryConfigurer.java +++ b/module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/AbstractJmsListenerContainerFactoryConfigurer.java @@ -24,16 +24,28 @@ import org.jspecify.annotations.Nullable; 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. + *

+ * This includes: + *

  • A {@link DestinationResolver} is such a component is present.
    • + *
  • A {@link MessageConverter} is such a component is present.
    • + *
  • An {@link ExceptionListener} is such a component is present.
    • + *
  • An {@link ObservationRegistry} is such a component is present.
    • + *
  • Configuration properties of the {@code spring.jms} namespace that are common to all + * implementations.
    • * * @param 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> { @@ -90,6 +102,15 @@ public abstract class AbstractJmsListenerContainerFactoryConfigurer * Can be injected into application code and used to define a custom * {@code DefaultJmsListenerContainerFactory} whose configuration is based upon that @@ -39,6 +39,7 @@ import org.springframework.transaction.jta.JtaTransactionManager; * @author Vedran Pavic * @author Lasse Wulff * @since 4.0.0 + * @see SimpleJmsListenerContainerFactoryConfigurer */ public final class DefaultJmsListenerContainerFactoryConfigurer extends AbstractJmsListenerContainerFactoryConfigurer { @@ -55,10 +56,10 @@ public final class DefaultJmsListenerContainerFactoryConfigurer } @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) { diff --git a/module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/SimpleJmsListenerContainerFactoryConfigurer.java b/module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/SimpleJmsListenerContainerFactoryConfigurer.java index c13f6c05e14..3558547d956 100644 --- a/module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/SimpleJmsListenerContainerFactoryConfigurer.java +++ b/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. + *

    + * As such, concurrency-related configuration properties from the {@code spring.jms} + * namespace are not taken into account by this implementation. + *

    + * 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 { - @Override - protected void configure(SimpleJmsListenerContainerFactory factory, ConnectionFactory connectionFactory, - JmsProperties jmsProperties) { - } - } diff --git a/module/spring-boot-jms/src/test/java/org/springframework/boot/jms/autoconfigure/JmsAutoConfigurationTests.java b/module/spring-boot-jms/src/test/java/org/springframework/boot/jms/autoconfigure/JmsAutoConfigurationTests.java index a140e67252e..84b406d10b3 100644 --- a/module/spring-boot-jms/src/test/java/org/springframework/boot/jms/autoconfigure/JmsAutoConfigurationTests.java +++ b/module/spring-boot-jms/src/test/java/org/springframework/boot/jms/autoconfigure/JmsAutoConfigurationTests.java @@ -45,6 +45,7 @@ import org.springframework.jms.core.JmsClient; 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 @@ class JmsAutoConfigurationTests { "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