001/* 002 * Copyright 2002-2019 the original author or authors. 003 * 004 * Licensed under the Apache License, Version 2.0 (the "License"); 005 * you may not use this file except in compliance with the License. 006 * You may obtain a copy of the License at 007 * 008 * https://www.apache.org/licenses/LICENSE-2.0 009 * 010 * Unless required by applicable law or agreed to in writing, software 011 * distributed under the License is distributed on an "AS IS" BASIS, 012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 013 * See the License for the specific language governing permissions and 014 * limitations under the License. 015 */ 016 017package org.springframework.messaging.handler.annotation.support; 018 019import java.lang.reflect.Type; 020 021import org.springframework.core.MethodParameter; 022import org.springframework.core.ResolvableType; 023import org.springframework.lang.Nullable; 024import org.springframework.messaging.Message; 025import org.springframework.messaging.converter.MessageConversionException; 026import org.springframework.messaging.converter.MessageConverter; 027import org.springframework.messaging.converter.SmartMessageConverter; 028import org.springframework.messaging.handler.invocation.HandlerMethodArgumentResolver; 029import org.springframework.messaging.support.MessageBuilder; 030import org.springframework.util.ClassUtils; 031import org.springframework.util.StringUtils; 032 033/** 034 * {@code HandlerMethodArgumentResolver} for {@link Message} method arguments. 035 * Validates that the generic type of the payload matches to the message value 036 * or otherwise applies {@link MessageConverter} to convert to the expected 037 * payload type. 038 * 039 * @author Rossen Stoyanchev 040 * @author Stephane Nicoll 041 * @author Juergen Hoeller 042 * @since 4.0 043 */ 044public class MessageMethodArgumentResolver implements HandlerMethodArgumentResolver { 045 046 @Nullable 047 private final MessageConverter converter; 048 049 050 /** 051 * Create a default resolver instance without message conversion. 052 */ 053 public MessageMethodArgumentResolver() { 054 this(null); 055 } 056 057 /** 058 * Create a resolver instance with the given {@link MessageConverter}. 059 * @param converter the MessageConverter to use (may be {@code null}) 060 * @since 4.3 061 */ 062 public MessageMethodArgumentResolver(@Nullable MessageConverter converter) { 063 this.converter = converter; 064 } 065 066 067 @Override 068 public boolean supportsParameter(MethodParameter parameter) { 069 return Message.class.isAssignableFrom(parameter.getParameterType()); 070 } 071 072 @Override 073 public Object resolveArgument(MethodParameter parameter, Message<?> message) throws Exception { 074 Class<?> targetMessageType = parameter.getParameterType(); 075 Class<?> targetPayloadType = getPayloadType(parameter, message); 076 077 if (!targetMessageType.isAssignableFrom(message.getClass())) { 078 throw new MethodArgumentTypeMismatchException(message, parameter, "Actual message type '" + 079 ClassUtils.getDescriptiveType(message) + "' does not match expected type '" + 080 ClassUtils.getQualifiedName(targetMessageType) + "'"); 081 } 082 083 Object payload = message.getPayload(); 084 if (targetPayloadType.isInstance(payload)) { 085 return message; 086 } 087 088 if (isEmptyPayload(payload)) { 089 throw new MessageConversionException(message, "Cannot convert from actual payload type '" + 090 ClassUtils.getDescriptiveType(payload) + "' to expected payload type '" + 091 ClassUtils.getQualifiedName(targetPayloadType) + "' when payload is empty"); 092 } 093 094 payload = convertPayload(message, parameter, targetPayloadType); 095 return MessageBuilder.createMessage(payload, message.getHeaders()); 096 } 097 098 /** 099 * Resolve the target class to convert the payload to. 100 * <p>By default this is the generic type declared in the {@code Message} 101 * method parameter but that can be overridden to select a more specific 102 * target type after also taking into account the "Content-Type", e.g. 103 * return {@code String} if target type is {@code Object} and 104 * {@code "Content-Type:text/**"}. 105 * @param parameter the target method parameter 106 * @param message the message being processed 107 * @return the target type to use 108 * @since 5.2 109 */ 110 protected Class<?> getPayloadType(MethodParameter parameter, Message<?> message) { 111 Type genericParamType = parameter.getGenericParameterType(); 112 ResolvableType resolvableType = ResolvableType.forType(genericParamType).as(Message.class); 113 return resolvableType.getGeneric().toClass(); 114 } 115 116 /** 117 * Check if the given {@code payload} is empty. 118 * @param payload the payload to check (can be {@code null}) 119 */ 120 protected boolean isEmptyPayload(@Nullable Object payload) { 121 if (payload == null) { 122 return true; 123 } 124 else if (payload instanceof byte[]) { 125 return ((byte[]) payload).length == 0; 126 } 127 else if (payload instanceof String) { 128 return !StringUtils.hasText((String) payload); 129 } 130 else { 131 return false; 132 } 133 } 134 135 private Object convertPayload(Message<?> message, MethodParameter parameter, Class<?> targetPayloadType) { 136 Object result = null; 137 if (this.converter instanceof SmartMessageConverter) { 138 SmartMessageConverter smartConverter = (SmartMessageConverter) this.converter; 139 result = smartConverter.fromMessage(message, targetPayloadType, parameter); 140 } 141 else if (this.converter != null) { 142 result = this.converter.fromMessage(message, targetPayloadType); 143 } 144 145 if (result == null) { 146 throw new MessageConversionException(message, "No converter found from actual payload type '" + 147 ClassUtils.getDescriptiveType(message.getPayload()) + "' to expected payload type '" + 148 ClassUtils.getQualifiedName(targetPayloadType) + "'"); 149 } 150 return result; 151 } 152 153}