org.dom4j.jaxb.JAXBReader Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of dom4j Show documentation
Show all versions of dom4j Show documentation
flexible XML framework for Java
/*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.jaxb;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.URL;
import java.nio.charset.Charset;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.ElementHandler;
import org.dom4j.ElementPath;
import org.dom4j.io.SAXReader;
import org.xml.sax.InputSource;
/**
* Reads an XML document and creates a DOM4J tree from SAX parsing events.
* {@link JAXBObjectHandler}objects can be registered to automatically receive
* unmarshalled XML fragments. Registered {@link org.dom4j.ElementHandler}
* implementations are notified when a certain element path is encountered
*
* @author Wonne Keysers (Realsoftware.be)
*
* @see org.dom4j.io.SAXReader
* @see javax.xml.bind.JAXBContext
*/
public class JAXBReader extends JAXBSupport {
private SAXReader reader;
private boolean pruneElements;
/**
* Creates a new JAXBReader for the given JAXB context path. This is the
* Java package where JAXB can find the generated XML classes. This package
* MUST contain jaxb.properties!
*
* @param contextPath
* context path to be used
*
* @see javax.xml.bind.JAXBContext
*/
public JAXBReader(String contextPath) {
super(contextPath);
}
/**
* Creates a new JAXBReader for the given JAXB context path, using the
* specified {@link java.lang.ClassLoader}. This is the Java package where
* JAXB can find the generated XML classes. This package MUST contain
* jaxb.properties!
*
* @param contextPath
* to be used
* @param classloader
* to be used
*
* @see javax.xml.bind.JAXBContext
*/
public JAXBReader(String contextPath, ClassLoader classloader) {
super(contextPath, classloader);
}
/**
* Parses the specified {@link java.io.File}
*
* @param source
* the file to parse
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
*/
public Document read(File source) throws DocumentException {
return getReader().read(source);
}
/**
* Parses the specified {@link java.io.File}, using the given {@link
* java.nio.charset.Charset}.
*
* @param file
* the file to parse
* @param charset
* the charset to be used
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
*/
public Document read(File file, Charset charset) throws DocumentException {
try {
Reader xmlReader = new InputStreamReader(new FileInputStream(file),
charset);
return getReader().read(xmlReader);
} catch (JAXBRuntimeException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
} catch (FileNotFoundException ex) {
throw new DocumentException(ex.getMessage(), ex);
}
}
/**
* Parses the specified {@link org.xml.sax.InputSource}
*
* @param source
* the source to parse
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
*/
public Document read(InputSource source) throws DocumentException {
try {
return getReader().read(source);
} catch (JAXBRuntimeException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Parses the specified {@link java.io.InputStream}
*
* @param source
* the input stream to parse
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
*/
public Document read(InputStream source) throws DocumentException {
try {
return getReader().read(source);
} catch (JAXBRuntimeException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Parses the specified {@link java.io.InputStream}
*
* @param source
* the input stream to parse
* @param systemId
* is the URI for the input
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
*/
public Document read(InputStream source, String systemId)
throws DocumentException {
try {
return getReader().read(source);
} catch (JAXBRuntimeException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Parses the specified {@link java.io.Reader}
*
* @param source
* the input reader to use
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
*/
public Document read(Reader source) throws DocumentException {
try {
return getReader().read(source);
} catch (JAXBRuntimeException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Parses the specified {@link java.io.Reader}
*
* @param source
* the input reader to parse
* @param systemId
* is the URI for the input
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
*/
public Document read(Reader source, String systemId)
throws DocumentException {
try {
return getReader().read(source);
} catch (JAXBRuntimeException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Parses the the given URL or filename.
*
* @param source
* the location to parse
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
*/
public Document read(String source) throws DocumentException {
try {
return getReader().read(source);
} catch (JAXBRuntimeException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Parses the the given URL.
*
* @param source
* the URL to parse
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
*/
public Document read(URL source) throws DocumentException {
try {
return getReader().read(source);
} catch (JAXBRuntimeException ex) {
Throwable cause = ex.getCause();
throw new DocumentException(cause.getMessage(), cause);
}
}
/**
* Registers a {@link JAXBObjectHandler}that will be supplied with the
* unmarshalled representation of the xml fragment whenever the specified
* path is encounted.
*
* @param path
* the path to listen for
* @param handler
* the handler to be notified
*/
public void addObjectHandler(String path, JAXBObjectHandler handler) {
ElementHandler eHandler = new UnmarshalElementHandler(this, handler);
getReader().addHandler(path, eHandler);
}
/**
* Removes the {@link JAXBObjectHandler}from the event based processor, for
* the specified element path.
*
* @param path
* The path to remove the {@link JAXBObjectHandler}for
*/
public void removeObjectHandler(String path) {
getReader().removeHandler(path);
}
/**
* Adds the ElementHandler
to be called when the specified
* path is encounted.
*
* @param path
* is the path to be handled
* @param handler
* is the ElementHandler
to be called by the event
* based processor.
*/
public void addHandler(String path, ElementHandler handler) {
getReader().addHandler(path, handler);
}
/**
* Removes the ElementHandler
from the event based processor,
* for the specified path.
*
* @param path
* is the path to remove the ElementHandler
for.
*/
public void removeHandler(String path) {
getReader().removeHandler(path);
}
/**
* Removes all registered {@link JAXBObjectHandler}and {@link
* org.dom4j.ElementHandler} instances from the event based processor.
*/
public void resetHandlers() {
getReader().resetHandlers();
}
/**
* When 'true', the DOM4J document will not be kept in memory while parsing.
*
* @return Returns the pruneElements.
*/
public boolean isPruneElements() {
return pruneElements;
}
/**
* Set to true when DOM4J elements must immediately be pruned from the tree.
* The {@link Document}will not be available afterwards!
*
* @param pruneElements DOCUMENT ME!
*/
public void setPruneElements(boolean pruneElements) {
this.pruneElements = pruneElements;
if (pruneElements) {
getReader().setDefaultHandler(new PruningElementHandler());
}
}
private SAXReader getReader() {
if (reader == null) {
reader = new SAXReader();
}
return reader;
}
private class UnmarshalElementHandler implements ElementHandler {
private JAXBReader jaxbReader;
private JAXBObjectHandler handler;
public UnmarshalElementHandler(JAXBReader documentReader,
JAXBObjectHandler handler) {
this.jaxbReader = documentReader;
this.handler = handler;
}
public void onStart(ElementPath elementPath) {
}
public void onEnd(ElementPath elementPath) {
try {
org.dom4j.Element elem = elementPath.getCurrent();
javax.xml.bind.Element jaxbObject
= (javax.xml.bind.Element) jaxbReader.unmarshal(elem);
if (jaxbReader.isPruneElements()) {
elem.detach();
}
handler.handleObject(jaxbObject);
} catch (Exception ex) {
throw new JAXBRuntimeException(ex);
}
}
}
private class PruningElementHandler implements ElementHandler {
public PruningElementHandler() {
}
public void onStart(ElementPath parm1) {
}
public void onEnd(ElementPath elementPath) {
Element elem = elementPath.getCurrent();
elem.detach();
elem = null;
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* 3. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact [email protected].
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL METASTUFF, LTD. OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/
© 2015 - 2025 Weber Informatics LLC | Privacy Policy