@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); } } }
@Nullable protected Message<?> convertJmsMessage(@Nullable javax.jms.Message message) { if (message == null) { return null; } try { return (Message<?>) getJmsMessageConverter().fromMessage(message); } catch (Exception ex) { throw new MessageConversionException("Could not convert '" + message + "'", ex); } }
@Override @Nullable public Object fromMessage(Message<?> message, Class<?> targetClass) { Object payload = message.getPayload(); if (this.conversionService.canConvert(payload.getClass(), targetClass)) { try { return this.conversionService.convert(payload, targetClass); } catch (ConversionException ex) { throw new MessageConversionException(message, "Failed to convert message payload '" + payload + "' to '" + targetClass.getName() + "'", ex); } } return (ClassUtils.isAssignableValue(targetClass, payload) ? payload : null); }
@Override @Nullable protected Object convertFromInternal(Message<?> message, Class<?> targetClass, @Nullable Object conversionHint) { Assert.notNull(this.unmarshaller, "Property 'unmarshaller' is required"); try { Source source = getSource(message.getPayload()); Object result = this.unmarshaller.unmarshal(source); if (!targetClass.isInstance(result)) { throw new TypeMismatchException(result, targetClass); } return result; } catch (Exception ex) { throw new MessageConversionException(message, "Could not unmarshal XML: " + ex.getMessage(), ex); } }
/** * Convert from the given message to the given target class. * @param message the message to convert * @param targetClass the target class to convert the payload to * @return the converted payload of the reply message (never {@code null}) */ @SuppressWarnings("unchecked") @Nullable protected <T> T doConvert(Message<?> message, Class<T> targetClass) { MessageConverter messageConverter = getMessageConverter(); T value = (T) messageConverter.fromMessage(message, targetClass); if (value == null) { throw new MessageConversionException(message, "Unable to convert payload [" + message.getPayload() + "] to type [" + targetClass + "] using converter [" + messageConverter + "]"); } return value; }
@Override @Nullable protected Object convertToInternal(Object payload, @Nullable MessageHeaders headers, @Nullable Object conversionHint) { Assert.notNull(this.marshaller, "Property 'marshaller' is required"); try { if (byte[].class == getSerializedPayloadClass()) { ByteArrayOutputStream out = new ByteArrayOutputStream(); Result result = new StreamResult(out); this.marshaller.marshal(payload, result); payload = out.toByteArray(); } else { Writer writer = new StringWriter(); Result result = new StreamResult(writer); this.marshaller.marshal(payload, result); payload = writer.toString(); } } catch (Throwable ex) { throw new MessageConversionException("Could not marshal XML: " + ex.getMessage(), ex); } return payload; }
throw new MessageConversionException("Could not write JSON: " + ex.getMessage(), ex);
@Override @Nullable protected Object convertFromInternal(Message<?> message, Class<?> targetClass, @Nullable Object conversionHint) { JavaType javaType = getJavaType(targetClass, conversionHint); Object payload = message.getPayload(); Class<?> view = getSerializationView(conversionHint); // Note: in the view case, calling withType instead of forType for compatibility with Jackson <2.5 try { if (payload instanceof byte[]) { if (view != null) { return this.objectMapper.readerWithView(view).forType(javaType).readValue((byte[]) payload); } else { return this.objectMapper.readValue((byte[]) payload, javaType); } } else { if (view != null) { return this.objectMapper.readerWithView(view).forType(javaType).readValue(payload.toString()); } else { return this.objectMapper.readValue(payload.toString(), javaType); } } } catch (IOException ex) { throw new MessageConversionException(message, "Could not read JSON: " + ex.getMessage(), ex); } }
private void invokeHandler(StompFrameHandler handler, Message<byte[]> message, StompHeaders headers) { if (message.getPayload().length == 0) { handler.handleFrame(headers, null); return; } Type payloadType = handler.getPayloadType(headers); Class<?> resolvedType = ResolvableType.forType(payloadType).resolve(); if (resolvedType == null) { throw new MessageConversionException("Unresolvable payload type [" + payloadType + "] from handler type [" + handler.getClass() + "]"); } Object object = getMessageConverter().fromMessage(message, resolvedType); if (object == null) { throw new MessageConversionException("No suitable converter for payload type [" + payloadType + "] from handler type [" + handler.getClass() + "]"); } handler.handleFrame(headers, object); }
private Object convertPayload(Message<?> message, MethodParameter parameter, Class<?> targetPayloadType) { Object result = null; if (this.converter instanceof SmartMessageConverter) { SmartMessageConverter smartConverter = (SmartMessageConverter) this.converter; result = smartConverter.fromMessage(message, targetPayloadType, parameter); } else if (this.converter != null) { result = this.converter.fromMessage(message, targetPayloadType); } if (result == null) { throw new MessageConversionException(message, "No converter found from actual payload type '" + ClassUtils.getDescriptiveType(message.getPayload()) + "' to expected payload type '" + ClassUtils.getQualifiedName(targetPayloadType) + "'"); } return result; }
@Override public Object resolveArgument(MethodParameter parameter, Message<?> message) throws Exception { Class<?> targetMessageType = parameter.getParameterType(); Class<?> targetPayloadType = getPayloadType(parameter); if (!targetMessageType.isAssignableFrom(message.getClass())) { throw new MethodArgumentTypeMismatchException(message, parameter, "Actual message type '" + ClassUtils.getDescriptiveType(message) + "' does not match expected type '" + ClassUtils.getQualifiedName(targetMessageType) + "'"); } Object payload = message.getPayload(); if (targetPayloadType.isInstance(payload)) { return message; } if (isEmptyPayload(payload)) { throw new MessageConversionException(message, "Cannot convert from actual payload type '" + ClassUtils.getDescriptiveType(payload) + "' to expected payload type '" + ClassUtils.getQualifiedName(targetPayloadType) + "' when payload is empty"); } payload = convertPayload(message, parameter, targetPayloadType); return MessageBuilder.createMessage(payload, message.getHeaders()); }
protected MessagingException convertJmsException(JmsException ex) { if (ex instanceof org.springframework.jms.support.destination.DestinationResolutionException || ex instanceof InvalidDestinationException) { return new DestinationResolutionException(ex.getMessage(), ex); } if (ex instanceof org.springframework.jms.support.converter.MessageConversionException) { return new MessageConversionException(ex.getMessage(), ex); } // Fallback return new MessagingException(ex.getMessage(), ex); }
String payloadType = payload.getClass().getName(); Object contentType = (messageHeaders != null ? messageHeaders.get(MessageHeaders.CONTENT_TYPE) : null); throw new MessageConversionException("Unable to convert payload with type='" + payloadType + "', contentType='" + contentType + "', converter=[" + getMessageConverter() + "]");
throw new MessageConversionException(message, "Cannot convert from [" + payloadClass.getName() + "] to [" + targetClass.getName() + "] for " + message);
@SuppressWarnings("unchecked") private Message<byte[]> createMessage(StompHeaderAccessor accessor, @Nullable Object payload) { accessor.updateSimpMessageHeadersFromStompHeaders(); Message<byte[]> message; if (payload == null) { message = MessageBuilder.createMessage(EMPTY_PAYLOAD, accessor.getMessageHeaders()); } else if (payload instanceof byte[]) { message = MessageBuilder.createMessage((byte[]) payload, accessor.getMessageHeaders()); } else { message = (Message<byte[]>) getMessageConverter().toMessage(payload, accessor.getMessageHeaders()); accessor.updateStompHeadersFromSimpMessageHeaders(); if (message == null) { throw new MessageConversionException("Unable to convert payload with type='" + payload.getClass().getName() + "', contentType='" + accessor.getContentType() + "', converter=[" + getMessageConverter() + "]"); } } return message; }
@Nullable @Override public Object fromMessage(Message<?> message, Class<?> targetClass) { try { return this.outboundMessageMapper.fromMessage(message); } catch (Exception e) { throw new MessageConversionException(message, "failed to convert Message to object", e); } }
@Nullable @Override public Message<?> toMessage(Object object, @Nullable MessageHeaders headers) { try { return this.inboundMessageMapper.toMessage(object, headers); } catch (Exception e) { throw new MessageConversionException("failed to convert object to Message", e); } }
protected String retrieveHeader(Headers headers, String headerName) { String classId = retrieveHeaderAsString(headers, headerName); if (classId == null) { throw new MessageConversionException( "failed to convert Message content. Could not resolve " + headerName + " in header"); } return classId; }
@Override @Nullable public Object fromMessage(Message<?> message, Class<?> targetClass) { Object payload = message.getPayload(); if (this.conversionService.canConvert(payload.getClass(), targetClass)) { try { return this.conversionService.convert(payload, targetClass); } catch (ConversionException ex) { throw new MessageConversionException(message, "Failed to convert message payload '" + payload + "' to '" + targetClass.getName() + "'", ex); } } return (ClassUtils.isAssignableValue(targetClass, payload) ? payload : null); }
private void invokeHandler(StompFrameHandler handler, Message<byte[]> message, StompHeaders headers) { if (message.getPayload().length == 0) { handler.handleFrame(headers, null); return; } Type payloadType = handler.getPayloadType(headers); Class<?> resolvedType = ResolvableType.forType(payloadType).resolve(); if (resolvedType == null) { throw new MessageConversionException("Unresolvable payload type [" + payloadType + "] from handler type [" + handler.getClass() + "]"); } Object object = getMessageConverter().fromMessage(message, resolvedType); if (object == null) { throw new MessageConversionException("No suitable converter for payload type [" + payloadType + "] from handler type [" + handler.getClass() + "]"); } handler.handleFrame(headers, object); }