CtrlK
BlogDocsLog inGet started
Tessl Logo

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

message-conversion.mddocs/

Message Conversion

Comprehensive message conversion system for automatic translation between Java objects and JMS messages. Spring JMS provides multiple converter implementations supporting JSON, XML, and custom serialization formats with intelligent type handling and configuration options.

Capabilities

MessageConverter Interface

Core interface for message conversion between Java objects and JMS messages, enabling seamless integration of POJOs with JMS messaging.

/**
 * Strategy interface for converting between Java objects and JMS messages
 */
public interface MessageConverter {
    
    /**
     * Convert a Java object to a JMS message
     * @param object the object to convert
     * @param session the JMS session to use for message creation
     * @return the JMS message
     * @throws JMSException in case of JMS errors
     * @throws MessageConversionException in case of conversion errors
     */
    Message toMessage(Object object, Session session) throws JMSException, MessageConversionException;
    
    /**
     * Convert a JMS message to a Java object
     * @param message the JMS message to convert
     * @return the converted Java object
     * @throws JMSException in case of JMS errors
     * @throws MessageConversionException in case of conversion errors
     */
    Object fromMessage(Message message) throws JMSException, MessageConversionException;
}

/**
 * Extended message converter interface with conversion hint support
 */
public interface SmartMessageConverter extends MessageConverter {
    
    /**
     * Convert a Java object to a JMS message with conversion hint support
     * @param object the object to convert
     * @param session the JMS session
     * @param conversionHint an extra object passed to the MessageConverter for context
     * @return the JMS message
     * @throws JMSException in case of JMS errors
     * @throws MessageConversionException in case of conversion errors
     */
    Message toMessage(Object object, Session session, Object conversionHint) 
        throws JMSException, MessageConversionException;
    
    /**
     * Convert a JMS message to a Java object of the specified target class
     * @param message the JMS message to convert
     * @param targetClass the target class for conversion
     * @return the converted Java object
     * @throws JMSException in case of JMS errors
     * @throws MessageConversionException in case of conversion errors
     */
    <T> T fromMessage(Message message, Class<T> targetClass) throws JMSException, MessageConversionException;
}

SimpleMessageConverter

Default message converter supporting basic Java types and automatic serialization for complex objects.

/**
 * Simple message converter for basic types and Serializable objects
 */
public class SimpleMessageConverter implements MessageConverter {
    
    public SimpleMessageConverter();
    
    // Configuration
    public void setCreateMessageIdOnSend(boolean createMessageIdOnSend);
    public void setCreateTimestampOnSend(boolean createTimestampOnSend);
    
    // Type mapping methods
    protected Message createMessageForString(String text, Session session) throws JMSException;
    protected Message createMessageForByteArray(byte[] bytes, Session session) throws JMSException;
    protected Message createMessageForMap(Map<?, ?> map, Session session) throws JMSException;
    protected Message createMessageForSerializable(Serializable object, Session session) throws JMSException;
    
    // Extraction methods
    protected String extractStringFromMessage(TextMessage message) throws JMSException;
    protected byte[] extractByteArrayFromMessage(BytesMessage message) throws JMSException;
    protected Map<?, ?> extractMapFromMessage(MapMessage message) throws JMSException;
    protected Serializable extractSerializableFromMessage(ObjectMessage message) throws JMSException;
}

MappingJackson2MessageConverter

JSON message converter using Jackson for serializing objects to JSON format, supporting custom ObjectMapper configuration and type handling.

/**
 * Message converter using Jackson for JSON serialization
 */
public class MappingJackson2MessageConverter implements SmartMessageConverter {
    
    // Constructors
    public MappingJackson2MessageConverter();
    
    // ObjectMapper configuration
    public void setObjectMapper(ObjectMapper objectMapper);
    public ObjectMapper getObjectMapper();
    
    // Target type configuration
    public void setTargetType(MessageType targetType);
    public MessageType getTargetType();
    
    // Type mapping configuration
    public void setTypeIdPropertyName(String typeIdPropertyName);
    public void setTypeIdMappings(Map<String, Class<?>> typeIdMappings);
    
    // Encoding configuration
    public void setEncoding(String encoding);
    public String getEncoding();
    
    // Message properties configuration
    public void setCreateMessageIdOnSend(boolean createMessageIdOnSend);
    public void setCreateTimestampOnSend(boolean createTimestampOnSend);
}

/**
 * Enumeration of JMS message types for targeting specific message formats
 */
public enum MessageType {
    TEXT,
    BYTES,
    MAP,
    OBJECT
}

MarshallingMessageConverter

Message converter using Spring's marshalling framework for XML serialization, supporting various XML binding technologies.

/**
 * Message converter using Spring's marshalling/unmarshalling framework
 */
public class MarshallingMessageConverter implements MessageConverter {
    
    // Constructors
    public MarshallingMessageConverter();
    public MarshallingMessageConverter(Marshaller marshaller);
    public MarshallingMessageConverter(Marshaller marshaller, Unmarshaller unmarshaller);
    
    // Marshaller configuration
    public void setMarshaller(Marshaller marshaller);
    public void setUnmarshaller(Unmarshaller unmarshaller);
    
    // Target type configuration
    public void setTargetType(MessageType targetType);
    
    // Message properties configuration
    public void setCreateMessageIdOnSend(boolean createMessageIdOnSend);
    public void setCreateTimestampOnSend(boolean createTimestampOnSend);
}

MessagingMessageConverter

Converter for Spring Messaging integration, enabling use of Spring Messaging Message objects with JMS.

/**
 * Message converter for Spring Messaging integration
 */
public class MessagingMessageConverter implements MessageConverter {
    
    public MessagingMessageConverter();
    public MessagingMessageConverter(MessageConverter payloadConverter);
    public MessagingMessageConverter(MessageConverter payloadConverter, MessageBuilderFactory messageBuilderFactory);
    
    // Configuration
    public void setPayloadConverter(MessageConverter payloadConverter);
    public void setMessageBuilderFactory(MessageBuilderFactory messageBuilderFactory);
    public void setHeaderMapper(JmsHeaderMapper headerMapper);
    public void setStrictContentTypeMatch(boolean strictContentTypeMatch);
    
    // Header mapping configuration
    public void setInboundHeaderNames(String... inboundHeaderNames);
    public void setOutboundHeaderNames(String... outboundHeaderNames);
}

// Supporting interfaces
public interface MessageBuilderFactory {
    <T> MessageBuilder<T> withPayload(T payload);
}

public interface JmsHeaderMapper {
    void fromHeaders(MessageHeaders headers, Message target) throws JMSException;
    MessageHeaders toHeaders(Message source) throws JMSException;
}

Message Conversion Exceptions

Exception hierarchy for message conversion errors with specific error categorization.

/**
 * Exception thrown when message conversion fails
 */
public class MessageConversionException extends JmsException {
    
    public MessageConversionException(String msg);
    public MessageConversionException(String msg, Throwable cause);
}

Usage Examples:

import org.springframework.jms.support.converter.*;
import com.fasterxml.jackson.databind.ObjectMapper;

// Configuration with different converters
@Configuration
public class MessageConversionConfig {
    
    // Simple converter for basic types
    @Bean
    public MessageConverter simpleMessageConverter() {
        SimpleMessageConverter converter = new SimpleMessageConverter();
        converter.setCreateMessageIdOnSend(true);
        converter.setCreateTimestampOnSend(true);
        return converter;
    }
    
    // Jackson JSON converter
    @Bean
    public MessageConverter jsonMessageConverter() {
        MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter();
        converter.setTargetType(MessageType.TEXT);
        converter.setTypeIdPropertyName("_type");
        
        // Custom ObjectMapper configuration
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
        converter.setObjectMapper(objectMapper);
        
        return converter;
    }
    
    // XML marshalling converter
    @Bean
    public MessageConverter xmlMessageConverter() {
        // Assuming JAXB marshaller
        Jaxb2Marshaller marshaller = new Jaxb2Marshaller();
        marshaller.setPackagesToScan("com.example.model");
        
        MarshallingMessageConverter converter = new MarshallingMessageConverter(marshaller);
        converter.setTargetType(MessageType.TEXT);
        return converter;
    }
    
    // JmsTemplate with custom converter
    @Bean
    public JmsTemplate jmsTemplate() {
        JmsTemplate template = new JmsTemplate(connectionFactory());
        template.setMessageConverter(jsonMessageConverter());
        return template;
    }
}

// Usage in service classes
@Service
public class ProductService {
    
    @Autowired
    private JmsTemplate jmsTemplate;
    
    // Sending objects - automatically converted to JSON
    public void publishProduct(Product product) {
        jmsTemplate.convertAndSend("product.events", product);
    }
    
    // Receiving objects - automatically converted from JSON
    @JmsListener(destination = "product.events")
    public void handleProductEvent(Product product) {
        System.out.println("Received product: " + product.getName());
    }
    
    // Manual conversion with specific converter
    public void sendWithCustomConversion() {
        MessageConverter converter = new MappingJackson2MessageConverter();
        
        jmsTemplate.send("custom.queue", session -> {
            Product product = new Product("Test Product");
            return converter.toMessage(product, session);
        });
    }
}

// Custom converter implementation
@Component
public class CustomProductConverter implements SmartMessageConverter {
    
    private final ObjectMapper objectMapper = new ObjectMapper();
    
    @Override
    public Message toMessage(Object object, Session session) throws JMSException, MessageConversionException {
        if (object instanceof Product) {
            try {
                Product product = (Product) object;
                String json = objectMapper.writeValueAsString(product);
                
                TextMessage message = session.createTextMessage(json);
                message.setStringProperty("productType", product.getType());
                message.setLongProperty("timestamp", System.currentTimeMillis());
                
                return message;
            } catch (Exception e) {
                throw new MessageConversionException("Failed to convert product", e);
            }
        }
        throw new MessageConversionException("Unsupported object type: " + object.getClass());
    }
    
    @Override
    public Object fromMessage(Message message) throws JMSException, MessageConversionException {
        if (message instanceof TextMessage) {
            try {
                String json = ((TextMessage) message).getText();
                return objectMapper.readValue(json, Product.class);
            } catch (Exception e) {
                throw new MessageConversionException("Failed to convert message to product", e);
            }
        }
        throw new MessageConversionException("Unsupported message type: " + message.getClass());
    }
    
    @Override
    public <T> T fromMessage(Message message, Class<T> targetClass) throws JMSException, MessageConversionException {
        Object result = fromMessage(message);
        if (targetClass.isInstance(result)) {
            return targetClass.cast(result);
        }
        throw new MessageConversionException("Cannot convert to target class: " + targetClass);
    }
    
    @Override
    public Message toMessage(Object object, Session session, MessageType targetType) 
            throws JMSException, MessageConversionException {
        // Implementation for specific target types
        return toMessage(object, session);
    }
}

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