Java Language
XOM - Modelo de objetos XML

Leyendo un archivo XML

Para cargar los datos XML con XOM , tendrá que crear un Builder desde el cual puede construirlo en un Document .

Builder builder = new Builder();
Document doc = builder.build(file);

Para obtener el elemento raíz, el padre primario más alto en el archivo xml, necesita usar getRootElement() en la instancia del Document .

Element root = doc.getRootElement();

Ahora, la clase Element tiene muchos métodos prácticos que hacen que la lectura de xml sea realmente fácil. Algunos de los más útiles se enumeran a continuación:

• getChildElements(String name) : devuelve una instancia de Elements que actúa como una matriz de elementos
• getFirstChildElement(String name) : devuelve el primer elemento secundario con esa etiqueta.
• getValue() : devuelve el valor dentro del elemento.
• getAttributeValue(String name) : devuelve el valor de un atributo con el nombre especificado.

Cuando llama a getChildElements() obtiene una instancia de Elements . A partir de esto, puede recorrer y llamar al método get(int index) para recuperar todos los elementos que contiene.

Elements colors = root.getChildElements("color");
for (int q = 0; q < colors.size(); q++){
    Element color = colors.get(q);
}

Ejemplo: Aquí hay un ejemplo de leer un archivo XML:

Archivo XML:

Código para leerlo e imprimirlo:

import java.io.File;
import java.io.IOException;
import nu.xom.Builder;
import nu.xom.Document;
import nu.xom.Element;
import nu.xom.Elements;
import nu.xom.ParsingException;

public class XMLReader {
    
    public static void main(String[] args) throws ParsingException, IOException{
        File file = new File("insert path here");
        // builder builds xml data
        Builder builder = new Builder();
        Document doc = builder.build(file);
        
        // get the root element <example>
        Element root = doc.getRootElement();
        
        // gets all element with tag <person>
        Elements people = root.getChildElements("person");
        
        for (int q = 0; q < people.size(); q++){
            // get the current person element
            Element person = people.get(q);
            
            // get the name element and its children: first and last
            Element nameElement = person.getFirstChildElement("name");
            Element firstNameElement = nameElement.getFirstChildElement("first");
            Element lastNameElement = nameElement.getFirstChildElement("last");
            
            // get the age element
            Element ageElement = person.getFirstChildElement("age");
            
            // get the favorite color element
            Element favColorElement = person.getFirstChildElement("fav_color");
            
            String fName, lName, ageUnit, favColor;
            int age;
            
            try {
                fName = firstNameElement.getValue();
                lName = lastNameElement.getValue();
                age = Integer.parseInt(ageElement.getValue());
                ageUnit = ageElement.getAttributeValue("unit");
                favColor = favColorElement.getValue();
                
                System.out.println("Name: " + lName + ", " + fName);
                System.out.println("Age: " + age + " (" + ageUnit + ")");
                System.out.println("Favorite Color: " + favColor);
                System.out.println("----------------");
                
            } catch (NullPointerException ex){
                ex.printStackTrace();
            } catch (NumberFormatException ex){
                ex.printStackTrace();
            }
        }
    }
    
}

Esto se imprimirá en la consola:

Name: Smith, Dan
Age: 23 (years)
Favorite Color: green
----------------
Name: Autry, Bob
Age: 3 (months)
Favorite Color: N/A
----------------

Escribir en un archivo XML

Escribir en un archivo XML utilizando XOM es muy similar a leerlo, excepto que en este caso estamos creando instancias en lugar de recuperarlas de la raíz.

Para hacer un nuevo elemento use el Element(String name) constructor Element(String name) . Querrá crear un elemento raíz para poder agregarlo fácilmente a un Document .

Element root = new Element("root");

La clase Element tiene algunos métodos prácticos para editar elementos. Se enumeran a continuación:

• appendChild(String name) - esto básicamente establecerá el valor del elemento a nombre.
• appendChild(Node node) : esto hará que el node el elemento principal. (Los elementos son nodos para que pueda analizar elementos).
• addAttribute(Attribute attribute) : agregará un atributo al elemento.

La clase Attribute tiene un par de constructores diferentes. El más simple es el Attribute(String name, String value) .

Una vez que haya agregado todos sus elementos a su elemento raíz, puede convertirlo en un Document . Document tomará un Element como argumento en su constructor.

Puede usar un Serializer para escribir su XML en un archivo. Deberá crear un nuevo flujo de salida para analizar en el constructor de Serializer .

FileOutputStream fileOutputStream = new FileOutputStream(file);
Serializer serializer = new Serializer(fileOutputStream, "UTF-8");
serializer.setIndent(4);
serializer.write(doc);

Ejemplo

Código:

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import nu.xom.Attribute;
import nu.xom.Builder;
import nu.xom.Document;
import nu.xom.Element;
import nu.xom.Elements;
import nu.xom.ParsingException;
import nu.xom.Serializer;

public class XMLWriter{
    
    public static void main(String[] args) throws UnsupportedEncodingException, 
            IOException{
        // root element <example>
        Element root = new Element("example");
        
        // make a array of people to store
        Person[] people = {new Person("Smith", "Dan", "years", "green", 23), 
            new Person("Autry", "Bob", "months", "N/A", 3)};
        
        // add all the people
        for (Person person : people){
            
            // make the main person element <person>
            Element personElement = new Element("person");
            
            // make the name element and it's children: first and last
            Element nameElement = new Element("name");
            Element firstNameElement = new Element("first");
            Element lastNameElement = new Element("last");
            
            // make age element
            Element ageElement = new Element("age");
            
            // make favorite color element
            Element favColorElement = new Element("fav_color");
            
            // add value to names
            firstNameElement.appendChild(person.getFirstName());
            lastNameElement.appendChild(person.getLastName());
            
            // add names to name
            nameElement.appendChild(firstNameElement);
            nameElement.appendChild(lastNameElement);
            
            // add value to age
            ageElement.appendChild(String.valueOf(person.getAge()));
            
            // add unit attribute to age
            ageElement.addAttribute(new Attribute("unit", person.getAgeUnit()));
            
            // add value to favColor
            favColorElement.appendChild(person.getFavoriteColor());
            
            // add all contents to person
            personElement.appendChild(nameElement);
            personElement.appendChild(ageElement);
            personElement.appendChild(favColorElement);
            
            // add person to root
            root.appendChild(personElement);
        }
        
        // create doc off of root
        Document doc = new Document(root);
        
        // the file it will be stored in
        File file = new File("out.xml");
        if (!file.exists()){
            file.createNewFile();
        }
        
        // get a file output stream ready
        FileOutputStream fileOutputStream = new FileOutputStream(file);
        
        // use the serializer class to write it all
        Serializer serializer = new Serializer(fileOutputStream, "UTF-8");
        serializer.setIndent(4);
        serializer.write(doc);
    }

    private static class Person {

        private String lName, fName, ageUnit, favColor;
        private int age;

        public Person(String lName, String fName, String ageUnit, String favColor, int age){
            this.lName = lName;
            this.fName = fName;
            this.age = age;
            this.ageUnit = ageUnit;
            this.favColor = favColor;
        }

        public String getLastName() { return lName; }
        public String getFirstName() { return fName; }
        public String getAgeUnit() { return ageUnit; }
        public String getFavoriteColor() { return favColor; }
        public int getAge() { return age; }
    }
    
}

Este será el contenido de "out.xml":