Java Language
XOM - XML-Objektmodell

Eine XML-Datei lesen

Um die XML-Daten mit XOM zu laden, müssen Sie einen Builder erstellen, aus dem Sie sie in ein Document erstellen können.

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

Um das getRootElement() , das höchste übergeordnete Element in der XML-Datei, zu erhalten, müssen Sie das getRootElement() für die Document Instanz verwenden.

Element root = doc.getRootElement();

Die Element-Klasse verfügt jetzt über viele praktische Methoden, die das Lesen von XML sehr einfach machen. Einige der nützlichsten sind unten aufgeführt:

• getChildElements(String name) - gibt eine Elements Instanz zurück, die als Array von Elementen fungiert
• getFirstChildElement(String name) - gibt das erste getFirstChildElement(String name) Element mit diesem Tag zurück.
• getValue() - gibt den Wert innerhalb des Elements zurück.
• getAttributeValue(String name) - gibt den Wert eines Attributs mit dem angegebenen Namen zurück.

Wenn Sie getChildElements() aufrufen, getChildElements() Sie eine Elements Instanz. Von hier aus können Sie die Methode get(int index) durchlaufen und aufrufen, get(int index) alle darin enthaltenen Elemente abzurufen.

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

Beispiel: Hier ist ein Beispiel zum Lesen einer XML-Datei:

XML-Datei:

Code zum Lesen und Ausdrucken:

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

Dies wird in der Konsole ausgedruckt:

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

In eine XML-Datei schreiben

Das Schreiben in eine XML-Datei mit XOM ist dem Lesen sehr ähnlich. In diesem Fall erstellen wir die Instanzen, anstatt sie vom Stammverzeichnis abzurufen.

Um ein neues Element zu erstellen, verwenden Sie den Konstruktor Element(String name) . Sie möchten ein Wurzelelement erstellen, damit Sie es einfach zu einem Document hinzufügen können.

Element root = new Element("root");

Die Element Klasse verfügt über einige praktische Methoden zum Bearbeiten von Elementen. Sie sind unten aufgeführt:

• appendChild(String name) - Dies setzt den Wert des Elements grundsätzlich auf name.
• appendChild(Node node) - Dies macht node zum übergeordneten Element. (Elemente sind Knoten, damit Sie Elemente analysieren können).
• addAttribute(Attribute attribute) - fügt dem Element ein Attribut hinzu.

Die Attribute Klasse verfügt über verschiedene Konstruktoren. Das einfachste ist Attribute(String name, String value) .

Wenn Sie alle Elemente zu Ihrem Stammelement hinzugefügt haben, können Sie es in ein Document . Document ein Element als Argument in seinem Konstruktor.

Sie können einen Serializer , um Ihr XML in eine Datei zu schreiben. Sie müssen einen neuen Ausgabestrom erstellen, um im Konstruktor von Serializer zu analysieren.

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

Beispiel

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

Dies wird der Inhalt von "out.xml" sein: