How to use org.springframework.jms.support.converter

@Override
public Object fromMessage(Message message) throws JMSException, MessageConversionException {
  try {
    JavaType targetJavaType = getJavaTypeForMessage(message);
    return convertToObject(message, targetJavaType);
  }
  catch (IOException ex) {
    throw new MessageConversionException("Failed to convert JSON message content", ex);
  }
}

/**
 * Extract the payload of the specified {@link javax.jms.Message}.
 */
protected Object extractPayload(javax.jms.Message message) throws JMSException {
  return this.payloadConverter.fromMessage(message);
}

/**
 * Create the invoker request message.
 * <p>The default implementation creates a JMS {@link javax.jms.ObjectMessage}
 * for the given RemoteInvocation object.
 * @param session the current JMS Session
 * @param invocation the remote invocation to send
 * @return the JMS Message to send
 * @throws JMSException if the message could not be created
 */
protected Message createRequestMessage(Session session, RemoteInvocation invocation) throws JMSException {
  return this.messageConverter.toMessage(invocation, session);
}

protected Message toMessage(Object object, Session session, ObjectWriter objectWriter)
    throws JMSException, MessageConversionException {
  Message message;
  try {
    switch (this.targetType) {
      case TEXT:
        message = mapToTextMessage(object, session, objectWriter);
        break;
      case BYTES:
        message = mapToBytesMessage(object, session, objectWriter);
        break;
      default:
        message = mapToMessage(object, session, objectWriter, this.targetType);
    }
  }
  catch (IOException ex) {
    throw new MessageConversionException("Could not map JSON object [" + object + "]", ex);
  }
  setTypeIdOnMessage(object, message);
  return message;
}

@Override
protected Message createMessageForPayload(Object payload, Session session, @Nullable Object conversionHint)
    throws JMSException {
  MessageConverter converter = getMessageConverter();
  if (converter == null) {
    throw new IllegalStateException("No message converter, cannot handle '" + payload + "'");
  }
  if (converter instanceof SmartMessageConverter) {
    return ((SmartMessageConverter) converter).toMessage(payload, session, conversionHint);
  }
  return converter.toMessage(payload, session);
}

/**
 * Initialize the default implementations for the template's strategies:
 * DynamicDestinationResolver and SimpleMessageConverter.
 * @see #setDestinationResolver
 * @see #setMessageConverter
 * @see org.springframework.jms.support.destination.DynamicDestinationResolver
 * @see org.springframework.jms.support.converter.SimpleMessageConverter
 */
protected void initDefaultStrategies() {
  setMessageConverter(new SimpleMessageConverter());
}

protected Message<?> toMessagingMessage(javax.jms.Message jmsMessage) {
  try {
    return (Message<?>) getMessagingMessageConverter().fromMessage(jmsMessage);
  }
  catch (JMSException ex) {
    throw new MessageConversionException("Could not convert JMS message", ex);
  }
}

@Test(expected = MessageConversionException.class)
public void testToMessageThrowsExceptionIfGivenNullObjectToConvert() throws Exception {
  new SimpleMessageConverter().toMessage(null, null);
}

/**
 * Convenience method to dispatch to converters for individual message types.
 */
private Object convertToObject(Message message, JavaType targetJavaType) throws JMSException, IOException {
  if (message instanceof TextMessage) {
    return convertFromTextMessage((TextMessage) message, targetJavaType);
  }
  else if (message instanceof BytesMessage) {
    return convertFromBytesMessage((BytesMessage) message, targetJavaType);
  }
  else {
    return convertFromMessage(message, targetJavaType);
  }
}

  @Override
  public javax.jms.Message toMessage(Object object, Session session)
      throws JMSException, org.springframework.jms.support.converter.MessageConversionException {
    throw new org.springframework.jms.support.converter.MessageConversionException("Test exception");
  }
});

@Override
public Message toMessage(Object object, Session session, @Nullable Object conversionHint)
    throws JMSException, MessageConversionException {
  return toMessage(object, session, getSerializationView(conversionHint));
}

@SuppressWarnings("unchecked")
@Override
public Object fromMessage(javax.jms.Message message) throws JMSException, MessageConversionException {
  Map<String, Object> mappedHeaders = extractHeaders(message);
  Object convertedObject = extractPayload(message);
  MessageBuilder<Object> builder = (convertedObject instanceof org.springframework.messaging.Message ?
      MessageBuilder.fromMessage((org.springframework.messaging.Message<Object>) convertedObject) :
      MessageBuilder.withPayload(convertedObject));
  return builder.copyHeadersIfAbsent(mappedHeaders).build();
}

public MyAnotherBean none() {
  return new MyAnotherBean();
}

/**
 * Create a JMS message for the specified payload and conversionHint.
 * The conversion hint is an extra object passed to the {@link MessageConverter},
 * e.g. the associated {@code MethodParameter} (may be {@code null}}.
 * @since 4.3
 * @see MessageConverter#toMessage(Object, Session)
 */
protected javax.jms.Message createMessageForPayload(
    Object payload, Session session, @Nullable Object conversionHint) throws JMSException {
  return this.payloadConverter.toMessage(payload, session);
}

/**
 * Create an instance with a default payload converter.
 * @see org.springframework.jms.support.converter.SimpleMessageConverter
 * @see org.springframework.jms.support.SimpleJmsHeaderMapper
 */
public MessagingMessageConverter() {
  this(new SimpleMessageConverter(), new SimpleJmsHeaderMapper());
}

@Override
public Object getPayload() {
  if (this.payload == null) {
    try {
      this.payload = unwrapPayload();
    }
    catch (JMSException ex) {
      throw new MessageConversionException(
          "Failed to extract payload from [" + this.message + "]", ex);
    }
  }
  return this.payload;
}

@JsonView(Summary.class)
public MyAnotherBean summary() {
  return new MyAnotherBean();
}

  @Override
  public javax.jms.Message createMessage(Session session) throws JMSException {
    try {
      return this.messageConverter.toMessage(this.message, session);
    }
    catch (Exception ex) {
      throw new MessageConversionException("Could not convert '" + this.message + "'", ex);
    }
  }
}

@JsonView({Summary.class, Full.class})
public MyAnotherBean invalid() {
  return new MyAnotherBean();
}

@Override
public void convertAndSend(Destination destination, final Object message) throws JmsException {
  send(destination, session -> getRequiredMessageConverter().toMessage(message, session));
}