Welche Möglichkeiten gibt es, XML in Java zu analysieren?

Zu den Methoden, mit denen Java XML analysiert, gehört die Verwendung von DOM-Parsing, um sie in einer Baumstruktur über DOM-Objekte zu verbinden; die Verwendung von SAX, um es Zeile für Zeile zu analysieren, wenn auf verschiedene Elemente gestoßen wird; Extrahieren Sie die erforderlichen Daten aus

XML ist ein universelles Datenaustauschformat. Seine Plattformunabhängigkeit, Sprachunabhängigkeit und Systemunabhängigkeit sorgen für großen Komfort bei der Datenintegration und -interaktion. Als nächstes werde ich im Artikel die Methode zum Parsen von XML in Java ausführlich vorstellen, die hoffentlich für alle hilfreich ist

[Empfohlener Kurs: XML-Tutorial]

DOM-Parsing verwenden

DOM-Parser Wird hauptsächlich verwendet, um XML als Objektdiagramm (Baumstruktur) im Speicher zu verwenden, bei dem es sich um das Document Object Model (DOM) handelt. Zuerst durchläuft der Parser die XML-Eingabedatei und erstellt DOM-Objekte, die den Knoten in der XML-Datei entsprechen. Diese DOM-Objekte sind in einer Baumstruktur miteinander verknüpft. Sobald der Parser den Analysevorgang abgeschlossen hat, erhält er diese baumartige DOM-Objektstruktur.

Beispiel: XML-Inhalt in allen Codebeispielen analysieren

public class DOMParserDemo {
 
  public static void main(String[] args) throws Exception {
    DocumentBuilderFactory factory =
        DocumentBuilderFactory.newInstance();
    DocumentBuilder builder = factory.newDocumentBuilder();
    Document document =
      builder.parse(
        ClassLoader.getSystemResourceAsStream("xml/employee.xml"));
    List<Employee> empList = new ArrayList<>();
    NodeList nodeList = document.getDocumentElement().getChildNodes();
    for (int i = 0; i < nodeList.getLength(); i++) {
      Node node = nodeList.item(i);
      if (node instanceof Element) {
        Employee emp = new Employee();
        emp.id = node.getAttributes().
            getNamedItem("id").getNodeValue();
        NodeList childNodes = node.getChildNodes();
        for (int j = 0; j < childNodes.getLength(); j++) {
          Node cNode = childNodes.item(j);
          if (cNode instanceof Element) {
            String content = cNode.getLastChild().
                getTextContent().trim();
            switch (cNode.getNodeName()) {
              case "firstName":
                emp.firstName = content;
                break;
              case "lastName":
                emp.lastName = content;
                break;
              case "location":
                emp.location = content;
                break;
            }
          }
        }
        empList.add(emp);
      }
    }
   
    for (Employee emp : empList) {
      System.out.println(emp);
    }
 
  }
}
class Employee{
  String id;
  String firstName;
  String lastName;
  String location;
 
  @Override
  public String toString() {
    return firstName+" "+lastName+"("+id+")"+location;
  }
}

Das Ausgabeergebnis ist:

Rakesh Mishra(111)Bangalore
John Davis(112)Chennai
Rajesh Sharma(113)Pune

SAX-Parsing verwenden

Der Unterschied zwischen SAX-Parser und DOM-Parser besteht darin, dass der SAX-Parser nicht das gesamte XML in den Speicher lädt, sondern das XML Zeile für Zeile analysiert, wenn es auf verschiedene Elemente trifft. c Verschiedene Ereignisse auslösen, wie zum Beispiel: öffnendes Tag, schließendes Tag, Zeichendaten, Kommentare usw.

Der Code zum Parsen von XML mit SAX Parser lautet wie folgt:

import java.util.ArrayList;
import java.util.List;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
public class SAXParserDemo {
  public static void main(String[] args) throws Exception {
    SAXParserFactory parserFactor = SAXParserFactory.newInstance();
    SAXParser parser = parserFactor.newSAXParser();
    SAXHandler handler = new SAXHandler();
    parser.parse(ClassLoader.getSystemResourceAsStream("xml/employee.xml"),
                 handler);
    for ( Employee emp : handler.empList){
      System.out.println(emp);
    }
  }
}
class SAXHandler extends DefaultHandler {
 
  List<Employee> empList = new ArrayList<>();
  Employee emp = null;
  String content = null;
  @Override
  public void startElement(String uri, String localName,
                           String qName, Attributes attributes)
                           throws SAXException {
       
    switch(qName){
      case "employee":
        emp = new Employee();
        emp.id = attributes.getValue("id");
        break;
    }
  }
 
  @Override
  public void endElement(String uri, String localName,
                         String qName) throws SAXException {
   switch(qName){
     case "employee":
       empList.add(emp);      
       break;
     case "firstName":
       emp.firstName = content;
       break;
     case "lastName":
       emp.lastName = content;
       break;
     case "location":
       emp.location = content;
       break;
   }
  }
 
  @Override
  public void characters(char[] ch, int start, int length)
          throws SAXException {
    content = String.copyValueOf(ch, start, length).trim();
  }
     
}
 
class Employee {
  String id;
  String firstName;
  String lastName;
  String location;
 
  @Override
  public String toString() {
    return firstName + " " + lastName + "(" + id + ")" + location;
  }
}

Das Ausgabeergebnis ist:

Rakesh Mishra(111)Bangalore
John Davis(112)Chennai
Rajesh Sharma(113)Pune

Mit StAX Parser

StAX wird für die Streaming-API von XML verwendet, und der Unterschied zwischen StAX Parser und SA ist der SAX Parser. Der StAX-Parser unterscheidet sich auch vom SAX-Parser

Der SAX-Parser überträgt Daten, aber der StAX-Parser extrahiert die erforderlichen Daten aus XML. Der StAX-Parser hält den Cursor an der aktuellen Position im Dokument und ermöglicht so das Extrahieren des am Cursor verfügbaren Inhalts, während der SAX-Parser Ereignisse ausgibt, wenn bestimmte Daten angetroffen werden.

XMLInputFactory und XMLStreamReader sind zwei Klassen, die zum Laden von XML-Dateien verwendet werden können. Wenn wir eine XML-Datei mit XMLStreamReader lesen, werden Ereignisse in Form von Ganzzahlwerten generiert und diese Ereignisse dann mit Konstanten in XMLStreamConstants verglichen. Der folgende Code zeigt, wie man XML mit dem StAX-Parser analysiert:

import java.util.ArrayList;
import java.util.List;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
 
public class StaxParserDemo {
  public static void main(String[] args) throws XMLStreamException {
    List<Employee> empList = null;
    Employee currEmp = null;
    String tagContent = null;
    XMLInputFactory factory = XMLInputFactory.newInstance();
    XMLStreamReader reader =
        factory.createXMLStreamReader(
        ClassLoader.getSystemResourceAsStream("xml/employee.xml"));
         
    while(reader.hasNext()){
      int event = reader.next();
      switch(event){
        case XMLStreamConstants.START_ELEMENT:
          if ("employee".equals(reader.getLocalName())){
            currEmp = new Employee();
            currEmp.id = reader.getAttributeValue(0);
          }
          if("employees".equals(reader.getLocalName())){
            empList = new ArrayList<>();
          }
          break;
           
        case XMLStreamConstants.CHARACTERS:
          tagContent = reader.getText().trim();
          break;
           
        case XMLStreamConstants.END_ELEMENT:
          switch(reader.getLocalName()){
            case "employee":
              empList.add(currEmp);
              break;
            case "firstName":
              currEmp.firstName = tagContent;
              break;
            case "lastName":
              currEmp.lastName = tagContent;
              break;
            case "location":
              currEmp.location = tagContent;
              break;
          }
          break;
        case XMLStreamConstants.START_DOCUMENT:
          empList = new ArrayList<>();
          break;
      }
 
    }
    for ( Employee emp : empList){
      System.out.println(emp);
    }
       
  }
}
 
class Employee{
  String id;
  String firstName;
  String lastName;
  String location;
   
  @Override
  public String toString(){
    return firstName+" "+lastName+"("+id+") "+location;
  }
}

Die Ausgabe ist:

Rakesh Mishra(111) Bangalore
John Davis(112) Chennai
Rajesh Sharma(113) Pune

Zusammenfassung: Das ist alles für diesen Artikel, ich hoffe es hilft allen

Das obige ist der detaillierte Inhalt vonWelche Möglichkeiten gibt es, XML in Java zu analysieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!