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}