XML

XML

概念

# Extensible Markup Language 可扩展标记语言
　　* 可扩展：标签都是自定义的，如：<user> <student>

# 功能：
　　* 存储数据
　　* 配置文件
　　* 在网络中传输，可以跨平台

# xml 与 html 的区别
　　* xml 标签都是自定义的，html 标签是预定义的
　　* xml 的语法严格，html 语法松散
　　* xml 是存储数据的，html 是展示数据的
　　* 二者都由 w3c（万维网联盟）研制

语法 

# 基本语法
　　* xml 文档的后缀名 .xml
　　* xml 文档 第一行 必须定义为文档声明
　　* xml 文档中有且仅有 一个 根标签
　　* 属性值必须使用引号（单双都可）引起来
　　* 标签必须正确关闭
　　* xml 标签名称区分大小写

# 快速入门

<?xml version='1.0' encoding='utf-8'?>

<users>
    <user id='1'>
        <name>张三</name>
        <age>23</age>
        <gender>male</gender>
    </user>
    
    <user id='2'>
        <name>李四</name>
        <age>24</age>
        <gender>female</gender>
    </user>

</users>

 

# 组成部分
　　* 文档声明
　　　　1）格式：<?xml 属性列表 ?>
　　　　2）属性列表：
　　　　　　* version：版本号（必须的属性）
　　　　　　* encoding：编码方式，告知解析引擎当前文档的字符集，默认：ISO-8859-1
　　　　　　* standalone：是否独立（yes / no）
　　* 指令：结合 css
　　　　 <?xml-stylesheet type="text/css" href="a.css" ?>
　　* 标签：标签名称自定义
　　　　* 规则：
　　　　　　1）名称可以包含数字、字母以及其他的字符
　　　　　　2）名称不能以数字或者标点符号开始
　　　　　　3）名称不能以 xml（或者 XML、Xml 等）开始
　　　　　　4）名称不能包含空格
　　* 属性：id属性值唯一
　　* 文本：
　　　　* CDATA区：在该区域中的数据会被原样展示
　　　　　　* 格式：< ! [CDATA[ 数据 ] ] >

# 约束：规定 xml 文档的书写规则
　　* 作为框架的使用者（程序员）
　　　　1）能够在 xml 中引入约束文档
　　　　2）能够简单读懂约束文档

　　* 分类：
　　　　1）DTD：一种简单的约束技术
　　　　2）Schema：一种复杂的约束技术

　　* DTD：
　　　　* 将 dtd 文档引入到 xml文档中
　　　　* 内部 dtd：将约束规则定义在 xml 文档中
　　　　　　* <!DOCTYPE 根标签名 [ dtd文档内容 ]>
　　　　* 外部 dtd：将约束规则定义在外部的 dtd 文件中
　　　　　　* 本地：<!DOCTYPE 根标签名 SYSTEM "dtd文件的位置">
　　　　　　* 网络：<!DOCTYPE 根标签名 PUBLIC "dtd文件名" "dtd文件的URL位置">
　　　　* 虽然能规定标签名，但是无法明确标签体内容

<!ELEMENT students (student*) >
<!ELEMENT student (name,age,sex)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT age (#PCDATA)>
<!ELEMENT sex (#PCDATA)>
<!ATTLIST student number ID #REQUIRED>

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE students SYSTEM "student.dtd">

<students>
    <student number="itcast_0001">
        <name>tom</name>
        <age>18</age>
        <sex>male</sex>
    </student>
    
</students>

　* Schema：
　　　　* 引入：
　　　　　　1）填写 xml 文档的根元素
　　　　　　2）引入 xsi 前缀   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
　　　　　　3）引入 xsd 文件命名空间  xsi:schemaLocation = "http://www.itcast.cn/xml   student.xsd"
　　　　　　4）为每一个 xsd 约束声明一个前缀，作为标识   xmlns = "http://www.itcast.cn/xml"

 <students   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xmlns="http://www.itcast.cn/xml" 
            xsi:schemaLocation="http://www.itcast.cn/xml  student.xsd"
             >

<?xml version="1.0"?>
<xsd:schema xmlns="http://www.itcast.cn/xml"
        xmlns:xsd="http://www.w3.org/2001/XMLSchema"
        targetNamespace="http://www.itcast.cn/xml" elementFormDefault="qualified">
    <xsd:element name="students" type="studentsType"/>
    <xsd:complexType name="studentsType">
        <xsd:sequence>
            <xsd:element name="student" type="studentType" minOccurs="0" maxOccurs="unbounded"/>
        </xsd:sequence>
    </xsd:complexType>
    <xsd:complexType name="studentType">
        <xsd:sequence>
            <xsd:element name="name" type="xsd:string"/>
            <xsd:element name="age" type="ageType" />
            <xsd:element name="sex" type="sexType" />
        </xsd:sequence>
        <xsd:attribute name="number" type="numberType" use="required"/>
    </xsd:complexType>
    <xsd:simpleType name="sexType">
        <xsd:restriction base="xsd:string">
            <xsd:enumeration value="male"/>
            <xsd:enumeration value="female"/>
        </xsd:restriction>
    </xsd:simpleType>
    <xsd:simpleType name="ageType">
        <xsd:restriction base="xsd:integer">
            <xsd:minInclusive value="0"/>
            <xsd:maxInclusive value="256"/>
        </xsd:restriction>
    </xsd:simpleType>
    <xsd:simpleType name="numberType">
        <xsd:restriction base="xsd:string">
            <xsd:pattern value="heima_d{4}"/>
        </xsd:restriction>
    </xsd:simpleType>
</xsd:schema> 

<?xml version="1.0" encoding="UTF-8" ?>
<!-- 
    1.填写xml文档的根元素
    2.引入xsi前缀.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3.引入xsd文件命名空间.  xsi:schemaLocation="http://www.itcast.cn/xml  student.xsd"
    4.为每一个xsd约束声明一个前缀,作为标识  xmlns="http://www.itcast.cn/xml" 
    
    
 -->
 <students   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xmlns="http://www.itcast.cn/xml" 
            xsi:schemaLocation="http://www.itcast.cn/xml  student.xsd"
             >
     <student number="heima_0001">
         <name>tom</name>
         <age>18</age>
         <sex>male</sex>
     </student>
         
 </students>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    
    <context:annotation-config />

   
    <context:component-scan base-package="cn.cisol.mvcdemo">
        <context:include-filter type="annotation"
            expression="org.springframework.stereotype.Controller" />
    </context:component-scan>

   
    <mvc:annotation-driven />

    
    <mvc:resources mapping="/resources/**" location="/resources/" />


    
    <bean
        class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
        <property name="order" value="1" />
        <property name="mediaTypes">
            <map>
                <entry key="json" value="application/json" />
                <entry key="xml" value="application/xml" />
                <entry key="htm" value="text/html" />
            </map>
        </property>

        <property name="defaultViews">
            <list>
                
                <bean
                    class="org.springframework.web.servlet.view.json.MappingJackson2JsonView">
                </bean>
            </list>
        </property>
        <property name="ignoreAcceptHeader" value="true" />
    </bean>

    <bean
        class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass"
            value="org.springframework.web.servlet.view.JstlView" />
        <property name="prefix" value="/WEB-INF/jsps/" />
        <property name="suffix" value=".jsp" />
    </bean>


  
    <bean id="multipartResolver"
        class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize" value="209715200" />
        <property name="defaultEncoding" value="UTF-8" />
        <property name="resolveLazily" value="true" />
    </bean>

</beans>

解析

# 操作 xml 文档，将文档中的数据读取到内存中

# 操作 xml 文档
　　* 解析（读取）：将文档中的数据读取到内存中
　　* 写入：将内存中的数据保存到 xml 文档中，持久化的存储

# 解析 xml 的方式：
　　* DOM：将标记语言文档一次性加载进内存，在内存中形成一颗 DOM 树
　　　　* 优点：操作方便，可以对文档进行 CRUD 的所有操作
　　　　* 缺点：占内存
　　* SAX：逐行读取，基于事件驱动的
　　　　* 优点：不占内存
　　　　* 缺点：只能读取，不能增删改

# xml 常见的解析器：
　　* JAXP：sun公司提供的解析器，支持 dom 和 sax 两种思想，性能相对较差
　　* DOM4J：一款非常优秀的基于DOM的解析器
　　* Jsoup：jsoup 是一款 Java 的 HTML 解析器，可以直接解析某个 URL 地址、HTML文本内容。它提供了一套非常省力的 API，可以通过 DOM，CSS以及类似于 Jquery的操作方法来去除和操作数据
　　* PULL：Android操作系统内置的解析器，sax 方式的

Jsoup

# 快速入门：
　　* 步骤：
　　　　1）导入 jar 包
　　　　2）获取 Document 对象
　　　　3）获取对应的标签 Element 对象
　　　　4）获取数据

# 对象的使用
　　* Jsoup：工具类，可以解析 html 或 xml 文档，返回 Document对象
　　　　* parse()：解析 html 或 xml 文档，返回 Document对象
　　　　　　* parse(File in, String charsetName)：解析 xml 或 html 文件的
　　　　　　* parse(String html)：解析 xml 或 html 字符串
　　　　　　* parse(URL url, int timeoutMillis)：通过网络路径获取指定的 html 或 xml 的文档对象

package cn.itcast.jsoup;

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import java.io.File;
import java.io.IOException;
import java.net.URL;

/**
 * Jsoup快速入门
 */
public class JsoupDemo2 {
    public static void main(String[] args) throws IOException {
        //获取 student.xml 的path
        String path= JsoupDemo2.class.getClassLoader().getResource("student.xml").getPath();
        //解析 xml 文档，加载文档进内存，获取 dom 树
        /*Document document = Jsoup.parse(new File(path), "utf-8");
        System.out.println(document);*/

        /*String str = "<?xml version="1.0" encoding="UTF-8" ?>
" +
                "
" +
                "<students>
" +
                "	<student number="itcast_0001">
" +
                "		<name>zwb</name>
" +
                "		<age>20</age>
" +
                "		<sex>male</sex>
" +
                "	</student>
" +
                "
" +
                "	<student number="itcast_0002">
" +
                "		<name>cly</name>
" +
                "		<age>20</age>
" +
                "		<sex>female</sex>
" +
                "	</student>
" +
                "	
" +
                "</students>";
        Document document = Jsoup.parse(str);
        System.out.println(document);*/

        URL url = new URL("https://www.baidu.com/s?cl=3&tn=baidutop10&fr=top1000&wd=%E5%8D%B0%E5%BA%A6%E5%A4%B1%E4%BA%8B%E5%AE%A2%E6%9C%BA%E9%BB%91%E5%8C%A3%E5%AD%90%E5%B7%B2%E6%89%BE%E5%88%B0&rsv_idx=2&rsv_dl=fyb_n_homepage&hisfilter=1");
        Document document = Jsoup.parse(url, 10000);
        System.out.println(document);
    }

}

　　* Document：文档对象，代表内存中的 DOM 树
　　　　* 获取 Element 对象
　　　　　　* getElementById(String id)：根据 id 属性值获取唯一的 element 对象
　　　　　　* getElementsByTag(String tagname)：根据标签名称获取元素对象集合
　　　　　　* getElementsByAttribute(String key)：根据属性名称获取元素对象集合
　　　　　　* getElementsByAttributeValue(String key, String value)：根据对应的属性名和属性值获取元素对象集合

package cn.itcast.jsoup;

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import java.io.File;
import java.io.IOException;

/**
 * Jsoup快速入门
 */
public class JsoupDemo3 {
    public static void main(String[] args) throws IOException {
        // 根据 xml 文档获取 Document 对象
        //获取 student.xml 的path
        String path= JsoupDemo3.class.getClassLoader().getResource("student.xml").getPath();
        //解析 xml 文档，加载文档进内存，获取 dom 树
        Document document = Jsoup.parse(new File(path), "utf-8");
        // 获取元素对象
        Elements elements = document.getElementsByTag("student");
        System.out.println(elements);
        System.out.println("---------------------");
        Elements elements1 = document.getElementsByAttribute("id");
        System.out.println(elements1);
        System.out.println("---------------------");
        Elements elements2 = document.getElementsByAttributeValue("number", "itcast_0001");
        System.out.println(elements2);
        System.out.println("---------------------");
        Element element = document.getElementById("heima");
        System.out.println(element);
    }

}

　　* Elements：元素 Element 对象的集合，可以当作 ArrayList<Element>来使用，可以迭代遍历

　　* Element：元素对象
　　　　* 获取子元素对象
　　　　　　* getElementById(String id)：根据 id 属性值获取唯一的 element 对象
　　　　　　* getElementsByTag(String tagname)：根据标签名称获取元素对象集合
　　　　　　* getElementsByAttribute(String key)：根据属性名称获取元素对象集合
　　　　　　* getElementsByAttributeValue(String key, String value)：根据对应的属性名和属性值获取元素对象集合
　　　　* 获取属性值
　　　　　　* String attr(String key)：根据属性名称获取属性值
　　　　* 获取文本内容
　　　　　　* String text()：获取文本内容
　　　　　　* String html()：获取标签体的所有内容（包括子标签的字符串内容）

package cn.itcast.jsoup;

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import java.io.File;
import java.io.IOException;

/**
 * Jsoup快速入门
 */
public class JsoupDemo4 {
    public static void main(String[] args) throws IOException {
        // 根据 xml 文档获取 Document 对象
        //获取 student.xml 的path
        String path = JsoupDemo4.class.getClassLoader().getResource("student.xml").getPath();
        //解析 xml 文档，加载文档进内存，获取 dom 树
        Document document = Jsoup.parse(new File(path), "utf-8");

        // 通过document对象获取name标签，可以获取到两个
        Elements elements = document.getElementsByTag("name");

        // 通过element对象获取子标签对象
        Element element = document.getElementsByTag("student").get(0);
        Elements name = element.getElementsByTag("name");

        // 获取element对象的属性值(不区分大小写)
        String number = element.attr("number");

        // 获取文本内容
        String text = name.text();
        String html = name.html();
        System.out.println(html);
        System.out.println(text);
    }

}

　　* Node：节点对象
　　　　* 是 Document 和 Element 的父类

# 快捷查询方式
　　* selector：选择器
　　　　* 使用方法：Elements select(String cssQuery)
　　　　　　* 语法：参考 Selector类中定义的语法

package cn.itcast.jsoup;

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import java.io.File;
import java.io.IOException;

/**
 * Jsoup快速入门
 */
public class JsoupDemo5 {
    public static void main(String[] args) throws IOException {
        // 根据 xml 文档获取 Document 对象
        //获取 student.xml 的path
        String path = JsoupDemo5.class.getClassLoader().getResource("student.xml").getPath();
        //解析 xml 文档，加载文档进内存，获取 dom 树
        Document document = Jsoup.parse(new File(path), "utf-8");

        Elements elements = document.select("name");
        System.out.println(elements);
        System.out.println("---------------");
        Elements elements1 = document.select("#heima");
        System.out.println(elements1);
        System.out.println("---------------");
        Elements elements2 = document.select("student[number='itcast_0002']");
        System.out.println(elements2);
        System.out.println("---------------");
        Elements elements3 = document.select("student[number='itcast_0002'] > age");
        System.out.println(elements3);

    }

}

　　* XPath：XPath即为XML路径语言，它是一种用来确定 XML文档中某部分位置的语言
　　　　* 使用 Jsoup 的 Xpath 需要额外导入 jar 包
　　　　* 查询 w3cschool 参考手册，使用 xpath完成查询      https://www.w3school.com.cn/xpath/xpath_functions.asp

package cn.itcast.jsoup;

import cn.wanghaomiao.xpath.exception.XpathSyntaxErrorException;
import cn.wanghaomiao.xpath.model.JXDocument;
import cn.wanghaomiao.xpath.model.JXNode;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.select.Elements;

import java.io.File;
import java.io.IOException;
import java.util.List;

/**
 * Jsoup快速入门
 */
public class JsoupDemo6 {
    public static void main(String[] args) throws IOException, XpathSyntaxErrorException {
        // 根据 xml 文档获取 Document 对象
        //获取 student.xml 的path
        String path = JsoupDemo6.class.getClassLoader().getResource("student.xml").getPath();
        //解析 xml 文档，加载文档进内存，获取 dom 树
        Document document = Jsoup.parse(new File(path), "utf-8");

        // 根据document对象 创建JXdocument对象
        JXDocument jxDocument = new JXDocument(document);

        // 结合 Xpath 语法进行查询
        List<JXNode> jxNodes = jxDocument.selN("//student");
        for (JXNode jxNode : jxNodes) {
            System.out.println(jxNode);
        }
        System.out.println("------------");
        // 查询所有 student 标签下的 name 标签
        List<JXNode> jxNodes2 = jxDocument.selN("//student/name");
        for (JXNode jxNode : jxNodes2) {
            System.out.println(jxNode);
        }
        System.out.println("------------");
        // 查询 student 标签下带有 id 属性的标签
        List<JXNode> jxNodes3 = jxDocument.selN("//student/name[@id]");
        for (JXNode jxNode : jxNodes3) {
            System.out.println(jxNode);
        }

        // 查询 student 标签下带有 id 属性的标签 并且id 属性值为 itcast
        System.out.println("------------");
        List<JXNode> jxNodes4 = jxDocument.selN("//student/name[@id=heima]");
        for (JXNode jxNode : jxNodes4) {
            System.out.println(jxNode);
        }
    }

}