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

Connection Management

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

Connection factory implementations providing connection pooling, caching, single connection sharing, and transaction-aware connection management for optimal resource utilization. Spring JMS offers various connection management strategies to balance performance, resource usage, and transaction requirements.

Capabilities

CachingConnectionFactory

A connection factory wrapper that caches connections, sessions, and producers for improved performance by reusing expensive JMS resources.

/**
 * Connection factory with caching capabilities for improved performance
 */
public class CachingConnectionFactory implements ConnectionFactory, ExceptionListener, DisposableBean {
    
    // Constructors
    public CachingConnectionFactory();
    public CachingConnectionFactory(ConnectionFactory targetConnectionFactory);
    
    // Target connection factory configuration
    public void setTargetConnectionFactory(ConnectionFactory targetConnectionFactory);
    public ConnectionFactory getTargetConnectionFactory();
    
    // Session cache configuration
    public void setSessionCacheSize(int sessionCacheSize);
    public int getSessionCacheSize();
    
    // Producer/Consumer cache configuration
    public void setCacheProducers(boolean cacheProducers);
    public boolean isCacheProducers();
    public void setCacheConsumers(boolean cacheConsumers);
    public boolean isCacheConsumers();
    
    // Connection cache configuration
    public void setCacheLevel(int cacheLevel);
    public int getCacheLevel();
    public void setCacheLevelName(String constantName);
    
    // Reconnection configuration
    public void setReconnectOnException(boolean reconnectOnException);
    public boolean isReconnectOnException();
    
    // Exception handling
    public void setExceptionListener(ExceptionListener exceptionListener);
    
    // Statistics and monitoring
    public String getCacheStatistics();
    public void clearCache();
    
    // Lifecycle methods
    public void resetConnection();
    public void destroy();
}

SingleConnectionFactory

A connection factory that returns the same connection on all createConnection() calls, suitable for simple scenarios where connection sharing is acceptable.

/**
 * Connection factory that uses a single shared connection
 */
public class SingleConnectionFactory implements ConnectionFactory, ExceptionListener, DisposableBean {
    
    // Constructors
    public SingleConnectionFactory();
    public SingleConnectionFactory(Connection target);
    public SingleConnectionFactory(ConnectionFactory targetConnectionFactory);
    
    // Target connection factory configuration
    public void setTargetConnectionFactory(ConnectionFactory targetConnectionFactory);
    public ConnectionFactory getTargetConnectionFactory();
    
    // Connection configuration
    public void setConnection(Connection connection);
    
    // Client ID configuration  
    public void setClientId(String clientId);
    public String getClientId();
    
    // Exception handling and reconnection
    public void setExceptionListener(ExceptionListener exceptionListener);
    public void setReconnectOnException(boolean reconnectOnException);
    public boolean isReconnectOnException();
    
    // Lifecycle methods
    public void resetConnection();
    public void destroy();
    
    // Connection creation
    public Connection createConnection() throws JMSException;
    public Connection createConnection(String username, String password) throws JMSException;
}

UserCredentialsConnectionFactoryAdapter

Connection factory adapter that applies given user credentials to every standard createConnection() call, returning a wrapped Connection that applies the given user credentials to every createSession() call.

/**
 * Connection factory adapter for applying user credentials
 */
public class UserCredentialsConnectionFactoryAdapter implements ConnectionFactory {
    
    // Constructors
    public UserCredentialsConnectionFactoryAdapter();
    
    // Target connection factory configuration
    public void setTargetConnectionFactory(ConnectionFactory targetConnectionFactory);
    public ConnectionFactory getTargetConnectionFactory();
    
    // Credentials configuration
    public void setUsername(String username);
    public void setPassword(String password);
    
    // Connection creation with credentials
    public Connection createConnection() throws JMSException;
    public Connection createConnection(String username, String password) throws JMSException;
}

TransactionAwareConnectionFactoryProxy

Proxy for a target JMS ConnectionFactory that is aware of Spring-managed transactions, similar to a transactional JNDI ConnectionFactory as provided by a Java EE application server.

/**
 * Transaction-aware connection factory proxy
 */
public class TransactionAwareConnectionFactoryProxy implements ConnectionFactory {
    
    // Constructors
    public TransactionAwareConnectionFactoryProxy();
    public TransactionAwareConnectionFactoryProxy(ConnectionFactory targetConnectionFactory);
    
    // Target connection factory configuration
    public void setTargetConnectionFactory(ConnectionFactory targetConnectionFactory);
    public ConnectionFactory getTargetConnectionFactory();
    
    // Transaction synchronization configuration
    public void setSynchedLocalTransactionAllowed(boolean synchedLocalTransactionAllowed);
    public boolean isSynchedLocalTransactionAllowed();
    
    // Connection creation
    public Connection createConnection() throws JMSException;
    public Connection createConnection(String username, String password) throws JMSException;
}

JmsTransactionManager

PlatformTransactionManager implementation for JMS, providing transaction management for JMS operations using local JMS transactions.

/**
 * PlatformTransactionManager for JMS transactions
 */
public class JmsTransactionManager extends AbstractPlatformTransactionManager implements InitializingBean {
    
    // Constructors
    public JmsTransactionManager();
    public JmsTransactionManager(ConnectionFactory connectionFactory);
    
    // Connection factory configuration
    public void setConnectionFactory(ConnectionFactory connectionFactory);
    public ConnectionFactory getConnectionFactory();
    
    // Transaction configuration
    public void setResourceFactory(ConnectionFactory resourceFactory);
    
    // Template methods for transaction management
    protected Object doGetTransaction() throws TransactionException;
    protected void doBegin(Object transaction, TransactionDefinition definition) throws TransactionException;
    protected void doCommit(DefaultTransactionStatus status) throws TransactionException;
    protected void doRollback(DefaultTransactionStatus status) throws TransactionException;
}

Connection and Resource Management Utilities

Utility classes for managing JMS connections and resources with proper exception handling and resource cleanup.

/**
 * Utility methods for JMS connection and resource management
 */
public abstract class ConnectionFactoryUtils {
    
    // Connection management
    public static Connection doGetTransactionalConnection(ConnectionFactory cf, ResourceFactory resourceFactory) 
        throws JMSException;
    public static void releaseConnection(Connection con, ConnectionFactory cf, boolean started);
    
    // Session management  
    public static Session getTransactionalSession(ConnectionFactory cf, ResourceFactory resourceFactory, boolean startConnection) 
        throws JMSException;
    public static boolean isSessionTransactional(Session session, ConnectionFactory cf);
    
    // Resource synchronization
    public static void registerSynchronization(JmsResourceHolder resourceHolder, ConnectionFactory connectionFactory, 
        ResourceFactory resourceFactory);
    
    // Exception conversion
    public static JmsException convertJmsAccessException(JMSException ex);
}

/**
 * Resource holder for JMS connections and sessions
 */
public class JmsResourceHolder extends ResourceHolderSupport {
    
    // Constructors
    public JmsResourceHolder();
    public JmsResourceHolder(Connection connection, Session session);
    public JmsResourceHolder(ConnectionFactory connectionFactory, Connection connection, Session session);
    
    // Resource management
    public void addConnection(Connection connection);
    public void addSession(Session session, Connection connection);
    public Connection getConnection();
    public Session getSession();
    public Session getSession(Class<?> requiredType);
    
    // Transaction support
    public boolean isTransacted();
    public void commitAll() throws JMSException;
    public void closeAll();
}

SmartConnectionFactory

Extended ConnectionFactory interface that indicates that the underlying JMS ConnectionFactory is capable of providing pooled Connections that participate in a particular transaction.

/**
 * Extended ConnectionFactory interface for advanced connection features
 */
public interface SmartConnectionFactory extends ConnectionFactory {
    
    /**
     * Create a connection that should be used within a transaction
     * @return a connection suitable for transactional use
     * @throws JMSException in case of JMS errors
     */
    Connection createConnection() throws JMSException;
    
    /**
     * Determine whether the underlying ConnectionFactory supports the given ConnectionFactory
     * @param connectionFactory the ConnectionFactory to check
     * @return true if supported, false otherwise
     */
    boolean shouldClose(Connection connection);
}

Usage Examples:

import org.springframework.jms.connection.*;
import javax.jms.ConnectionFactory;

// Configuration for different connection management strategies
@Configuration
public class ConnectionConfig {
    
    // Basic connection factory (typically from JNDI or JMS provider)
    @Bean
    public ConnectionFactory targetConnectionFactory() {
        // Configure your actual JMS provider's connection factory
        // e.g., ActiveMQ, IBM MQ, etc.
        return new org.apache.activemq.ActiveMQConnectionFactory("tcp://localhost:61616");
    }
    
    // Caching connection factory for performance
    @Bean
    public ConnectionFactory cachingConnectionFactory() {
        CachingConnectionFactory factory = new CachingConnectionFactory(targetConnectionFactory());
        factory.setSessionCacheSize(10);
        factory.setCacheProducers(true);
        factory.setCacheConsumers(true);
        factory.setReconnectOnException(true);
        return factory;
    }
    
    // Single connection factory for simple scenarios
    @Bean
    public ConnectionFactory singleConnectionFactory() {
        SingleConnectionFactory factory = new SingleConnectionFactory(targetConnectionFactory());
        factory.setReconnectOnException(true);
        factory.setClientId("myApplication");
        return factory;
    }
    
    // Connection factory with user credentials
    @Bean
    public ConnectionFactory credentialsConnectionFactory() {
        UserCredentialsConnectionFactoryAdapter factory = new UserCredentialsConnectionFactoryAdapter();
        factory.setTargetConnectionFactory(targetConnectionFactory());
        factory.setUsername("jmsuser");
        factory.setPassword("jmspassword");
        return factory;
    }
    
    // Transaction-aware connection factory
    @Bean
    public ConnectionFactory transactionAwareConnectionFactory() {
        TransactionAwareConnectionFactoryProxy factory = 
            new TransactionAwareConnectionFactoryProxy(cachingConnectionFactory());
        factory.setSynchedLocalTransactionAllowed(true);
        return factory;
    }
    
    // JMS transaction manager
    @Bean
    public PlatformTransactionManager jmsTransactionManager() {
        return new JmsTransactionManager(transactionAwareConnectionFactory());
    }
    
    // JmsTemplate with caching connection factory
    @Bean
    public JmsTemplate jmsTemplate() {
        return new JmsTemplate(cachingConnectionFactory());
    }
}

// Service using transactional JMS operations
@Service
@Transactional
public class OrderProcessingService {
    
    @Autowired
    private JmsTemplate jmsTemplate;
    
    // Transactional message sending
    @Transactional
    public void processOrderWithTransaction(Order order) {
        // Send order confirmation
        jmsTemplate.convertAndSend("order.confirmation", order);
        
        // Send inventory update
        jmsTemplate.convertAndSend("inventory.update", 
            new InventoryUpdate(order.getProductId(), -order.getQuantity()));
        
        // Send billing notification
        jmsTemplate.convertAndSend("billing.notification", 
            new BillingInfo(order.getCustomerId(), order.getTotal()));
        
        // If any exception occurs, all messages will be rolled back
    }
}

// Monitoring and management
@Component
public class JmsConnectionMonitor {
    
    @Autowired
    private ConnectionFactory connectionFactory;
    
    public void monitorConnectionHealth() {
        if (connectionFactory instanceof CachingConnectionFactory) {
            CachingConnectionFactory cachingFactory = (CachingConnectionFactory) connectionFactory;
            System.out.println("Cache statistics: " + cachingFactory.getCacheStatistics());
        }
    }
    
    public void resetConnections() {
        if (connectionFactory instanceof CachingConnectionFactory) {
            ((CachingConnectionFactory) connectionFactory).resetConnection();
        } else if (connectionFactory instanceof SingleConnectionFactory) {
            ((SingleConnectionFactory) connectionFactory).resetConnection();
        }
    }
}

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

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