StaxUtils relies on JAXP 1.4 (as included in JDK 1.6+)
This commit is contained in:
Juergen Hoeller
parent
87e5f19c3f
commit
7f0a780925
|
|
@ -1,113 +0,0 @@
|
|||
/*
|
||||
* Copyright 2002-2013 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.util.xml;
|
||||
|
||||
import javax.xml.stream.XMLEventFactory;
|
||||
import javax.xml.stream.XMLEventWriter;
|
||||
import javax.xml.stream.XMLStreamWriter;
|
||||
import javax.xml.transform.sax.SAXResult;
|
||||
|
||||
import org.xml.sax.ContentHandler;
|
||||
|
||||
/**
|
||||
* Implementation of the {@code Result} tagging interface for StAX writers. Can be constructed with
|
||||
* an {@code XMLEventConsumer} or an {@code XMLStreamWriter}.
|
||||
*
|
||||
* <p>This class is necessary because there is no implementation of {@code Source} for StaxReaders
|
||||
* in JAXP 1.3. There is a {@code StAXResult} in JAXP 1.4 (JDK 1.6), but this class is kept around
|
||||
* for backwards compatibility reasons.
|
||||
*
|
||||
* <p>Even though {@code StaxResult} extends from {@code SAXResult}, calling the methods of
|
||||
* {@code SAXResult} is <strong>not supported</strong>. In general, the only supported operation
|
||||
* on this class is to use the {@code ContentHandler} obtained via {@link #getHandler()} to parse an
|
||||
* input source using an {@code XMLReader}. Calling {@link #setHandler(org.xml.sax.ContentHandler)}
|
||||
* will result in {@code UnsupportedOperationException}s.
|
||||
*
|
||||
* @author Arjen Poutsma
|
||||
* @since 3.0
|
||||
* @see XMLEventWriter
|
||||
* @see XMLStreamWriter
|
||||
* @see javax.xml.transform.Transformer
|
||||
*/
|
||||
class StaxResult extends SAXResult {
|
||||
|
||||
private XMLEventWriter eventWriter;
|
||||
|
||||
private XMLStreamWriter streamWriter;
|
||||
|
||||
|
||||
/**
|
||||
* Construct a new instance of the {@code StaxResult} with the specified {@code XMLStreamWriter}.
|
||||
* @param streamWriter the {@code XMLStreamWriter} to write to
|
||||
*/
|
||||
StaxResult(XMLStreamWriter streamWriter) {
|
||||
super.setHandler(new StaxStreamContentHandler(streamWriter));
|
||||
this.streamWriter = streamWriter;
|
||||
}
|
||||
|
||||
/**
|
||||
* Construct a new instance of the {@code StaxResult} with the specified {@code XMLEventWriter}.
|
||||
* @param eventWriter the {@code XMLEventWriter} to write to
|
||||
*/
|
||||
StaxResult(XMLEventWriter eventWriter) {
|
||||
super.setHandler(new StaxEventContentHandler(eventWriter));
|
||||
this.eventWriter = eventWriter;
|
||||
}
|
||||
|
||||
/**
|
||||
* Construct a new instance of the {@code StaxResult} with the specified {@code XMLEventWriter}
|
||||
* and {@code XMLEventFactory}.
|
||||
* @param eventWriter the {@code XMLEventWriter} to write to
|
||||
* @param eventFactory the {@code XMLEventFactory} to use for creating events
|
||||
*/
|
||||
StaxResult(XMLEventWriter eventWriter, XMLEventFactory eventFactory) {
|
||||
super.setHandler(new StaxEventContentHandler(eventWriter, eventFactory));
|
||||
this.eventWriter = eventWriter;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Return the {@code XMLEventWriter} used by this {@code StaxResult}. If this {@code StaxResult}
|
||||
* was created with an {@code XMLStreamWriter}, the result will be {@code null}.
|
||||
* @return the StAX event writer used by this result
|
||||
* @see #StaxResult(javax.xml.stream.XMLEventWriter)
|
||||
*/
|
||||
XMLEventWriter getXMLEventWriter() {
|
||||
return this.eventWriter;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the {@code XMLStreamWriter} used by this {@code StaxResult}. If this {@code StaxResult}
|
||||
* was created with an {@code XMLEventConsumer}, the result will be {@code null}.
|
||||
* @return the StAX stream writer used by this result
|
||||
* @see #StaxResult(javax.xml.stream.XMLStreamWriter)
|
||||
*/
|
||||
XMLStreamWriter getXMLStreamWriter() {
|
||||
return this.streamWriter;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Throws an {@code UnsupportedOperationException}.
|
||||
* @throws UnsupportedOperationException always
|
||||
*/
|
||||
@Override
|
||||
public void setHandler(ContentHandler handler) {
|
||||
throw new UnsupportedOperationException("setHandler is not supported");
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,117 +0,0 @@
|
|||
/*
|
||||
* Copyright 2002-2013 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.util.xml;
|
||||
|
||||
import javax.xml.stream.XMLEventReader;
|
||||
import javax.xml.stream.XMLStreamReader;
|
||||
import javax.xml.transform.sax.SAXSource;
|
||||
|
||||
import org.xml.sax.InputSource;
|
||||
import org.xml.sax.XMLReader;
|
||||
|
||||
/**
|
||||
* Implementation of the {@code Source} tagging interface for StAX readers. Can be constructed with
|
||||
* an {@code XMLEventReader} or an {@code XMLStreamReader}.
|
||||
*
|
||||
* <p>This class is necessary because there is no implementation of {@code Source} for StAX Readers
|
||||
* in JAXP 1.3. There is a {@code StAXSource} in JAXP 1.4 (JDK 1.6), but this class is kept around
|
||||
* for backwards compatibility reasons.
|
||||
*
|
||||
* <p>Even though {@code StaxSource} extends from {@code SAXSource}, calling the methods of
|
||||
* {@code SAXSource} is <strong>not supported</strong>. In general, the only supported operation
|
||||
* on this class is to use the {@code XMLReader} obtained via {@link #getXMLReader()} to parse the
|
||||
* input source obtained via {@link #getInputSource()}. Calling {@link #setXMLReader(XMLReader)}
|
||||
* or {@link #setInputSource(InputSource)} will result in {@code UnsupportedOperationException}s.
|
||||
*
|
||||
* @author Arjen Poutsma
|
||||
* @since 3.0
|
||||
* @see XMLEventReader
|
||||
* @see XMLStreamReader
|
||||
* @see javax.xml.transform.Transformer
|
||||
*/
|
||||
class StaxSource extends SAXSource {
|
||||
|
||||
private XMLEventReader eventReader;
|
||||
|
||||
private XMLStreamReader streamReader;
|
||||
|
||||
|
||||
/**
|
||||
* Construct a new instance of the {@code StaxSource} with the specified {@code XMLStreamReader}.
|
||||
* The supplied stream reader must be in {@code XMLStreamConstants.START_DOCUMENT} or
|
||||
* {@code XMLStreamConstants.START_ELEMENT} state.
|
||||
* @param streamReader the {@code XMLStreamReader} to read from
|
||||
* @throws IllegalStateException if the reader is not at the start of a document or element
|
||||
*/
|
||||
StaxSource(XMLStreamReader streamReader) {
|
||||
super(new StaxStreamXMLReader(streamReader), new InputSource());
|
||||
this.streamReader = streamReader;
|
||||
}
|
||||
|
||||
/**
|
||||
* Construct a new instance of the {@code StaxSource} with the specified {@code XMLEventReader}.
|
||||
* The supplied event reader must be in {@code XMLStreamConstants.START_DOCUMENT} or
|
||||
* {@code XMLStreamConstants.START_ELEMENT} state.
|
||||
* @param eventReader the {@code XMLEventReader} to read from
|
||||
* @throws IllegalStateException if the reader is not at the start of a document or element
|
||||
*/
|
||||
StaxSource(XMLEventReader eventReader) {
|
||||
super(new StaxEventXMLReader(eventReader), new InputSource());
|
||||
this.eventReader = eventReader;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Return the {@code XMLEventReader} used by this {@code StaxSource}. If this {@code StaxSource}
|
||||
* was created with an {@code XMLStreamReader}, the result will be {@code null}.
|
||||
* @return the StAX event reader used by this source
|
||||
* @see StaxSource#StaxSource(javax.xml.stream.XMLEventReader)
|
||||
*/
|
||||
XMLEventReader getXMLEventReader() {
|
||||
return this.eventReader;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the {@code XMLStreamReader} used by this {@code StaxSource}. If this {@code StaxSource}
|
||||
* was created with an {@code XMLEventReader}, the result will be {@code null}.
|
||||
* @return the StAX event reader used by this source
|
||||
* @see StaxSource#StaxSource(javax.xml.stream.XMLEventReader)
|
||||
*/
|
||||
XMLStreamReader getXMLStreamReader() {
|
||||
return this.streamReader;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Throws an {@code UnsupportedOperationException}.
|
||||
* @throws UnsupportedOperationException always
|
||||
*/
|
||||
@Override
|
||||
public void setInputSource(InputSource inputSource) {
|
||||
throw new UnsupportedOperationException("setInputSource is not supported");
|
||||
}
|
||||
|
||||
/**
|
||||
* Throws an {@code UnsupportedOperationException}.
|
||||
* @throws UnsupportedOperationException always
|
||||
*/
|
||||
@Override
|
||||
public void setXMLReader(XMLReader reader) {
|
||||
throw new UnsupportedOperationException("setXMLReader is not supported");
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -31,10 +31,10 @@ import org.xml.sax.ContentHandler;
|
|||
import org.xml.sax.XMLReader;
|
||||
|
||||
import org.springframework.util.Assert;
|
||||
import org.springframework.util.ClassUtils;
|
||||
|
||||
/**
|
||||
* Convenience methods for working with the StAX API.
|
||||
* Convenience methods for working with the StAX API. Partly historic due to JAXP 1.3 compatibility;
|
||||
* as of Spring 4.0, relying on JAXP 1.4 as included in JDK 1.6 and higher.
|
||||
*
|
||||
* <p>In particular, methods for using StAX ({@code javax.xml.stream}) in combination with the TrAX API
|
||||
* ({@code javax.xml.transform}), and converting StAX readers/writers into SAX readers/handlers and vice-versa.
|
||||
|
|
@ -45,218 +45,104 @@ import org.springframework.util.ClassUtils;
|
|||
*/
|
||||
public abstract class StaxUtils {
|
||||
|
||||
// JAXP 1.4 is only available on JDK 1.6+
|
||||
private static boolean jaxp14Available =
|
||||
ClassUtils.isPresent("javax.xml.transform.stax.StAXSource", StaxUtils.class.getClassLoader());
|
||||
|
||||
|
||||
// Stax Source
|
||||
|
||||
/**
|
||||
* Create a custom, non-JAXP 1.4 StAX {@link Source} for the given {@link XMLStreamReader}.
|
||||
* Create a JAXP 1.4 {@link StAXSource} for the given {@link XMLStreamReader}.
|
||||
* @param streamReader the StAX stream reader
|
||||
* @return a source wrapping the {@code streamReader}
|
||||
*/
|
||||
public static Source createCustomStaxSource(XMLStreamReader streamReader) {
|
||||
return new StaxSource(streamReader);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a StAX {@link Source} for the given {@link XMLStreamReader}.
|
||||
* <p>If JAXP 1.4 is available, this method returns a {@link StAXSource};
|
||||
* otherwise it returns a custom StAX Source.
|
||||
* @param streamReader the StAX stream reader
|
||||
* @return a source wrapping the {@code streamReader}
|
||||
* @see #createCustomStaxSource(XMLStreamReader)
|
||||
*/
|
||||
public static Source createStaxSource(XMLStreamReader streamReader) {
|
||||
if (jaxp14Available) {
|
||||
return Jaxp14StaxHandler.createStaxSource(streamReader);
|
||||
}
|
||||
else {
|
||||
return createCustomStaxSource(streamReader);
|
||||
}
|
||||
return new StAXSource(streamReader);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a custom, non-JAXP 1.4 StAX {@link Source} for the given {@link XMLEventReader}.
|
||||
* @param eventReader the StAX event reader
|
||||
* @return a source wrapping the {@code eventReader}
|
||||
*/
|
||||
public static Source createCustomStaxSource(XMLEventReader eventReader) {
|
||||
return new StaxSource(eventReader);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a StAX {@link Source} for the given {@link XMLEventReader}.
|
||||
* <p>If JAXP 1.4 is available, this method returns a {@link StAXSource};
|
||||
* otherwise it returns a custom StAX Source.
|
||||
* Create a JAXP 1.4 a {@link StAXSource} for the given {@link XMLEventReader}.
|
||||
* @param eventReader the StAX event reader
|
||||
* @return a source wrapping the {@code eventReader}
|
||||
* @throws XMLStreamException in case of StAX errors
|
||||
* @see #createCustomStaxSource(XMLEventReader)
|
||||
*/
|
||||
public static Source createStaxSource(XMLEventReader eventReader) throws XMLStreamException {
|
||||
if (jaxp14Available) {
|
||||
return Jaxp14StaxHandler.createStaxSource(eventReader);
|
||||
}
|
||||
else {
|
||||
return createCustomStaxSource(eventReader);
|
||||
}
|
||||
return new StAXSource(eventReader);
|
||||
}
|
||||
|
||||
/**
|
||||
* Indicate whether the given {@link Source} is a StAX Source.
|
||||
* @return {@code true} if {@code source} is a custom StAX source or JAXP
|
||||
* 1.4 {@link StAXSource}; {@code false} otherwise.
|
||||
* @return {@code true} if {@code source} is a JAXP 1.4 {@link StAXSource};
|
||||
* {@code false} otherwise.
|
||||
*/
|
||||
public static boolean isStaxSource(Source source) {
|
||||
return (source instanceof StaxSource || (jaxp14Available && Jaxp14StaxHandler.isStaxSource(source)));
|
||||
}
|
||||
|
||||
|
||||
// Stax Result
|
||||
|
||||
/**
|
||||
* Create a custom, non-JAXP 1.4 StAX {@link Result} for the given {@link XMLStreamWriter}.
|
||||
* @param streamWriter the StAX stream writer
|
||||
* @return a source wrapping the {@code streamWriter}
|
||||
*/
|
||||
public static Result createCustomStaxResult(XMLStreamWriter streamWriter) {
|
||||
return new StaxResult(streamWriter);
|
||||
return (source instanceof StAXSource);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a StAX {@link Result} for the given {@link XMLStreamWriter}.
|
||||
* <p>If JAXP 1.4 is available, this method returns a {@link StAXResult};
|
||||
* otherwise it returns a custom StAX Result.
|
||||
* Create a JAXP 1.4 {@link StAXResult} for the given {@link XMLStreamWriter}.
|
||||
* @param streamWriter the StAX stream writer
|
||||
* @return a result wrapping the {@code streamWriter}
|
||||
* @see #createCustomStaxResult(XMLStreamWriter)
|
||||
*/
|
||||
public static Result createStaxResult(XMLStreamWriter streamWriter) {
|
||||
if (jaxp14Available) {
|
||||
return Jaxp14StaxHandler.createStaxResult(streamWriter);
|
||||
}
|
||||
else {
|
||||
return createCustomStaxResult(streamWriter);
|
||||
}
|
||||
return new StAXResult(streamWriter);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a custom, non-JAXP 1.4 StAX {@link Result} for the given {@link XMLEventWriter}.
|
||||
* @param eventWriter the StAX event writer
|
||||
* @return a source wrapping the {@code eventWriter}
|
||||
*/
|
||||
public static Result createCustomStaxResult(XMLEventWriter eventWriter) {
|
||||
return new StaxResult(eventWriter);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a StAX {@link Result} for the given {@link XMLEventWriter}.
|
||||
* <p>If JAXP 1.4 is available, this method returns a {@link StAXResult}; otherwise it returns a
|
||||
* custom StAX Result.
|
||||
* Create a JAXP 1.4 {@link StAXResult} for the given {@link XMLEventWriter}.
|
||||
* @param eventWriter the StAX event writer
|
||||
* @return a result wrapping {@code streamReader}
|
||||
* @throws XMLStreamException in case of StAX errors
|
||||
* @see #createCustomStaxResult(XMLEventWriter)
|
||||
*/
|
||||
public static Result createStaxResult(XMLEventWriter eventWriter) throws XMLStreamException {
|
||||
if (jaxp14Available) {
|
||||
return Jaxp14StaxHandler.createStaxResult(eventWriter);
|
||||
}
|
||||
else {
|
||||
return createCustomStaxResult(eventWriter);
|
||||
}
|
||||
return new StAXResult(eventWriter);
|
||||
}
|
||||
|
||||
/**
|
||||
* Indicate whether the given {@link javax.xml.transform.Result} is a StAX Result.
|
||||
* @return {@code true} if {@code result} is a custom Stax Result or JAXP 1.4
|
||||
* {@link StAXResult}; {@code false} otherwise.
|
||||
* @return {@code true} if {@code result} is a JAXP 1.4 {@link StAXResult};
|
||||
* {@code false} otherwise.
|
||||
*/
|
||||
public static boolean isStaxResult(Result result) {
|
||||
return (result instanceof StaxResult || (jaxp14Available && Jaxp14StaxHandler.isStaxResult(result)));
|
||||
return (result instanceof StAXResult);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the {@link XMLStreamReader} for the given StAX Source.
|
||||
* @param source a {@linkplain #createCustomStaxSource(XMLStreamReader) custom StAX Source} or
|
||||
* JAXP 1.4 {@link StAXSource}
|
||||
* @param source a JAXP 1.4 {@link StAXSource}
|
||||
* @return the {@link XMLStreamReader}
|
||||
* @throws IllegalArgumentException if {@code source} is neither a custom StAX Source
|
||||
* nor JAXP 1.4 {@link StAXSource}
|
||||
* @throws IllegalArgumentException if {@code source} isn't a JAXP 1.4 {@link StAXSource}
|
||||
*/
|
||||
public static XMLStreamReader getXMLStreamReader(Source source) {
|
||||
if (source instanceof StaxSource) {
|
||||
return ((StaxSource) source).getXMLStreamReader();
|
||||
}
|
||||
else if (jaxp14Available) {
|
||||
return Jaxp14StaxHandler.getXMLStreamReader(source);
|
||||
}
|
||||
else {
|
||||
throw new IllegalArgumentException("Source '" + source + "' is neither StaxSource nor StAXSource");
|
||||
}
|
||||
Assert.isInstanceOf(StAXSource.class, source);
|
||||
return ((StAXSource) source).getXMLStreamReader();
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the {@link XMLEventReader} for the given StAX Source.
|
||||
* @param source a {@linkplain #createCustomStaxSource(XMLEventReader) custom StAX Source} or
|
||||
* JAXP 1.4 {@link StAXSource}
|
||||
* @param source a JAXP 1.4 {@link StAXSource}
|
||||
* @return the {@link XMLEventReader}
|
||||
* @throws IllegalArgumentException if {@code source} is neither a custom StAX Source
|
||||
* nor a JAXP 1.4 {@link StAXSource}
|
||||
* @throws IllegalArgumentException if {@code source} isn't a JAXP 1.4 {@link StAXSource}
|
||||
*/
|
||||
public static XMLEventReader getXMLEventReader(Source source) {
|
||||
if (source instanceof StaxSource) {
|
||||
return ((StaxSource) source).getXMLEventReader();
|
||||
}
|
||||
else if (jaxp14Available) {
|
||||
return Jaxp14StaxHandler.getXMLEventReader(source);
|
||||
}
|
||||
else {
|
||||
throw new IllegalArgumentException("Source '" + source + "' is neither StaxSource nor StAXSource");
|
||||
}
|
||||
Assert.isInstanceOf(StAXSource.class, source);
|
||||
return ((StAXSource) source).getXMLEventReader();
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the {@link XMLStreamWriter} for the given StAX Result.
|
||||
* @param result a {@linkplain #createCustomStaxResult(XMLStreamWriter) custom StAX Result} or
|
||||
* JAXP 1.4 {@link StAXResult}
|
||||
* @param result a JAXP 1.4 {@link StAXResult}
|
||||
* @return the {@link XMLStreamReader}
|
||||
* @throws IllegalArgumentException if {@code source} is neither a custom StAX Result
|
||||
* nor a JAXP 1.4 {@link StAXResult}
|
||||
* @throws IllegalArgumentException if {@code source} isn't a JAXP 1.4 {@link StAXResult}
|
||||
*/
|
||||
public static XMLStreamWriter getXMLStreamWriter(Result result) {
|
||||
if (result instanceof StaxResult) {
|
||||
return ((StaxResult) result).getXMLStreamWriter();
|
||||
}
|
||||
else if (jaxp14Available) {
|
||||
return Jaxp14StaxHandler.getXMLStreamWriter(result);
|
||||
}
|
||||
else {
|
||||
throw new IllegalArgumentException("Result '" + result + "' is neither StaxResult nor StAXResult");
|
||||
}
|
||||
Assert.isInstanceOf(StAXResult.class, result);
|
||||
return ((StAXResult) result).getXMLStreamWriter();
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the {@link XMLEventWriter} for the given StAX Result.
|
||||
* @param result a {@linkplain #createCustomStaxResult(XMLEventWriter) custom StAX Result} or
|
||||
* JAXP 1.4 {@link StAXResult}
|
||||
* @param result a JAXP 1.4 {@link StAXResult}
|
||||
* @return the {@link XMLStreamReader}
|
||||
* @throws IllegalArgumentException if {@code source} is neither a custom StAX Result
|
||||
* nor a JAXP 1.4 {@link StAXResult}
|
||||
* @throws IllegalArgumentException if {@code source} isn't a JAXP 1.4 {@link StAXResult}
|
||||
*/
|
||||
public static XMLEventWriter getXMLEventWriter(Result result) {
|
||||
if (result instanceof StaxResult) {
|
||||
return ((StaxResult) result).getXMLEventWriter();
|
||||
}
|
||||
else if (jaxp14Available) {
|
||||
return Jaxp14StaxHandler.getXMLEventWriter(result);
|
||||
}
|
||||
else {
|
||||
throw new IllegalArgumentException("Result '" + result + "' is neither StaxResult nor StAXResult");
|
||||
}
|
||||
Assert.isInstanceOf(StAXResult.class, result);
|
||||
return ((StAXResult) result).getXMLEventWriter();
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -296,8 +182,9 @@ public abstract class StaxUtils {
|
|||
}
|
||||
|
||||
/**
|
||||
* Return a {@link XMLStreamReader} that reads from a {@link XMLEventReader}. Useful, because the StAX
|
||||
* {@code XMLInputFactory} allows one to create a event reader from a stream reader, but not vice-versa.
|
||||
* Return a {@link XMLStreamReader} that reads from a {@link XMLEventReader}.
|
||||
* Useful because the StAX {@code XMLInputFactory} allows one to create an
|
||||
* event reader from a stream reader, but not vice-versa.
|
||||
* @return a stream reader that reads from an event reader
|
||||
*/
|
||||
public static XMLStreamReader createEventStreamReader(XMLEventReader eventReader) throws XMLStreamException {
|
||||
|
|
@ -322,55 +209,4 @@ public abstract class StaxUtils {
|
|||
return new XMLEventStreamWriter(eventWriter, eventFactory);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Inner class to avoid a static JAXP 1.4 dependency.
|
||||
*/
|
||||
private static class Jaxp14StaxHandler {
|
||||
|
||||
private static Source createStaxSource(XMLStreamReader streamReader) {
|
||||
return new StAXSource(streamReader);
|
||||
}
|
||||
|
||||
private static Source createStaxSource(XMLEventReader eventReader) throws XMLStreamException {
|
||||
return new StAXSource(eventReader);
|
||||
}
|
||||
|
||||
private static Result createStaxResult(XMLStreamWriter streamWriter) {
|
||||
return new StAXResult(streamWriter);
|
||||
}
|
||||
|
||||
private static Result createStaxResult(XMLEventWriter eventWriter) {
|
||||
return new StAXResult(eventWriter);
|
||||
}
|
||||
|
||||
private static boolean isStaxSource(Source source) {
|
||||
return (source instanceof StAXSource);
|
||||
}
|
||||
|
||||
private static boolean isStaxResult(Result result) {
|
||||
return (result instanceof StAXResult);
|
||||
}
|
||||
|
||||
private static XMLStreamReader getXMLStreamReader(Source source) {
|
||||
Assert.isInstanceOf(StAXSource.class, source);
|
||||
return ((StAXSource) source).getXMLStreamReader();
|
||||
}
|
||||
|
||||
private static XMLEventReader getXMLEventReader(Source source) {
|
||||
Assert.isInstanceOf(StAXSource.class, source);
|
||||
return ((StAXSource) source).getXMLEventReader();
|
||||
}
|
||||
|
||||
private static XMLStreamWriter getXMLStreamWriter(Result result) {
|
||||
Assert.isInstanceOf(StAXResult.class, result);
|
||||
return ((StAXResult) result).getXMLStreamWriter();
|
||||
}
|
||||
|
||||
private static XMLEventWriter getXMLEventWriter(Result result) {
|
||||
Assert.isInstanceOf(StAXResult.class, result);
|
||||
return ((StAXResult) result).getXMLEventWriter();
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,77 +0,0 @@
|
|||
/*
|
||||
* Copyright 2002-2009 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.util.xml;
|
||||
|
||||
import java.io.Reader;
|
||||
import java.io.StringReader;
|
||||
import java.io.StringWriter;
|
||||
import javax.xml.stream.XMLEventWriter;
|
||||
import javax.xml.stream.XMLOutputFactory;
|
||||
import javax.xml.stream.XMLStreamWriter;
|
||||
import javax.xml.transform.Source;
|
||||
import javax.xml.transform.Transformer;
|
||||
import javax.xml.transform.TransformerFactory;
|
||||
import javax.xml.transform.stream.StreamSource;
|
||||
|
||||
import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertNull;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
|
||||
public class StaxResultTests {
|
||||
|
||||
private static final String XML = "<root xmlns='namespace'><child/></root>";
|
||||
|
||||
private Transformer transformer;
|
||||
|
||||
private XMLOutputFactory inputFactory;
|
||||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
TransformerFactory transformerFactory = TransformerFactory.newInstance();
|
||||
transformer = transformerFactory.newTransformer();
|
||||
inputFactory = XMLOutputFactory.newInstance();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void streamWriterSource() throws Exception {
|
||||
StringWriter stringWriter = new StringWriter();
|
||||
XMLStreamWriter streamWriter = inputFactory.createXMLStreamWriter(stringWriter);
|
||||
Reader reader = new StringReader(XML);
|
||||
Source source = new StreamSource(reader);
|
||||
StaxResult result = new StaxResult(streamWriter);
|
||||
assertEquals("Invalid streamWriter returned", streamWriter, result.getXMLStreamWriter());
|
||||
assertNull("EventWriter returned", result.getXMLEventWriter());
|
||||
transformer.transform(source, result);
|
||||
assertXMLEqual("Invalid result", XML, stringWriter.toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void eventWriterSource() throws Exception {
|
||||
StringWriter stringWriter = new StringWriter();
|
||||
XMLEventWriter eventWriter = inputFactory.createXMLEventWriter(stringWriter);
|
||||
Reader reader = new StringReader(XML);
|
||||
Source source = new StreamSource(reader);
|
||||
StaxResult result = new StaxResult(eventWriter);
|
||||
assertEquals("Invalid eventWriter returned", eventWriter, result.getXMLEventWriter());
|
||||
assertNull("StreamWriter returned", result.getXMLStreamWriter());
|
||||
transformer.transform(source, result);
|
||||
assertXMLEqual("Invalid result", XML, stringWriter.toString());
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,108 +0,0 @@
|
|||
/*
|
||||
* Copyright 2002-2012 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.util.xml;
|
||||
|
||||
import static org.custommonkey.xmlunit.XMLAssert.assertXMLEqual;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertNull;
|
||||
|
||||
import java.io.StringReader;
|
||||
import java.io.StringWriter;
|
||||
|
||||
import javax.xml.parsers.DocumentBuilder;
|
||||
import javax.xml.parsers.DocumentBuilderFactory;
|
||||
import javax.xml.stream.XMLEventReader;
|
||||
import javax.xml.stream.XMLInputFactory;
|
||||
import javax.xml.stream.XMLStreamReader;
|
||||
import javax.xml.transform.Transformer;
|
||||
import javax.xml.transform.TransformerFactory;
|
||||
import javax.xml.transform.dom.DOMResult;
|
||||
import javax.xml.transform.stream.StreamResult;
|
||||
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import org.w3c.dom.Document;
|
||||
import org.xml.sax.InputSource;
|
||||
|
||||
public class StaxSourceTests {
|
||||
|
||||
private static final String XML = "<root xmlns='namespace'><child/></root>";
|
||||
|
||||
private Transformer transformer;
|
||||
|
||||
private XMLInputFactory inputFactory;
|
||||
|
||||
private DocumentBuilder documentBuilder;
|
||||
|
||||
@Before
|
||||
public void setUp() throws Exception {
|
||||
TransformerFactory transformerFactory = TransformerFactory.newInstance();
|
||||
transformer = transformerFactory.newTransformer();
|
||||
inputFactory = XMLInputFactory.newInstance();
|
||||
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
|
||||
documentBuilderFactory.setNamespaceAware(true);
|
||||
documentBuilder = documentBuilderFactory.newDocumentBuilder();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void streamReaderSourceToStreamResult() throws Exception {
|
||||
XMLStreamReader streamReader = inputFactory.createXMLStreamReader(new StringReader(XML));
|
||||
StaxSource source = new StaxSource(streamReader);
|
||||
assertEquals("Invalid streamReader returned", streamReader, source.getXMLStreamReader());
|
||||
assertNull("EventReader returned", source.getXMLEventReader());
|
||||
StringWriter writer = new StringWriter();
|
||||
transformer.transform(source, new StreamResult(writer));
|
||||
assertXMLEqual("Invalid result", XML, writer.toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void streamReaderSourceToDOMResult() throws Exception {
|
||||
XMLStreamReader streamReader = inputFactory.createXMLStreamReader(new StringReader(XML));
|
||||
StaxSource source = new StaxSource(streamReader);
|
||||
assertEquals("Invalid streamReader returned", streamReader, source.getXMLStreamReader());
|
||||
assertNull("EventReader returned", source.getXMLEventReader());
|
||||
|
||||
Document expected = documentBuilder.parse(new InputSource(new StringReader(XML)));
|
||||
Document result = documentBuilder.newDocument();
|
||||
transformer.transform(source, new DOMResult(result));
|
||||
assertXMLEqual("Invalid result", expected, result);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void eventReaderSourceToStreamResult() throws Exception {
|
||||
XMLEventReader eventReader = inputFactory.createXMLEventReader(new StringReader(XML));
|
||||
StaxSource source = new StaxSource(eventReader);
|
||||
assertEquals("Invalid eventReader returned", eventReader, source.getXMLEventReader());
|
||||
assertNull("StreamReader returned", source.getXMLStreamReader());
|
||||
StringWriter writer = new StringWriter();
|
||||
transformer.transform(source, new StreamResult(writer));
|
||||
assertXMLEqual("Invalid result", XML, writer.toString());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void eventReaderSourceToDOMResult() throws Exception {
|
||||
XMLEventReader eventReader = inputFactory.createXMLEventReader(new StringReader(XML));
|
||||
StaxSource source = new StaxSource(eventReader);
|
||||
assertEquals("Invalid eventReader returned", eventReader, source.getXMLEventReader());
|
||||
assertNull("StreamReader returned", source.getXMLStreamReader());
|
||||
|
||||
Document expected = documentBuilder.parse(new InputSource(new StringReader(XML)));
|
||||
Document result = documentBuilder.newDocument();
|
||||
transformer.transform(source, new DOMResult(result));
|
||||
assertXMLEqual("Invalid result", expected, result);
|
||||
}
|
||||
}
|
||||
|
|
@ -1,93 +0,0 @@
|
|||
/*
|
||||
* Copyright 2002-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.util.xml;
|
||||
|
||||
import java.io.StringReader;
|
||||
import java.io.StringWriter;
|
||||
import javax.xml.stream.XMLInputFactory;
|
||||
import javax.xml.stream.XMLOutputFactory;
|
||||
import javax.xml.stream.XMLStreamReader;
|
||||
import javax.xml.stream.XMLStreamWriter;
|
||||
import javax.xml.transform.Result;
|
||||
import javax.xml.transform.Source;
|
||||
import javax.xml.transform.dom.DOMResult;
|
||||
import javax.xml.transform.dom.DOMSource;
|
||||
import javax.xml.transform.sax.SAXResult;
|
||||
import javax.xml.transform.sax.SAXSource;
|
||||
import javax.xml.transform.stax.StAXResult;
|
||||
import javax.xml.transform.stax.StAXSource;
|
||||
import javax.xml.transform.stream.StreamResult;
|
||||
import javax.xml.transform.stream.StreamSource;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
import org.junit.Test;
|
||||
|
||||
public class StaxUtilsTest {
|
||||
|
||||
@Test
|
||||
public void isStaxSourceInvalid() throws Exception {
|
||||
assertFalse("A StAX Source", StaxUtils.isStaxSource(new DOMSource()));
|
||||
assertFalse("A StAX Source", StaxUtils.isStaxSource(new SAXSource()));
|
||||
assertFalse("A StAX Source", StaxUtils.isStaxSource(new StreamSource()));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isStaxSource() throws Exception {
|
||||
XMLInputFactory inputFactory = XMLInputFactory.newInstance();
|
||||
String expected = "<element/>";
|
||||
XMLStreamReader streamReader = inputFactory.createXMLStreamReader(new StringReader(expected));
|
||||
Source source = StaxUtils.createCustomStaxSource(streamReader);
|
||||
|
||||
assertTrue("Not a StAX Source", StaxUtils.isStaxSource(source));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isStaxSourceJaxp14() throws Exception {
|
||||
XMLInputFactory inputFactory = XMLInputFactory.newInstance();
|
||||
String expected = "<element/>";
|
||||
XMLStreamReader streamReader = inputFactory.createXMLStreamReader(new StringReader(expected));
|
||||
StAXSource source = new StAXSource(streamReader);
|
||||
|
||||
assertTrue("Not a StAX Source", StaxUtils.isStaxSource(source));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isStaxResultInvalid() throws Exception {
|
||||
assertFalse("A StAX Result", StaxUtils.isStaxResult(new DOMResult()));
|
||||
assertFalse("A StAX Result", StaxUtils.isStaxResult(new SAXResult()));
|
||||
assertFalse("A StAX Result", StaxUtils.isStaxResult(new StreamResult()));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isStaxResult() throws Exception {
|
||||
XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
|
||||
XMLStreamWriter streamWriter = outputFactory.createXMLStreamWriter(new StringWriter());
|
||||
Result result = StaxUtils.createCustomStaxResult(streamWriter);
|
||||
|
||||
assertTrue("Not a StAX Result", StaxUtils.isStaxResult(result));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void isStaxResultJaxp14() throws Exception {
|
||||
XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
|
||||
XMLStreamWriter streamWriter = outputFactory.createXMLStreamWriter(new StringWriter());
|
||||
StAXResult result = new StAXResult(streamWriter);
|
||||
|
||||
assertTrue("Not a StAX Result", StaxUtils.isStaxResult(result));
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
* Copyright 2002-2011 the original author or authors.
|
||||
* Copyright 2002-2013 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.
|
||||
|
|
@ -22,6 +22,7 @@ import javax.xml.stream.XMLEventReader;
|
|||
import javax.xml.stream.XMLInputFactory;
|
||||
import javax.xml.transform.Transformer;
|
||||
import javax.xml.transform.TransformerFactory;
|
||||
import javax.xml.transform.stax.StAXSource;
|
||||
import javax.xml.transform.stream.StreamResult;
|
||||
|
||||
import org.junit.Before;
|
||||
|
|
@ -54,10 +55,10 @@ public class XMLEventStreamReaderTests {
|
|||
@Test
|
||||
public void readCorrect() throws Exception {
|
||||
Transformer transformer = TransformerFactory.newInstance().newTransformer();
|
||||
StaxSource source = new StaxSource(streamReader);
|
||||
StAXSource source = new StAXSource(streamReader);
|
||||
StringWriter writer = new StringWriter();
|
||||
transformer.transform(source, new StreamResult(writer));
|
||||
assertXMLEqual(XML, writer.toString());
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue