/*
* Copyright 2005-2010 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 javax.xml.stream.Location;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import javax.xml.stream.util.StreamReaderDelegate;
import javax.xml.transform.Source;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.sax.SAXSource;
import javax.xml.transform.stax.StAXSource;
import javax.xml.transform.stream.StreamSource;
import org.springframework.core.MethodParameter;
import org.springframework.xml.JaxpVersion;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.xml.sax.InputSource;
/**
* Implementation of {@link MethodArgumentResolver} and {@link MethodReturnValueHandler} that supports {@link Source}
* objects.
*
* @author Arjen Poutsma
* @since 2.0
*/
public class SourcePayloadMethodProcessor extends AbstractPayloadSourceMethodProcessor {
private XMLInputFactory inputFactory = createXmlInputFactory();
// MethodArgumentResolver
@Override
protected boolean supportsRequestPayloadParameter(MethodParameter parameter) {
return supports(parameter);
}
@Override
protected Source resolveRequestPayloadArgument(MethodParameter parameter, Source requestPayload) throws Exception {
Class<?> parameterType = parameter.getParameterType();
if (parameterType.isAssignableFrom(requestPayload.getClass())) {
return requestPayload;
}
if (DOMSource.class.isAssignableFrom(parameterType)) {
DOMResult domResult = new DOMResult();
transform(requestPayload, domResult);
Node node = domResult.getNode();
if (node.getNodeType() == Node.DOCUMENT_NODE) {
return new DOMSource(((Document) node).getDocumentElement());
}
else {
return new DOMSource(domResult.getNode());
}
}
else if (SAXSource.class.isAssignableFrom(parameterType)) {
ByteArrayInputStream bis = convertToByteArrayInputStream(requestPayload);
InputSource inputSource = new InputSource(bis);
return new SAXSource(inputSource);
}
else if (StreamSource.class.isAssignableFrom(parameterType)) {
ByteArrayInputStream bis = convertToByteArrayInputStream(requestPayload);
return new StreamSource(bis);
}
else if (JaxpVersion.isAtLeastJaxp14() && Jaxp14StaxHandler.isStaxSource(parameterType)) {
XMLStreamReader streamReader;
try {
streamReader = inputFactory.createXMLStreamReader(requestPayload);
} catch (UnsupportedOperationException ignored) {
streamReader = null;
}
catch (XMLStreamException ignored) {
streamReader = null;
}
if (streamReader == null) {
ByteArrayInputStream bis = convertToByteArrayInputStream(requestPayload);
streamReader = inputFactory.createXMLStreamReader(bis);
}
return Jaxp14StaxHandler.createStaxSource(streamReader, requestPayload.getSystemId());
}
throw new IllegalArgumentException("Unknown Source type: " + parameterType);
}
// MethodReturnValueHandler
@Override
protected boolean supportsResponsePayloadReturnType(MethodParameter returnType) {
return supports(returnType);
}
@Override
protected Source createResponsePayload(MethodParameter returnType, Object returnValue) {
return (Source) returnValue;
}
private boolean supports(MethodParameter parameter) {
return Source.class.isAssignableFrom(parameter.getParameterType());
}
/**
* Create a {@code XMLInputFactory} that this resolver will use to create {@link javax.xml.stream.XMLStreamReader}
* and {@link javax.xml.stream.XMLEventReader} objects.
*
* <p>Can be overridden in subclasses, adding further initialization of the factory. The resulting factory is cached,
* so this method will only be called once.
*
* @return the created factory
*/
protected XMLInputFactory createXmlInputFactory() {
return XMLInputFactory.newInstance();
}
/** Inner class to avoid a static JAXP 1.4 dependency. */
private static class Jaxp14StaxHandler {
private static boolean isStaxSource(Class<?> clazz) {
return StAXSource.class.isAssignableFrom(clazz);
}
private static Source createStaxSource(XMLStreamReader streamReader, String systemId) {
return new StAXSource(new SystemIdStreamReaderDelegate(streamReader, systemId));
}
}
private static class SystemIdStreamReaderDelegate extends StreamReaderDelegate {
private final String systemId;
private SystemIdStreamReaderDelegate(XMLStreamReader reader, String systemId) {
super(reader);
this.systemId = systemId;
}
@Override
public Location getLocation() {
final Location parentLocation = getParent().getLocation();
return new Location() {
public int getLineNumber() {
return parentLocation != null ? parentLocation.getLineNumber() : -1;
}
public int getColumnNumber() {
return parentLocation != null ? parentLocation.getColumnNumber() : -1;
}
public int getCharacterOffset() {
return parentLocation != null ? parentLocation.getLineNumber() : -1;
}
public String getPublicId() {
return parentLocation != null ? parentLocation.getPublicId() : null;
}
public String getSystemId() {
return systemId;
}
};
}
}
}