[Introducción a XML] Un artículo del que nunca había oído hablar antes de usarlo de manera competente

prefacio

Hoy continuaremos aprendiendo el XML en la parte [Java Web] En comparación con otras partes, XML sigue siendo muy simple. A menudo lo usaremos cuando escribamos grandes proyectos en el futuro, por lo que es bastante importante.

A continuación, comenzamos oficialmente el aprendizaje de XML.

Descripción general de XML

concepto basico:

Lenguaje de marcado extensible (XML), Extensible significa que las etiquetas son personalizadas.

Uso de XML:

XML se utiliza principalmente para almacenar datos, como archivo de configuración, y transmitirlos en la red.

Funciones XML:

(1) XML es un lenguaje de marcas, muy similar a HTML
(2) XML está diseñado para transmitir datos, no para mostrar datos
(3) XML no tiene etiquetas predefinidas. Al usar, debe definir sus propias etiquetas
(4) XML es un lenguaje muy flexible. No hay etiquetas fijas y todas las etiquetas se pueden personalizar.

Diferencias entre XML y HTML:

(1) Las etiquetas XML son personalizadas y las etiquetas HTML están predefinidas.
(2) La sintaxis XML es estricta, la sintaxis HTML es flexible.
(3) XML y HTML están diseñados para diferentes propósitos:

1. XML está diseñado para transmitir y almacenar datos, y su enfoque está en el contenido de los datos.

2. HTML está diseñado para mostrar datos y la atención se centra en la apariencia de los datos.

3. HTML está diseñado para mostrar información, mientras que XML está diseñado para transmitir información.

sintaxis XML

Al igual que otros lenguajes, el lenguaje XML tiene su propia sintaxis. detalles de la siguiente manera:

(1) El sufijo del documento xml es .xml.
(2) La primera línea de xml debe definirse como una declaración de documento.
(3) Solo hay una etiqueta raíz en el documento xml.
(4) El valor del atributo debe estar entre comillas simples (simples y dobles) y el valor del atributo es único.
(5) Las etiquetas xml deben cerrarse correctamente, es decir, ya sea autocierre y etiquetas, o etiquetas de contención.
(6) El nombre de la etiqueta xml distingue entre mayúsculas y minúsculas.

¡Implementemos un archivo XML! como sigue:

<!--人力资源管理系统-->
<?xml version="1.0" encoding="utf-8"?>
<hr>
    <employee no="7706">
        <name>张三</name>
        <age>31</age>
        <salary>5000</salary>
        <department>
            <dname>技术部</dname>
            <address>xx大厦-B104</address>
        </department>
    </employee>
    <employee no="7707">
        <name>李四</name>
        <age>29</age>
        <salary>4000</salary>
        <department>
            <dname>会计部</dname>
            <address>xx大厦-B106</address>
        </department>
    </employee>
</hr>

Así es un archivo XML bien formado.
La primera línea de código es la parte de declaración, recuerde que el valor de codificación aquí no se puede omitir y debe escribirse. Hay uno y sólo un
nodo raíz .<hr></hr>

Dado que nosotros personalizamos todas las etiquetas en XML, sabemos de un vistazo lo que expresa y describe este archivo. Por lo tanto, también debemos definir nombres de etiquetas significativos al personalizar las etiquetas.

Introduzca el área CDATA, los datos en esta área se mostrarán tal cual, en el formato:<![CDATA[数据]]>

Restricciones XML

Un documento XML válido tiene las siguientes características:

(1) Primero debe estar bien formado.
(2) Utilice DTD y XSD (esquema XML) para definir restricciones.

Bien formado es como nuestro archivo XML anterior, las etiquetas son significativas, la sintaxis está bien, etc. ¿Cuál es la restricción?

Por ejemplo, hay una definición de la edad de una persona, por lo que si hay un error en la entrada de datos, la edad se define como un número negativo, ¿está bien? Esto definitivamente no es posible, no es tan escandaloso.

Pero el archivo XML no puede verificar este error, porque su contenido es gratuito, en este momento tenemos que introducirle restricciones, restringir los datos, etiquetas, etc. en él.

Escribir un documento para restringir la especificación de escritura de un documento xml se denomina restricción XML.

Las restricciones XML se dividen en DTD y XSD, a continuación continuaremos hablando de estas dos restricciones.

Restricciones DTD

Una declaración DTD completa consta principalmente de tres partes básicas: declaración de elementos, declaración de atributos y declaración de entidades.

Declaración de elementos:

La sintaxis básica es:

<!ELEMENT 元素名 元素内容模型>

Utilice !ELEMENT para declarar un elemento, seguido del nombre del elemento, que es el nombre de la etiqueta, y el modelo de contenido del elemento después del nombre del elemento.

El modelo de contenido de un elemento define el contenido del elemento permitido. Un elemento puede contener un subelemento, un bloque de texto o una combinación de texto de campo de subelemento, y el contenido del elemento también puede estar vacío.

En XML, los elementos pueden tener elementos secundarios. Podemos usar DTD para definir qué elementos secundarios se pueden incluir en un elemento. Para limitar qué elementos secundarios se pueden incluir en un elemento, solo necesitamos escribir el nombre del elemento secundario después del elemento padre ()medio.

Si hay etiquetas de nombre y dirección debajo de la etiqueta del departamento antes, entonces podemos escribir así

<!ELEMENT department (dname,address)>

Hay varias etiquetas de empleados debajo de la etiqueta de recursos humanos anterior. También podemos agregar un * después de () para representar 0 o más etiquetas de empleados.

<!ELEMENT hr (employee)*>

También puede usar otros ? significa una o cero veces, + significa una o más veces y * significa cero o más veces.

Debajo de la etiqueta del empleado también hay etiquetas como nombre, edad, salario, departamento, etc., las podemos escribir así:

<!ELEMENT employee (name,age,salary,department)>

El uso ,de delimitado significa que los elementos secundarios deben aparecer en este orden; de lo contrario, se informará un error. Si no se requiere ordenar, podemos usar |la separación de elementos secundarios. como sigue:

<!ELEMENT employee (name|age|salary|department)>

Si el contenido del elemento es contenido de texto sin formato, use la #PCDATAdefinición:

<!ELEMENT name #PCDATA>

Si el elemento es solo un elemento vacío, también conocido como etiqueta de cierre automático, podemos EMPTYdefinirlo con:

<!ELEMENT br EMPTY>

ANY significa que cualquier contenido se puede definir en el elemento:

<!ELEMENT test ANY>

Declaración de propiedad:

Use la palabra clave ATTLIST para declarar atributos en elementos

<!ATTLIST employee no CDATA "">

El ejemplo anterior declara un atributo sin para el elemento empleado

Entonces, ¿cómo vinculamos el archivo DTD al archivo XML después de escribir el archivo DTD?

El formato es el siguiente:

<!DOCTYPE 文档根节点 SYSTEM "dtd文件路径">

Solo necesitamos descargar esta sección con la siguiente línea declarada en el archivo XML.

A continuación, completamos la escritura de un archivo de restricciones para el archivo XML anterior:

<?xml version="1.0" encoding="UTF-8" ?>
<!ELEMENT hr (employee)*>
<!ELEMENT employee (name,age,salary,department)>
<!ATTLIST employee no CDATA "">
<!ELEMENT name (#PCDATA)>
<!ELEMENT age (#PCDATA)>
<!ELEMENT salary (#PCDATA)>
<!ELEMENT department (dname,address)>
<!ELEMENT dname (#PCDATA)>
<!ELEMENT address (#PCDATA)>

Restricciones XSD

XSD significa XML Schema, y ​​la función de XML Schema es definir los componentes básicos legales de los documentos XML.

El papel de XSD:

(1) Definir los elementos que pueden aparecer en el documento
(2) Definir los atributos que pueden aparecer en el documento
(3) Definir qué elemento es un elemento secundario
(4) Definir el orden de los elementos secundarios
(5) Definir el número de elementos secundarios
(6) Define si un elemento está vacío o puede contener texto
(7) Define el tipo de datos de elementos y atributos
(8) Define valores predeterminados y fijos para elementos y atributos

Una de las capacidades más importantes de XML Schema es su soporte para tipos de datos.

<schema>El elemento es el elemento raíz de cada esquema XML.

Sintaxis para definir elementos simples:

<element name="标签名" type="元素类型"/>

Los tipos de datos comunes son:

string表示字符串类型
decimal表示小数类型
integer表示整数类型
boolean表示布尔类型
date表示日期类型
time表示时间类型

La sintaxis para definir propiedades es:

<attribute name="属性名" type="属性的数据类型"/>

La segunda característica importante de los esquemas XML es que están escritos en XML.

A continuación, usamos XSD para restringir el archivo XML.

<?xml version="1.0" encoding="UTF-8" ?>
<schema xmlns="http://www.w3.org/2001/XMLSchema">
    <element name="hr">
<!--complexType是复杂节点，包含子节点时必须使用它-->
        <complexType>
            <sequence>
                <element name="employee" minOccurs="99">
                    <complexType>
                        <sequence>
                            <element name="name" type="string"></element>
                            <element name="age" >
                                <simpleType>
                                    <restriction base="integer">
                                    <!--年龄最小为18，最大为60-->
                                        <minInclusive value="18"></minInclusive>
                                        <maxInclusive value="60"></maxInclusive>
                                    </restriction>
                                </simpleType>
                            </element>
                            <element name="salary" type="integer"></element>
                            <element name="dapartment">
                                <complexType>
                                    <sequence>
                                        <element name="dname" type="string"></element>
                                        <element name="address" type="string"></element>
                                    </sequence>
                                </complexType>
                            </element>
                        </sequence>
                        <attribute name="no" type="string" use="required"></attribute>
                    </complexType>
                </element>
            </sequence>
        </complexType>
    </element>
</schema>

Para hacer referencia a una restricción XSD en XML:

<hr xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="文件路径">

Simplemente agréguelo debajo de la definición XML.

análisis XML

El análisis XML es para leer y escribir archivos XML. Usamos dom4j para analizar XML. Aquí hay algunas introducciones a dom4j:

dom4j es una API XML de Java, similar a jdom, para leer y escribir archivos XML. dom4j es una muy, muy buena API XML de Java con excelente rendimiento, funciones potentes y extrema facilidad de uso. También es un software de código abierto, que se puede encontrar en SourceForge. Evaluación de rendimiento, funcionalidad y facilidad de uso, dom4j es muy bueno en ese sentido. Ahora puede ver que cada vez más software Java utiliza dom4j para leer y escribir XML, como Hibernate, incluido el propio JAXM de Sun que también utiliza Dom4j.

Usamos el código directamente para explicar el ejercicio.

Lea el archivo XML anterior:

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.sql.SQLOutput;
import java.util.List;

public class HrReader {
    public void readXml() {
        String file = "d:/Java/Java Web/XML/src/hr.xml";
        //SAXReader是读取XML文件的核心类，用于将XML解析之后以树的形式保存在内存
        SAXReader reader = new SAXReader();
        try {
            Document document = reader.read(file);
            //获取XML文档的根节点，即hr标签
            Element root = document.getRootElement();
            //elements方法用于获取指定的标签集合
            List<Element> employees = root.elements("employee");
            for(Element employee:employees){
                //emement方法用于获取唯一的子节点对象
                Element name = employee.element("name");
                //getText()用于获取标签文本值
                String empName = name.getText();
                System.out.println(empName);
                System.out.println(employee.elementText("age"));
                System.out.println(employee.elementText("salary"));
                Element department = employee.element("department");
                System.out.println(department.element("dname").getText());
                System.out.println(department.element("address").getText());
                Attribute att = employee.attribute("no");
                System.out.println(att.getText());
            }
        }catch(DocumentException e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws DocumentException {
        HrReader reader = new HrReader();
        reader.readXml();
    }
}

Salida:

operación de escritura en el archivo XML anterior:

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.sql.SQLOutput;
import java.util.List;

public class HrReader {
    public void readXml() {
        String file = "d:/Java/Java Web/XML/src/hr.xml";
        //SAXReader是读取XML文件的核心类，用于将XML解析之后以树的形式保存在内存
        SAXReader reader = new SAXReader();
        try {
            Document document = reader.read(file);
            //获取XML文档的根节点，即hr标签
            Element root = document.getRootElement();
            //elements方法用于获取指定的标签集合
            List<Element> employees = root.elements("employee");
            for(Element employee:employees){
                //emement方法用于获取唯一的子节点对象
                Element name = employee.element("name");
                //getText()用于获取标签文本值
                String empName = name.getText();
                System.out.println(empName);
                System.out.println(employee.elementText("age"));
                System.out.println(employee.elementText("salary"));
                Element department = employee.element("department");
                System.out.println(department.element("dname").getText());
                System.out.println(department.element("address").getText());
                Attribute att = employee.attribute("no");
                System.out.println(att.getText());
            }
        }catch(DocumentException e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws DocumentException {
        HrReader reader = new HrReader();
        reader.readXml();
    }
}

Expresiones XPath

XPath es un lenguaje para encontrar información en documentos XML. XPath se puede utilizar para recorrer elementos y atributos en un documento XML.

Nodo (Node):
En XPath, hay siete tipos de nodos: elementos, atributos, texto, espacios de nombres, instrucciones de procesamiento, comentarios y nodos de documento (raíz). Los documentos XML se tratan como árboles de nodos. La raíz del árbol se denomina nodo de documento o nodo raíz.

Expresiones de ruta XPath:
XPath utiliza expresiones de ruta para seleccionar nodos o conjuntos de nodos en un documento XML. Estas expresiones de ruta son muy similares a las expresiones que vemos en los sistemas de archivos de computadora normales.

Seleccionar nodos:
XPath utiliza expresiones de ruta para seleccionar nodos en un documento XML. Los nodos se seleccionan siguiendo un camino o paso

Expresiones de ruta comunes:

Ejemplos correspondientes:

Expresiones de ruta con predicados Ejemplos:

Aquí hay algunos ejercicios sobre expresiones de ruta XPath

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;

import java.util.List;
import java.util.zip.DataFormatException;

public class XPathTestor {
    public void xpath(String xpathExp){
        String file = "d:/Java/Java Web/XML/src/hr.xml";
        SAXReader reader = new SAXReader();
        try {
            Document document = reader.read(file);
            List<Node> nodes = document.selectNodes(xpathExp);
            for(Node node : nodes){
                Element emp = (Element) node;
                System.out.println(emp.attributeValue("no"));
                System.out.println(emp.elementText("name"));
                System.out.println(emp.elementText("age"));
                System.out.println(emp.elementText("salary"));
                System.out.println("================================");
            }
        } catch(DocumentException e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        XPathTestor testor = new XPathTestor();
       //testor.xpath("/hr/employee");
       //testor.xpath("//employee");
       //testor.xpath("//employee[salary<4000]");
       //testor.xpath("//employee[name='张三']");
       //testor.xpath("//employee[@no=7706]");
       //testor.xpath("//employee[1]");
       //testor.xpath("//employee[last()]");
       //testor.xpath("//employee[position()<3]");
       testor.xpath("//employee[1] | //employee[3]");
    }
}