Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Add support for auto-configuring SimpleMessageListenerContainer #44465

Open
wants to merge 1 commit into
base: main
Choose a base branch
from
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
@@ -0,0 +1,129 @@
/*
* Copyright 2012-2025 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.autoconfigure.jms;

import io.micrometer.observation.ObservationRegistry;
import jakarta.jms.ConnectionFactory;
import jakarta.jms.ExceptionListener;

import org.springframework.boot.autoconfigure.jms.JmsProperties.Listener.Session;
import org.springframework.boot.context.properties.PropertyMapper;
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 <T> the connection factory type.
* @author Vedran Pavic
* @since 3.5.0
*/
public abstract class AbstractJmsListenerContainerFactoryConfigurer<T extends AbstractJmsListenerContainerFactory<?>> {

private DestinationResolver destinationResolver;

private MessageConverter messageConverter;

private ExceptionListener exceptionListener;

private ObservationRegistry observationRegistry;

private 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(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(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(ExceptionListener exceptionListener) {
this.exceptionListener = exceptionListener;
}

/**
* Set the {@link ObservationRegistry} to use.
* @param observationRegistry the {@link ObservationRegistry}
*/
void setObservationRegistry(ObservationRegistry observationRegistry) {
this.observationRegistry = observationRegistry;
}

/**
* Set the {@link JmsProperties} to use.
* @param jmsProperties the {@link JmsProperties}
*/
void setJmsProperties(JmsProperties jmsProperties) {
this.jmsProperties = 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.Listener listenerProperties = this.jmsProperties.getListener();
Session sessionProperties = listenerProperties.getSession();
factory.setConnectionFactory(connectionFactory);
PropertyMapper map = PropertyMapper.get().alwaysApplyingWhenNonNull();
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);

}
Original file line number Diff line number Diff line change
Expand Up @@ -20,66 +20,26 @@

import io.micrometer.observation.ObservationRegistry;
import jakarta.jms.ConnectionFactory;
import jakarta.jms.ExceptionListener;

import org.springframework.boot.autoconfigure.jms.JmsProperties.Listener.Session;
import org.springframework.boot.context.properties.PropertyMapper;
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.
* Configures {@link DefaultJmsListenerContainerFactory} with sensible defaults.
*
* @author Stephane Nicoll
* @author Eddú Meléndez
* @author Vedran Pavic
* @author Lasse Wulff
* @since 1.3.3
*/
public final class DefaultJmsListenerContainerFactoryConfigurer {

private DestinationResolver destinationResolver;

private MessageConverter messageConverter;

private ExceptionListener exceptionListener;
public final class DefaultJmsListenerContainerFactoryConfigurer
extends AbstractJmsListenerContainerFactoryConfigurer<DefaultJmsListenerContainerFactory> {

private JtaTransactionManager transactionManager;

private JmsProperties jmsProperties;

private 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(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(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(ExceptionListener exceptionListener) {
this.exceptionListener = exceptionListener;
}

/**
* Set the {@link JtaTransactionManager} to use or {@code null} if the JTA support
* should not be used.
Expand All @@ -89,50 +49,26 @@ void setTransactionManager(JtaTransactionManager transactionManager) {
this.transactionManager = transactionManager;
}

/**
* Set the {@link JmsProperties} to use.
* @param jmsProperties the {@link JmsProperties}
*/
void setJmsProperties(JmsProperties jmsProperties) {
this.jmsProperties = jmsProperties;
}

/**
* Set the {@link ObservationRegistry} to use.
* @param observationRegistry the {@link ObservationRegistry}
* @since 3.2.1
*/
@Override
public void setObservationRegistry(ObservationRegistry observationRegistry) {
this.observationRegistry = observationRegistry;
super.setObservationRegistry(observationRegistry);
}
Comment on lines +57 to 60
Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This override is here to preserve backwards compatibility (see #44466), as AbstractJmsListenerContainerFactoryConfigurer introduced in this PR reduces visibility to package private.


/**
* 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");
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().alwaysApplyingWhenNonNull();
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);
Expand Down
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
/*
* Copyright 2012-2024 the original author or authors.
* Copyright 2012-2025 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.
Expand All @@ -24,13 +24,15 @@
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnJndi;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.autoconfigure.condition.ConditionalOnSingleCandidate;
import org.springframework.boot.jms.ConnectionFactoryUnwrapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jms.annotation.EnableJms;
import org.springframework.jms.config.DefaultJmsListenerContainerFactory;
import org.springframework.jms.config.JmsListenerConfigUtils;
import org.springframework.jms.config.SimpleJmsListenerContainerFactory;
import org.springframework.jms.support.converter.MessageConverter;
import org.springframework.jms.support.destination.DestinationResolver;
import org.springframework.jms.support.destination.JndiDestinationResolver;
Expand All @@ -42,56 +44,74 @@
* @author Phillip Webb
* @author Stephane Nicoll
* @author Eddú Meléndez
* @author Vedran Pavic
*/
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(EnableJms.class)
class JmsAnnotationDrivenConfiguration {

private final ObjectProvider<DestinationResolver> destinationResolver;

private final ObjectProvider<JtaTransactionManager> transactionManager;
@Configuration(proxyBeanMethods = false)
@ConditionalOnProperty(name = "spring.jms.listener.container-type", havingValue = "default", matchIfMissing = true)
static class DefaultJmsListenerContainerFactoryConfiguration {

private final ObjectProvider<MessageConverter> messageConverter;
@Bean
@ConditionalOnMissingBean
DefaultJmsListenerContainerFactoryConfigurer jmsListenerContainerFactoryConfigurer(
ObjectProvider<DestinationResolver> destinationResolver,
ObjectProvider<JtaTransactionManager> transactionManager,
ObjectProvider<MessageConverter> messageConverter, ObjectProvider<ExceptionListener> exceptionListener,
ObjectProvider<ObservationRegistry> observationRegistry, JmsProperties properties) {
DefaultJmsListenerContainerFactoryConfigurer configurer = new DefaultJmsListenerContainerFactoryConfigurer();
configurer.setDestinationResolver(destinationResolver.getIfUnique());
configurer.setTransactionManager(transactionManager.getIfUnique());
configurer.setMessageConverter(messageConverter.getIfUnique());
configurer.setExceptionListener(exceptionListener.getIfUnique());
configurer.setObservationRegistry(observationRegistry.getIfUnique());
configurer.setJmsProperties(properties);
return configurer;
}

private final ObjectProvider<ExceptionListener> exceptionListener;
@Bean
@ConditionalOnSingleCandidate(ConnectionFactory.class)
@ConditionalOnMissingBean(name = "jmsListenerContainerFactory")
DefaultJmsListenerContainerFactory jmsListenerContainerFactory(
DefaultJmsListenerContainerFactoryConfigurer configurer, ConnectionFactory connectionFactory) {
DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
configurer.configure(factory, ConnectionFactoryUnwrapper.unwrapCaching(connectionFactory));
return factory;
}

private final ObjectProvider<ObservationRegistry> observationRegistry;
}

private final JmsProperties properties;
@Configuration(proxyBeanMethods = false)
@ConditionalOnProperty(name = "spring.jms.listener.container-type", havingValue = "simple")
static class SimpleJmsListenerContainerFactoryConfiguration {

JmsAnnotationDrivenConfiguration(ObjectProvider<DestinationResolver> destinationResolver,
ObjectProvider<JtaTransactionManager> transactionManager, ObjectProvider<MessageConverter> messageConverter,
ObjectProvider<ExceptionListener> exceptionListener,
ObjectProvider<ObservationRegistry> observationRegistry, JmsProperties properties) {
this.destinationResolver = destinationResolver;
this.transactionManager = transactionManager;
this.messageConverter = messageConverter;
this.exceptionListener = exceptionListener;
this.observationRegistry = observationRegistry;
this.properties = properties;
}
@Bean
@ConditionalOnMissingBean
SimpleJmsListenerContainerFactoryConfigurer jmsListenerContainerFactoryConfigurer(
ObjectProvider<DestinationResolver> destinationResolver,
ObjectProvider<MessageConverter> messageConverter, ObjectProvider<ExceptionListener> exceptionListener,
ObjectProvider<ObservationRegistry> observationRegistry, JmsProperties properties) {
SimpleJmsListenerContainerFactoryConfigurer configurer = new SimpleJmsListenerContainerFactoryConfigurer();
configurer.setDestinationResolver(destinationResolver.getIfUnique());
configurer.setMessageConverter(messageConverter.getIfUnique());
configurer.setExceptionListener(exceptionListener.getIfUnique());
configurer.setObservationRegistry(observationRegistry.getIfUnique());
configurer.setJmsProperties(properties);
return configurer;
}

@Bean
@ConditionalOnMissingBean
DefaultJmsListenerContainerFactoryConfigurer jmsListenerContainerFactoryConfigurer() {
DefaultJmsListenerContainerFactoryConfigurer configurer = new DefaultJmsListenerContainerFactoryConfigurer();
configurer.setDestinationResolver(this.destinationResolver.getIfUnique());
configurer.setTransactionManager(this.transactionManager.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")
SimpleJmsListenerContainerFactory jmsListenerContainerFactory(
SimpleJmsListenerContainerFactoryConfigurer configurer, ConnectionFactory connectionFactory) {
SimpleJmsListenerContainerFactory factory = new SimpleJmsListenerContainerFactory();
configurer.configure(factory, ConnectionFactoryUnwrapper.unwrapCaching(connectionFactory));
return factory;
}

@Bean
@ConditionalOnSingleCandidate(ConnectionFactory.class)
@ConditionalOnMissingBean(name = "jmsListenerContainerFactory")
DefaultJmsListenerContainerFactory jmsListenerContainerFactory(
DefaultJmsListenerContainerFactoryConfigurer configurer, ConnectionFactory connectionFactory) {
DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
configurer.configure(factory, ConnectionFactoryUnwrapper.unwrapCaching(connectionFactory));
return factory;
}

@Configuration(proxyBeanMethods = false)
Expand Down
Loading