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..b99fa99326c --- /dev/null +++ b/module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/AbstractJmsListenerContainerFactoryConfigurer.java @@ -0,0 +1,141 @@ +/* + * 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.config.JmsListenerContainerFactory; +import org.springframework.jms.support.converter.MessageConverter; +import org.springframework.jms.support.destination.DestinationResolver; +import org.springframework.util.Assert; + +/** + * 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 + * @author Lasse Wulff + * @since 4.1.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; + } + + /** + * 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. + * @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"); + JmsProperties properties = getJmsProperties(); + JmsProperties.Listener listenerProperties = properties.getListener(); + Session sessionProperties = listenerProperties.getSession(); + factory.setConnectionFactory(connectionFactory); + PropertyMapper map = PropertyMapper.get(); + 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); + } + +} 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..6eaf3104b62 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,18 +18,13 @@ 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 @@ -44,48 +39,13 @@ import org.springframework.util.Assert; * @author Vedran Pavic * @author Lasse Wulff * @since 4.0.0 + * @see SimpleJmsListenerContainerFactoryConfigurer */ -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 +55,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 - */ + @Override 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); + super.configure(factory, 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); + JmsProperties.Listener listenerProperties = getJmsProperties().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..3558547d956 --- /dev/null +++ b/module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/SimpleJmsListenerContainerFactoryConfigurer.java @@ -0,0 +1,45 @@ +/* + * 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 org.springframework.jms.config.SimpleJmsListenerContainerFactory; +import org.springframework.jms.listener.DefaultMessageListenerContainer; +import org.springframework.jms.listener.SimpleMessageListenerContainer; + +/** + * 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 { + +} 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..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; @@ -75,6 +76,7 @@ class JmsAutoConfigurationTests { .doesNotHaveBean(JmsMessagingTemplate.class) .doesNotHaveBean(JmsClient.class) .doesNotHaveBean(DefaultJmsListenerContainerFactoryConfigurer.class) + .doesNotHaveBean(SimpleJmsListenerContainerFactoryConfigurer.class) .doesNotHaveBean(DefaultJmsListenerContainerFactory.class)); } @@ -167,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 @@ -495,9 +515,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; }