/*
* Copyright 2005-2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.ws.server.endpoint.adapter.method;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import javax.xml.transform.Source;
import javax.xml.transform.TransformerException;
import javax.xml.transform.stream.StreamResult;
import org.springframework.core.MethodParameter;
import org.springframework.util.Assert;
import org.springframework.ws.server.endpoint.annotation.RequestPayload;
import org.springframework.ws.server.endpoint.annotation.ResponsePayload;
import org.springframework.xml.transform.TransformerObjectSupport;
/**
* Abstract base class for {@link MethodArgumentResolver} and {@link MethodReturnValueHandler} implementations based on
* {@link RequestPayload} and {@link ResponsePayload} annotations.
*
* @author Arjen Poutsma
* @since 2.0
*/
public abstract class AbstractPayloadMethodProcessor extends TransformerObjectSupport
implements MethodArgumentResolver, MethodReturnValueHandler {
// MethodArgumentResolver
/**
* {@inheritDoc}
*
* <p>This implementation gets checks if the given parameter is annotated with {@link RequestPayload}, and invokes
* {@link #supportsRequestPayloadParameter(org.springframework.core.MethodParameter)} afterwards.
*/
@Override
public final boolean supportsParameter(MethodParameter parameter) {
Assert.isTrue(parameter.getParameterIndex() >= 0, "Parameter index larger smaller than 0");
if (parameter.getParameterAnnotation(RequestPayload.class) == null) {
return false;
}
else {
return supportsRequestPayloadParameter(parameter);
}
}
/**
* Indicates whether the given {@linkplain MethodParameter method parameter}, annotated with {@link RequestPayload},
* is supported by this resolver.
*
* @param parameter the method parameter to check
* @return {@code true} if this resolver supports the supplied parameter; {@code false} otherwise
*/
protected abstract boolean supportsRequestPayloadParameter(MethodParameter parameter);
// MethodReturnValueHandler
/**
* {@inheritDoc}
*
* <p>This implementation gets checks if the method of the given return type is annotated with {@link ResponsePayload},
* and invokes {@link #supportsResponsePayloadReturnType(org.springframework.core.MethodParameter)} afterwards.
*/
@Override
public final boolean supportsReturnType(MethodParameter returnType) {
Assert.isTrue(returnType.getParameterIndex() == -1, "Parameter index is not -1");
if (returnType.getMethodAnnotation(ResponsePayload.class) == null) {
return false;
}
else {
return supportsResponsePayloadReturnType(returnType);
}
}
/**
* Indicates whether the given {@linkplain MethodParameter method return type}, annotated with {@link
* ResponsePayload}, is supported.
*
* @param returnType the method parameter to check
* @return {@code true} if this resolver supports the supplied return type; {@code false} otherwise
*/
protected abstract boolean supportsResponsePayloadReturnType(MethodParameter returnType);
/**
* Converts the given source to a byte array input stream.
*
* @param source the source to convert
* @return the input stream
* @throws javax.xml.transform.TransformerException in case of transformation errors
*/
protected ByteArrayInputStream convertToByteArrayInputStream(Source source) throws TransformerException {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
transform(source, new StreamResult(bos));
return new ByteArrayInputStream(bos.toByteArray());
}
}