Java Language
XOM - XML-objectmodel

Een XML-bestand lezen

Om de XML-gegevens met XOM te laden, moet u een Builder van waaruit u deze in een Document kunt inbouwen.

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

Om het root-element te krijgen, het hoogste bovenliggende element in het xml-bestand, moet u getRootElement() in de Document instantie.

Element root = doc.getRootElement();

Nu heeft de Element-klasse veel handige methoden die het lezen van XML erg eenvoudig maken. Enkele van de meest bruikbare zijn hieronder opgesomd:

• getChildElements(String name) - retourneert een instantie Elements die fungeert als een array van elementen
• getFirstChildElement(String name) - retourneert het eerste onderliggende element met die tag.
• getValue() - retourneert de waarde binnen het element.
• getAttributeValue(String name) - retourneert de waarde van een kenmerk met de opgegeven naam.

Wanneer u getChildElements() krijgt u een instantie Elements . Hieruit kun je doorlussen en de methode get(int index) gebruiken om alle elementen binnenin op te halen.

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

Voorbeeld: hier is een voorbeeld van het lezen van een XML-bestand:

XML-bestand:

Code voor het lezen en afdrukken:

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

Dit wordt afgedrukt in de console:

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

Schrijven naar een XML-bestand

Schrijven naar een XML-bestand met behulp van XOM lijkt erg op het lezen ervan, behalve in dit geval maken we de instanties in plaats van ze uit de root te halen.

Gebruik de constructor Element(String name) om een nieuw element te maken. U wilt een root-element maken zodat u het eenvoudig aan een Document kunt toevoegen.

Element root = new Element("root");

De klasse Element heeft enkele handige methoden voor het bewerken van elementen. Ze worden hieronder vermeld:

• appendChild(String name) - hiermee wordt in principe de waarde van het element ingesteld op naam.
• appendChild(Node node) - dit maakt node de elementen ouder. (Elementen zijn knooppunten zodat u elementen kunt parseren).
• addAttribute(Attribute attribute) - voegt een attribuut toe aan het element.

De klasse Attribute heeft een aantal verschillende constructors. De eenvoudigste is Attribute(String name, String value) .

Als je al je elementen aan je root-element hebt toegevoegd, kun je er een Document . Document neemt een Element als argument in zijn constructor.

U kunt een Serializer gebruiken om uw XML naar een bestand te schrijven. U moet een nieuwe uitvoerstroom maken om te parseren in de constructor van Serializer .

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

Voorbeeld

Code:

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; }
    }
    
}

Dit is de inhoud van "out.xml":