Skip to content

S
spring-framework

爱吃血肠 / spring-framework

通知 1
Star 0
Fork 0
S
spring-framework

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 555fa3b4 编写于 作者: J Juergen Hoeller
浏览文件
操作

revised OXM package: no provider-specific exceptions anymore, etc

上级 866ee115
展开全部 隐藏空白更改
内联 并排
Showing with 1476 addition and 2570 deletion
org.springframework.core/src/main/java/org/springframework/util/Md5HashUtils.java
浏览文件 @ 555fa3b4
/*
* Copyright 2008 the original author or authors.
* 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.
......@@ -31,8 +31,7 @@ public abstract class Md5HashUtils {
{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
/**
* Calculates the MD5 hash of the given bytes.
*
* Calculate the MD5 hash of the given bytes.
* @param bytes the bytes to calculate the hash over
* @return the hash
*/
......@@ -59,8 +58,7 @@ public abstract class Md5HashUtils {
}
/**
* Returns a hex string representation of the MD5 hash of the given bytes.
*
* Return a hex string representation of the MD5 hash of the given bytes.
* @param bytes the bytes to calculate the hash over
* @return a hexadecimal hash string
*/
......@@ -69,9 +67,8 @@ public abstract class Md5HashUtils {
}
/**
* Appends a hex string representation of the MD5 hash of the given bytes to the given {@link StringBuilder}.
*
* @param bytes the bytes to calculate the hash over
* Append a hex string representation of the MD5 hash of the given bytes to the given {@link StringBuilder}.
* @param bytes the bytes to calculate the hash over
* @param builder the string builder to append the hash to
* @return the given string builder
*/
......
org.springframework.core/src/main/java/org/springframework/util/xml/AbstractStaxXMLReader.java
浏览文件 @ 555fa3b4
......@@ -34,11 +34,11 @@ import org.springframework.util.StringUtils;
* Abstract base class for SAX <code>XMLReader</code> implementations that use StAX as a basis.
*
* @author Arjen Poutsma
* @since 3.0
* @see #setContentHandler(org.xml.sax.ContentHandler)
* @see #setDTDHandler(org.xml.sax.DTDHandler)
* @see #setEntityResolver(org.xml.sax.EntityResolver)
* @see #setErrorHandler(org.xml.sax.ErrorHandler)
* @since 3.0
*/
abstract class AbstractStaxXMLReader extends AbstractXMLReader {
......@@ -48,23 +48,25 @@ abstract class AbstractStaxXMLReader extends AbstractXMLReader {
private static final String IS_STANDALONE_FEATURE_NAME = "http://xml.org/sax/features/is-standalone";
private boolean namespacesFeature = true;
private boolean namespacePrefixesFeature = false;
private Boolean isStandalone;
@Override
public boolean getFeature(String name) throws SAXNotRecognizedException, SAXNotSupportedException {
if (NAMESPACES_FEATURE_NAME.equals(name)) {
return namespacesFeature;
return this.namespacesFeature;
}
else if (NAMESPACE_PREFIXES_FEATURE_NAME.equals(name)) {
return namespacePrefixesFeature;
return this.namespacePrefixesFeature;
}
else if (IS_STANDALONE_FEATURE_NAME.equals(name)) {
if (isStandalone != null) {
return isStandalone;
if (this.isStandalone != null) {
return this.isStandalone;
}
else {
throw new SAXNotSupportedException("startDocument() callback not completed yet");
......@@ -88,35 +90,66 @@ abstract class AbstractStaxXMLReader extends AbstractXMLReader {
}
}
/** Indicates whether the SAX feature <code>http://xml.org/sax/features/namespaces</code> is turned on. */
protected void setStandalone(boolean standalone) {
this.isStandalone = standalone;
}
/**
* Indicates whether the SAX feature <code>http://xml.org/sax/features/namespaces</code> is turned on.
*/
protected boolean hasNamespacesFeature() {
return namespacesFeature;
return this.namespacesFeature;
}
/** Indicates whether the SAX feature <code>http://xml.org/sax/features/namespaces-prefixes</code> is turned on. */
/**
* Indicates whether the SAX feature <code>http://xml.org/sax/features/namespaces-prefixes</code> is turned on.
*/
protected boolean hasNamespacePrefixesFeature() {
return namespacePrefixesFeature;
return this.namespacePrefixesFeature;
}
protected void setStandalone(boolean standalone) {
isStandalone = (standalone) ? Boolean.TRUE : Boolean.FALSE;
/**
* Sett the SAX <code>Locator</code> based on the given StAX <code>Location</code>.
* @param location the location
* @see ContentHandler#setDocumentLocator(org.xml.sax.Locator)
*/
protected void setLocator(Location location) {
if (getContentHandler() != null) {
getContentHandler().setDocumentLocator(new StaxLocator(location));
}
}
/**
* Convert a <code>QName</code> to a qualified name, as used by DOM and SAX.
* The returned string has a format of <code>prefix:localName</code> if the
* prefix is set, or just <code>localName</code> if not.
* @param qName the <code>QName</code>
* @return the qualified name
*/
protected String toQualifiedName(QName qName) {
String prefix = qName.getPrefix();
if (!StringUtils.hasLength(prefix)) {
return qName.getLocalPart();
}
else {
return prefix + ":" + qName.getLocalPart();
}
}
/**
* Parses the StAX XML reader passed at construction-time. <p/> <strong>Note</strong> that the given
* <code>InputSource</code> is not read, but ignored.
*
* Parse the StAX XML reader passed at construction-time.
* <p><b>NOTE:</b>: The given <code>InputSource</code> is not read, but ignored.
* @param ignored is ignored
* @throws SAXException A SAX exception, possibly wrapping a <code>XMLStreamException</code>
* @throws SAXException a SAX exception, possibly wrapping a <code>XMLStreamException</code>
*/
public final void parse(InputSource ignored) throws SAXException {
parse();
}
/**
* Parses the StAX XML reader passed at construction-time. <p/> <strong>Note</strong> that the given system identifier
* is not read, but ignored.
*
* Parse the StAX XML reader passed at construction-time.
* <p><b>NOTE:</b>: The given system identifier is not read, but ignored.
* @param ignored is ignored
* @throws SAXException A SAX exception, possibly wrapping a <code>XMLStreamException</code>
*/
......@@ -144,40 +177,13 @@ abstract class AbstractStaxXMLReader extends AbstractXMLReader {
}
/**
* Sets the SAX <code>Locator</code> based on the given StAX <code>Location</code>.
*
* @param location the location
* @see ContentHandler#setDocumentLocator(org.xml.sax.Locator)
* Template-method that parses the StAX reader passed at construction-time.
*/
protected void setLocator(Location location) {
if (getContentHandler() != null) {
getContentHandler().setDocumentLocator(new StaxLocator(location));
}
}
/** Template-method that parses the StAX reader passed at construction-time. */
protected abstract void parseInternal() throws SAXException, XMLStreamException;
/**
* Convert a <code>QName</code> to a qualified name, as used by DOM and SAX. The returned string has a format of
* <code>prefix:localName</code> if the prefix is set, or just <code>localName</code> if not.
*
* @param qName the <code>QName</code>
* @return the qualified name
*/
protected String toQualifiedName(QName qName) {
String prefix = qName.getPrefix();
if (!StringUtils.hasLength(prefix)) {
return qName.getLocalPart();
}
else {
return prefix + ":" + qName.getLocalPart();
}
}
/**
* Implementation of the <code>Locator</code> interface that is based on a StAX <code>Location</code>.
*
* @see Locator
* @see Location
*/
......@@ -205,4 +211,5 @@ abstract class AbstractStaxXMLReader extends AbstractXMLReader {
return location.getColumnNumber();
}
}
}
org.springframework.core/src/main/java/org/springframework/util/xml/JaxpVersion.java 已删除 100644 → 0
浏览文件 @ 866ee115
/*
* 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 org.springframework.util.ClassUtils;
/**
* Helper class used to find the current version of JAXP. We cannot depend on the Java version, since JAXP can be
* upgraded independently of the Java version. <p/> Only distinguishes between JAXP 1.0, 1.1, 1.3, and 1.4, since JAXP
* 1.2 was a maintenance release with no new classes.
*
* @author Arjen Poutsma
* @since 3.0.0
*/
abstract class JaxpVersion {
public static final int JAXP_10 = 0;
public static final int JAXP_11 = 1;
public static final int JAXP_13 = 3;
public static final int JAXP_14 = 4;
private static final String JAXP_14_CLASS_NAME = "javax.xml.transform.stax.StAXSource";
private static int jaxpVersion;
static {
try {
ClassUtils.forName(JAXP_14_CLASS_NAME);
jaxpVersion = JAXP_14;
}
catch (ClassNotFoundException ignored) {
// default to JAXP 1.3, since Spring 3 requires JDK 1.5
jaxpVersion = JAXP_13;
}
}
/**
* Gets the JAXP version. This means we can do things like if <code>(getJaxpVersion() < JAXP_13)</code>.
*
* @return a code comparable to the JAXP_XX codes in this class
* @see #JAXP_10
* @see #JAXP_11
* @see #JAXP_13
* @see #JAXP_14
*/
public static int getJaxpVersion() {
return jaxpVersion;
}
/**
* Convenience method to determine if the current JAXP version is at least 1.3 (packaged with JDK 1.5).
*
* @return <code>true</code> if the current JAXP version is at least JAXP 1.3
* @see #getJaxpVersion()
* @see #JAXP_13
*/
public static boolean isAtLeastJaxp13() {
return getJaxpVersion() >= JAXP_13;
}
/**
* Convenience method to determine if the current JAXP version is at least 1.4 (packaged with JDK 1.6).
*
* @return <code>true</code> if the current JAXP version is at least JAXP 1.4
* @see #getJaxpVersion()
* @see #JAXP_14
*/
public static boolean isAtLeastJaxp14() {
return getJaxpVersion() >= JAXP_14;
}
}
\ No newline at end of file
org.springframework.core/src/main/java/org/springframework/util/xml/StaxUtils.java
浏览文件 @ 555fa3b4
......@@ -30,27 +30,32 @@ 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.
*
* In particular, methods for using StAX in combination with the TrAX API (<code>javax.xml.transform</code>), and
* converting StAX readers/writers into SAX readers/handlers and vice-versa.
* <p>In particular, methods for using StAX in combination with the TrAX API
* (<code>javax.xml.transform</code>), and converting StAX readers/writers
* into SAX readers/handlers and vice-versa.
*
* @author Arjen Poutsma
* @author Juergen Hoeller
* @since 3.0
*/
public abstract class StaxUtils {
private static boolean jaxp14Available =
ClassUtils.isPresent("javax.xml.transform.stax.StAXSource", StaxUtils.class.getClassLoader());
/**
* Creates a StAX {@link Source} for the given {@link XMLStreamReader}. Returns a {@link StAXSource} under JAXP 1.4 or
* higher, or a {@link StaxSource} otherwise.
*
* Create a StAX {@link Source} for the given {@link XMLStreamReader}.
* @param streamReader the StAX stream reader
* @return a source wrapping <code>streamReader</code>
*/
public static Source createStaxSource(XMLStreamReader streamReader) {
if (JaxpVersion.isAtLeastJaxp14()) {
if (jaxp14Available) {
return Jaxp14StaxHandler.createStaxSource(streamReader);
}
else {
......@@ -59,15 +64,13 @@ public abstract class StaxUtils {
}
/**
* Creates a StAX {@link Source} for the given {@link XMLEventReader}. Returns a {@link StAXSource} under JAXP 1.4 or
* higher, or a {@link StaxSource} otherwise.
*
* Create a StAX {@link Source} for the given {@link XMLEventReader}.
* @param eventReader the StAX event reader
* @return a source wrapping <code>streamReader</code>
* @throws XMLStreamException in case of StAX errors
*/
public static Source createStaxSource(XMLEventReader eventReader) throws XMLStreamException {
if (JaxpVersion.isAtLeastJaxp14()) {
if (jaxp14Available) {
return Jaxp14StaxHandler.createStaxSource(eventReader);
}
else {
......@@ -76,14 +79,21 @@ public abstract class StaxUtils {
}
/**
* Creates a StAX {@link Result} for the given {@link XMLStreamWriter}. Returns a {@link StAXResult} under JAXP 1.4 or
* higher, or a {@link StaxResult} otherwise.
*
* Indicate whether the given {@link javax.xml.transform.Source} is a StAX Source.
* @return <code>true</code> if <code>source</code> is a Spring StaxSource or JAXP
* 1.4 {@link javax.xml.transform.stax.StAXSource}; <code>false</code> otherwise.
*/
public static boolean isStaxSource(Source source) {
return (source instanceof StaxSource || (jaxp14Available && Jaxp14StaxHandler.isStaxSource(source)));
}
/**
* Create a StAX {@link Result} for the given {@link XMLStreamWriter}.
* @param streamWriter the StAX stream writer
* @return a result wrapping <code>streamWriter</code>
*/
public static Result createStaxResult(XMLStreamWriter streamWriter) {
if (JaxpVersion.isAtLeastJaxp14()) {
if (jaxp14Available) {
return Jaxp14StaxHandler.createStaxResult(streamWriter);
}
else {
......@@ -92,15 +102,13 @@ public abstract class StaxUtils {
}
/**
* Creates a StAX {@link Result} for the given {@link XMLEventWriter}. Returns a {@link StAXResult} under JAXP 1.4 or
* higher, or a {@link StaxResult} otherwise.
*
* Create a StAX {@link Result} for the given {@link XMLEventWriter}.
* @param eventWriter the StAX event writer
* @return a result wrapping <code>streamReader</code>
* @throws XMLStreamException in case of StAX errors
*/
public static Result createStaxResult(XMLEventWriter eventWriter) throws XMLStreamException {
if (JaxpVersion.isAtLeastJaxp14()) {
if (jaxp14Available) {
return Jaxp14StaxHandler.createStaxResult(eventWriter);
}
else {
......@@ -109,54 +117,26 @@ public abstract class StaxUtils {
}
/**
* Indicates whether the given {@link javax.xml.transform.Source} is a StAX Source.
*
* @return <code>true</code> if <code>source</code> is a Spring {@link org.springframework.util.xml.StaxSource} or JAXP
* 1.4 {@link javax.xml.transform.stax.StAXSource}; <code>false</code> otherwise.
*/
public static boolean isStaxSource(Source source) {
if (source instanceof StaxSource) {
return true;
}
else if (JaxpVersion.isAtLeastJaxp14()) {
return Jaxp14StaxHandler.isStaxSource(source);
}
else {
return false;
}
}
/**
* Indicates whether the given {@link javax.xml.transform.Result} is a StAX Result.
*
* @return <code>true</code> if <code>result</code> is a Spring {@link org.springframework.util.xml.StaxResult} or JAXP
* 1.4 {@link javax.xml.transform.stax.StAXResult}; <code>false</code> otherwise.
* Indicate whether the given {@link javax.xml.transform.Result} is a StAX Result.
* @return <code>true</code> if <code>result</code> is a Spring StaxResult or JAXP
* 1.4 {@link javax.xml.transform.stax.StAXResult}; <code>false</code> otherwise.
*/
public static boolean isStaxResult(Result result) {
if (result instanceof StaxResult) {
return true;
}
else if (JaxpVersion.isAtLeastJaxp14()) {
return Jaxp14StaxHandler.isStaxResult(result);
}
else {
return false;
}
return (result instanceof StaxResult || (jaxp14Available && Jaxp14StaxHandler.isStaxResult(result)));
}
/**
* Returns the {@link javax.xml.stream.XMLStreamReader} for the given StAX Source.
*
* @param source a Spring {@link org.springframework.util.xml.StaxSource} or {@link javax.xml.transform.stax.StAXSource}
* Return the {@link javax.xml.stream.XMLStreamReader} for the given StAX Source.
* @param source a Spring StaxSource or JAXP 1.4 {@link javax.xml.transform.stax.StAXSource}
* @return the {@link javax.xml.stream.XMLStreamReader}
* @throws IllegalArgumentException if <code>source</code> is neither a Spring-WS {@link org.springframework.util.xml.StaxSource}
* or {@link javax.xml.transform.stax.StAXSource}
* @throws IllegalArgumentException if <code>source</code> is neither a Spring StaxSource
* nor JAXP 1.4 {@link javax.xml.transform.stax.StAXSource}
*/
public static XMLStreamReader getXMLStreamReader(Source source) {
if (source instanceof StaxSource) {
return ((StaxSource) source).getXMLStreamReader();
}
else if (JaxpVersion.isAtLeastJaxp14()) {
else if (jaxp14Available) {
return Jaxp14StaxHandler.getXMLStreamReader(source);
}
else {
......@@ -165,18 +145,17 @@ public abstract class StaxUtils {
}
/**
* Returns the {@link javax.xml.stream.XMLEventReader} for the given StAX Source.
*
* @param source a Spring {@link org.springframework.util.xml.StaxSource} or {@link javax.xml.transform.stax.StAXSource}
* Return the {@link javax.xml.stream.XMLEventReader} for the given StAX Source.
* @param source a Spring StaxSource or JAXP 1.4 {@link javax.xml.transform.stax.StAXSource}
* @return the {@link javax.xml.stream.XMLEventReader}
* @throws IllegalArgumentException if <code>source</code> is neither a Spring {@link org.springframework.util.xml.StaxSource}
* or {@link javax.xml.transform.stax.StAXSource}
* @throws IllegalArgumentException if <code>source</code> is neither a Spring StaxSource
* nor a JAXP 1.4 {@link javax.xml.transform.stax.StAXSource}
*/
public static XMLEventReader getXMLEventReader(Source source) {
if (source instanceof StaxSource) {
return ((StaxSource) source).getXMLEventReader();
}
else if (JaxpVersion.isAtLeastJaxp14()) {
else if (jaxp14Available) {
return Jaxp14StaxHandler.getXMLEventReader(source);
}
else {
......@@ -185,18 +164,17 @@ public abstract class StaxUtils {
}
/**
* Returns the {@link javax.xml.stream.XMLStreamWriter} for the given StAX Result.
*
* @param result a Spring {@link org.springframework.util.xml.StaxResult} or {@link javax.xml.transform.stax.StAXResult}
* Return the {@link javax.xml.stream.XMLStreamWriter} for the given StAX Result.
* @param result a Spring StaxResult or JAXP 1.4 {@link javax.xml.transform.stax.StAXResult}
* @return the {@link javax.xml.stream.XMLStreamReader}
* @throws IllegalArgumentException if <code>source</code> is neither a Spring {@link org.springframework.util.xml.StaxResult}
* or {@link javax.xml.transform.stax.StAXResult}
* @throws IllegalArgumentException if <code>source</code> is neither a Spring StaxResult
* nor a JAXP 1.4 {@link javax.xml.transform.stax.StAXResult}
*/
public static XMLStreamWriter getXMLStreamWriter(Result result) {
if (result instanceof StaxResult) {
return ((StaxResult) result).getXMLStreamWriter();
}
else if (JaxpVersion.isAtLeastJaxp14()) {
else if (jaxp14Available) {
return Jaxp14StaxHandler.getXMLStreamWriter(result);
}
else {
......@@ -205,18 +183,17 @@ public abstract class StaxUtils {
}
/**
* Returns the {@link XMLEventWriter} for the given StAX Result.
*
* @param result a Spring {@link org.springframework.util.xml.StaxResult} or {@link javax.xml.transform.stax.StAXResult}
* Return the {@link XMLEventWriter} for the given StAX Result.
* @param result a Spring StaxResult or JAXP 1.4 {@link javax.xml.transform.stax.StAXResult}
* @return the {@link javax.xml.stream.XMLStreamReader}
* @throws IllegalArgumentException if <code>source</code> is neither a Spring {@link org.springframework.util.xml.StaxResult}
* or {@link javax.xml.transform.stax.StAXResult}
* @throws IllegalArgumentException if <code>source</code> is neither a Spring StaxResult
* nor a JAXP 1.4 {@link javax.xml.transform.stax.StAXResult}
*/
public static XMLEventWriter getXMLEventWriter(Result result) {
if (result instanceof StaxResult) {
return ((StaxResult) result).getXMLEventWriter();
}
else if (JaxpVersion.isAtLeastJaxp14()) {
else if (jaxp14Available) {
return Jaxp14StaxHandler.getXMLEventWriter(result);
}
else {
......@@ -225,8 +202,7 @@ public abstract class StaxUtils {
}
/**
* Creates a SAX {@link ContentHandler} that writes to the given StAX {@link XMLStreamWriter}.
*
* Create a SAX {@link ContentHandler} that writes to the given StAX {@link XMLStreamWriter}.
* @param streamWriter the StAX stream writer
* @return a content handler writing to the <code>streamWriter</code>
*/
......@@ -235,8 +211,7 @@ public abstract class StaxUtils {
}
/**
* Creates a SAX {@link ContentHandler} that writes events to the given StAX {@link XMLEventWriter}.
*
* Create a SAX {@link ContentHandler} that writes events to the given StAX {@link XMLEventWriter}.
* @param eventWriter the StAX event writer
* @return a content handler writing to the <code>eventWriter</code>
*/
......@@ -245,8 +220,7 @@ public abstract class StaxUtils {
}
/**
* Creates a SAX {@link XMLReader} that reads from the given StAX {@link XMLStreamReader}.
*
* Create a SAX {@link XMLReader} that reads from the given StAX {@link XMLStreamReader}.
* @param streamReader the StAX stream reader
* @return a XMLReader reading from the <code>streamWriter</code>
*/
......@@ -255,8 +229,7 @@ public abstract class StaxUtils {
}
/**
* Creates a SAX {@link XMLReader} that reads from the given StAX {@link XMLEventReader}.
*
* Create a SAX {@link XMLReader} that reads from the given StAX {@link XMLEventReader}.
* @param eventReader the StAX event reader
* @return a XMLReader reading from the <code>eventWriter</code>
*/
......@@ -265,16 +238,18 @@ public abstract class StaxUtils {
}
/**
* Returns a {@link XMLStreamReader} that reads from a {@link XMLEventReader}. Useful, because the StAX
* Return a {@link XMLStreamReader} that reads from a {@link XMLEventReader}. Useful, because the StAX
* <code>XMLInputFactory</code> allows one to create a 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 {
return new XMLEventStreamReader(eventReader);
}
/** Inner class to avoid a static JAXP 1.4 dependency. */
/**
* Inner class to avoid a static JAXP 1.4 dependency.
*/
private static class Jaxp14StaxHandler {
private static Source createStaxSource(XMLStreamReader streamReader) {
......
org.springframework.jms/src/main/java/org/springframework/jms/support/converter/MarshallingMessageConverter.java
浏览文件 @ 555fa3b4
/*
* Copyright 2007 the original author or authors.
* 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.
......@@ -33,57 +33,54 @@ import javax.xml.transform.stream.StreamSource;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.oxm.Marshaller;
import org.springframework.oxm.MarshallingFailureException;
import org.springframework.oxm.Unmarshaller;
import org.springframework.oxm.UnmarshallingFailureException;
import org.springframework.oxm.XmlMappingException;
import org.springframework.util.Assert;
/**
* Spring JMS {@link MessageConverter} that uses a {@link Marshaller} and {@link Unmarshaller}. Marshals an object to a
* {@link BytesMessage}, or to a {@link TextMessage} if the {@link #setMarshalTo marshalTo} is set to {@link
* #MARSHAL_TO_TEXT_MESSAGE}. Unmarshals from a {@link TextMessage} or {@link BytesMessage} to an object.
* Spring JMS {@link MessageConverter} that uses a {@link Marshaller} and {@link Unmarshaller}.
* Marshals an object to a {@link BytesMessage}, or to a {@link TextMessage} if the
* {@link #setTargetType marshalTo} is set to {@link MessageType#TEXT}.
* Unmarshals from a {@link TextMessage} or {@link BytesMessage} to an object.
*
* @author Arjen Poutsma
* @author Juergen Hoeller
* @since 3.0
* @see org.springframework.jms.core.JmsTemplate#convertAndSend
* @see org.springframework.jms.core.JmsTemplate#receiveAndConvert
* @since 3.0
*/
public class MarshallingMessageConverter implements MessageConverter, InitializingBean {
/** Constant that indicates that {@link #toMessage(Object, Session)} should marshal to a {@link BytesMessage}. */
public static final int MARSHAL_TO_BYTES_MESSAGE = 1;
/** Constant that indicates that {@link #toMessage(Object, Session)} should marshal to a {@link TextMessage}. */
public static final int MARSHAL_TO_TEXT_MESSAGE = 2;
private Marshaller marshaller;
private Unmarshaller unmarshaller;
private int marshalTo = MARSHAL_TO_BYTES_MESSAGE;
private MessageType targetType = MessageType.BYTES;
/**
* Constructs a new <code>MarshallingMessageConverter</code> with no {@link Marshaller} set. The marshaller must be set
* after construction by invoking {@link #setMarshaller(Marshaller)}.
* Construct a new <code>MarshallingMessageConverter</code> with no {@link Marshaller} set.
* The marshaller must be set after construction by invoking {@link #setMarshaller(Marshaller)}.
*/
public MarshallingMessageConverter() {
}
/**
* Constructs a new <code>MarshallingMessageConverter</code> with the given {@link Marshaller} set. If the given
* {@link Marshaller} also implements the {@link Unmarshaller} interface, it is used for both marshalling and
* unmarshalling. Otherwise, an exception is thrown. <p/> Note that all {@link Marshaller} implementations in Spring-WS
* also implement the {@link Unmarshaller} interface, so that you can safely use this constructor.
*
* Construct a new <code>MarshallingMessageConverter</code> with the given {@link Marshaller} set.
* <p>If the given {@link Marshaller} also implements the {@link Unmarshaller} interface,
* it is used for both marshalling and unmarshalling. Otherwise, an exception is thrown.
* <p>Note that all {@link Marshaller} implementations in Spring also implement the
* {@link Unmarshaller} interface, so that you can safely use this constructor.
* @param marshaller object used as marshaller and unmarshaller
* @throws IllegalArgumentException when <code>marshaller</code> does not implement the {@link Unmarshaller} interface
* @throws IllegalArgumentException when <code>marshaller</code> does not implement the
* {@link Unmarshaller} interface as well
*/
public MarshallingMessageConverter(Marshaller marshaller) {
Assert.notNull(marshaller, "marshaller must not be null");
if (!(marshaller instanceof Unmarshaller)) {
throw new IllegalArgumentException("Marshaller [" + marshaller + "] does not implement the Unmarshaller " +
throw new IllegalArgumentException(
"Marshaller [" + marshaller + "] does not implement the Unmarshaller " +
"interface. Please set an Unmarshaller explicitely by using the " +
"AbstractMarshallingPayloadEndpoint(Marshaller, Unmarshaller) constructor.");
"MarshallingMessageConverter(Marshaller, Unmarshaller) constructor.");
}
else {
this.marshaller = marshaller;
......@@ -92,10 +89,10 @@ public class MarshallingMessageConverter implements MessageConverter, Initializi
}
/**
* Creates a new <code>MarshallingMessageConverter</code> with the given marshaller and unmarshaller.
*
* @param marshaller the marshaller to use
* @param unmarshaller the unmarshaller to use
* Construct a new <code>MarshallingMessageConverter</code> with the
* given Marshaller and Unmarshaller.
* @param marshaller the Marshaller to use
* @param unmarshaller the Unmarshaller to use
*/
public MarshallingMessageConverter(Marshaller marshaller, Unmarshaller unmarshaller) {
Assert.notNull(marshaller, "marshaller must not be null");
......@@ -104,52 +101,59 @@ public class MarshallingMessageConverter implements MessageConverter, Initializi
this.unmarshaller = unmarshaller;
}
/**
* Indicates whether {@link #toMessage(Object,Session)} should marshal to a {@link BytesMessage} or a {@link
* TextMessage}. The default is {@link #MARSHAL_TO_BYTES_MESSAGE}, i.e. this converter marshals to a {@link
* BytesMessage}.
*
* @see #MARSHAL_TO_BYTES_MESSAGE
* @see #MARSHAL_TO_TEXT_MESSAGE
* Set the {@link Marshaller} to be used by this message converter.
*/
public void setMarshalTo(int marshalTo) {
this.marshalTo = marshalTo;
}
/** Sets the {@link Marshaller} to be used by this message converter. */
public void setMarshaller(Marshaller marshaller) {
this.marshaller = marshaller;
}
/** Sets the {@link Unmarshaller} to be used by this message converter. */
/**
* Set the {@link Unmarshaller} to be used by this message converter.
*/
public void setUnmarshaller(Unmarshaller unmarshaller) {
this.unmarshaller = unmarshaller;
}
public void afterPropertiesSet() throws Exception {
Assert.notNull(marshaller, "Property 'marshaller' is required");
Assert.notNull(unmarshaller, "Property 'unmarshaller' is required");
/**
* Specify whether {@link #toMessage(Object, Session)} should marshal to
* a {@link BytesMessage} or a {@link TextMessage}.
* <p>The default is {@link MessageType#BYTES}, i.e. this converter marshals
* to a {@link BytesMessage}. Note that the default version of this converter
* supports {@link MessageType#BYTES} and {@link MessageType#TEXT} only.
* @see MessageType#BYTES
* @see MessageType#TEXT
*/
public void setTargetType(MessageType targetType) {
this.targetType = targetType;
}
public void afterPropertiesSet() {
Assert.notNull(this.marshaller, "Property 'marshaller' is required");
Assert.notNull(this.unmarshaller, "Property 'unmarshaller' is required");
}
/**
* Marshals the given object to a {@link TextMessage} or {@link javax.jms.BytesMessage}. The desired message type can
* be defined by setting the {@link #setMarshalTo(int) marshalTo} property.
*
* This implementation marshals the given object to a {@link javax.jms.TextMessage} or
* {@link javax.jms.BytesMessage}. The desired message type can be defined by setting
* the {@link #setTargetType "marshalTo"} property.
* @see #marshalToTextMessage
* @see #marshalToBytesMessage
*/
public Message toMessage(Object object, Session session) throws JMSException, MessageConversionException {
try {
switch (marshalTo) {
case MARSHAL_TO_TEXT_MESSAGE:
return marshalToTextMessage(object, session, marshaller);
case MARSHAL_TO_BYTES_MESSAGE:
return marshalToBytesMessage(object, session, marshaller);
switch (this.targetType) {
case TEXT:
return marshalToTextMessage(object, session, this.marshaller);
case BYTES:
return marshalToBytesMessage(object, session, this.marshaller);
default:
return marshalToMessage(object, session, marshaller);
return marshalToMessage(object, session, this.marshaller, this.targetType);
}
}
catch (MarshallingFailureException ex) {
catch (XmlMappingException ex) {
throw new MessageConversionException("Could not marshal [" + object + "]", ex);
}
catch (IOException ex) {
......@@ -158,8 +162,7 @@ public class MarshallingMessageConverter implements MessageConverter, Initializi
}
/**
* Unmarshals the given {@link Message} into an object.
*
* This implementation unmarshals the given {@link Message} into an object.
* @see #unmarshalFromTextMessage
* @see #unmarshalFromBytesMessage
*/
......@@ -167,38 +170,40 @@ public class MarshallingMessageConverter implements MessageConverter, Initializi
try {
if (message instanceof TextMessage) {
TextMessage textMessage = (TextMessage) message;
return unmarshalFromTextMessage(textMessage, unmarshaller);
return unmarshalFromTextMessage(textMessage, this.unmarshaller);
}
else if (message instanceof BytesMessage) {
BytesMessage bytesMessage = (BytesMessage) message;
return unmarshalFromBytesMessage(bytesMessage, unmarshaller);
return unmarshalFromBytesMessage(bytesMessage, this.unmarshaller);
}
else {
return unmarshalFromMessage(message, unmarshaller);
return unmarshalFromMessage(message, this.unmarshaller);
}
}
catch (UnmarshallingFailureException ex) {
throw new MessageConversionException("Could not unmarshal message [" + message + "]", ex);
}
catch (IOException ex) {
throw new MessageConversionException("Could not unmarshal message [" + message + "]", ex);
throw new MessageConversionException("Could not access message content: " + message, ex);
}
catch (XmlMappingException ex) {
throw new MessageConversionException("Could not unmarshal message: " + message, ex);
}
}
/**
* Marshals the given object to a {@link TextMessage}.
*
* @param object the object to be marshalled
* @param session current JMS session
* Marshal the given object to a {@link TextMessage}.
* @param object the object to be marshalled
* @param session current JMS session
* @param marshaller the marshaller to use
* @return the resulting message
* @throws JMSException if thrown by JMS methods
* @throws IOException in case of I/O errors
* @throws IOException in case of I/O errors
* @throws XmlMappingException in case of OXM mapping errors
* @see Session#createTextMessage
* @see Marshaller#marshal(Object, Result)
*/
protected TextMessage marshalToTextMessage(Object object, Session session, Marshaller marshaller)
throws JMSException, IOException {
throws JMSException, IOException, XmlMappingException {
StringWriter writer = new StringWriter();
Result result = new StreamResult(writer);
marshaller.marshal(object, result);
......@@ -206,19 +211,20 @@ public class MarshallingMessageConverter implements MessageConverter, Initializi
}
/**
* Marshals the given object to a {@link BytesMessage}.
*
* @param object the object to be marshalled
* @param session current JMS session
* Marshal the given object to a {@link BytesMessage}.
* @param object the object to be marshalled
* @param session current JMS session
* @param marshaller the marshaller to use
* @return the resulting message
* @throws JMSException if thrown by JMS methods
* @throws IOException in case of I/O errors
* @throws IOException in case of I/O errors
* @throws XmlMappingException in case of OXM mapping errors
* @see Session#createBytesMessage
* @see Marshaller#marshal(Object, Result)
*/
protected BytesMessage marshalToBytesMessage(Object object, Session session, Marshaller marshaller)
throws JMSException, IOException {
throws JMSException, IOException, XmlMappingException {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
StreamResult streamResult = new StreamResult(bos);
marshaller.marshal(object, streamResult);
......@@ -228,51 +234,57 @@ public class MarshallingMessageConverter implements MessageConverter, Initializi
}
/**
* Template method that allows for custom message marshalling. Invoked when {@link #setMarshalTo(int)} is not {@link
* #MARSHAL_TO_TEXT_MESSAGE} or {@link #MARSHAL_TO_BYTES_MESSAGE}. <p/> Default implemenetation throws a {@link
* MessageConversionException}.
*
* @param object the object to marshal
* @param session the JMS session
* Template method that allows for custom message marshalling.
* Invoked when {@link #setTargetType} is not {@link MessageType#TEXT} or
* {@link MessageType#BYTES}.
* <p>The default implementation throws an {@link IllegalArgumentException}.
* @param object the object to marshal
* @param session the JMS session
* @param marshaller the marshaller to use
* @param targetType the target message type (other than TEXT or BYTES)
* @return the resulting message
* @throws JMSException if thrown by JMS methods
* @throws IOException in case of I/O errors
* @throws IOException in case of I/O errors
* @throws XmlMappingException in case of OXM mapping errors
*/
protected Message marshalToMessage(Object object, Session session, Marshaller marshaller)
throws JMSException, IOException {
throw new MessageConversionException(
"Unknown 'marshalTo' value [" + marshalTo + "]. Cannot convert object to Message");
protected Message marshalToMessage(Object object, Session session, Marshaller marshaller, MessageType targetType)
throws JMSException, IOException, XmlMappingException {
throw new IllegalArgumentException(
"Unsupported message type [" + targetType + "]. Cannot marshal to the specified message type.");
}
/**
* Unmarshals the given {@link TextMessage} into an object.
*
* @param message the message
* Unmarshal the given {@link TextMessage} into an object.
* @param message the message
* @param unmarshaller the unmarshaller to use
* @return the unmarshalled object
* @throws JMSException if thrown by JMS methods
* @throws IOException in case of I/O errors
* @throws IOException in case of I/O errors
* @throws XmlMappingException in case of OXM mapping errors
* @see Unmarshaller#unmarshal(Source)
*/
protected Object unmarshalFromTextMessage(TextMessage message, Unmarshaller unmarshaller)
throws JMSException, IOException {
throws JMSException, IOException, XmlMappingException {
Source source = new StreamSource(new StringReader(message.getText()));
return unmarshaller.unmarshal(source);
}
/**
* Unmarshals the given {@link BytesMessage} into an object.
*
* @param message the message
* Unmarshal the given {@link BytesMessage} into an object.
* @param message the message
* @param unmarshaller the unmarshaller to use
* @return the unmarshalled object
* @throws JMSException if thrown by JMS methods
* @throws IOException in case of I/O errors
* @throws IOException in case of I/O errors
* @throws XmlMappingException in case of OXM mapping errors
* @see Unmarshaller#unmarshal(Source)
*/
protected Object unmarshalFromBytesMessage(BytesMessage message, Unmarshaller unmarshaller)
throws JMSException, IOException {
throws JMSException, IOException, XmlMappingException {
byte[] bytes = new byte[(int) message.getBodyLength()];
message.readBytes(bytes);
ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
......@@ -281,19 +293,22 @@ public class MarshallingMessageConverter implements MessageConverter, Initializi
}
/**
* Template method that allows for custom message unmarshalling. Invoked when {@link #fromMessage(Message)} is invoked
* with a message that is not a {@link TextMessage} or {@link BytesMessage}. <p/> Default implemenetation throws a
* {@link MessageConversionException}.
*
* @param message the message
* Template method that allows for custom message unmarshalling.
* Invoked when {@link #fromMessage(Message)} is invoked with a message
* that is not a {@link TextMessage} or {@link BytesMessage}.
* <p>The default implemenetation throws an {@link IllegalArgumentException}.
* @param message the message
* @param unmarshaller the unmarshaller to use
* @return the unmarshalled object
* @throws JMSException if thrown by JMS methods
* @throws IOException in case of I/O errors
* @throws IOException in case of I/O errors
* @throws XmlMappingException in case of OXM mapping errors
*/
protected Object unmarshalFromMessage(Message message, Unmarshaller unmarshaller) throws JMSException, IOException {
throw new MessageConversionException(
protected Object unmarshalFromMessage(Message message, Unmarshaller unmarshaller)
throws JMSException, IOException, XmlMappingException {
throw new IllegalArgumentException(
"MarshallingMessageConverter only supports TextMessages and BytesMessages");
}
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/castor/CastorSystemException.java → org.springframework.jms/src/main/java/org/springframework/jms/support/converter/MessageType.java
浏览文件 @ 555fa3b4
/*
* Copyright 2005 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.oxm.castor;
import org.springframework.oxm.UncategorizedXmlMappingException;
/**
* Castor-specific subclass of <code>UncategorizedXmlMappingException</code>, for Castor exceptions that cannot be
* distinguished further.
*
* @author Arjen Poutsma
* @since 3.0
*/
public class CastorSystemException extends UncategorizedXmlMappingException {
public CastorSystemException(String msg, Throwable ex) {
super(msg, ex);
}
}
/*
* 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.jms.support.converter;
/**
* Constants that indicate a target message type to convert to: a
* {@link javax.jms.TextMessage}, a {@link javax.jms.BytesMessage},
* a {@link javax.jms.MapMessage} or an {@link ObjectMessage}.
*
* @author Juergen Hoeller
* @since 3.0
* @see MarshallingMessageConverter#setTargetType
*/
public enum MessageType {
TEXT, BYTES, MAP, OBJECT
}
org.springframework.jms/src/test/java/org/springframework/jms/support/converter/MarshallingMessageConverterTests.java
浏览文件 @ 555fa3b4
/*
* Copyright 2007 the original author or authors.
* 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.
......@@ -23,13 +23,16 @@ import javax.xml.transform.Result;
import javax.xml.transform.Source;
import static org.easymock.EasyMock.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.*;
import org.junit.Before;
import org.junit.Test;
import org.springframework.oxm.Marshaller;
import org.springframework.oxm.Unmarshaller;
/**
* @author Arjen Poutsma
*/
public class MarshallingMessageConverterTests {
private MarshallingMessageConverter converter;
......@@ -83,7 +86,7 @@ public class MarshallingMessageConverterTests {
@Test
public void toTextMessage() throws Exception {
converter.setMarshalTo(MarshallingMessageConverter.MARSHAL_TO_TEXT_MESSAGE);
converter.setTargetType(MessageType.TEXT);
TextMessage textMessageMock = createMock(TextMessage.class);
Object toBeMarshalled = new Object();
......@@ -114,4 +117,4 @@ public class MarshallingMessageConverterTests {
verify(marshallerMock, unmarshallerMock, sessionMock, textMessageMock);
}
}
\ No newline at end of file
}
org.springframework.oxm/src/main/java/org/springframework/oxm/Marshaller.java
浏览文件 @ 555fa3b4
/*
* Copyright 2005 the original author or authors.
* 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.
......@@ -13,39 +13,42 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.oxm;
import java.io.IOException;
import javax.xml.transform.Result;
/**
* Defines the contract for Object XML Mapping Marshallers. Implementations of this interface can serialize a given
* Object to an XML Stream. <p/> Although the <code>marshal</code> method accepts a <code>java.lang.Object</code> as its
* first parameter, most <code>Marshaller</code> implementations cannot handle arbitrary <code>java.lang.Object</code>.
* Instead, a object class must be registered with the marshaller, or have a common base class.
* Defines the contract for Object XML Mapping Marshallers. Implementations of this interface
* can serialize a given Object to an XML Stream.
*
* <p>Although the <code>marshal</code> method accepts a <code>java.lang.Object</code> as its
* first parameter, most <code>Marshaller</code> implementations cannot handle arbitrary
* <code>Object</code>s. Instead, a object class must be registered with the marshaller,
* or have a common base class.
*
* @author Arjen Poutsma
* @since 3.0
* @see Unmarshaller
*/
public interface Marshaller {
/**
* Marshals the object graph with the given root into the provided {@link Result}.
*
* @param graph the root of the object graph to marshal
* @param result the result to marshal to
* @throws XmlMappingException if the given object cannot be marshalled to the result
* @throws IOException if an I/O exception occurs
*/
void marshal(Object graph, Result result) throws XmlMappingException, IOException;
/**
* Indicates whether this marshaller can marshal instances of the supplied type.
*
* @param clazz the class that this marshaller is being asked if it can marshal
* @return <code>true</code> if this marshaller can indeed marshal instances of the supplied class; <code>false</code>
* otherwise
* @return <code>true</code> if this marshaller can indeed marshal instances of the supplied class;
* <code>false</code> otherwise
*/
boolean supports(Class<?> clazz);
/**
* Marshals the object graph with the given root into the provided {@link Result}.
* @param graph the root of the object graph to marshal
* @param result the result to marshal to
* @throws IOException if an I/O error occurs
* @throws XmlMappingException if the given object cannot be marshalled to the result
*/
void marshal(Object graph, Result result) throws IOException, XmlMappingException;
}
org.springframework.oxm/src/main/java/org/springframework/oxm/GenericMarshallingFailureException.java → org.springframework.oxm/src/main/java/org/springframework/oxm/MarshallingException.java
浏览文件 @ 555fa3b4
/*
* Copyright 2005 the original author or authors.
* 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.
......@@ -13,26 +13,36 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.oxm;
/**
* Base class for exception thrown when a marshalling or unmarshalling error occurs.
*
* @author Arjen Poutsma
* @author Juergen Hoeller
* @since 3.0
* @see MarshallingFailureException
* @see UnmarshallingFailureException
* @since 3.0
*/
public abstract class GenericMarshallingFailureException extends XmlMappingException {
public abstract class MarshallingException extends XmlMappingException {
/** Constructor for <code>GenericMarshallingFailureException</code>. */
public GenericMarshallingFailureException(String msg) {
/**
* Construct a <code>MarshallingException</code> with the specified detail message.
* @param msg the detail message
*/
protected MarshallingException(String msg) {
super(msg);
}
/** Constructor for <code>GenericMarshallingFailureException</code>. */
public GenericMarshallingFailureException(String msg, Throwable ex) {
super(msg, ex);
/**
* Construct a <code>MarshallingException</code> with the specified detail message
* and nested exception.
* @param msg the detail message
* @param cause the nested exception
*/
protected MarshallingException(String msg, Throwable cause) {
super(msg, cause);
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/MarshallingFailureException.java
浏览文件 @ 555fa3b4
/*
* Copyright 2005 the original author or authors.
* 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.
......@@ -13,6 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.oxm;
/**
......@@ -21,11 +22,10 @@ package org.springframework.oxm;
* @author Arjen Poutsma
* @since 3.0
*/
public class MarshallingFailureException extends GenericMarshallingFailureException {
public class MarshallingFailureException extends MarshallingException {
/**
* Construct a <code>MarshallingFailureException</code> with the specified detail message.
*
* @param msg the detail message
*/
public MarshallingFailureException(String msg) {
......@@ -33,12 +33,13 @@ public class MarshallingFailureException extends GenericMarshallingFailureExcept
}
/**
* Construct a <code>MarshallingFailureException</code> with the specified detail message and nested exception.
*
* Construct a <code>MarshallingFailureException</code> with the specified detail message
* and nested exception.
* @param msg the detail message
* @param ex the nested exception
* @param cause the nested exception
*/
public MarshallingFailureException(String msg, Throwable ex) {
super(msg, ex);
public MarshallingFailureException(String msg, Throwable cause) {
super(msg, cause);
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/UncategorizedXmlMappingException.java → org.springframework.oxm/src/main/java/org/springframework/oxm/UncategorizedMappingException.java
浏览文件 @ 555fa3b4
/*
* Copyright 2005 the original author or authors.
* 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.
......@@ -13,18 +13,25 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.oxm;
/**
* Superclass for exceptions that cannot be distinguished further.
* Exception that indicates that the cause cannot be distinguished further.
*
* @author Arjen Poutsma
* @since 3.0
*/
public abstract class UncategorizedXmlMappingException extends XmlMappingException {
public class UncategorizedMappingException extends XmlMappingException {
/** Constructor for <code>UncategorizedXmlMappingException</code>. */
protected UncategorizedXmlMappingException(String msg, Throwable ex) {
super(msg, ex);
/**
* Construct an <code>UncategorizedMappingException</code> with the specified detail message
* and nested exception.
* @param msg the detail message
* @param cause the nested exception
*/
public UncategorizedMappingException(String msg, Throwable cause) {
super(msg, cause);
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/Unmarshaller.java
浏览文件 @ 555fa3b4
/*
* Copyright 2005-2007 the original author or authors.
* 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.
......@@ -13,37 +13,37 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.oxm;
import java.io.IOException;
import javax.xml.transform.Source;
/**
* Defines the contract for Object XML Mapping unmarshallers. <p/> <p>Implementations of this interface can deserialize
* a given XML Stream to an Object graph.
* Defines the contract for Object XML Mapping unmarshallers. Implementations of this
* interface can deserialize a given XML Stream to an Object graph.
*
* @author Arjen Poutsma
* @since 3.0
* @see Marshaller
*/
public interface Unmarshaller {
/**
* Indicates whether this unmarshaller can unmarshal instances of the supplied type.
* @param clazz the class that this unmarshaller is being asked if it can marshal
* @return <code>true</code> if this unmarshaller can indeed unmarshal to the supplied class;
* <code>false</code> otherwise
*/
boolean supports(Class<?> clazz);
/**
* Unmarshals the given {@link Source} into an object graph.
*
* @param source the source to marshal from
* @return the object graph
* @throws IOException if an I/O error occurs
* @throws XmlMappingException if the given source cannot be mapped to an object
* @throws IOException if an I/O Exception occurs
*/
Object unmarshal(Source source) throws XmlMappingException, IOException;
/**
* Indicates whether this unmarshaller can unmarshal instances of the supplied type.
*
* @param clazz the class that this unmarshaller is being asked if it can marshal
* @return <code>true</code> if this unmarshaller can indeed unmarshal to the supplied class; <code>false</code>
* otherwise
*/
boolean supports(Class<?> clazz);
Object unmarshal(Source source) throws IOException, XmlMappingException;
}
org.springframework.oxm/src/main/java/org/springframework/oxm/UnmarshallingFailureException.java
浏览文件 @ 555fa3b4
/*
* Copyright 2005 the original author or authors.
* 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.
......@@ -13,6 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.oxm;
/**
......@@ -21,15 +22,24 @@ package org.springframework.oxm;
* @author Arjen Poutsma
* @since 3.0
*/
public class UnmarshallingFailureException extends GenericMarshallingFailureException {
public class UnmarshallingFailureException extends MarshallingException {
/** Constructor for <code>UnmarshallingFailureException</code>. */
/**
* Construct a <code>MarshallingFailureException</code> with the specified detail message.
* @param msg the detail message
*/
public UnmarshallingFailureException(String msg) {
super(msg);
}
/** Constructor for <code>UnmarshallingFailureException</code>. */
public UnmarshallingFailureException(String msg, Throwable ex) {
super(msg, ex);
/**
* Construct a <code>MarshallingFailureException</code> with the specified detail message
* and nested exception.
* @param msg the detail message
* @param cause the nested exception
*/
public UnmarshallingFailureException(String msg, Throwable cause) {
super(msg, cause);
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/ValidationFailureException.java
浏览文件 @ 555fa3b4
/*
* Copyright 2005 the original author or authors.
* 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.
......@@ -13,6 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.oxm;
/**
......@@ -23,13 +24,22 @@ package org.springframework.oxm;
*/
public class ValidationFailureException extends XmlMappingException {
/** Constructor for <code>ValidationFailureException</code>. */
/**
* Construct a <code>ValidationFailureException</code> with the specified detail message.
* @param msg the detail message
*/
public ValidationFailureException(String msg) {
super(msg);
}
/** Constructor for <code>ValidationFailureException</code>. */
public ValidationFailureException(String msg, Throwable ex) {
super(msg, ex);
/**
* Construct a <code>ValidationFailureException</code> with the specified detail message
* and nested exception.
* @param msg the detail message
* @param cause the nested exception
*/
public ValidationFailureException(String msg, Throwable cause) {
super(msg, cause);
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/XmlMappingException.java
浏览文件 @ 555fa3b4
/*
* Copyright 2005 the original author or authors.
* 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.
......@@ -13,6 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.oxm;
import org.springframework.core.NestedRuntimeException;
......@@ -25,13 +26,22 @@ import org.springframework.core.NestedRuntimeException;
*/
public abstract class XmlMappingException extends NestedRuntimeException {
/** Constructor for <code>XmlMappingException</code>. */
/**
* Construct an <code>XmlMappingException</code> with the specified detail message.
* @param msg the detail message
*/
public XmlMappingException(String msg) {
super(msg);
}
/** Constructor for <code>XmlMappingException</code>. */
public XmlMappingException(String msg, Throwable ex) {
super(msg, ex);
/**
* Construct an <code>XmlMappingException</code> with the specified detail message
* and nested exception.
* @param msg the detail message
* @param cause the nested exception
*/
public XmlMappingException(String msg, Throwable cause) {
super(msg, cause);
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/castor/CastorMarshallingFailureException.java → org.springframework.oxm/src/main/java/org/springframework/oxm/castor/CastorMappingException.java
浏览文件 @ 555fa3b4
/*
* Copyright 2005 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.oxm.castor;
import org.exolab.castor.xml.MarshalException;
import org.springframework.oxm.MarshallingFailureException;
/**
* Castor-specific subclass of <code>MarshallingFailureException</code>.
*
* @author Arjen Poutsma
* @see CastorUtils#convertXmlException
* @since 3.0
*/
public class CastorMarshallingFailureException extends MarshallingFailureException {
public CastorMarshallingFailureException(MarshalException ex) {
super("Castor marshalling exception: " + ex.getMessage(), ex);
}
}
/*
* 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.oxm.castor;
import org.springframework.oxm.XmlMappingException;
/**
* Exception thrown by {@link CastorMarshaller} whenever it encounters a mapping problem.
*
* @author Juergen Hoeller
* @since 3.0
*/
public class CastorMappingException extends XmlMappingException {
/**
* Construct a <code>CastorMappingException</code> with the specified detail message
* and nested exception.
* @param msg the detail message
* @param cause the nested exception
*/
public CastorMappingException(String msg, Throwable cause) {
super(msg, cause);
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/castor/CastorMarshaller.java
浏览文件 @ 555fa3b4
/*
* Copyright 2005 the original author or authors.
* 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.
......@@ -13,6 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.oxm.castor;
import java.io.IOException;
......@@ -21,8 +22,7 @@ import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;
import java.util.Iterator;
import java.util.Properties;
import java.util.Map;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLEventWriter;
import javax.xml.stream.XMLStreamReader;
......@@ -30,13 +30,14 @@ import javax.xml.stream.XMLStreamWriter;
import org.exolab.castor.mapping.Mapping;
import org.exolab.castor.mapping.MappingException;
import org.exolab.castor.xml.MarshalException;
import org.exolab.castor.xml.Marshaller;
import org.exolab.castor.xml.ResolverException;
import org.exolab.castor.xml.UnmarshalHandler;
import org.exolab.castor.xml.Unmarshaller;
import org.exolab.castor.xml.XMLContext;
import org.exolab.castor.xml.XMLException;
import org.exolab.castor.xml.ValidationException;
import org.exolab.castor.xml.MarshalException;
import org.w3c.dom.Node;
import org.xml.sax.ContentHandler;
import org.xml.sax.InputSource;
......@@ -46,12 +47,16 @@ import org.xml.sax.ext.LexicalHandler;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.core.io.Resource;
import org.springframework.oxm.AbstractMarshaller;
import org.springframework.oxm.UnmarshallingFailureException;
import org.springframework.oxm.XmlMappingException;
import org.springframework.oxm.ValidationFailureException;
import org.springframework.oxm.MarshallingFailureException;
import org.springframework.oxm.UncategorizedMappingException;
import org.springframework.oxm.support.AbstractMarshaller;
import org.springframework.oxm.support.SaxResourceUtils;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;
import org.springframework.util.xml.DomUtils;
import org.springframework.util.xml.SaxUtils;
import org.springframework.util.xml.StaxUtils;
/**
......@@ -76,18 +81,17 @@ import org.springframework.util.xml.StaxUtils;
public class CastorMarshaller extends AbstractMarshaller implements InitializingBean {
/**
* The default encoding used for stream access.
* The default encoding used for stream access: UTF-8.
*/
public static final String DEFAULT_ENCODING = "UTF-8";
private Resource[] mappingLocations;
private String encoding = DEFAULT_ENCODING;
private Class targetClass;
private XMLContext xmlContext;
private boolean validating = false;
private boolean whitespacePreserve = false;
......@@ -96,68 +100,45 @@ public class CastorMarshaller extends AbstractMarshaller implements Initializing
private boolean ignoreExtraElements = false;
private Properties namespaceMappings;
private Map<String, String> namespaceMappings;
/**
* Returns whether the Castor {@link Unmarshaller} should ignore attributes that do not match a specific field.
*/
public boolean getIgnoreExtraAttributes() {
return ignoreExtraAttributes;
}
/**
* Sets whether the Castor {@link Unmarshaller} should ignore attributes that do not match a specific field. Default
* is <code>true</code>: extra attributes are ignored.
*
* @see org.exolab.castor.xml.Unmarshaller#setIgnoreExtraAttributes(boolean)
*/
public void setIgnoreExtraAttributes(boolean ignoreExtraAttributes) {
this.ignoreExtraAttributes = ignoreExtraAttributes;
}
private XMLContext xmlContext;
/**
* Returns whether the Castor {@link Unmarshaller} should ignore elements that do not match a specific field.
*/
public boolean getIgnoreExtraElements() {
return ignoreExtraElements;
}
/**
* Sets whether the Castor {@link Unmarshaller} should ignore elements that do not match a specific field. Default is
* <code>false</code>, extra attributes are flagged as an error.
*
* @see org.exolab.castor.xml.Unmarshaller#setIgnoreExtraElements(boolean)
* Set the encoding to be used for stream access.
* @see #DEFAULT_ENCODING
*/
public void setIgnoreExtraElements(boolean ignoreExtraElements) {
this.ignoreExtraElements = ignoreExtraElements;
public void setEncoding(String encoding) {
this.encoding = encoding;
}
/**
* Returns whether the Castor {@link Unmarshaller} should preserve "ignorable" whitespace.
* Set the locations of the Castor XML Mapping files.
*/
public boolean getWhitespacePreserve() {
return whitespacePreserve;
public void setMappingLocation(Resource mappingLocation) {
this.mappingLocations = new Resource[] {mappingLocation};
}
/**
* Sets whether the Castor {@link Unmarshaller} should preserve "ignorable" whitespace. Default is <code>false</code>.
*
* @see org.exolab.castor.xml.Unmarshaller#setWhitespacePreserve(boolean)
* Set the locations of the Castor XML Mapping files.
*/
public void setWhitespacePreserve(boolean whitespacePreserve) {
this.whitespacePreserve = whitespacePreserve;
public void setMappingLocations(Resource[] mappingLocations) {
this.mappingLocations = mappingLocations;
}
/**
* Returns whether this marshaller should validate in- and outgoing documents.
* Set the Castor target class. If this property is set, this <code>CastorMarshaller</code>
* is tied to this one specific class. Use a mapping file for unmarshalling multiple classes.
* <p>You cannot set both this property and the mapping (location).
*/
public boolean isValidating() {
return validating;
public void setTargetClass(Class targetClass) {
this.targetClass = targetClass;
}
/**
* Sets whether this marshaller should validate in- and outgoing documents. Default is <code>false</code>.
*
* Set whether this marshaller should validate in- and outgoing documents.
* <p>Default is <code>false</code>.
* @see Marshaller#setValidation(boolean)
*/
public void setValidating(boolean validating) {
......@@ -165,104 +146,86 @@ public class CastorMarshaller extends AbstractMarshaller implements Initializing
}
/**
* Returns the namespace mappings. Property names are interpreted as namespace prefixes; values are namespace URIs.
* Set whether the Castor {@link Unmarshaller} should preserve "ignorable" whitespace.
* <p>Default is <code>false</code>.
* @see org.exolab.castor.xml.Unmarshaller#setWhitespacePreserve(boolean)
*/
public Properties getNamespaceMappings() {
return namespaceMappings;
public void setWhitespacePreserve(boolean whitespacePreserve) {
this.whitespacePreserve = whitespacePreserve;
}
/**
* Sets the namespace mappings. Property names are interpreted as namespace prefixes; values are namespace URIs.
*
* @see org.exolab.castor.xml.Marshaller#setNamespaceMapping(String, String)
* Set whether the Castor {@link Unmarshaller} should ignore attributes that do not match a specific field.
* <p>Default is <code>true</code>: extra attributes are ignored.
* @see org.exolab.castor.xml.Unmarshaller#setIgnoreExtraAttributes(boolean)
*/
public void setNamespaceMappings(Properties namespaceMappings) {
this.namespaceMappings = namespaceMappings;
public void setIgnoreExtraAttributes(boolean ignoreExtraAttributes) {
this.ignoreExtraAttributes = ignoreExtraAttributes;
}
/**
* Sets the encoding to be used for stream access. If this property is not set, the default encoding is used.
*
* @see #DEFAULT_ENCODING
* Set whether the Castor {@link Unmarshaller} should ignore elements that do not match a specific field.
* <p>Default is <code>false</code>, extra attributes are flagged as an error.
* @see org.exolab.castor.xml.Unmarshaller#setIgnoreExtraElements(boolean)
*/
public void setEncoding(String encoding) {
this.encoding = encoding;
public void setIgnoreExtraElements(boolean ignoreExtraElements) {
this.ignoreExtraElements = ignoreExtraElements;
}
/**
* Sets the locations of the Castor XML Mapping files.
* Set the namespace mappings. Property names are interpreted as namespace prefixes; values are namespace URIs.
* @see org.exolab.castor.xml.Marshaller#setNamespaceMapping(String, String)
*/
public void setMappingLocation(Resource mappingLocation) {
mappingLocations = new Resource[]{mappingLocation};
public void setNamespaceMappings(Map<String, String> namespaceMappings) {
this.namespaceMappings = namespaceMappings;
}
/**
* Sets the locations of the Castor XML Mapping files.
*/
public void setMappingLocations(Resource[] mappingLocations) {
this.mappingLocations = mappingLocations;
}
/**
* Sets the Castor target class. If this property is set, this <code>CastorMarshaller</code> is tied to this one
* specific class. Use a mapping file for unmarshalling multiple classes. <p/> You cannot set both this property and
* the mapping (location).
*/
public void setTargetClass(Class targetClass) {
this.targetClass = targetClass;
}
public final void afterPropertiesSet() throws IOException {
if (mappingLocations != null && targetClass != null) {
public final void afterPropertiesSet() throws CastorMappingException, IOException {
if (this.mappingLocations != null && this.targetClass != null) {
throw new IllegalArgumentException("Cannot set both the 'mappingLocations' and 'targetClass' property. " +
"Set targetClass for unmarshalling a single class, and 'mappingLocations' for multiple classes'");
"Set 'targetClass' for unmarshalling a single class, and 'mappingLocations' for multiple classes.");
}
if (logger.isInfoEnabled()) {
if (mappingLocations != null) {
logger.info("Configured using " + StringUtils.arrayToCommaDelimitedString(mappingLocations));
if (this.mappingLocations != null) {
logger.info("Configured using " + StringUtils.arrayToCommaDelimitedString(this.mappingLocations));
}
else if (targetClass != null) {
logger.info("Configured for target class [" + targetClass.getName() + "]");
else if (this.targetClass != null) {
logger.info("Configured for target class [" + this.targetClass.getName() + "]");
}
else {
logger.info("Using default configuration");
}
}
try {
xmlContext = createXMLContext(mappingLocations, targetClass);
this.xmlContext = createXMLContext(this.mappingLocations, this.targetClass);
}
catch (MappingException ex) {
throw new CastorSystemException("Could not load Castor mapping: " + ex.getMessage(), ex);
throw new CastorMappingException("Could not load Castor mapping", ex);
}
catch (ResolverException rex) {
throw new CastorSystemException("Could not load Castor mapping: " + rex.getMessage(), rex);
catch (ResolverException ex) {
throw new CastorMappingException("Could not resolve Castor mapping", ex);
}
}
/**
* Returns <code>true</code> for all classes, i.e. Castor supports arbitrary classes.
*/
public boolean supports(Class<?> clazz) {
return true;
}
/**
* Creates the Castor <code>XMLContext</code>. Subclasses can override this to create a custom context. <p/> The
* default implementation loads mapping files if defined, and the target class if not defined.
*
* Create the Castor <code>XMLContext</code>. Subclasses can override this to create a custom context.
* <p>The default implementation loads mapping files if defined, and the target class if not defined.
* @return the created resolver
* @throws MappingException when the mapping file cannot be loaded
* @throws IOException in case of I/O errors
* @throws IOException in case of I/O errors
* @see XMLContext#addMapping(org.exolab.castor.mapping.Mapping)
* @see XMLContext#addClass(Class)
*/
protected XMLContext createXMLContext(Resource[] mappingLocations, Class targetClass)
throws MappingException, IOException, ResolverException {
throws MappingException, ResolverException, IOException {
XMLContext context = new XMLContext();
if (!ObjectUtils.isEmpty(mappingLocations)) {
Mapping mapping = new Mapping();
for (Resource mappingLocation : mappingLocations) {
mapping.loadMapping(SaxUtils.createInputSource(mappingLocation));
mapping.loadMapping(SaxResourceUtils.createInputSource(mappingLocation));
}
context.addMapping(mapping);
}
......@@ -272,9 +235,16 @@ public class CastorMarshaller extends AbstractMarshaller implements Initializing
return context;
}
//
/**
* Returns <code>true</code> for all classes, i.e. Castor supports arbitrary classes.
*/
public boolean supports(Class<?> clazz) {
return true;
}
// Marshalling
//
@Override
protected final void marshalDomNode(Object graph, Node node) throws XmlMappingException {
......@@ -323,26 +293,22 @@ public class CastorMarshaller extends AbstractMarshaller implements Initializing
}
/**
* Template method that allows for customizing of the given Castor {@link Marshaller}. <p/> Default implementation
* invokes {@link Marshaller#setValidation(boolean)} with the property set on this marshaller, and calls {@link
* Marshaller#setNamespaceMapping(String, String)} with the {@linkplain #setNamespaceMappings(java.util.Properties)
* namespace mappings}.
* Template method that allows for customizing of the given Castor {@link Marshaller}.
* <p>The default implementation invokes {@link Marshaller#setValidation(boolean)}
* with the property set on this marshaller, and calls {@link Marshaller#setNamespaceMapping(String, String)}
* with the {@linkplain #setNamespaceMappings(java.util.Properties) namespace mappings}.
*/
protected void customizeMarshaller(Marshaller marshaller) {
marshaller.setValidation(isValidating());
Properties namespaceMappings = getNamespaceMappings();
if (namespaceMappings != null) {
for (Iterator iterator = namespaceMappings.keySet().iterator(); iterator.hasNext();) {
String prefix = (String) iterator.next();
String uri = namespaceMappings.getProperty(prefix);
marshaller.setNamespaceMapping(prefix, uri);
marshaller.setValidation(this.validating);
if (this.namespaceMappings != null) {
for (Map.Entry<String, String> entry : namespaceMappings.entrySet()) {
marshaller.setNamespaceMapping(entry.getKey(), entry.getValue());
}
}
}
//
// Unmarshalling
//
@Override
protected final Object unmarshalDomNode(Node node) throws XmlMappingException {
......@@ -381,13 +347,14 @@ public class CastorMarshaller extends AbstractMarshaller implements Initializing
return unmarshalSaxReader(reader, new InputSource());
}
catch (IOException ex) {
throw new CastorUnmarshallingFailureException(new MarshalException(ex));
throw new UnmarshallingFailureException("Failed to read XML stream", ex);
}
}
@Override
protected final Object unmarshalSaxReader(XMLReader xmlReader, InputSource inputSource)
throws XmlMappingException, IOException {
UnmarshalHandler unmarshalHandler = createUnmarshaller().createHandler();
try {
ContentHandler contentHandler = Unmarshaller.getContentHandler(unmarshalHandler);
......@@ -396,7 +363,7 @@ public class CastorMarshaller extends AbstractMarshaller implements Initializing
return unmarshalHandler.getObject();
}
catch (SAXException ex) {
throw new CastorUnmarshallingFailureException(ex);
throw new UnmarshallingFailureException("SAX reader exception", ex);
}
}
......@@ -407,47 +374,60 @@ public class CastorMarshaller extends AbstractMarshaller implements Initializing
return unmarshalSaxReader(reader, new InputSource());
}
catch (IOException ex) {
throw new CastorUnmarshallingFailureException(new MarshalException(ex));
throw new UnmarshallingFailureException("Failed to read XML stream", ex);
}
}
private Unmarshaller createUnmarshaller() {
Unmarshaller unmarshaller = xmlContext.createUnmarshaller();
if (targetClass != null) {
unmarshaller.setClass(targetClass);
unmarshaller.setClassLoader(targetClass.getClassLoader());
Unmarshaller unmarshaller = this.xmlContext.createUnmarshaller();
if (this.targetClass != null) {
unmarshaller.setClass(this.targetClass);
unmarshaller.setClassLoader(this.targetClass.getClassLoader());
}
customizeUnmarshaller(unmarshaller);
return unmarshaller;
}
/**
* Template method that allows for customizing of the given Castor {@link Unmarshaller}. <p/> Default implementation
* invokes {@link Unmarshaller#setValidation(boolean)}, {@link Unmarshaller#setWhitespacePreserve(boolean)}, {@link
* Unmarshaller#setIgnoreExtraAttributes(boolean)}, and {@link Unmarshaller#setIgnoreExtraElements(boolean)} with the
* properties set on this marshaller.
* Template method that allows for customizing of the given Castor {@link Unmarshaller}.
* <p>The default implementation invokes {@link Unmarshaller#setValidation(boolean)},
* {@link Unmarshaller#setWhitespacePreserve(boolean)}, {@link Unmarshaller#setIgnoreExtraAttributes(boolean)},
* and {@link Unmarshaller#setIgnoreExtraElements(boolean)} with the properties set on this marshaller.
*/
protected void customizeUnmarshaller(Unmarshaller unmarshaller) {
unmarshaller.setValidation(isValidating());
unmarshaller.setWhitespacePreserve(getWhitespacePreserve());
unmarshaller.setIgnoreExtraAttributes(getIgnoreExtraAttributes());
unmarshaller.setIgnoreExtraElements(getIgnoreExtraElements());
unmarshaller.setValidation(this.validating);
unmarshaller.setWhitespacePreserve(this.whitespacePreserve);
unmarshaller.setIgnoreExtraAttributes(this.ignoreExtraAttributes);
unmarshaller.setIgnoreExtraElements(this.ignoreExtraElements);
}
/**
* Converts the given <code>CastorException</code> to an appropriate exception from the
* <code>org.springframework.oxm</code> hierarchy. <p/> The default implementation delegates to
* <code>CastorUtils</code>. Can be overridden in subclasses. <p/> A boolean flag is used to indicate whether this
* exception occurs during marshalling or unmarshalling, since Castor itself does not make this distinction in its
* exception hierarchy.
*
* @param ex Castor <code>XMLException</code> that occured
* @param marshalling indicates whether the exception occurs during marshalling (<code>true</code>), or unmarshalling
* (<code>false</code>)
* Convert the given <code>XMLException</code> to an appropriate exception from the
* <code>org.springframework.oxm</code> hierarchy.
* <p>A boolean flag is used to indicate whether this exception occurs during marshalling or
* unmarshalling, since Castor itself does not make this distinction in its exception hierarchy.
* @param ex Castor <code>XMLException</code> that occured
* @param marshalling indicates whether the exception occurs during marshalling (<code>true</code>),
* or unmarshalling (<code>false</code>)
* @return the corresponding <code>XmlMappingException</code>
* @see CastorUtils#convertXmlException
* @see CastorUtils#convertCastorException
*/
public XmlMappingException convertCastorException(XMLException ex, boolean marshalling) {
return CastorUtils.convertXmlException(ex, marshalling);
protected XmlMappingException convertCastorException(XMLException ex, boolean marshalling) {
if (ex instanceof ValidationException) {
return new ValidationFailureException("Castor validation exception", ex);
}
else if (ex instanceof MarshalException) {
if (marshalling) {
return new MarshallingFailureException("Castor marshalling exception", ex);
}
else {
return new UnmarshallingFailureException("Castor unmarshalling exception", ex);
}
}
else {
// fallback
return new UncategorizedMappingException("Unknown Castor exception", ex);
}
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/castor/CastorUnmarshallingFailureException.java 已删除 100644 → 0
浏览文件 @ 866ee115
/*
* Copyright 2005 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.oxm.castor;
import org.exolab.castor.xml.MarshalException;
import org.xml.sax.SAXException;
import org.springframework.oxm.UnmarshallingFailureException;
/**
* Castor-specific subclass of <code>UnmarshallingFailureException</code>.
*
* @author Arjen Poutsma
* @see CastorUtils#convertXmlException
* @since 3.0
*/
public class CastorUnmarshallingFailureException extends UnmarshallingFailureException {
public CastorUnmarshallingFailureException(MarshalException ex) {
super("Castor unmarshalling exception: " + ex.getMessage(), ex);
}
public CastorUnmarshallingFailureException(SAXException ex) {
super("Castor unmarshalling exception: " + ex.getMessage(), ex);
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/castor/CastorUtils.java 已删除 100644 → 0
浏览文件 @ 866ee115
/*
* Copyright 2005 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.oxm.castor;
import org.exolab.castor.xml.MarshalException;
import org.exolab.castor.xml.ValidationException;
import org.exolab.castor.xml.XMLException;
import org.springframework.oxm.XmlMappingException;
/**
* Generic utility methods for working with Castor. Mainly for internal use within the framework.
*
* @author Arjen Poutsma
* @since 3.0
*/
public class CastorUtils {
/**
* Converts the given <code>XMLException</code> to an appropriate exception from the
* <code>org.springframework.oxm</code> hierarchy. <p/> A boolean flag is used to indicate whether this exception
* occurs during marshalling or unmarshalling, since Castor itself does not make this distinction in its exception
* hierarchy.
*
* @param ex Castor <code>XMLException</code> that occured
* @param marshalling indicates whether the exception occurs during marshalling (<code>true</code>), or unmarshalling
* (<code>false</code>)
* @return the corresponding <code>XmlMappingException</code>
*/
public static XmlMappingException convertXmlException(XMLException ex, boolean marshalling) {
if (ex instanceof MarshalException) {
MarshalException marshalException = (MarshalException) ex;
if (marshalling) {
return new CastorMarshallingFailureException(marshalException);
}
else {
return new CastorUnmarshallingFailureException(marshalException);
}
}
else if (ex instanceof ValidationException) {
return new CastorValidationFailureException((ValidationException) ex);
}
// fallback
return new CastorSystemException("Unknown Castor exception: " + ex.getMessage(), ex);
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/castor/CastorValidationFailureException.java 已删除 100644 → 0
浏览文件 @ 866ee115
/*
* Copyright 2005 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.oxm.castor;
import org.exolab.castor.xml.ValidationException;
import org.springframework.oxm.ValidationFailureException;
/**
* Castor-specific subclass of <code>MarshallingFailureException</code>.
*
* @author Arjen Poutsma
* @see CastorUtils#convertXmlException
* @since 3.0
*/
public class CastorValidationFailureException extends ValidationFailureException {
public CastorValidationFailureException(ValidationException ex) {
super("Castor validation exception: " + ex.getMessage(), ex);
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/config/Jaxb2MarshallerBeanDefinitionParser.java
浏览文件 @ 555fa3b4
/*
* Copyright 2007 the original author or authors.
*
* 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
......
org.springframework.oxm/src/main/java/org/springframework/oxm/config/JibxMarshallerBeanDefinitionParser.java
浏览文件 @ 555fa3b4
/*
* Copyright 2008 the original author or authors.
* 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.
......
org.springframework.oxm/src/main/java/org/springframework/oxm/config/OxmNamespaceHandler.java
浏览文件 @ 555fa3b4
/*
* Copyright 2008 the original author or authors.
*
* 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
......@@ -32,4 +32,5 @@ public class OxmNamespaceHandler extends NamespaceHandlerSupport {
registerBeanDefinitionParser("jibx-marshaller", new JibxMarshallerBeanDefinitionParser());
registerBeanDefinitionParser("xmlbeans-marshaller", new XmlBeansMarshallerBeanDefinitionParser());
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/config/XmlBeansMarshallerBeanDefinitionParser.java
浏览文件 @ 555fa3b4
/*
* Copyright 2008 the original author or authors.
* 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.
......@@ -45,4 +45,5 @@ class XmlBeansMarshallerBeanDefinitionParser extends AbstractSingleBeanDefinitio
beanDefinitionBuilder.addPropertyReference("xmlOptions", optionsName);
}
}
}
\ No newline at end of file
}
org.springframework.oxm/src/main/java/org/springframework/oxm/jaxb/JaxbMarshallingFailureException.java 已删除 100644 → 0
浏览文件 @ 866ee115
/*
* Copyright 2005 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.oxm.jaxb;
import javax.xml.bind.MarshalException;
import org.springframework.oxm.MarshallingFailureException;
/**
* JAXB-specific subclass of <code>MarshallingFailureException</code>.
*
* @author Arjen Poutsma
* @see JaxbUtils#convertJaxbException
* @since 3.0
*/
public class JaxbMarshallingFailureException extends MarshallingFailureException {
public JaxbMarshallingFailureException(MarshalException ex) {
super("JAXB marshalling exception: " + ex.getMessage(), ex);
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/jaxb/JaxbSystemException.java 已删除 100644 → 0
浏览文件 @ 866ee115
/*
* Copyright 2005 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.oxm.jaxb;
import javax.xml.bind.JAXBException;
import org.springframework.oxm.UncategorizedXmlMappingException;
/**
* JAXB-specific subclass of <code>UncategorizedXmlMappingException</code>, for <code>JAXBException</code>s that cannot
* be distinguished further.
*
* @author Arjen Poutsma
* @see JaxbUtils#convertJaxbException(javax.xml.bind.JAXBException)
* @since 3.0
*/
public class JaxbSystemException extends UncategorizedXmlMappingException {
public JaxbSystemException(JAXBException ex) {
super(ex.getMessage(), ex);
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/jaxb/JaxbUnmarshallingFailureException.java 已删除 100644 → 0
浏览文件 @ 866ee115
/*
* Copyright 2005 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.oxm.jaxb;
import java.io.IOException;
import javax.xml.bind.UnmarshalException;
import org.springframework.oxm.UnmarshallingFailureException;
/**
* JAXB-specific subclass of <code>UnmarshallingFailureException</code>.
*
* @author Arjen Poutsma
* @since 3.0
*/
public class JaxbUnmarshallingFailureException extends UnmarshallingFailureException {
public JaxbUnmarshallingFailureException(UnmarshalException ex) {
super("JAXB unmarshalling exception: " + ex.getMessage(), ex);
}
public JaxbUnmarshallingFailureException(IOException ex) {
super("JAXB unmarshalling exception: " + ex.getMessage(), ex);
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/jaxb/JaxbUtils.java 已删除 100644 → 0
浏览文件 @ 866ee115
/*
* Copyright 2005 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.oxm.jaxb;
import javax.xml.bind.JAXBException;
import javax.xml.bind.MarshalException;
import javax.xml.bind.UnmarshalException;
import javax.xml.bind.ValidationException;
import org.springframework.oxm.XmlMappingException;
/**
* Generic utility methods for working with JAXB. Mainly for internal use within the framework.
*
* @author Arjen Poutsma
* @since 3.0
*/
public abstract class JaxbUtils {
/**
* Converts the given <code>JAXBException</code> to an appropriate exception from the
* <code>org.springframework.oxm</code> hierarchy.
*
* @param ex <code>JAXBException</code> that occured
* @return the corresponding <code>XmlMappingException</code>
*/
public static XmlMappingException convertJaxbException(JAXBException ex) {
if (ex instanceof MarshalException) {
return new JaxbMarshallingFailureException((MarshalException) ex);
}
else if (ex instanceof UnmarshalException) {
return new JaxbUnmarshallingFailureException((UnmarshalException) ex);
}
else if (ex instanceof ValidationException) {
return new JaxbValidationFailureException((ValidationException) ex);
}
// fallback
return new JaxbSystemException(ex);
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/jaxb/JaxbValidationFailureException.java 已删除 100644 → 0
浏览文件 @ 866ee115
/*
* Copyright 2005 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.oxm.jaxb;
import javax.xml.bind.ValidationException;
import org.springframework.oxm.ValidationFailureException;
/**
* JAXB-specific subclass of <code>ValidationFailureException</code>.
*
* @author Arjen Poutsma
* @see JaxbUtils#convertJaxbException
* @since 3.0
*/
public class JaxbValidationFailureException extends ValidationFailureException {
public JaxbValidationFailureException(ValidationException ex) {
super("JAXB validation exception: " + ex.getMessage(), ex);
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/jibx/JibxMarshaller.java
浏览文件 @ 555fa3b4
/*
* Copyright 2006 the original author or authors.
* 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.
......@@ -45,6 +45,7 @@ import org.jibx.runtime.IUnmarshallingContext;
import org.jibx.runtime.IXMLReader;
import org.jibx.runtime.IXMLWriter;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.ValidationException;
import org.jibx.runtime.impl.MarshallingContext;
import org.jibx.runtime.impl.StAXReaderWrapper;
import org.jibx.runtime.impl.StAXWriter;
......@@ -56,21 +57,25 @@ import org.xml.sax.XMLReader;
import org.xml.sax.ext.LexicalHandler;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.oxm.AbstractMarshaller;
import org.springframework.oxm.MarshallingFailureException;
import org.springframework.oxm.UnmarshallingFailureException;
import org.springframework.oxm.ValidationFailureException;
import org.springframework.oxm.XmlMappingException;
import org.springframework.oxm.support.AbstractMarshaller;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
import org.springframework.util.xml.StaxUtils;
/**
* Implementation of the <code>Marshaller</code> and <code>Unmarshaller</code> interfaces for JiBX. <p/> The typical
* usage will be to set the <code>targetClass</code> and optionally the <code>bindingName</code> property on this bean,
* and to refer to it.
* Implementation of the <code>Marshaller</code> and <code>Unmarshaller</code> interfaces for JiBX.
*
* <p>The typical usage will be to set the <code>targetClass</code> and optionally the
* <code>bindingName</code> property on this bean.
*
* @author Arjen Poutsma
* @since 3.0
* @see org.jibx.runtime.IMarshallingContext
* @see org.jibx.runtime.IUnmarshallingContext
* @since 3.0
*/
public class JibxMarshaller extends AbstractMarshaller implements InitializingBean {
......@@ -78,77 +83,73 @@ public class JibxMarshaller extends AbstractMarshaller implements InitializingBe
private String bindingName;
private IBindingFactory bindingFactory;
private static TransformerFactory transformerFactory = TransformerFactory.newInstance();
private int indent = -1;
private String encoding;
private Boolean standalone;
private IBindingFactory bindingFactory;
private TransformerFactory transformerFactory = TransformerFactory.newInstance();
/**
* Sets the optional binding name for this instance.
* Set the target class for this instance. This property is required.
*/
public void setBindingName(String bindingName) {
this.bindingName = bindingName;
public void setTargetClass(Class targetClass) {
this.targetClass = targetClass;
}
/**
* Sets the target class for this instance. This property is required.
* Set the optional binding name for this instance.
*/
public void setTargetClass(Class targetClass) {
this.targetClass = targetClass;
public void setBindingName(String bindingName) {
this.bindingName = bindingName;
}
/**
* Sets the number of nesting indent spaces. Default is <code>-1</code>, i.e. no indentation.
* Set the number of nesting indent spaces. Default is <code>-1</code>, i.e. no indentation.
*/
public void setIndent(int indent) {
this.indent = indent;
}
/**
* Sets the document encoding using for marshalling. Default is UTF-8.
* Set the document encoding using for marshalling. Default is UTF-8.
*/
public void setEncoding(String encoding) {
this.encoding = encoding;
}
/**
* Sets the document standalone flag for marshalling. By default, this flag is not present.
* Set the document standalone flag for marshalling. By default, this flag is not present.
*/
public void setStandalone(Boolean standalone) {
this.standalone = standalone;
}
public void afterPropertiesSet() throws Exception {
Assert.notNull(targetClass, "targetClass is required");
if (logger.isInfoEnabled()) {
if (StringUtils.hasLength(bindingName)) {
logger.info("Configured for target class [" + targetClass + "] using binding [" + bindingName + "]");
}
else {
logger.info("Configured for target class [" + targetClass + "]");
public void afterPropertiesSet() throws JiBXException {
Assert.notNull(this.targetClass, "targetClass is required");
if (StringUtils.hasLength(this.bindingName)) {
if (logger.isInfoEnabled()) {
logger.info("Configured for target class [" + this.targetClass + "] using binding [" + this.bindingName + "]");
}
this.bindingFactory = BindingDirectory.getFactory(this.bindingName, this.targetClass);
}
try {
if (StringUtils.hasLength(bindingName)) {
bindingFactory = BindingDirectory.getFactory(bindingName, targetClass);
}
else {
bindingFactory = BindingDirectory.getFactory(targetClass);
else {
if (logger.isInfoEnabled()) {
logger.info("Configured for target class [" + this.targetClass + "]");
}
}
catch (JiBXException ex) {
throw new JibxSystemException(ex);
this.bindingFactory = BindingDirectory.getFactory(this.targetClass);
}
}
public boolean supports(Class<?> clazz) {
Assert.notNull(clazz, "'clazz' must not be null");
String[] mappedClasses = bindingFactory.getMappedClasses();
String[] mappedClasses = this.bindingFactory.getMappedClasses();
String className = clazz.getName();
for (String mappedClass : mappedClasses) {
if (className.equals(mappedClass)) {
......@@ -158,32 +159,15 @@ public class JibxMarshaller extends AbstractMarshaller implements InitializingBe
return false;
}
/**
* Convert the given <code>JiBXException</code> to an appropriate exception from the
* <code>org.springframework.oxm</code> hierarchy. <p/> The default implementation delegates to <code>JibxUtils</code>.
* Can be overridden in subclasses. <p/> A boolean flag is used to indicate whether this exception occurs during
* marshalling or unmarshalling, since JiBX itself does not make this distinction in its exception hierarchy.
*
* @param ex <code>JiBXException</code> that occured
* @param marshalling indicates whether the exception occurs during marshalling (<code>true</code>), or unmarshalling
* (<code>false</code>)
* @return the corresponding <code>XmlMappingException</code> instance
* @see JibxUtils#convertJibxException(org.jibx.runtime.JiBXException,boolean)
*/
public XmlMappingException convertJibxException(JiBXException ex, boolean marshalling) {
return JibxUtils.convertJibxException(ex, marshalling);
}
//
// Supported Marshalling
//
@Override
protected void marshalOutputStream(Object graph, OutputStream outputStream)
throws XmlMappingException, IOException {
try {
IMarshallingContext marshallingContext = createMarshallingContext();
marshallingContext.marshalDocument(graph, encoding, standalone, outputStream);
marshallingContext.marshalDocument(graph, this.encoding, this.standalone, outputStream);
}
catch (JiBXException ex) {
throw convertJibxException(ex, true);
......@@ -194,7 +178,7 @@ public class JibxMarshaller extends AbstractMarshaller implements InitializingBe
protected void marshalWriter(Object graph, Writer writer) throws XmlMappingException, IOException {
try {
IMarshallingContext marshallingContext = createMarshallingContext();
marshallingContext.marshalDocument(graph, encoding, standalone, writer);
marshallingContext.marshalDocument(graph, this.encoding, this.standalone, writer);
}
catch (JiBXException ex) {
throw convertJibxException(ex, true);
......@@ -214,9 +198,8 @@ public class JibxMarshaller extends AbstractMarshaller implements InitializingBe
}
}
//
// Unsupported Marshalling
//
@Override
protected void marshalDomNode(Object graph, Node node) throws XmlMappingException {
......@@ -225,14 +208,11 @@ public class JibxMarshaller extends AbstractMarshaller implements InitializingBe
ByteArrayOutputStream os = new ByteArrayOutputStream();
marshalOutputStream(graph, os);
ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
Transformer transformer = transformerFactory.newTransformer();
Transformer transformer = this.transformerFactory.newTransformer();
transformer.transform(new StreamSource(is), new DOMResult(node));
}
catch (IOException ex) {
throw new JibxSystemException(ex);
}
catch (TransformerException ex) {
throw new JibxSystemException(ex);
catch (Exception ex) {
throw new MarshallingFailureException("JiBX marshalling exception", ex);
}
}
......@@ -244,16 +224,13 @@ public class JibxMarshaller extends AbstractMarshaller implements InitializingBe
ByteArrayOutputStream os = new ByteArrayOutputStream();
marshalOutputStream(graph, os);
ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
Transformer transformer = transformerFactory.newTransformer();
Transformer transformer = this.transformerFactory.newTransformer();
SAXResult saxResult = new SAXResult(contentHandler);
saxResult.setLexicalHandler(lexicalHandler);
transformer.transform(new StreamSource(is), saxResult);
}
catch (IOException ex) {
throw new JibxSystemException(ex);
}
catch (TransformerException ex) {
throw new JibxSystemException(ex);
catch (Exception ex) {
throw new MarshallingFailureException("JiBX marshalling exception", ex);
}
}
......@@ -263,9 +240,8 @@ public class JibxMarshaller extends AbstractMarshaller implements InitializingBe
marshalSaxHandlers(graph, contentHandler, null);
}
//
// Unmarshalling
//
@Override
protected Object unmarshalInputStream(InputStream inputStream) throws XmlMappingException, IOException {
......@@ -309,13 +285,12 @@ public class JibxMarshaller extends AbstractMarshaller implements InitializingBe
return unmarshalXmlStreamReader(streamReader);
}
catch (XMLStreamException ex) {
throw new JibxSystemException(ex);
return new UnmarshallingFailureException("JiBX unmarshalling exception", ex);
}
}
//
// Unsupported Unmarshalling
//
@Override
protected Object unmarshalDomNode(Node node) throws XmlMappingException {
......@@ -326,11 +301,8 @@ public class JibxMarshaller extends AbstractMarshaller implements InitializingBe
ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
return unmarshalInputStream(is);
}
catch (IOException ex) {
throw new JibxSystemException(ex);
}
catch (TransformerException ex) {
throw new JibxSystemException(ex);
catch (Exception ex) {
throw new UnmarshallingFailureException("JiBX unmarshalling exception", ex);
}
}
......@@ -338,41 +310,60 @@ public class JibxMarshaller extends AbstractMarshaller implements InitializingBe
protected Object unmarshalSaxReader(XMLReader xmlReader, InputSource inputSource)
throws XmlMappingException, IOException {
try {
Transformer transformer = transformerFactory.newTransformer();
Transformer transformer = this.transformerFactory.newTransformer();
ByteArrayOutputStream os = new ByteArrayOutputStream();
transformer.transform(new SAXSource(xmlReader, inputSource), new StreamResult(os));
ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
return unmarshalInputStream(is);
}
catch (IOException ex) {
throw new JibxSystemException(ex);
}
catch (TransformerException ex) {
throw new JibxSystemException(ex);
throw new UnmarshallingFailureException("JiBX unmarshalling exception", ex);
}
}
/**
* Creates a new <code>IMarshallingContext</code>, set with the correct indentation.
*
* Create a new <code>IMarshallingContext</code>, configured with the correct indentation.
* @return the created marshalling context
* @throws JiBXException in case of errors
*/
protected IMarshallingContext createMarshallingContext() throws JiBXException {
IMarshallingContext marshallingContext = bindingFactory.createMarshallingContext();
marshallingContext.setIndent(indent);
IMarshallingContext marshallingContext = this.bindingFactory.createMarshallingContext();
marshallingContext.setIndent(this.indent);
return marshallingContext;
}
/**
* Creates a new <code>IUnmarshallingContext</code>, set with the correct indentation.
*
* Create a new <code>IUnmarshallingContext</code>.
* @return the created unmarshalling context
* @throws JiBXException in case of errors
*/
protected IUnmarshallingContext createUnmarshallingContext() throws JiBXException {
return bindingFactory.createUnmarshallingContext();
return this.bindingFactory.createUnmarshallingContext();
}
/**
* Convert the given <code>JiBXException</code> to an appropriate exception from the
* <code>org.springframework.oxm</code> hierarchy.
* <p>A boolean flag is used to indicate whether this exception occurs during marshalling or
* unmarshalling, since JiBX itself does not make this distinction in its exception hierarchy.
* @param ex <code>JiBXException</code> that occured
* @param marshalling indicates whether the exception occurs during marshalling (<code>true</code>),
* or unmarshalling (<code>false</code>)
* @return the corresponding <code>XmlMappingException</code>
*/
public XmlMappingException convertJibxException(JiBXException ex, boolean marshalling) {
if (ex instanceof ValidationException) {
return new ValidationFailureException("JiBX validation exception", ex);
}
else {
if (marshalling) {
return new MarshallingFailureException("JiBX marshalling exception", ex);
}
else {
return new UnmarshallingFailureException("JiBX unmarshalling exception", ex);
}
}
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/jibx/JibxMarshallingFailureException.java 已删除 100644 → 0
浏览文件 @ 866ee115
/*
* Copyright 2006 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.oxm.jibx;
import org.jibx.runtime.JiBXException;
import org.springframework.oxm.MarshallingFailureException;
/**
* JiXB-specific subclass of <code>MarshallingFailureException</code>.
*
* @author Arjen Poutsma
* @see JibxUtils#convertJibxException(org.jibx.runtime.JiBXException,boolean)
* @since 3.0
*/
public class JibxMarshallingFailureException extends MarshallingFailureException {
public JibxMarshallingFailureException(JiBXException ex) {
super("JiBX marshalling exception: " + ex.getMessage(), ex);
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/jibx/JibxSystemException.java 已删除 100644 → 0
浏览文件 @ 866ee115
/*
* Copyright 2006 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.oxm.jibx;
import org.springframework.oxm.UncategorizedXmlMappingException;
/**
* JiBX-specific subclass of <code>UncategorizedXmlMappingException</code>, for <code>JiBXBException</code>s that cannot
* be distinguished further.
*
* @author Arjen Poutsma
* @see JibxUtils#convertJibxException(org.jibx.runtime.JiBXException,boolean)
* @since 3.0
*/
public class JibxSystemException extends UncategorizedXmlMappingException {
public JibxSystemException(Exception ex) {
super(ex.getMessage(), ex);
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/jibx/JibxUnmarshallingFailureException.java 已删除 100644 → 0
浏览文件 @ 866ee115
/*
* Copyright 2006 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.oxm.jibx;
import org.jibx.runtime.JiBXException;
import org.springframework.oxm.UnmarshallingFailureException;
/**
* JiXB-specific subclass of <code>UnmarshallingFailureException</code>.
*
* @author Arjen Poutsma
* @see JibxUtils#convertJibxException(org.jibx.runtime.JiBXException,boolean)
* @since 3.0
*/
public class JibxUnmarshallingFailureException extends UnmarshallingFailureException {
public JibxUnmarshallingFailureException(JiBXException ex) {
super("JiBX unmarshalling exception: " + ex.getMessage(), ex);
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/jibx/JibxUtils.java 已删除 100644 → 0
浏览文件 @ 866ee115
/*
* Copyright 2006 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.oxm.jibx;
import org.jibx.runtime.JiBXException;
import org.jibx.runtime.ValidationException;
import org.springframework.oxm.XmlMappingException;
/**
* Generic utility methods for working with JiBX. Mainly for internal use within the framework.
*
* @author Arjen Poutsma
* @since 3.0
*/
public abstract class JibxUtils {
/**
* Converts the given <code>JiBXException</code> to an appropriate exception from the
* <code>org.springframework.oxm</code> hierarchy. <p/> A boolean flag is used to indicate whether this exception
* occurs during marshalling or unmarshalling, since JiBX itself does not make this distinction in its exception
* hierarchy.
*
* @param ex <code>JiBXException</code> that occured
* @param marshalling indicates whether the exception occurs during marshalling (<code>true</code>), or unmarshalling
* (<code>false</code>)
* @return the corresponding <code>XmlMappingException</code>
*/
public static XmlMappingException convertJibxException(JiBXException ex, boolean marshalling) {
if (ex instanceof ValidationException) {
return new JibxValidationFailureException((ValidationException) ex);
}
else {
if (marshalling) {
return new JibxMarshallingFailureException(ex);
}
else {
return new JibxUnmarshallingFailureException(ex);
}
}
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/jibx/JibxValidationFailureException.java 已删除 100644 → 0
浏览文件 @ 866ee115
/*
* Copyright 2006 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.oxm.jibx;
import org.jibx.runtime.ValidationException;
import org.springframework.oxm.ValidationFailureException;
/**
* JAXB-specific subclass of <code>ValidationFailureException</code>.
*
* @author Arjen Poutsma
* @see JibxUtils#convertJibxException(org.jibx.runtime.JiBXException,boolean)
* @since 3.0
*/
public class JibxValidationFailureException extends ValidationFailureException {
public JibxValidationFailureException(ValidationException ex) {
super("JiBX validation exception: " + ex.getMessage(), ex);
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/mime/MimeContainer.java
浏览文件 @ 555fa3b4
/*
* Copyright 2007 the original author or authors.
* 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.
......@@ -19,44 +19,43 @@ package org.springframework.oxm.mime;
import javax.activation.DataHandler;
/**
* Represents a container for MIME attachments. Concrete implementations might adapt a SOAPMesage, or an email message.
* Represents a container for MIME attachments
* Concrete implementations might adapt a SOAPMessage or an email message.
*
* @author Arjen Poutsma
* @see <a href="http://www.w3.org/TR/2005/REC-xop10-20050125/">XML-binary Optimized Packaging</a>
* @since 3.0
* @see <a href="http://www.w3.org/TR/2005/REC-xop10-20050125/">XML-binary Optimized Packaging</a>
*/
public interface MimeContainer {
/**
* Indicates whether this container is a XOP package.
*
* @return <code>true</code> when the constraints specified in <a href="http://www.w3.org/TR/2005/REC-xop10-20050125/#identifying_xop_documents">Identifying
* XOP Documents</a> are met.
* Indicate whether this container is a XOP package.
* @return <code>true</code> when the constraints specified in
* <a href="http://www.w3.org/TR/2005/REC-xop10-20050125/#identifying_xop_documents">Identifying XOP Documents</a>
* are met
* @see <a href="http://www.w3.org/TR/2005/REC-xop10-20050125/#xop_packages">XOP Packages</a>
*/
boolean isXopPackage();
/**
* Turns this message into a XOP package.
*
* @return <code>true</code> when the message is a XOP package
* Turn this message into a XOP package.
* @return <code>true</code> when the message actually is a XOP package
* @see <a href="http://www.w3.org/TR/2005/REC-xop10-20050125/#xop_packages">XOP Packages</a>
*/
boolean convertToXopPackage();
/**
* Adds the given data handler as an attachment to this container.
*
* @param contentId the content id of the attachment
* Add the given data handler as an attachment to this container.
* @param contentId the content id of the attachment
* @param dataHandler the data handler containing the data of the attachment
*/
void addAttachment(String contentId, DataHandler dataHandler);
/**
* Returns the attachment with the given content id, or <code>null</code> if not found.
*
* Return the attachment with the given content id, or <code>null</code> if not found.
* @param contentId the content id
* @return the attachment, as a data handler
*/
DataHandler getAttachment(String contentId);
}
org.springframework.oxm/src/main/java/org/springframework/oxm/mime/MimeMarshaller.java
浏览文件 @ 555fa3b4
/*
* Copyright 2007 the original author or authors.
* 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.
......@@ -23,28 +23,25 @@ import org.springframework.oxm.Marshaller;
import org.springframework.oxm.XmlMappingException;
/**
* Subinterface of {@link Marshaller} that can use MIME attachments to optimize storage of binary data. Attachments can
* be added as MTOM, XOP, or SwA.
* Subinterface of {@link Marshaller} that can use MIME attachments to optimize
* storage of binary data. Attachments can be added as MTOM, XOP, or SwA.
*
* @author Arjen Poutsma
* @see <a href="http://www.w3.org/TR/2004/WD-soap12-mtom-20040608/">SOAP Message Transmission Optimization
* Mechanism</a>
* @see <a href="http://www.w3.org/TR/2005/REC-xop10-20050125/">XML-binary Optimized Packaging</a>
* @since 3.0
* @see <a href="http://www.w3.org/TR/2004/WD-soap12-mtom-20040608/">SOAP Message Transmission Optimization Mechanism</a>
* @see <a href="http://www.w3.org/TR/2005/REC-xop10-20050125/">XML-binary Optimized Packaging</a>
*/
public interface MimeMarshaller extends Marshaller {
/**
* Marshals the object graph with the given root into the provided {@link Result}, writing binary data to a {@link
* MimeContainer}.
*
* @param graph the root of the object graph to marshal
* @param result the result to marshal to
* Marshals the object graph with the given root into the provided {@link Result},
* writing binary data to a {@link MimeContainer}.
* @param graph the root of the object graph to marshal
* @param result the result to marshal to
* @param mimeContainer the MIME container to write extracted binary content to
* @throws XmlMappingException if the given object cannot be marshalled to the result
* @throws IOException if an I/O exception occurs
* @throws IOException if an I/O exception occurs
*/
void marshal(Object graph, Result result, MimeContainer mimeContainer) throws XmlMappingException, IOException;
}
org.springframework.oxm/src/main/java/org/springframework/oxm/mime/MimeUnmarshaller.java
浏览文件 @ 555fa3b4
/*
* Copyright 2007 the original author or authors.
* 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.
......@@ -23,26 +23,25 @@ import org.springframework.oxm.Unmarshaller;
import org.springframework.oxm.XmlMappingException;
/**
* Subinterface of {@link org.springframework.oxm.Marshaller} that can use MIME attachments to optimize storage of
* binary data. Attachments can be added as MTOM, XOP, or SwA.
* Subinterface of {@link org.springframework.oxm.Marshaller} that can use MIME attachments
* to optimize storage of binary data. Attachments can be added as MTOM, XOP, or SwA.
*
* @author Arjen Poutsma
* @see <a href="http://www.w3.org/TR/2004/WD-soap12-mtom-20040608/">SOAP Message Transmission Optimization
* Mechanism</a>
* @see <a href="http://www.w3.org/TR/2005/REC-xop10-20050125/">XML-binary Optimized Packaging</a>
* @since 3.0
* @see <a href="http://www.w3.org/TR/2004/WD-soap12-mtom-20040608/">SOAP Message Transmission Optimization Mechanism</a>
* @see <a href="http://www.w3.org/TR/2005/REC-xop10-20050125/">XML-binary Optimized Packaging</a>
*/
public interface MimeUnmarshaller extends Unmarshaller {
/**
* Unmarshals the given provided {@link Source} into an object graph, reading binary attachments from a {@link
* MimeContainer}.
*
* @param source the source to marshal from
* Unmarshals the given provided {@link Source} into an object graph,
* reading binary attachments from a {@link MimeContainer}.
* @param source the source to marshal from
* @param mimeContainer the MIME container to read extracted binary content from
* @return the object graph
* @throws XmlMappingException if the given source cannot be mapped to an object
* @throws IOException if an I/O Exception occurs
* @throws IOException if an I/O Exception occurs
*/
Object unmarshal(Source source, MimeContainer mimeContainer) throws XmlMappingException, IOException;
}
org.springframework.oxm/src/main/java/org/springframework/oxm/support/MarshallingSource.java
浏览文件 @ 555fa3b4
......@@ -28,7 +28,6 @@ import org.xml.sax.ErrorHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXNotRecognizedException;
import org.xml.sax.SAXNotSupportedException;
import org.xml.sax.SAXParseException;
import org.xml.sax.XMLReader;
import org.xml.sax.ext.LexicalHandler;
......@@ -37,8 +36,8 @@ import org.springframework.oxm.Marshaller;
import org.springframework.util.Assert;
/**
* {@link Source} implementation that uses a {@link Marshaller}.Can be constructed with a <code>Marshaller</code> and an
* object to be marshalled.
* {@link Source} implementation that uses a {@link Marshaller}.Can be constructed with a
* <code>Marshaller</code> and an object to be marshalled.
*
* <p>Even though <code>MarshallingSource</code> extends from <code>SAXSource</code>, calling the methods of
* <code>SAXSource</code> is <strong>not supported</strong>. In general, the only supported operation on this class is
......@@ -47,8 +46,8 @@ import org.springframework.util.Assert;
* <code>UnsupportedOperationException</code>s.
*
* @author Arjen Poutsma
* @see javax.xml.transform.Transformer
* @since 3.0
* @see javax.xml.transform.Transformer
*/
public class MarshallingSource extends SAXSource {
......@@ -56,11 +55,11 @@ public class MarshallingSource extends SAXSource {
private final Object content;
/**
* Creates a new <code>MarshallingSource</code> with the given marshaller and content.
*
* Create a new <code>MarshallingSource</code> with the given marshaller and content.
* @param marshaller the marshaller to use
* @param content the object to be marshalled
* @param content the object to be marshalled
*/
public MarshallingSource(Marshaller marshaller, Object content) {
super(new MarshallingXMLReader(marshaller, content), new InputSource());
......@@ -70,20 +69,23 @@ public class MarshallingSource extends SAXSource {
this.content = content;
}
/** Returns the <code>Marshaller</code> used by this <code>MarshallingSource</code>. */
/**
* Return the <code>Marshaller</code> used by this <code>MarshallingSource</code>.
*/
public Marshaller getMarshaller() {
return marshaller;
return this.marshaller;
}
/** Returns the object to be marshalled. */
/**
* Return the object to be marshalled.
*/
public Object getContent() {
return content;
return this.content;
}
/**
* Throws a <code>UnsupportedOperationException</code>.
*
* @throws UnsupportedOperationException always
*/
@Override
public void setInputSource(InputSource inputSource) {
......@@ -92,14 +94,13 @@ public class MarshallingSource extends SAXSource {
/**
* Throws a <code>UnsupportedOperationException</code>.
*
* @throws UnsupportedOperationException always
*/
@Override
public void setXMLReader(XMLReader reader) {
throw new UnsupportedOperationException("setXMLReader is not supported");
}
private static class MarshallingXMLReader implements XMLReader {
private final Marshaller marshaller;
......@@ -123,51 +124,51 @@ public class MarshallingSource extends SAXSource {
this.content = content;
}
public ContentHandler getContentHandler() {
return contentHandler;
}
public void setContentHandler(ContentHandler contentHandler) {
this.contentHandler = contentHandler;
}
public ContentHandler getContentHandler() {
return this.contentHandler;
}
public void setDTDHandler(DTDHandler dtdHandler) {
this.dtdHandler = dtdHandler;
}
public DTDHandler getDTDHandler() {
return dtdHandler;
}
public EntityResolver getEntityResolver() {
return entityResolver;
return this.dtdHandler;
}
public void setEntityResolver(EntityResolver entityResolver) {
this.entityResolver = entityResolver;
}
public ErrorHandler getErrorHandler() {
return errorHandler;
public EntityResolver getEntityResolver() {
return this.entityResolver;
}
public void setErrorHandler(ErrorHandler errorHandler) {
this.errorHandler = errorHandler;
}
public ErrorHandler getErrorHandler() {
return this.errorHandler;
}
protected LexicalHandler getLexicalHandler() {
return lexicalHandler;
return this.lexicalHandler;
}
public boolean getFeature(String name) throws SAXNotRecognizedException, SAXNotSupportedException {
public boolean getFeature(String name) throws SAXNotRecognizedException {
throw new SAXNotRecognizedException(name);
}
public void setFeature(String name, boolean value) throws SAXNotRecognizedException, SAXNotSupportedException {
public void setFeature(String name, boolean value) throws SAXNotRecognizedException {
throw new SAXNotRecognizedException(name);
}
public Object getProperty(String name) throws SAXNotRecognizedException, SAXNotSupportedException {
public Object getProperty(String name) throws SAXNotRecognizedException {
if ("http://xml.org/sax/properties/lexical-handler".equals(name)) {
return lexicalHandler;
}
......@@ -176,20 +177,20 @@ public class MarshallingSource extends SAXSource {
}
}
public void setProperty(String name, Object value) throws SAXNotRecognizedException, SAXNotSupportedException {
public void setProperty(String name, Object value) throws SAXNotRecognizedException {
if ("http://xml.org/sax/properties/lexical-handler".equals(name)) {
lexicalHandler = (LexicalHandler) value;
this.lexicalHandler = (LexicalHandler) value;
}
else {
throw new SAXNotRecognizedException(name);
}
}
public void parse(InputSource input) throws IOException, SAXException {
public void parse(InputSource input) throws SAXException {
parse();
}
public void parse(String systemId) throws IOException, SAXException {
public void parse(String systemId) throws SAXException {
parse();
}
......@@ -197,18 +198,19 @@ public class MarshallingSource extends SAXSource {
SAXResult result = new SAXResult(getContentHandler());
result.setLexicalHandler(getLexicalHandler());
try {
marshaller.marshal(content, result);
this.marshaller.marshal(this.content, result);
}
catch (IOException ex) {
SAXParseException saxException = new SAXParseException(ex.getMessage(), null, null, -1, -1, ex);
if (getErrorHandler() != null) {
getErrorHandler().fatalError(saxException);
ErrorHandler errorHandler = getErrorHandler();
if (errorHandler != null) {
errorHandler.fatalError(saxException);
}
else {
throw saxException;
}
}
}
}
}
org.springframework.core/src/main/java/org/springframework/util/xml/SaxUtils.java → org.springframework.oxm/src/main/java/org/springframework/oxm/support/SaxResourceUtils.java
浏览文件 @ 555fa3b4
......@@ -14,7 +14,7 @@
* limitations under the License.
*/
package org.springframework.util.xml;
package org.springframework.oxm.support;
import java.io.IOException;
......@@ -26,14 +26,14 @@ import org.springframework.core.io.Resource;
* Convenient utility methods for dealing with SAX.
*
* @author Arjen Poutsma
* @author Juergen Hoeller
* @since 3.0
*/
public abstract class SaxUtils {
public abstract class SaxResourceUtils {
/**
* Creates a SAX <code>InputSource</code> from the given resource. Sets the system identifier to the resource's
* <code>URL</code>, if available.
*
* Create a SAX <code>InputSource</code> from the given resource.
* <p>Sets the system identifier to the resource's <code>URL</code>, if available.
* @param resource the resource
* @return the input source created from the resource
* @throws IOException if an I/O exception occurs
......@@ -46,12 +46,15 @@ public abstract class SaxUtils {
return inputSource;
}
/** Retrieves the URL from the given resource as System ID. Returns <code>null</code> if it cannot be openened. */
/**
* Retrieve the URL from the given resource as System ID.
* <p>Returns <code>null</code> if it cannot be opened.
*/
private static String getSystemId(Resource resource) {
try {
return resource.getURI().toString();
}
catch (IOException e) {
catch (IOException ex) {
return null;
}
}
......
org.springframework.oxm/src/main/java/org/springframework/oxm/xmlbeans/XmlBeansMarshaller.java
浏览文件 @ 555fa3b4
/*
* 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.oxm.xmlbeans;
import java.io.IOException;
......@@ -6,7 +22,6 @@ import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLEventWriter;
......@@ -19,6 +34,7 @@ import org.apache.xmlbeans.XmlObject;
import org.apache.xmlbeans.XmlOptions;
import org.apache.xmlbeans.XmlSaxHandler;
import org.apache.xmlbeans.XmlValidationError;
import org.apache.xmlbeans.XMLStreamValidationException;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
......@@ -30,24 +46,33 @@ import org.xml.sax.SAXNotSupportedException;
import org.xml.sax.XMLReader;
import org.xml.sax.ext.LexicalHandler;
import org.springframework.oxm.AbstractMarshaller;
import org.springframework.oxm.Marshaller;
import org.springframework.oxm.ValidationFailureException;
import org.springframework.oxm.XmlMappingException;
import org.springframework.oxm.MarshallingFailureException;
import org.springframework.oxm.UnmarshallingFailureException;
import org.springframework.oxm.UncategorizedMappingException;
import org.springframework.oxm.support.AbstractMarshaller;
import org.springframework.util.xml.StaxUtils;
/**
* Implementation of the {@link Marshaller} interface for XMLBeans. Further options can be set by setting the
* <code>xmlOptions</code> property. The {@link XmlOptionsFactoryBean} is provided to easily wire up {@link XmlOptions}
* instances. <p/> Unmarshalled objects can be validated by setting the <code>validating</code> property, or by calling
* the {@link #validate(XmlObject)} method directly. Invalid objects will result in an {@link
* XmlBeansValidationFailureException}. <p/> <strong>Note</strong> that due to the nature of XMLBeans, this marshaller
* requires all passed objects to be of type {@link XmlObject}.
* Implementation of the {@link Marshaller} interface for Apache XMLBeans.
*
* <p>Options can be set by setting the <code>xmlOptions</code> property.
* The {@link XmlOptionsFactoryBean} is provided to easily set up an {@link XmlOptions} instance.
*
* <p>Unmarshalled objects can be validated by setting the <code>validating</code> property,
* or by calling the {@link #validate(XmlObject)} method directly. Invalid objects will
* result in an {@link XmlBeansValidationFailureException}.
*
* <p><b>NOTE:</b> Due to the nature of XMLBeans, this marshaller requires
* all passed objects to be of type {@link XmlObject}.
*
* @author Arjen Poutsma
* @see #setXmlOptions(org.apache.xmlbeans.XmlOptions)
* @see XmlOptionsFactoryBean
* @see #setValidating(boolean)
* @since 3.0
* @see #setValidating
* @see #setXmlOptions
* @see XmlOptionsFactoryBean
*/
public class XmlBeansMarshaller extends AbstractMarshaller {
......@@ -55,16 +80,9 @@ public class XmlBeansMarshaller extends AbstractMarshaller {
private boolean validating = false;
/**
* Returns the <code>XmlOptions</code>.
*/
public XmlOptions getXmlOptions() {
return xmlOptions;
}
/**
* Sets the <code>XmlOptions</code>.
*
* Set the <code>XmlOptions</code>.
* @see XmlOptionsFactoryBean
*/
public void setXmlOptions(XmlOptions xmlOptions) {
......@@ -72,21 +90,30 @@ public class XmlBeansMarshaller extends AbstractMarshaller {
}
/**
* Returns whether this marshaller should validate in- and outgoing documents.
* Return the <code>XmlOptions</code>.
*/
public boolean isValidating() {
return validating;
public XmlOptions getXmlOptions() {
return this.xmlOptions;
}
/**
* Sets whether this marshaller should validate in- and outgoing documents. Default is <code>false</code>.
* Set whether this marshaller should validate in- and outgoing documents.
* Default is <code>false</code>.
*/
public void setValidating(boolean validating) {
this.validating = validating;
}
/**
* Returns true if the given class is an implementation of {@link XmlObject}.
* Return whether this marshaller should validate in- and outgoing documents.
*/
public boolean isValidating() {
return this.validating;
}
/**
* This implementation returns true if the given class is an implementation of {@link XmlObject}.
*/
public boolean supports(Class<?> clazz) {
return XmlObject.class.isAssignableFrom(clazz);
......@@ -107,6 +134,7 @@ public class XmlBeansMarshaller extends AbstractMarshaller {
@Override
protected final void marshalOutputStream(Object graph, OutputStream outputStream)
throws XmlMappingException, IOException {
((XmlObject) graph).save(outputStream, getXmlOptions());
}
......@@ -225,30 +253,13 @@ public class XmlBeansMarshaller extends AbstractMarshaller {
}
}
/**
* Converts the given XMLBeans exception to an appropriate exception from the <code>org.springframework.oxm</code>
* hierarchy. <p/> The default implementation delegates to <code>XmlBeansUtils</code>. Can be overridden in subclasses.
* <p/> A boolean flag is used to indicate whether this exception occurs during marshalling or unmarshalling, since
* XMLBeans itself does not make this distinction in its exception hierarchy.
*
* @param ex XMLBeans Exception that occured
* @param marshalling indicates whether the exception occurs during marshalling (<code>true</code>), or unmarshalling
* (<code>false</code>)
* @return the corresponding <code>XmlMappingException</code>
* @see XmlBeansUtils#convertXmlBeansException(Exception,boolean)
*/
public XmlMappingException convertXmlBeansException(Exception ex, boolean marshalling) {
return XmlBeansUtils.convertXmlBeansException(ex, marshalling);
}
/**
* Validates the given <code>XmlObject</code>.
*
* Validate the given <code>XmlObject</code>.
* @param object the xml object to validate
* @throws XmlBeansValidationFailureException
* if the given object is not valid
* @throws XmlBeansValidationFailureException if the given object is not valid
*/
public void validate(XmlObject object) throws XmlBeansValidationFailureException {
protected void validate(XmlObject object) throws ValidationFailureException {
if (isValidating() && object != null) {
// create a temporary xmlOptions just for validation
XmlOptions validateOptions = getXmlOptions() != null ? getXmlOptions() : new XmlOptions();
......@@ -256,15 +267,44 @@ public class XmlBeansMarshaller extends AbstractMarshaller {
validateOptions.setErrorListener(errorsList);
if (!object.validate(validateOptions)) {
StringBuilder builder = new StringBuilder("Could not validate XmlObject :");
for (Iterator iterator = errorsList.iterator(); iterator.hasNext();) {
XmlError xmlError = (XmlError) iterator.next();
for (Object anErrorsList : errorsList) {
XmlError xmlError = (XmlError) anErrorsList;
if (xmlError instanceof XmlValidationError) {
builder.append(xmlError.toString());
}
}
XmlException ex = new XmlException(builder.toString(), null, errorsList);
throw new XmlBeansValidationFailureException(ex);
throw new ValidationFailureException("XMLBeans validation failure",
new XmlException(builder.toString(), null, errorsList));
}
}
}
/**
* Convert the given XMLBeans exception to an appropriate exception from the
* <code>org.springframework.oxm</code> hierarchy.
* <p>A boolean flag is used to indicate whether this exception occurs during marshalling or
* unmarshalling, since XMLBeans itself does not make this distinction in its exception hierarchy.
* @param ex XMLBeans Exception that occured
* @param marshalling indicates whether the exception occurs during marshalling (<code>true</code>),
* or unmarshalling (<code>false</code>)
* @return the corresponding <code>XmlMappingException</code>
*/
protected XmlMappingException convertXmlBeansException(Exception ex, boolean marshalling) {
if (ex instanceof XMLStreamValidationException) {
return new ValidationFailureException("XmlBeans validation exception", ex);
}
else if (ex instanceof XmlException || ex instanceof SAXException) {
if (marshalling) {
return new MarshallingFailureException("XMLBeans marshalling exception", ex);
}
else {
return new UnmarshallingFailureException("XMLBeans unmarshalling exception", ex);
}
}
else {
// fallback
return new UncategorizedMappingException("Unknown XMLBeans exception", ex);
}
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/xmlbeans/XmlBeansMarshallingFailureException.java 已删除 100644 → 0
浏览文件 @ 866ee115
/*
* Copyright 2005 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.oxm.xmlbeans;
import org.apache.xmlbeans.XmlException;
import org.xml.sax.SAXException;
import org.springframework.oxm.MarshallingFailureException;
/**
* XMLBeans-specific subclass of <code>MarshallingFailureException</code>.
*
* @author Arjen Poutsma
* @see XmlBeansUtils#convertXmlBeansException(Exception,boolean)
* @since 3.0
*/
public class XmlBeansMarshallingFailureException extends MarshallingFailureException {
public XmlBeansMarshallingFailureException(XmlException ex) {
super("XMLBeans marshalling exception: " + ex.getMessage(), ex);
}
public XmlBeansMarshallingFailureException(SAXException ex) {
super("XMLBeans marshalling exception: " + ex.getMessage(), ex);
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/xmlbeans/XmlBeansSystemException.java 已删除 100644 → 0
浏览文件 @ 866ee115
/*
* Copyright 2005 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.oxm.xmlbeans;
import org.springframework.oxm.UncategorizedXmlMappingException;
/**
* XMLBeans-specific subclass of <code>UncategorizedXmlMappingException</code>, for XMLBeans exceptions that cannot be
* distinguished further.
*
* @author Arjen Poutsma
* @since 3.0
*/
public class XmlBeansSystemException extends UncategorizedXmlMappingException {
public XmlBeansSystemException(Exception e) {
super(e.getMessage(), e);
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/xmlbeans/XmlBeansUnmarshallingFailureException.java 已删除 100644 → 0
浏览文件 @ 866ee115
/*
* Copyright 2005 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.oxm.xmlbeans;
import org.apache.xmlbeans.XmlException;
import org.xml.sax.SAXException;
import org.springframework.oxm.UnmarshallingFailureException;
/**
* XMLBeans-specific subclass of <code>UnmarshallingFailureException</code>.
*
* @author Arjen Poutsma
* @see XmlBeansUtils#convertXmlBeansException(Exception,boolean)
* @since 3.0
*/
public class XmlBeansUnmarshallingFailureException extends UnmarshallingFailureException {
public XmlBeansUnmarshallingFailureException(XmlException ex) {
super("XMLBeans unmarshalling exception: " + ex.getMessage(), ex);
}
public XmlBeansUnmarshallingFailureException(SAXException ex) {
super("XMLBeans unmarshalling exception: " + ex.getMessage(), ex);
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/xmlbeans/XmlBeansUtils.java 已删除 100644 → 0
浏览文件 @ 866ee115
/*
* Copyright 2005 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.oxm.xmlbeans;
import org.apache.xmlbeans.XMLStreamValidationException;
import org.apache.xmlbeans.XmlException;
import org.xml.sax.SAXException;
import org.springframework.oxm.XmlMappingException;
/**
* Generic utility methods for working with XMLBeans. Mainly for internal use within the framework.
*
* @author Arjen Poutsma
* @since 3.0
*/
public class XmlBeansUtils {
/**
* Converts the given XMLBeans exception to an appropriate exception from the <code>org.springframework.oxm</code>
* hierarchy. <p/> A boolean flag is used to indicate whether this exception occurs during marshalling or
* unmarshalling, since XMLBeans itself does not make this distinction in its exception hierarchy.
*
* @param ex XMLBeans Exception that occured
* @param marshalling indicates whether the exception occurs during marshalling (<code>true</code>), or unmarshalling
* (<code>false</code>)
* @return the corresponding <code>XmlMappingException</code>
*/
public static XmlMappingException convertXmlBeansException(Exception ex, boolean marshalling) {
if (ex instanceof XMLStreamValidationException) {
return new XmlBeansValidationFailureException((XMLStreamValidationException) ex);
}
else if (ex instanceof XmlException) {
XmlException xmlException = (XmlException) ex;
if (marshalling) {
return new XmlBeansMarshallingFailureException(xmlException);
}
else {
return new XmlBeansUnmarshallingFailureException(xmlException);
}
}
else if (ex instanceof SAXException) {
SAXException saxException = (SAXException) ex;
if (marshalling) {
return new XmlBeansMarshallingFailureException(saxException);
}
else {
return new XmlBeansUnmarshallingFailureException(saxException);
}
}
// fallback
return new XmlBeansSystemException(ex);
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/xmlbeans/XmlBeansValidationFailureException.java 已删除 100644 → 0
浏览文件 @ 866ee115
/*
* Copyright 2005 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.oxm.xmlbeans;
import org.apache.xmlbeans.XMLStreamValidationException;
import org.apache.xmlbeans.XmlException;
import org.springframework.oxm.ValidationFailureException;
/**
* XMLBeans-specific subclass of <code>ValidationFailureException</code>.
*
* @author Arjen Poutsma
* @see org.springframework.oxm.xmlbeans.XmlBeansUtils#convertXmlBeansException
* @since 3.0
*/
public class XmlBeansValidationFailureException extends ValidationFailureException {
public XmlBeansValidationFailureException(XMLStreamValidationException ex) {
super("XmlBeans validation exception: " + ex.getMessage(), ex);
}
public XmlBeansValidationFailureException(XmlException ex) {
super("XmlBeans validation exception: " + ex.getMessage(), ex);
}
}
org.springframework.oxm/src/main/java/org/springframework/oxm/xmlbeans/XmlOptionsFactoryBean.java
浏览文件 @ 555fa3b4
/*
* Copyright 2006 the original author or authors.
* 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.
......@@ -16,64 +16,58 @@
package org.springframework.oxm.xmlbeans;
import java.util.Iterator;
import java.util.Map;
import org.apache.xmlbeans.XmlOptions;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;
/**
* Factory bean that configures an XMLBeans <code>XmlOptions</code> object and provides it as a bean reference. <p/>
* Typical usage will be to set XMLBeans options on this bean, and refer to it in the <code>XmlBeansMarshaller</code>.
* {@link FactoryBean} that configures an XMLBeans <code>XmlOptions</code> object
* and provides it as a bean reference.
*
* <p>Typical usage will be to set XMLBeans options on this bean, and refer to it
* in the {@link XmlBeansMarshaller}.
*
* @author Arjen Poutsma
* @since 3.0
* @see XmlOptions
* @see #setOptions(java.util.Map)
* @see XmlBeansMarshaller#setXmlOptions(org.apache.xmlbeans.XmlOptions)
* @since 3.0
* @see XmlBeansMarshaller#setXmlOptions(XmlOptions)
*/
public class XmlOptionsFactoryBean implements FactoryBean, InitializingBean {
public class XmlOptionsFactoryBean implements FactoryBean<XmlOptions> {
private XmlOptions xmlOptions;
private Map options;
/** Returns the singleton <code>XmlOptions</code>. */
public Object getObject() throws Exception {
return xmlOptions;
/**
* Set options on the underlying <code>XmlOptions</code> object.
* <p>The keys of the supplied map should be one of the String constants
* defined in <code>XmlOptions</code>, the values vary per option.
* @see XmlOptions#put(Object,Object)
* @see XmlOptions#SAVE_PRETTY_PRINT
* @see XmlOptions#LOAD_STRIP_COMMENTS
*/
public void setOptions(Map<String, ?> optionsMap) {
this.xmlOptions = new XmlOptions();
if (optionsMap != null) {
for (String option : optionsMap.keySet()) {
this.xmlOptions.put(option, optionsMap.get(option));
}
}
}
/** Returns the class of <code>XmlOptions</code>. */
public Class getObjectType() {
public XmlOptions getObject() {
return this.xmlOptions;
}
public Class<? extends XmlOptions> getObjectType() {
return XmlOptions.class;
}
/** Returns <code>true</code>. */
public boolean isSingleton() {
return true;
}
/**
* Sets options on the underlying <code>XmlOptions</code> object. The keys of the supplied map should be one of the
* string constants defined in <code>XmlOptions</code>, the values vary per option.
*
* @see XmlOptions#put(Object,Object)
* @see XmlOptions#SAVE_PRETTY_PRINT
* @see XmlOptions#LOAD_STRIP_COMMENTS
*/
public void setOptions(Map options) {
this.options = options;
}
public void afterPropertiesSet() throws Exception {
xmlOptions = new XmlOptions();
if (options != null) {
for (Iterator iterator = options.keySet().iterator(); iterator.hasNext();) {
Object option = iterator.next();
xmlOptions.put(option, options.get(option));
}
}
}
}
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或