Java&Xml-Tutorial (6) Verwenden von JDOM zum Parsen von XML-Dateien

JDOM bietet eine hervorragende Java-XML-API zum bequemeren Lesen, Ändern und Generieren von XML-Dokumenten. JDOM bietet außerdem Wrapper-Klassen, mit denen Benutzer bestimmte Implementierungen aus SAX, DOM, STAX-Ereignisanalyse und STAX-Stream-Analyse auswählen können.

In diesem Tutorial lernen wir, JDOM zu verwenden, um XML-Dateiinformationen zu lesen und sie in Java-Objekte zu konvertieren.
JDOM ist nicht Teil des Standard-JDK. Um JDOM verwenden zu können, müssen Sie das JDOM-Binärpaket von der offiziellen Website herunterladen. Fügen Sie nach dem Herunterladen das JDOM-Jar-Paket zum Klassenpfad des Projekts hinzu.
JDOM stellt eine Wrapper-Klasse zur Verfügung, mit der wir die zugrunde liegende XML-Parsing-API auswählen können. Sie stellt vier wichtige Klassen bereit, die wir zum Abrufen des JDOM-Dokumentobjekts verwenden können. Das JDOM-Dokumentobjekt bietet sehr nützliche Methoden zum Abrufen des Stammelements, der Liste der untergeordneten Elemente, Attributwerte usw.
Wichtige Klassen von JDOM:
org.jdom2.input.DOMBuilder:Verwenden Sie den DOM-Parsing-Mechanismus, um XML zu analysieren und in ein JDOM-Dokumentobjekt zu konvertieren.
org.jdom2.input.SAXBuilder:Verwenden Sie den SAX-Parsing-Mechanismus, um XML zu analysieren und in ein JDOM-Dokument zu konvertieren. Die Funktionen von
org.jdom2.input.StAXEventBuilder und org.jdom2.input.StAXStreamBuilder ähneln den beiden vorherigen und werden nicht noch einmal beschrieben.
org.jdom2.DocumentDas JDOM-Dokumentobjekt bietet nützliche Methoden zum Abrufen des Stammelements, zum Lesen oder Ändern des Elementinhalts usw. Wir werden es verwenden, um das Stammelement von XML abzurufen.
org.jdom2.Document bietet nützliche Methoden zum Abrufen der Sammlung untergeordneter Elemente, zum Abrufen des Werts des untergeordneten Elements, zum Abrufen des Attributwerts und für andere Vorgänge.
Als nächstes beginnen wir mit dem Case-Programm, um die XML-Datei zu lesen und Java-Objekte zu generieren.
employees.xml

<?xml version="1.0" encoding="UTF-8"?><Employees>
    <Employee id="1">
        <age>29</age>
        <name>Pankaj</name>
        <gender>Male</gender>
        <role>Java Developer</role>
    </Employee>
    <Employee id="2">
        <age>35</age>
        <name>Lisa</name>
        <gender>Female</gender>
        <role>CEO</role>
    </Employee>
    <Employee id="3">
        <age>40</age>
        <name>Tom</name>
        <gender>Male</gender>
        <role>Manager</role>
    </Employee></Employees>

Diese XML-Datei speichert Mitarbeiterinformationen. Wir verwenden die Employee-Klasse, um Mitarbeiter darzustellen.

package com.journaldev.xml;public class Employee {
    private int id;    
    private String name;    
    private String gender;    
    private int age;    
    private String role;    
    public int getId() {        
    return id;
    }    public void setId(int id) {        
    this.id = id;
    }    public String getName() {        
    return name;
    }    public void setName(String name) {        
    this.name = name;
    }    public String getGender() {        
    return gender;
    }    public void setGender(String gender) {        
    this.gender = gender;
    }    public int getAge() {        
    return age;
    }    public void setAge(int age) {        
    this.age = age;
    }    public String getRole() {        
    return role;
    }    public void setRole(String role) {        
    this.role = role;
    }    @Override
    public String toString() {        
    return "Employee:: ID="+this.id+" Name=" + this.name + " Age=" + this.age + " Gender=" + this.gender + 
                   " Role=" + this.role;
    }

}

Verwenden Sie dann DOMBuilder im Testprogramm, um die XML-Datei zu lesen und eine Sammlung von Employee-Objekten zu generieren.
JDOMXMLReader.java

package com.journaldev.xml.jdom;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.DOMBuilder;
import org.jdom2.input.SAXBuilder;
import org.jdom2.input.StAXEventBuilder;
import org.jdom2.input.StAXStreamBuilder;
import org.w3c.dom.Document;
import org.xml.sax.SAXException;
import com.journaldev.xml.Employee;
public class JDOMXMLReader {

    public static void main(String[] args) {
        final String fileName = "/Users/pankaj/employees.xml";
        org.jdom2.Document jdomDoc;
        try {
            //we can create JDOM Document from DOM, SAX and STAX Parser Builder classes
            jdomDoc = useDOMParser(fileName);
            Element root = jdomDoc.getRootElement();
            List<Element> empListElements = root.getChildren("Employee");
            List<Employee> empList = new ArrayList<>();
            for (Element empElement : empListElements) {
                Employee emp = new Employee();
                emp.setId(Integer.parseInt(empElement.getAttributeValue("id")));
                emp.setAge(Integer.parseInt(empElement.getChildText("age")));
                emp.setName(empElement.getChildText("name"));
                emp.setRole(empElement.getChildText("role"));
                emp.setGender(empElement.getChildText("gender"));
                empList.add(emp);
            }
            //lets print Employees list information
            for (Employee emp : empList)
                System.out.println(emp);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }


    //Get JDOM document from DOM Parser
    private static org.jdom2.Document useDOMParser(String fileName)
            throws ParserConfigurationException, SAXException, IOException {
        //creating DOM Document
        DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder dBuilder;
        dBuilder = dbFactory.newDocumentBuilder();
        Document doc = dBuilder.parse(new File(fileName));
        DOMBuilder domBuilder = new DOMBuilder();
        return domBuilder.build(doc);

    }
}

Wie Sie sehen können, verwende ich hier die DOM-Parsing-Wrapper-Klasse, um das JDOM-Dokumentobjekt abzurufen.
Führen Sie die Programmausgabe aus:

Employee:: ID=1 Name=Pankaj Age=29 Gender=Male Role=Java DeveloperEmployee:: ID=2 
Name=Lisa Age=35 Gender=Female Role=CEOEmployee:: ID=3 Name=Tom Age=40 Gender=Male Role=Manager

Wir können auch die SAX- und STAX-Parsing-Mechanismen verwenden, um den Vorgang abzuschließen Das Programm erhält dasselbe. Die Ausgabe liegt daran, dass wir nur unterschiedliche Wrapper-Klassen verwenden, aber die erhaltenen JDOM-Dokumentobjekte sind dieselben.

Der Vorteil der Verwendung von JDOM besteht darin, dass wir den zugrunde liegenden Analysemechanismus problemlos wechseln können, ohne den Verarbeitungscode zu ändern.

/Get JDOM document from SAX Parserprivate static org.jdom2.Document useSAXParser(String fileName) throws JDOMException,
        IOException {
    SAXBuilder saxBuilder = new SAXBuilder();    
    return saxBuilder.build(new File(fileName));
}
//Get JDOM Document from STAX Stream Parser or STAX Event Parserprivate static org.jdom2.
Document useSTAXParser(String fileName, String type) throws FileNotFoundException, XMLStreamException, JDOMException{    
if(type.equalsIgnoreCase("stream")){
        StAXStreamBuilder staxBuilder = new StAXStreamBuilder();
        XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();
        XMLStreamReader xmlStreamReader = xmlInputFactory.createXMLStreamReader(new FileInputStream(fileName));        
        return staxBuilder.build(xmlStreamReader);
    }
    StAXEventBuilder staxBuilder = new StAXEventBuilder();
    XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();
    XMLEventReader xmlEventReader = xmlInputFactory.createXMLEventReader(new FileInputStream(fileName));    
    return staxBuilder.build(xmlEventReader);

}

JDOM bietet eine hervorragende Java-XML-API zum bequemeren Lesen, Ändern und Generieren von XML-Dokumenten. JDOM bietet außerdem Wrapper-Klassen, mit denen Benutzer bestimmte Implementierungen aus SAX, DOM, STAX-Ereignisanalyse und STAX-Stream-Analyse auswählen können.
In diesem Tutorial lernen wir, JDOM zum Lesen von XML-Dateiinformationen und zum Konvertieren in Java-Objekte zu verwenden.

JDOM ist nicht Teil des Standard-JDK. Um JDOM verwenden zu können, müssen Sie das JDOM-Binärpaket von der offiziellen Website herunterladen. Fügen Sie nach dem Herunterladen das JDOM-Jar-Paket zum Klassenpfad des Projekts hinzu.

JDOM stellt eine Wrapper-Klasse zur Verfügung, mit der wir die zugrunde liegende XML-Parsing-API auswählen können. Sie stellt vier wichtige Klassen bereit, die wir zum Abrufen des JDOM-Dokumentobjekts verwenden können. Das JDOM-Dokumentobjekt bietet sehr nützliche Methoden zum Abrufen des Stammelements, der Liste der untergeordneten Elemente, Attributwerte usw.
Wichtige Klassen von JDOM:

Verwenden Sie den DOM-Parsing-Mechanismus, um XML zu analysieren und in ein JDOM-Dokumentobjekt zu konvertieren.

Verwenden Sie den SAX-Parsing-Mechanismus, um XML zu analysieren und in ein JDOM-Dokument zu konvertieren. Die Funktionen von org.jdom2.input.DOMBuilder:
und org.jdom2.input.SAXBuilder: ähneln den beiden vorherigen und werden nicht noch einmal beschrieben.
org.jdom2.input.StAXEventBuilderDas JDOM-Dokumentobjekt bietet nützliche Methoden zum Abrufen des Stammelements, zum Lesen oder Ändern des Elementinhalts usw. Wir werden es verwenden, um das Stammelement von XML abzurufen. org.jdom2.input.StAXStreamBuilder
bietet nützliche Methoden zum Abrufen der Sammlung untergeordneter Elemente, zum Abrufen des Werts des untergeordneten Elements, zum Abrufen des Attributwerts und für andere Vorgänge. org.jdom2.DocumentAls nächstes beginnen wir mit dem Case-Programm, um die XML-Datei zu lesen und Java-Objekte zu generieren.
employees.xmlorg.jdom2.Document

Diese XML-Datei speichert Mitarbeiterinformationen. Wir verwenden die Employee-Klasse, um Mitarbeiter darzustellen.

<?xml version="1.0" encoding="UTF-8"?><Employees>
    <Employee id="1">
        <age>29</age>
        <name>Pankaj</name>
        <gender>Male</gender>
        <role>Java Developer</role>
    </Employee>
    <Employee id="2">
        <age>35</age>
        <name>Lisa</name>
        <gender>Female</gender>
        <role>CEO</role>
    </Employee>
    <Employee id="3">
        <age>40</age>
        <name>Tom</name>
        <gender>Male</gender>
        <role>Manager</role>
    </Employee></Employees>

Verwenden Sie dann DOMBuilder im Testprogramm, um die XML-Datei zu lesen und eine Sammlung von Employee-Objekten zu generieren.

JDOMXMLReader.java

package com.journaldev.xml;
public class Employee {
    private int id;    
    private String name;    
    private String gender;    
    private int age;    
    private String role;    
    public int getId() {        
    return id;
    }    public void setId(int id) {        
    this.id = id;
    }    public String getName() {        
    return name;
    }    public void setName(String name) {        
    this.name = name;
    }    public String getGender() {        
    return gender;
    }    public void setGender(String gender) {        
    this.gender = gender;
    }    public int getAge() {        
    return age;
    }    public void setAge(int age) {        
    this.age = age;
    }    public String getRole() {        
    return role;
    }    public void setRole(String role) {        
    this.role = role;
    }    @Override
    public String toString() {        
    return "Employee:: ID="+this.id+" Name=" + this.name + " Age=" + this.age + " Gender=" + this.gender + 
                   " Role=" + this.role;
    }

}

Wie Sie sehen können, verwende ich hier die DOM-Parsing-Wrapper-Klasse, um das JDOM-Dokumentobjekt abzurufen.

Führen Sie die Programmausgabe aus:

package com.journaldev.xml.jdom;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;import java.util.ArrayList;
import java.util.List;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import org.jdom2.Element;import org.jdom2.JDOMException;
import org.jdom2.input.DOMBuilder;
import org.jdom2.input.SAXBuilder;
import org.jdom2.input.StAXEventBuilder;
import org.jdom2.input.StAXStreamBuilder;
import org.w3c.dom.Document;
import org.xml.sax.SAXException;
import com.journaldev.xml.Employee;
public class JDOMXMLReader {

    public static void main(String[] args) {
        final String fileName = "/Users/pankaj/employees.xml";
        org.jdom2.Document jdomDoc;
        try {
            //we can create JDOM Document from DOM, SAX and STAX Parser Builder classes
            jdomDoc = useDOMParser(fileName);
            Element root = jdomDoc.getRootElement();
            List<Element> empListElements = root.getChildren("Employee");
            List<Employee> empList = new ArrayList<>();
            for (Element empElement : empListElements) {
                Employee emp = new Employee();
                emp.setId(Integer.parseInt(empElement.getAttributeValue("id")));
                emp.setAge(Integer.parseInt(empElement.getChildText("age")));
                emp.setName(empElement.getChildText("name"));
                emp.setRole(empElement.getChildText("role"));
                emp.setGender(empElement.getChildText("gender"));
                empList.add(emp);
            }
            //lets print Employees list information
            for (Employee emp : empList)
                System.out.println(emp);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }


    //Get JDOM document from DOM Parser
    private static org.jdom2.Document useDOMParser(String fileName)
            throws ParserConfigurationException, SAXException, IOException {
        //creating DOM Document
        DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder dBuilder;
        dBuilder = dbFactory.newDocumentBuilder();
        Document doc = dBuilder.parse(new File(fileName));
        DOMBuilder domBuilder = new DOMBuilder();
        return domBuilder.build(doc);

    }
}

Wir können auch die SAX- und STAX-Parsing-Mechanismen verwenden, um den Vorgang abzuschließen Das Programm erhält dasselbe. Die Ausgabe liegt daran, dass wir nur unterschiedliche Wrapper-Klassen verwenden, die erhaltenen JDOM-Dokumentobjekte jedoch gleich sind.

Der Vorteil der Verwendung von JDOM besteht darin, dass wir den zugrunde liegenden Analysemechanismus problemlos wechseln können, ohne den Verarbeitungscode zu ändern.

Employee:: ID=1 Name=Pankaj Age=29 Gender=Male Role=Java DeveloperEmployee:: 
ID=2 Name=Lisa Age=35 Gender=Female Role=CEOEmployee:: ID=3 Name=Tom Age=40 Gender=Male Role=Manager

Das Obige ist der Inhalt des Java&Xml-Tutorials (6) mit JDOM zum Parsen von XML-Dateien. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!

/Get JDOM document from SAX Parserprivate static org.jdom2.Document useSAXParser(String fileName) throws JDOMException,
        IOException {
    SAXBuilder saxBuilder = new SAXBuilder();    return saxBuilder.build(new File(fileName));
}
//Get JDOM Document from STAX Stream Parser or STAX Event Parserprivate static org.jdom2.Document 
useSTAXParser(String fileName, String type) throws FileNotFoundException, XMLStreamException, JDOMException{    
if(type.equalsIgnoreCase("stream")){
        StAXStreamBuilder staxBuilder = new StAXStreamBuilder();
        XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();
        XMLStreamReader xmlStreamReader = xmlInputFactory.createXMLStreamReader(new FileInputStream(fileName));        
        return staxBuilder.build(xmlStreamReader);
    }
    StAXEventBuilder staxBuilder = new StAXEventBuilder();
    XMLInputFactory xmlInputFactory = XMLInputFactory.newInstance();
    XMLEventReader xmlEventReader = xmlInputFactory.createXMLEventReader(new FileInputStream(fileName));    
    return staxBuilder.build(xmlEventReader);

}