spring/spring-boot
1
0
Fork 0
mirror of https://github.com/spring-projects/spring-boot.git synced 2026-09-17 12:09:16 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #47716 from vpavic

Browse Source 
* pr/47716:
  Polish "Add support for configuring SimpleMessageListenerContainer"
  Add support for configuring SimpleMessageListenerContainer

Closes gh-47716
This commit is contained in:
Stéphane Nicoll
2025-12-19 11:44:59 +01:00
parent bc054066d5 30a56c2de9
commit 784fd6c13e
6 changed files with 247 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files
documentation/spring-boot-docs/src/docs/antora/modules/reference/pages/messaging/jms.adoc
+5
View File
@@ -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].
module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/AbstractJmsListenerContainerFactoryConfigurer.java
+141
View File
@@ -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.
* <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
* @author Lasse Wulff
* @since 4.1.0
*/
public abstract class AbstractJmsListenerContainerFactoryConfigurer<T extends AbstractJmsListenerContainerFactory<?>> {
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);
}
}
module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/DefaultJmsListenerContainerFactoryConfigurer.java
+7 -81
View File
@@ -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<DefaultJmsListenerContainerFactory> {
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);
module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/JmsAnnotationDrivenConfiguration.java
+14 -2
View File
@@ -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")
module/spring-boot-jms/src/main/java/org/springframework/boot/jms/autoconfigure/SimpleJmsListenerContainerFactoryConfigurer.java
+45
View File
@@ -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.
* <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> {
}
module/spring-boot-jms/src/test/java/org/springframework/boot/jms/autoconfigure/JmsAutoConfigurationTests.java
+35 -14
View File
@@ -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;
}