Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

StaxUtils relies on JAXP 1.4 (as included in JDK 1.6+)

Browse Source
This commit is contained in:
Juergen Hoeller
2013-03-19 13:15:05 +01:00
parent 87e5f19c3f
commit 7f0a780925
7 changed files with 39 additions and 710 deletions
Download Patch File Download Diff File Expand all files Collapse all files

113
spring-core/src/main/java/org/springframework/util/xml/StaxResult.java
View File

@@ -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");
}
}

117
spring-core/src/main/java/org/springframework/util/xml/StaxSource.java
View File

@@ -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");
}
}

234
spring-core/src/main/java/org/springframework/util/xml/StaxUtils.java
View File

@@ -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();
}
}
}