La última vez hablamos de las cuatro formas de analizar JSON, por lo que esta vez veremos las cuatro formas de analizar XML.
Cuatro formas de análisis
- Análisis DOM
- Análisis SAX
- Análisis JDOM
- Análisis DOM4J
Práctica de caso
Análisis DOM
DOM (Modelo de objeto de documento, modelo de objeto de documento), en la aplicación, el analizador XML basado en DOM convierte un documento XML en una colección de modelos de objeto (generalmente llamado árbol DOM ), la aplicación es a través del modelo de objeto La operación para realizar la operación de datos de documentos XML. El XML mismo aparece en forma de árbol, por lo que cuando se manipula el DOM, también se transformará en forma de árbol de capítulos. En todo el árbol DOM, el lugar más grande se refiere a Documento, que representa un documento en el que solo hay un nodo raíz.
Nota: Cuando se utilizan operaciones DOM, cada área de texto también es un nodo, llamado nodo de texto.
Interfaz de operación central
Existen las siguientes cuatro interfaces de operación principales en el análisis de DOM:
Documento : Esta interfaz representa todo el documento XML. Representa la raíz de todo el árbol DOM. Proporciona un punto de entrada para acceder y operar los datos en el documento. Todo el contenido de los elementos en el archivo XML se puede acceder a través del nodo Documento.
Nodo : esta interfaz juega un papel fundamental en todo el árbol DOM. Una gran parte de la interfaz principal de la operación DOM se hereda de la interfaz Node. Por ejemplo: Interfaces como Documento y Elemento En el árbol DOM, cada interfaz de nodo representa un nodo en el árbol DOM.
NodeList : esta interfaz representa una colección de nodos, que generalmente se usa para representar un grupo de nodos en una relación ordenada, por ejemplo: Los nodos secundarios de un nodo afectarán directamente a la colección NodeList cuando el documento cambie.
NamedNodeMap : esta interfaz representa una correspondencia uno a uno entre un conjunto de nodos y sus nombres únicos. Esta interfaz se utiliza principalmente para la representación de nodos de atributos.
Proceso de análisis de DOM
Si un programa necesita realizar operaciones de lectura y análisis de DOM, también debe seguir los pasos a continuación:
① 建立 DocumentBuilderFactory : DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
② 建立 DocumentBuilder: DocumentBuilder builder = factory.newDocumentBuilder();
③ 建立 Document : Document doc = builder.parse(“要解析的文件路径”);
④ 建立 NodeList : NodeList nl = doc.getElementsByTagName(“读取节点”);
⑤ 进行 XML 信息读取Análisis SAX
El análisis de SAX (API simple para XML) se analiza paso a paso en el orden de los archivos xml. SAX no tiene una organización oficial de estándares, no pertenece a ninguna organización o grupo de estándares, ni pertenece a ninguna empresa o individuo, pero proporciona una tecnología informática utilizada por cualquier persona.
SAX (API simple para XML, una interfaz simple para manipular XML), a diferencia de las operaciones DOM, SAX usa un modo secuencial para el acceso, que es una forma de leer rápidamente datos XML. Cuando se utiliza el analizador SAX para la operación, se activarán una serie de cosas. Cuando el escaneo llegue al principio y al final del documento (documento), al principio y al final del elemento (elemento), se llamarán los métodos de procesamiento relevantes y estos métodos de operación realizarán las acciones correspondientes. Opere hasta el final de todo el escaneo del documento.
Si desea lograr este tipo de análisis SAX, primero debe crear un analizador SAX.
// 1、创建解析器工厂
SAXParserFactory factory = SAXParserFactory.newInstance();
// 2、获得解析器
SAXParser parser = factory.newSAXParser();
// SAX 解析器 ，继承 DefaultHandler
String path = new File("resource/demo01.xml").getAbsolutePath();
// 解析
parser.parse(path, new MySaxHandler());Análisis JDOM
En los estándares de operación XML proporcionados por el propio W3C, DOM y SAX, pero desde una perspectiva de desarrollo, DOM y SAX tienen sus propias características. DOM se puede modificar, pero no es adecuado para leer archivos grandes, mientras que SAX puede leer archivos grandes. Pero no puede modificarse por sí solo. El llamado JDOM = DOM + SAX modificable para leer archivos grandes. JDOM en sí es un componente gratuito y de código abierto que se puede descargar directamente desde www.jdom.org.
Clases comunes de xml de manipulación de JDOM:
Documento: representa todo el documento xml, que es una estructura de árbol.
Eelment: representa un elemento xml y proporciona métodos para manipular sus subelementos, como texto, atributos y espacios de nombres.
Atributo: indica los atributos contenidos en el elemento.
Texto: representa información de texto xml
XMLOutputter: flujo de salida xml, la capa inferior se realiza a través del flujo medio de JDK
Formato: proporcione configuraciones como codificación, estilo y diseño de la salida del archivo xml
Descubrimos que la operación de salida de JDOM es mucho más conveniente que el DOM tradicional y es más intuitiva, incluida la salida es muy fácil. Lo que se observa en este momento es el soporte de JDOM para el análisis de DOM, pero también se dice que el propio JDOM también soporta las características de SAX; por lo tanto, SAX puede usarse para operaciones de análisis.
// 获取 SAX 解析器
SAXBuilder builder = new SAXBuilder();
File file = new File("resource/demo01.xml");
// 获取文档
Document doc = builder.build(new File(file.getAbsolutePath()));
// 获取根节点
Element root = doc.getRootElement();
System.out.println(root.getName());
// 获取根节点下所有的子节点， 也可以根据标签名称获取指定的直接点
List<Element> list = root.getChildren();
System.out.println(list.size());
for(int x = 0; x<list.size(); x++){
Element e = list.get(x);
// 获取元素的名称和里面的文本
String name = e.getName();
System.out.println(name + "=" + e.getText());
System.out.println("==================");
}Análisis DOM4J
dom4j es una biblioteca de código abierto simple para procesar XML, XPath y XSLT, se basa en la plataforma Java, utiliza el marco de recopilación de Java e integra completamente DOM, SAX y JAXP. Ruta de descarga:
http://www.dom4j.org/dom4j-1.6.1/
http://sourceforge.net/projects/dom4j
DOM4J es un componente de código abierto XML gratuito como JDOM, pero debido a que la tecnología se usa más en los marcos de desarrollo actuales, como Hibernate, Spring, etc., todos usan DOM4J, por lo que, como introducción, puede comprender este componente. No hay buenos ni malos, los frameworks generales usan más DOM4J, y si usualmente usamos JDOM, es más común. Se puede encontrar que DOM4J ha jugado muchas características nuevas, como que el formato de salida puede ser muy bueno.
File file = new File("resource/outputdom4j.xml");
SAXReader reader = new SAXReader();
// 读取文件作为文档
Document doc = reader.read(file);
// 获取文档的根元素
Element root = doc.getRootElement();
// 根据跟元素找到全部的子节点
Iterator<Element> iter = root.elementIterator();
while(iter.hasNext()){
Element name = iter.next();
System.out.println("value = " + name.getText());
}Extensión ~ Creación de XML
Creación de DOM
Si desea generar un archivo XML, debe utilizar el método newDocument () al crear un documento
Si desea generar el documento DOM, es más problemático. Escribe varias copias a la vez
public static void createXml() throws Exception{
//获取解析器工厂
DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
//获取解析器
DocumentBuilder builder=factory.newDocumentBuilder();
//创建文档
Document doc=builder.newDocument();
//创建元素、设置关系
Element root=doc.createElement("people");
Element person=doc.createElement("person");
Element name=doc.createElement("name");
Element age=doc.createElement("age");
name.appendChild(doc.createTextNode("lebyte"));
age.appendChild(doc.createTextNode("10"));
doc.appendChild(root);
root.appendChild(person);
person.appendChild(name);
person.appendChild(age);
//写出去
// 获得变压器工厂
TransformerFactory tsf=TransformerFactory.newInstance();
Transformer ts=tsf.newTransformer();
//设置编码
ts.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
//创建带有 DOM 节点的新输入源，充当转换 Source 树的持有者
DOMSource source=new DOMSource(doc);
//充当转换结果的持有者
File file=new File("src/output.xml");
StreamResult result=new StreamResult(file);
ts.transform(source, result);
} Creación SAX
//创建一个SAXtransformerfactory对象
SAXTransformerFactory stf = (SAXTransformerFactory) SAXTransformerFactory.newInstance();
try {
//通过SAXTransformerFactory对象创建一个TransfomerHandler对象
TransformerHandler handler = stf.newTransformerHandler();
//通过transformerHandler对象创建一个transformer对象
Transformer tf = handler.getTransformer();
//设置Transfomer对象的属性
tf.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
tf.setOutputProperty(OutputKeys.INDENT, "yes");
//创建一个Result的对象，将其与handler关联
File file = new File("src/output.xml");
if(!file.exists()){
file.createNewFile();
}
Result result = new StreamResult(new FileOutputStream(file));
handler.setResult(result);
//通过Handler编写XML的内容
//打开Document
handler.startDocument();
AttributesImpl attr = new AttributesImpl();
//创建根节点bookstore
handler.startElement("", "", "bookstore", attr);
attr.clear();
attr.addAttribute("", "", "id", "", "1");
handler.startElement("", "", "book", attr);
attr.clear();
handler.startElement("", "", "name", attr);
handler.characters("颈椎病康复指南".toCharArray(), 0, "颈椎病康复指南".length());
handler.endElement("","","name");
//关闭各节点
handler.endElement("", "", "book");
handler.endElement("", "", "bookstore");
handler.endDocument();
} catch (SAXException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (TransformerConfigurationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}Creación de JDOM
// 创建节点
Element person = new Element("person");
Element name = new Element("name");
Element age = new Element("age");
// 创建属性
Attribute id = new Attribute("id","1");
// 设置文本
name.setText("lebyte");
age.setText("10");
// 设置关系
Document doc = new Document(person);
person.addContent(name);
name.setAttribute(id);
person.addContent(age);
XMLOutputter out = new XMLOutputter();
File file = new File("resource/outputjdom.xml");
out.output(doc, new FileOutputStream(file.getAbsoluteFile())); Creación de DOM4J
// 使用 DocumentHelper 来创建 Document 对象
Document document = DocumentHelper.createDocument();
// 创建元素并设置关系
Element person = document.addElement("person");
Element name = person.addElement("name");
Element age = person.addElement("age");
// 设置文本 name.setText("lebyte");
age.setText("10");
// 创建格式化输出器
OutputFormat of = OutputFormat.createPrettyPrint();
of.setEncoding("utf-8");
// 输出到文件
File file = new File("resource/outputdom4j.xml");
XMLWriter writer = new XMLWriter(new FileOutputStream(new File(file.getAbsolutePath())),of);
// 写出
writer.write(document);
writer.flush();
writer.close();