1 Hay cuatro formas de analizar archivos XML en Java
- A. Analizar datos XML utilizando el método DOM
La estructura de árbol ayuda a comprender y dominar mejor, y el código es fácil de escribir. Durante el proceso de análisis, la estructura de árbol se guarda en la memoria, lo que facilita su modificación.
- B. Análisis SAX
Al utilizar el modo controlado por eventos, el consumo de memoria es relativamente pequeño, adecuado para su uso cuando solo se procesan datos en xml.
- C. Análisis del modo JDOM
Uso extensivo de la clase Colecciones.
- D. Análisis DOM4J
Una rama inteligente de JDOM que incorpora muchas funciones más allá de la representación básica de documentos XML; tiene
un rendimiento superior, flexibilidad, funciones potentes y extrema facilidad de uso.
2 archivos XML para procesar
<?xml versión="1.0" codificación="UTF-8"?>
<libros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<libro id="1001">
< nombre>JAVA 高级编程</nombre>
<autor>张三</autor>
<precio>85.72</precio>
</libro>
<libro id="1002">
<nombre>C++和C#</nombre>
<autor >李失失</autor>
<precio>125,73</precio>
</libro>
</libros>
3 pasos para analizar datos XML usando DOM
a. Crear un objeto DocumentBuilderFactory
b. Crear un objeto DocumentBuilder
c. Obtener el objeto Documento a través del método parse() de DocumentBuilder
d. Obtener la lista de nodos a través del método getElementsByTagName()
e. Usar un bucle for para atravesar el nodo
f Obtener los valores de todos los nodos Atributos y valores de atributos
g Obtener los nombres de nodos y los valores de todos los nodos
importar java.io.IOException;
importar javax.xml.parsers.DocumentBuilder;
importar javax.xml.parsers.DocumentBuilderFactory;
importar javax.xml.parsers.ParserConfigurationException;
importar org.w3c.dom.Document;
importar org.w3c.dom.NamedNodeMap;
importar org.w3c.dom.Node;
importar org.w3c.dom.NodeList;
importar org.xml.sax.SAXException;
clase pública TestDom4Xml {
public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {
//创建一个DocumentBuilderFactory对象
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
//创建一个DocumentBuilder对象
DocumentBuilder db = dbf.newDocumentBuilder();
//Obtener el objeto Documento a través del método parse() de DocumentBuilder
Document doc = db.parse("book.xml");
//Obtener la lista de nodos mediante el método getElementsByTagName()
NodeList nodelist = doc.getElementsByTagName("book ") ;
System.out.println(nodelist.getLength());
//Utilice un bucle for para recorrer los nodos
for(int i=0;i<nodelist.getLength();i++){
Nodo nodo = nodelist.item (i);
//Obtiene los objetos de todos los atributos del nodo y los valores de los atributos
NamedNodeMap nnm = node.getAttributes();
for(int j=0;j<nnm.getLength();j++){
Node sub_node = nnm. item(j);
//Obtener atributos y valores de atributos de todos los nodos
System.out.println(sub_node.getNodeName() + " : " + sub_node.getNodeValue());
}
//Obtener todos los nodos El
nodo secundario NodeList childlist = node.getChildNodes();
for(int j=0;j<childlist.getLength();j++){
Node sub_node = childlist.item(j);
//Obtener el tipo de nodo
short type = sub_node.getNodeType();
//Juzgar si el tipo de nodo no es #texto, porque los caracteres entre el final de la etiqueta anterior > y el comienzo de la siguiente etiqueta < se marcarán como #texto
//Por lo tanto, aquí se debe juzgar
if(type == Node.ELEMENT_NODE){
/
/ Obtener todos los nodos El nombre y el valor del nodo
System.out.println
( sub_node.getNodeName() +
"
: " + sub_node.getTextContent()); } } } }
}
La salida es la siguiente
2
identificación: 1001
nombre: Programación avanzada JAVA
autor: Zhang San
precio : 85,72
identificación: 1002
nombre: C++ y C#
autor: Li Mishui
precio : 125,73
4 método SAX para analizar archivos XML
4.1 Crear una subclase DeaultHandler para analizar documentos XML
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
public class BookDefaultHandler extends DefaultHandler {
/**
* Se llama al analizar documentos xml
*/
public void startDocument( ) throws SAXException {
System.out.println("Comenzar a analizar el documento XML");
super.startDocument();
}
/**
* Se llama cuando finaliza el análisis del documento xml
*/
public void endDocument() throws SAXException {
super.endDocument( ) ;
System.out.println("Completar el análisis del documento XML");
}
/**
* Se utiliza al iniciar el nodo de análisis del documento XML
*/
public void startElement (String uri, String localName, String qName, atributos de atributos) throws SAXException { super.startElement (
uri, localName, qName, atributos);
//Determine si es un nodo de libro y obtenga los atributos del nodo y
los valores de if(qName.quals("book")){
//Obtiene el número de atributos actuales
int len = atributos.getLength();
//Bucle para obtener cada atributo
for(int i=0;i<len; i++){
//Nombre del atributo
Nombre de cadena = atributos.getQName(i);
//Valor del atributo
Valor de cadena = atributos.getValue(i);
System.out.println("Nombre del atributo: " + nombre + "\tValor del atributo: " + valor);
}
}else if(!"libros".equals(qName) &&!"libro".equals(qName)){
System.out.print("Nombre del nodo: " + qName + "\t");
}
}
/**
* Se utiliza al final del análisis de nodos de documentos XML
*/
public void endElement(String uri, String localName, String qName ) lanza SAXException {
super.endElement(uri, localName, qName);
}
/**
* Analizar contenido de texto del nodo
*/
public void caracteres(char[] ch, int start, int length) lanza SAXException {
super.characters(ch, inicio, longitud);
//Convierte el texto del nodo en cadena
Valor de cadena = new String(ch, start , longitud);
//Excluir datos vacíos y texto del nodo de salida
if(!"".equals(value.trim())){
System.out.println(valor);
}
}
}
4.2 Pasos para analizar datos XML usando SAX
a. Crear un objeto SAXParserFactory
b. Crear un objeto SAXParser (como analizador)
c. Crear un objeto de subclase DefaultHandler
d. Llamar al método de análisis
importar java.io.IOException;
importar javax.xml.parsers.ParserConfigurationException;
importar javax.xml.parsers.SAXParser;
importar javax.xml.parsers.SAXParserFactory;
importar org.xml.sax.SAXException;
clase pública TestSax4Xml {
vacío estático público main(String[] args) throws ParserConfigurationException, SAXException, IOException {
//a. Crear un objeto SAXParserFactory
SAXParserFactory spf = SAXParserFactory.newInstance();
//b. Crear un objeto SAXParser (como analizador)
SAXParser sp = spf.newSAXParser () ;
//c. Crear un objeto de subclase DefaultHandler
BookDefaultHandler bdh = new BookDefaultHandler();
//d. Llamar al método de análisis del objeto SAXParser
sp.parse("libro.xml", bdh);
}
}
4.3 Resultados de salida
Comience a analizar el documento XML
Nombre del atributo: id Valor del atributo: 1001
El nombre del nodo: nombre Programación avanzada JAVA
Nombre del nodo: autor Zhang San
Nombre del nodo: precio 85,72
Nombre del atributo: id Valor del atributo: 1002
El nombre del nodo: nombre C++ y C#
Nombre del nodo: autor Li Mishui
Nombre del nodo: precio 125,73
Documento XML de análisis completo
5 métodos JDOM para analizar datos XML
5.1 Pasos
a. Crear un objeto SAXBuilder
b. Llamar al método de compilación y obtener el objeto Documento a través del flujo IO
c. Obtener el nodo raíz
d. Obtener la colección de nodos secundarios directos bajo el nodo raíz
e. Recorrer la colección
importar java.io.FileInputStream;
importar java.io.IOException;
importar java.util.List;
importar org.jdom2.Attribute;
importar org.jdom2.Document;
importar org.jdom2.Element;
importar org.jdom2.JDOMException;
importar org.jdom2.input.SAXBuilder;
public class TestJdom4Xml {
public static void main(String[] args) throws JDOMException, IOException {
//a. Crear un objeto SAXBuilder
SAXBuilder sb = new SAXBuilder();
//b. Llamar a la compilación método, obtener el objeto Documento a través de la secuencia OI
Document doc = sb.build(new FileInputStream("src/book.xml"));
//c. Obtener el
elemento del nodo raíz root = doc.getRootElement();
//d Obtener el nodo raíz Una colección de nodos secundarios directos
List<Element> books = root.getChildren();
//e. Recorre la colección y obtiene cada nodo secundario
for(int i=0;i<books.size();i++){ //Obtiene el
elemento Element
en collection book = books.get(i);
//Obtiene la colección de atributos List<Attribute> en el nodo actual
atts = book.getAttributes();
for(int j=0;j<atts.size();j++){
// Nombre del atributo de salida: valor del atributo
System.out.println(atts.get(j).getName() + "\t" + atts.get(j).getValue()); }
//
Obtener la lista de hijos nodos bajo el nodo actual
<Elemento> subEles = book.getChildren();
//Recorre los nodos secundarios y obtiene el nombre y el valor del texto
for(Element e: subEles){
System.out.println(e.getName() + "\t" + e.getValue());
}
}
}
}
5.2 Resultados de salida
identificación 1001
nombre Programación avanzada JAVA
autor Zhang San
precio 85,72
identificación 1002
nombre C++ y C#
autor Li Mishui
precio 125,73
6 XML de análisis DOM4J
6.1 Pasos de análisis XML de DOM4J
a. Crear un objeto SAXReader
b. Llamar al método de lectura
c. Obtener el nodo raíz
d. Atravesar nodos directos a través de un iterador
importar java.io.FileInputStream;
importar java.io.FileNotFoundException;
importar java.util.Iterator;
importar org.dom4j.Attribute;
importar org.dom4j.Document;
importar org.dom4j.DocumentException;
importar org.dom4j.Element;
importar org.dom4j.io.SAXReader;
public class TestDom4jXml {
public static void main(String[] args) throws FileNotFoundException, DocumentException {
//a. Crear un objeto SAXReader
SAXReader sr = new SAXReader();
//b. Llamar a la lectura método
Document doc = sr.read(new FileInputStream("src/book.xml"));
//c. Obtener el nodo raíz
Elemento root = doc.getRootElement();
//d. Atravesar el nodo directo a través del iterador
for(Iterator<Element> iter=root.elementIterator();iter.hasNext();){
Element book = iter.next();
//Obtiene todos los atributos bajo nodeIterator
<Attribute> arrts = book.attributeIterator();
//Recorre la información del atributo
while(arrts.hasNext()){
Atributo en = arrts.next();
Nombre de cadena = at.getName();
Valor de cadena = at.getValue();
System.out.println("Atributos del nodo ：" + nombre + "\t" + valor);
}
//Recorre los subnodos debajo del nodo
Iterator<Element> subele = book.elementIterator();
//Obtiene todos los nombres de nodos y valores de texto debajo del sub -nodo
mientras(subele.hasNext()){
Nodo de elemento = subele.next();
System.out.println(node.getName() + "\t" + node.getText());
}
}
}
}
6.2 Resultados de salida
Atributos del nodo: id 1001
nombre Programación avanzada JAVA
autor Zhang San
precio 85,72
Atributos del nodo: id 1002
nombre C++ y C#
autor Li Mishui
precio 125,73