style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">

Leer XML

Esta clase la escribí alguna vez cuando tenia la necesidad de leer documentos XML. No es mas que una clase obtiene la información del archivo dados byte[], InputStream o el org.w3c.dom.Document

Para guardar o leer el XML recomiendo utilzar este codigo que escribi para que complementara la tarea. Tambien pueden ponerle la carga directa según el API que utilicen

Por cierto, utilicé directamente org.w3c.dom.Document para que puedan usarlo con cualquier framework, fnalmente creo que todos tienen soporte para cargar el árbol desde el Document

package doo.daba.java.util.xml;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.*;
import org.w3c.dom.Document;
import org.xml.sax.SAXException;

/**
 * <p>
 * Esta clase facilita la lectura de documentos XML
 * </p>
 *
 * @author  Gerardo Aquino
 * @since  12/01/2008, 03:20:56 AM
 */

public final class XmlReader {

        /**
         * Almacena la representacion binarya del archivo XML
         */

        private byte[] byteXml;
        /**
         * Encapsula la informacion y estructura del archivo XML
         */

        private Document xmlDocument;
        /**
         * Indica si se ha producido un herror en el sistema
         */

        private boolean error;
        /*
         * Indica el mensaje de error sucedido
         */

        private String errorMessage;

        /**
         * <p>
         * Metodo contructor de la clase que recibe como parametro un arreglo de tipo {@code byte} que
         * representa el archivo XML del cual se extraen los datos. Los datos extraidos son almacenados
         * en la propiedad de clase {@link #xmlDocument}
         * </p>
         *
         * <p>
         * Este metodo contructor debe recibir un arreglo de tipo {@code byte} de un documento XML bien
         * formado y con na codificacion de UTF-8 asi como la correcta representacion del charset para
         * garantizar su correcta lectura
         * </p>
         *
         * @param byteXml       Arreglo de tipo {@code byte} que almacena el contenido del archivo XML del
         *                                      cual se extrae la informacion.
         */

        public XmlReader(byte[] byteXml) {
                setByteXml(byteXml);
        }

        /**
         * Metodo construcotr que recibe un objeto de tipo {@code InputStream} el cual define el flujo de paso
         * byte
         *
         * @param documentoXml
         *
         * @throws ParserConfigurationException
         * @throws SAXException
         * @throws IOException
         *
         * @see java.io.InputStream
         */

        public XmlReader(InputStream archivoXml)
                        throws
                        ParserConfigurationException,
                        SAXException,
                        IOException {

                DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
                DocumentBuilder builder = factory.newDocumentBuilder();

                this.byteXml = new byte[archivoXml.available()];
                archivoXml.read(this.byteXml);

                this.xmlDocument = builder.parse(new ByteArrayInputStream(this.byteXml));

        }

        /**
         * <p>
         * Metodo constructor que recibe un objeto {@code Document} en e que se encapsula el contenido
         * y estructura del archivo XML a procesar. Este metodo obtiene los bytes del archivo y los
         * almacena en la propiedad de clase {@link #byteXml}
         * </p>
         *
         * @param documentXml   Objeto de tipo {link Document} que encapsula la estructura e informacion
         *                                              del archivo XML
         */

        public XmlReader(final Document documentXml) {
                setDocumentXml(documentXml);
        }

        /**
         * <p>
         * Metodo contructor que obtiene la estructura y contenido de un almacenado en disco duro.
         * Este metodo obtiene la estructura y bytes del archivo y los almacena en las propiedades de
         * clase {@link #byteXml} y {@link #documentXml} respectivamente
         * </p>
         *
         * @param fileXml
         */

        public XmlReader(final File fileXml) {
                try {
                        readFromFile(fileXml);
                } catch (Exception e) {
                        this.error = true;
                        this.errorMessage = e.getMessage();
                }
        }

        /**
         * Metodo qe inicializa las propiedades de la clase para permitir el procesamiento de un nuevo
         * archivo XML
         */

        private void init() {
                this.byteXml = null;
                this.xmlDocument = null;
                this.errorMessage = null;
                this.error = false;
        }

        /**
         * <p>
         * Metodo que permite cargar el contenido de un archivo XML representado por su arrego de bytes
         * en el que se almacena su contenido binario.
         * </p>
         *
         * @throws SAXException
         * @throws ParserConfigurationException
         * @throws IOException
         */

        private void readFromByte()
                        throws SAXException,
                                   ParserConfigurationException,
                                   IOException {

                ByteArrayInputStream bais = new ByteArrayInputStream(byteXml);
                DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
                DocumentBuilder db = dbf.newDocumentBuilder();
                xmlDocument = db.parse(bais);
        }

        /**
         * <p>
         * Obtiene la informacion de un archivo XML representado por el objeto de tipo {@code Docment}
         * </p>
         *
         * @throws TransformerConfigurationException
         * @throws TransformerException
         */

        private void readFromDocumet()
                        throws TransformerConfigurationException,
                                   TransformerException {

                TransformerFactory tranFactory = TransformerFactory.newInstance();
                Transformer aTransformer = tranFactory.newTransformer();
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                Source src = new DOMSource(xmlDocument);
                Result dest = new StreamResult(baos);
                aTransformer.transform(src, dest);

                byteXml = baos.toByteArray();
        }

        /**
         * <p>
         * Obtiene la informacion y estructura de un archivo almacenado en disco duro. la informacion
         * extraida del archivo es almacenada en las variables miembro de la clase
         * </p>
         * @param fileXml       Objeto que encapsula la informacion del archivo que debe leerse
         *
         * @throws IOException
         * @throws ParserConfigurationException
         * @throws SAXException
         */

        private void readFromFile(final File fileXml)
                        throws IOException,
                                   ParserConfigurationException,
                                   SAXException {

                FileInputStream fin = new FileInputStream(fileXml);
                byteXml = new byte[(int) fileXml.length()];
                fin.read(byteXml);

                readFromByte();
        }

        public void writeToFile(File f) throws TransformerConfigurationException, TransformerException {
                TransformerFactory transformerFactory = TransformerFactory.newInstance();
                Transformer transformer = transformerFactory.newTransformer();
                DOMSource source = new DOMSource(xmlDocument);
                StreamResult result = new StreamResult(f);
                transformer.transform(source, result);
        }

        /**
         * <p>
         * Este metdo de acceso a la variable miembro byteXml permite el procesamiento de un nuevo
         * archivo XML mediante la representacion de un arreglo de bytes. Este metodo es lo mismo que
         * invocar al metodo contructor {@link #XmlReader(byte[])} con la ventaja deutilizarla misma
         * instancia de esa clase.
         * </p>
         *
         * @param byteXml       Archivo XML representado por un arreglo de {@code byte}
         */

        public void setByteXml(byte[] byteXml) {
                init();
                this.byteXml = byteXml;
                try {
                        readFromByte();
                } catch (Exception e) {
                        setError(e);
                }
        }

        /**
         * <p>
         * Este metdo de acceso a la variable miembro byteXml permite el procesamiento de un nuevo
         * archivo XML mediante la representacion del objeto {@code Document}. Este metodo es lo mismo
         * que invocar al metodo contructor {@link #XmlReader(org.w3c.dom.Document)} con la ventaja
         * deutilizarla misma instancia de esa clase.
         * </p>
         *
         * @param documentXml   Objeto que encapsulala informacion y estructura del archivo XML
         */

        public void setDocumentXml(Document documentXml) {
                init();
                this.xmlDocument = documentXml;
                try {
                        readFromDocumet();
                } catch (Exception e) {
                        setError(e);
                }
        }

        /**
         * Establece as acciones quedeben realizarse al presentarse un error en e procesamiento del
         * archivo XML
         *
         * @param t     Superclase de Exception que engloba cualquier causa de error
         */

        private void setError(Throwable t) {
                this.error = true;
                this.errorMessage = t.getMessage();
        }

        public boolean isError() {
                return error || xmlDocument == null || byteXml == null;
        }

        public void setError(boolean error) {
                this.error = error;
        }

        public String getErrorMessage() {
                return errorMessage;
        }

        public byte[] getByteXml() {
                return byteXml;
        }

        public Document getDocumentXml() {
                return xmlDocument;
        }

}

Comentarios

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Imagen de Algus Dark

Muy bueno.

Gracias, me ha servido tu código para re-estructurar algunas partes del mío. Se agradece mucho el aporte y la buena documentación que me ha hecho entender a la perfección.

Excelente

Por Dios!, qué buen nivel tienen los hermanos Mexicanos.

Les juro que me siento insignificante con mis conocimientos de Java.

Saludos!

style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">