tessl/maven-org-springframework--spring-jms

Spring JMS integration module that simplifies JMS development by providing template-based messaging, message-driven POJOs, declarative transaction management, and comprehensive exception handling

—

Pending

Overview

Eval results

Files

Configuration Support

Name: tessl/maven-org-springframework--spring-jms
Author: tessl

Factory classes and configuration support for creating and managing JMS listener containers, annotation processing, and XML namespace support for declarative configuration. Spring JMS provides comprehensive configuration options for both programmatic and declarative setup.

Capabilities

JmsListenerContainerFactory

Factory interface for creating JMS listener containers with specific configuration, enabling customizable container creation and management.

/**
 * Factory interface for creating JMS listener containers
 */
public interface JmsListenerContainerFactory<C extends MessageListenerContainer> {
    
    /**
     * Create a message listener container for the given endpoint
     * @param endpoint the JMS listener endpoint to configure
     * @return the configured message listener container
     */
    C createListenerContainer(JmsListenerEndpoint endpoint);
}

AbstractJmsListenerContainerFactory

Abstract base factory providing common configuration for JMS listener containers with template methods for container customization.

/**
 * Abstract base factory for JMS listener containers
 */
public abstract class AbstractJmsListenerContainerFactory<C extends AbstractMessageListenerContainer> 
    implements JmsListenerContainerFactory<C> {
    
    // Connection configuration
    public void setConnectionFactory(ConnectionFactory connectionFactory);
    public ConnectionFactory getConnectionFactory();
    
    // Destination configuration
    public void setDestinationResolver(DestinationResolver destinationResolver);
    public DestinationResolver getDestinationResolver();
    public void setPubSubDomain(Boolean pubSubDomain);
    public Boolean getPubSubDomain();
    
    // Session configuration
    public void setSessionAcknowledgeMode(Integer sessionAcknowledgeMode);
    public void setSessionTransacted(Boolean sessionTransacted);
    
    // Message handling configuration
    public void setMessageConverter(MessageConverter messageConverter);
    public MessageConverter getMessageConverter();
    public void setErrorHandler(ErrorHandler errorHandler);
    public ErrorHandler getErrorHandler();
    
    // Transaction configuration
    public void setTransactionManager(PlatformTransactionManager transactionManager);
    public PlatformTransactionManager getTransactionManager();
    
    // Auto-startup configuration
    public void setAutoStartup(Boolean autoStartup);
    public void setPhase(Integer phase);
    
    // Template methods for container creation and configuration
    protected abstract C createContainerInstance();
    protected void configureContainer(C container, JmsListenerEndpoint endpoint);
}

DefaultJmsListenerContainerFactory

Factory for creating DefaultMessageListenerContainer instances with advanced configuration options for dynamic scaling and resource management.

/**
 * Factory for DefaultMessageListenerContainer with advanced configuration
 */
public class DefaultJmsListenerContainerFactory extends AbstractJmsListenerContainerFactory<DefaultMessageListenerContainer> {
    
    public DefaultJmsListenerContainerFactory();
    
    // Concurrency configuration
    public void setConcurrency(String concurrency);
    public void setMaxConcurrentConsumers(Integer maxConcurrentConsumers);
    
    // Cache configuration
    public void setCacheLevel(Integer cacheLevel);
    public void setCacheLevelName(String cacheLevelName);
    
    // Recovery configuration
    public void setRecoveryInterval(Long recoveryInterval);
    public void setReceiveTimeout(Long receiveTimeout);
    
    // Task execution configuration
    public void setTaskExecutor(Executor taskExecutor);
    public void setMaxMessagesPerTask(Integer maxMessagesPerTask);
    public void setIdleConsumerLimit(Integer idleConsumerLimit);
    public void setIdleTaskExecutionLimit(Integer idleTaskExecutionLimit);
    
    // Backoff configuration
    public void setBackOff(BackOff backOff);
    
    @Override
    protected DefaultMessageListenerContainer createContainerInstance();
}

SimpleJmsListenerContainerFactory

Factory for creating SimpleMessageListenerContainer instances with simpler configuration for basic use cases.

/**
 * Factory for SimpleMessageListenerContainer with basic configuration
 */
public class SimpleJmsListenerContainerFactory extends AbstractJmsListenerContainerFactory<SimpleMessageListenerContainer> {
    
    public SimpleJmsListenerContainerFactory();
    
    // Concurrency configuration
    public void setConcurrentConsumers(Integer concurrentConsumers);
    
    // Task execution configuration
    public void setTaskExecutor(Executor taskExecutor);
    
    // Pub/Sub configuration
    public void setPubSubNoLocal(Boolean pubSubNoLocal);
    public void setSubscriptionDurable(Boolean subscriptionDurable);
    public void setSubscriptionShared(Boolean subscriptionShared);
    public void setClientId(String clientId);
    
    @Override
    protected SimpleMessageListenerContainer createContainerInstance();
}

JmsListenerEndpointRegistrar

Central class for managing JMS listener endpoint registration, providing programmatic configuration of listener endpoints and container factories.

/**
 * Helper for registering JMS listener endpoints programmatically
 */
public class JmsListenerEndpointRegistrar implements BeanFactoryAware, InitializingBean {
    
    public JmsListenerEndpointRegistrar();
    
    // Registry configuration
    public void setEndpointRegistry(JmsListenerEndpointRegistry endpointRegistry);
    public JmsListenerEndpointRegistry getEndpointRegistry();
    
    // Container factory configuration
    public void setContainerFactory(JmsListenerContainerFactory<?> containerFactory);
    public void setContainerFactoryBeanName(String containerFactoryBeanName);
    
    // Message handler configuration
    public void setMessageHandlerMethodFactory(MessageHandlerMethodFactory messageHandlerMethodFactory);
    
    // Endpoint registration
    public void registerEndpoint(JmsListenerEndpoint endpoint);
    public void registerEndpoint(JmsListenerEndpoint endpoint, JmsListenerContainerFactory<?> factory);
    
    // Bean factory integration
    public void setBeanFactory(BeanFactory beanFactory);
    
    // Lifecycle methods
    public void afterPropertiesSet();
}

JmsListenerEndpointRegistry

Registry that manages JMS listener containers and provides lifecycle control for all registered endpoints.

/**
 * Registry for managing JMS listener endpoints and containers
 */
public class JmsListenerEndpointRegistry implements DisposableBean, SmartLifecycle, ApplicationContextAware {
    
    public JmsListenerEndpointRegistry();
    
    // Container registration
    public void registerListenerContainer(JmsListenerEndpoint endpoint, JmsListenerContainerFactory<?> factory);
    public void registerListenerContainer(JmsListenerEndpoint endpoint, JmsListenerContainerFactory<?> factory, boolean startImmediately);
    
    // Container access
    public MessageListenerContainer getListenerContainer(String id);
    public Set<String> getListenerContainerIds();
    public Collection<MessageListenerContainer> getListenerContainers();
    
    // Lifecycle management
    public void start();
    public void stop();
    public void stop(Runnable callback);
    public boolean isRunning();
    public boolean isAutoStartup();
    public int getPhase();
    
    // Registry management
    public void unregisterListenerContainer(String id);
    public void destroy();
}

MessageHandlerMethodFactory

Factory interface for creating method handlers for JMS listener endpoints, enabling customization of method invocation and argument resolution.

/**
 * Factory for creating method handlers for JMS listener endpoints
 */
public interface MessageHandlerMethodFactory {
    
    /**
     * Create a method handler for the given method
     * @param bean the bean instance
     * @param method the method to invoke
     * @return the invocable handler method
     */
    InvocableHandlerMethod createInvocableHandlerMethod(Object bean, Method method);
}

/**
 * Default implementation of MessageHandlerMethodFactory
 */
public class DefaultMessageHandlerMethodFactory implements MessageHandlerMethodFactory, BeanFactoryAware {
    
    public DefaultMessageHandlerMethodFactory();
    
    // Configuration
    public void setMessageConverter(MessageConverter messageConverter);
    public void setValidator(Validator validator);
    public void setCustomArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers);
    public void setBeanFactory(BeanFactory beanFactory);
    
    // Initialization
    public void afterPropertiesSet();
    
    @Override
    public InvocableHandlerMethod createInvocableHandlerMethod(Object bean, Method method);
}

Annotation Processing Support

Classes for processing @JmsListener annotations and integrating with Spring's application context.

/**
 * Bean post-processor for processing @JmsListener annotations
 */
public class JmsListenerAnnotationBeanPostProcessor implements BeanPostProcessor, Ordered, BeanFactoryAware, 
    BeanClassLoaderAware, EnvironmentAware, SmartInitializingSingleton {
    
    public static final String DEFAULT_JMS_LISTENER_CONTAINER_FACTORY_BEAN_NAME = "jmsListenerContainerFactory";
    
    // Configuration
    public void setContainerFactoryBeanName(String containerFactoryBeanName);
    public void setEndpointRegistry(JmsListenerEndpointRegistry endpointRegistry);
    public void setMessageHandlerMethodFactory(MessageHandlerMethodFactory messageHandlerMethodFactory);
    
    // Bean post-processing
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
    
    // Ordering
    public int getOrder();
}

/**
 * Bootstrap configuration for JMS annotation processing
 */
@Configuration
@ConditionalOnClass(EnableJms.class)
public class JmsBootstrapConfiguration {
    
    @Bean(name = JmsListenerConfigurer.JMS_LISTENER_ANNOTATION_PROCESSOR_BEAN_NAME)
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public JmsListenerAnnotationBeanPostProcessor jmsListenerAnnotationProcessor();
    
    @Bean(name = JmsListenerConfigurer.JMS_LISTENER_ENDPOINT_REGISTRY_BEAN_NAME)
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public JmsListenerEndpointRegistry defaultJmsListenerEndpointRegistry();
}

XML Configuration Support

Namespace handlers and parsers for XML-based JMS configuration, enabling declarative configuration through Spring XML.

/**
 * Namespace handler for JMS XML configuration
 */
public class JmsNamespaceHandler extends NamespaceHandlerSupport {
    
    @Override
    public void init();
}

/**
 * Abstract parser for listener container XML elements
 */
public abstract class AbstractListenerContainerParser extends AbstractSingleBeanDefinitionParser {
    
    @Override
    protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder);
    
    // Template methods for container-specific parsing
    protected abstract String getContainerClassName();
    protected abstract void parseListenerConfiguration(Element element, BeanDefinitionBuilder builder);
}

/**
 * Parser for JMS listener container XML elements
 */
public class JmsListenerContainerParser extends AbstractListenerContainerParser {
    
    private static final String CONTAINER_TYPE_ATTRIBUTE = "container-type";
    private static final String CONNECTION_FACTORY_ATTRIBUTE = "connection-factory";
    private static final String TASK_EXECUTOR_ATTRIBUTE = "task-executor";
    private static final String DESTINATION_RESOLVER_ATTRIBUTE = "destination-resolver";
    private static final String MESSAGE_CONVERTER_ATTRIBUTE = "message-converter";
    
    @Override
    protected String getContainerClassName();
    
    @Override
    protected void parseListenerConfiguration(Element element, BeanDefinitionBuilder builder);
}

Usage Examples:

import org.springframework.jms.config.*;
import org.springframework.jms.annotation.*;

// Java-based configuration
@Configuration
@EnableJms
public class JmsConfiguration implements JmsListenerConfigurer {
    
    // Default container factory
    @Bean
    public DefaultJmsListenerContainerFactory jmsListenerContainerFactory() {
        DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory());
        factory.setDestinationResolver(destinationResolver());
        factory.setMessageConverter(messageConverter());
        factory.setConcurrency("1-10");
        factory.setSessionTransacted(false);
        factory.setSessionAcknowledgeMode(Session.AUTO_ACKNOWLEDGE);
        factory.setErrorHandler(new DefaultErrorHandler());
        return factory;
    }
    
    // High-throughput container factory
    @Bean("highThroughputFactory")
    public DefaultJmsListenerContainerFactory highThroughputFactory() {
        DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory());
        factory.setConcurrency("5-50");
        factory.setMaxMessagesPerTask(10);
        factory.setReceiveTimeout(5000L);
        factory.setCacheLevel(DefaultMessageListenerContainer.CACHE_CONSUMER);
        return factory;
    }
    
    // Simple container factory
    @Bean("simpleFactory")
    public SimpleJmsListenerContainerFactory simpleFactory() {
        SimpleJmsListenerContainerFactory factory = new SimpleJmsListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory());
        factory.setConcurrentConsumers(2);
        factory.setPubSubDomain(true); // For topics
        return factory;
    }
    
    // Transaction-aware container factory
    @Bean("transactionalFactory")
    public DefaultJmsListenerContainerFactory transactionalFactory() {
        DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory());
        factory.setTransactionManager(jmsTransactionManager());
        factory.setSessionTransacted(true);
        factory.setConcurrency("1-5");
        return factory;
    }
    
    @Override
    public void configureJmsListeners(JmsListenerEndpointRegistrar registrar) {
        // Set default container factory
        registrar.setContainerFactory(jmsListenerContainerFactory());
        
        // Custom message handler factory for argument resolution
        registrar.setMessageHandlerMethodFactory(messageHandlerMethodFactory());
    }
    
    @Bean
    public MessageHandlerMethodFactory messageHandlerMethodFactory() {
        DefaultMessageHandlerMethodFactory factory = new DefaultMessageHandlerMethodFactory();
        factory.setMessageConverter(messageConverter());
        return factory;
    }
}

// Service using different container factories
@Service
public class MessageProcessingService {
    
    // Default container factory
    @JmsListener(destination = "standard.queue")
    public void processStandardMessage(String message) {
        System.out.println("Standard: " + message);
    }
    
    // High-throughput container factory
    @JmsListener(destination = "bulk.queue", containerFactory = "highThroughputFactory")
    public void processBulkMessage(String message) {
        System.out.println("Bulk: " + message);
    }
    
    // Simple container factory for topics
    @JmsListener(destination = "notification.topic", containerFactory = "simpleFactory")
    public void processNotification(String notification) {
        System.out.println("Notification: " + notification);
    }
    
    // Transactional container factory
    @JmsListener(destination = "transaction.queue", containerFactory = "transactionalFactory")
    @Transactional
    public void processTransactionalMessage(Order order) {
        // Transactional processing
        orderService.processOrder(order);
        auditService.logOrderProcessing(order.getId());
    }
}

// Programmatic endpoint registration
@Component
public class ProgrammaticJmsConfiguration {
    
    @Autowired
    private JmsListenerEndpointRegistrar registrar;
    
    @Autowired
    private DefaultJmsListenerContainerFactory containerFactory;
    
    @PostConstruct
    public void configureListeners() {
        // Create endpoint programmatically
        SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
        endpoint.setId("programmatic-listener");
        endpoint.setDestination("dynamic.queue");
        endpoint.setMessageListener(message -> {
            System.out.println("Programmatic listener: " + message);
        });
        
        // Register endpoint
        registrar.registerEndpoint(endpoint, containerFactory);
    }
}

// Dynamic listener management
@Service
public class DynamicListenerService {
    
    @Autowired
    private JmsListenerEndpointRegistry registry;
    
    @Autowired
    private DefaultJmsListenerContainerFactory containerFactory;
    
    public void startDynamicListener(String destinationName, MessageListener listener) {
        SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
        endpoint.setId("dynamic-" + destinationName);
        endpoint.setDestination(destinationName);
        endpoint.setMessageListener(listener);
        
        registry.registerListenerContainer(endpoint, containerFactory, true);
    }
    
    public void stopListener(String listenerId) {
        MessageListenerContainer container = registry.getListenerContainer(listenerId);
        if (container != null) {
            container.stop();
        }
    }
    
    public void removeListener(String listenerId) {
        registry.unregisterListenerContainer(listenerId);
    }
    
    public Collection<String> getActiveListeners() {
        return registry.getListenerContainerIds();
    }
}

XML Configuration Example

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:jms="http://www.springframework.org/schema/jms"
       xsi:schemaLocation="
           http://www.springframework.org/schema/beans 
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/jms 
           http://www.springframework.org/schema/jms/spring-jms.xsd">
           
    <!-- Enable annotation-driven JMS -->
    <jms:annotation-driven container-factory="jmsContainerFactory" />
    
    <!-- JMS listener container -->
    <jms:listener-container 
        connection-factory="connectionFactory"
        task-executor="taskExecutor"
        destination-resolver="destinationResolver"
        message-converter="messageConverter"
        concurrency="1-10">
        
        <jms:listener destination="order.queue" ref="orderService" method="processOrder" />
        <jms:listener destination="notification.topic" ref="notificationService" method="handleNotification" />
    </jms:listener-container>
    
    <!-- Container factory definition -->
    <bean id="jmsContainerFactory" class="org.springframework.jms.config.DefaultJmsListenerContainerFactory">
        <property name="connectionFactory" ref="connectionFactory" />
        <property name="concurrency" value="1-5" />
        <property name="sessionTransacted" value="false" />
    </bean>
</beans>

Install with Tessl CLI

npx tessl i tessl/maven-org-springframework--spring-jms

docs

configuration.md

connection-management.md

core-operations.md

destination-resolution.md

index.md

message-conversion.md

message-listeners.md

tile.json