XML技术

XML概述

1.概念

XML（Extensible Markup Language）：可拓展标记语言

可拓展：标签都是自定义的

2.发展历程

HTML 和 XML 都是 W3C（万维网联盟）制定的标准，最开始 HTML 的语法过于松散，

于是 W3C 制定了更严格的 XML 语法标准，希望能取代 HTML。但是程序员和浏览器厂商

并不喜欢使用 XML，于是现在的 XML 更多的用于***配置文件及传输数据***等功能

传输数据：

在网络中传输数据时并不能传输java对象，所以我们需要将JAVA对象转成字符串传输，其中一种方式就是将对象转为XML类型的字符串

配置文件：

使用框架时，需要我们书写配置文件配置相关的参数，让框架满足我们的开发需求。而我们书写的配置文件中就有一种文件类型是XML

3.xml和html的区别

xml标签自定义，html标签预定义

xml语法严格，html语法松散

4.XML基本语法

文件后缀名是.xml

第一行必须是文档声明

有且仅有一个根标签

标签必须正确关闭

标签名区分大小写

属性值必须用单引号（单双都可）引起来

5.XML组成部分

<?xml version="1.0"?>
5.1  文档声明必须放在第一行，格式为：<?xml 属性列表?>
  属性列表：
	version：版本号（必须）
	encoding：编码方式

5.3（了解指令）
指令是结合 css 使用的，但现在 XML 一般不结合 CSS，语法为： <?xml-stylesheet type="text/css" href="a.css" ?>
<students>
  5.2 XML 中标签名是自定义的，标签名有以下要求： 
     包含数字、字母、其他字符 
     不能以数字和标点符号开头 
     不能包含空格
	
    <student>
		<stuid id="001">1</stuid>5.4  属性值必须用引号（单双都可）引起来
		<name sss='aaa'>喜羊羊</name>
		<_age.1>
		<![CDATA[if(a==0){}]]>
         5.5 文本
  		如果想要原样展示文本，需要设置CDATA区，格式为：<![CDATA[文本]]>
		</_age.1>
	</student>
	<student>
		<stuid>2</stuid>
		<name>meiyangyang</name>
		<age>6</age>
	</student>
</students>

约束

1.什么是约束？

约束是一个文件，可以规定xml文档的书写规则。我们作为框架的使用者，不需要会写约束文件，只要能够在xml种引入约束文档，简单的读懂约束文档即可。XML有两种约束文件类型：

DTD和Schema

2.DTD约束

DTD 是一种较简单的约束技术

<!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"?>
<!DOCTYPE students SYSTEM "student.dtd">

//引入
本地：<!DOCTYPE 根标签名 SYSTEM "dtd文件的位置">
网络：<!DOCTYPE 根标签名 PUBLIC "dtd 文件的位置" "dtd 文件路径">

<students>
    <student number="baizhan001">
            <name>喜羊羊</name>
            <age>15</age>
            <sex>男</sex>
    </student>
    <student number="baizhan002">
            <name>美羊羊</name>
            <age>20</age>
            <sex>女</sex>
    </student>
</students>

3.Schema约束

<?xml version="1.0"?>
<xsd:schema xmlns="http://www.itbaizhan.cn/xml"
        xmlns:xsd="http://www.w3.org/2001/XMLSchema"
        targetNamespace="http://www.itbaizhan.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="baizhan_\d{4}"/>
        </xsd:restriction>
    </xsd:simpleType>
</xsd:schema>

<?xml version = "1.0" ?>
<students
  （1）写xml文档的根标签
        
        xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
  （2）引入xsi前缀：确定Schema文件的版本
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
          
	    xsi:schemaLocation = "http://www.itbaizhan.cn/xml student.xsd"
  （3）引入Schema文件
        xsi:schemaLocation="Schema 文件定义的命名空间 Schema文件的具体路径  
          
    
        xmlns = "http://www.itbaizhan.cn/xml">
  （4）为 Schema 约束的标签声明前缀     
         xmlns:前缀="Schema 文件定义的命名空间"                                    

    <student number="baizhan_0001">
        <name>喜羊羊</name>
        <age>14</age>
        <sex>male</sex>
    </student>

    <student number="baizhan_0002">
        <name>meiyangyang</name>
        <age>8</age>
        <sex>female</sex>
    </student>

</students>

XML解析

XML 解析即读写 XML 文档中的数据。框架的开发者通过 XML 解析读取框架使用者配

置的参数信息，开发者也可以通过 XML 解析读取网络传来的数据。（html）

1.XML解析思想

DOM

将标记语言文档一次性加载进内存，在内存中形成一颗dom树

优点：操作方便，可以对文档进行 CRUD 的所有操作

缺点：占内存

SAX

逐行读取，基于事件驱动的。

优点：不占内存，一般用于手机 APP 开发中读取 XML

缺点：只能读取，不能增删改

2.常见的解析器

JAXP

SUN 公司提供的解析器，支持 DOM 和 SAX 两种思想

DOM4J

一款非常优秀的解析器

Jsoup

Jsoup 是一款 Java 的 HTML 解析器，可直接解析某个 URL 地址、HTML 文本内容。它提供了一套非常省力的 API，可通过 DOM，CSS 以及类似于 jQuery 的操作方法来取出和操作数据

PULL

Android 操作系统内置的解析器，支持 SAX 思想

Jsoup解析器

1.快速入门

（1）导入jar包

（2）加载XML文档进内存，获取DOM树对象Document

（3）获取对应的标签Element对象

（4）获取数据

package com.baizhan.xml.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;

public class Demo1 {
    
    //获取XML中所有的学生姓名
    public static void main(String[] args) throws IOException {
       //1.加载XML文档进内存，获取DOM树对象Document
        //1.1 找到XML文档的绝对路径
        //利用类加载器，通过项目中文件的相对路径找到硬盘中的绝对路径
        ClassLoader classLoader = Demo1.class.getClassLoader();
        String path = classLoader.getResource("com/baizhan/xml/xsd/student.xml").getPath();
        System.out.println(path);

        //1.2 根据XML文档的路径，把XML文档加载进内存，并解析成Dom树对象
         Document document = Jsoup.parse(new File(path),"utf-8");
        System.out.println(document);

        //2.获取对应的标签Element对象
        Elements name = document.getElementsByTag("name");

        // 3.获取数据
        for(Element element:name)
        {
            String text = element.text();
            System.out.println(text);
        }



    }
}

2.常用对象

Jsoup

解析xml或html，形成dom树对象

常用方法;

static Document parse(File in,String charsetName):解析本地文件

static Document parse(String html)：解析 html 或 xml 字符串

static Document parse(URL url, int timeoutMillis)：解析网页源文件

package com.baizhan.xml.jsoup;

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;

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

public class Demo2 {
    //Jsoup
    public static void main(String[] args) throws IOException {
        
        //解析本地XML
        String path = Demo2.class.getClassLoader().getResource("com/baizhan/xml/xsd/student.xml").getPath();
        Document document = Jsoup.parse(new File(path),"utf-8");
        
        System.out.println(document);
        System.out.println("-------------------------------");
        //解析字符串
        Document document1 = Jsoup.parse("<student number=\"baizhan_0001\">\n" +
                "        <name>喜羊羊</name>\n" +
                "        <age>14</age>\n" +
                "        <sex>male</sex>\n" +
                "    </student>\n" +
                "\n" +
                "    <student number=\"baizhan_0002\">\n" +
                "        <name>meiyangyang</name>\n" +
                "        <age>8</age>\n" +
                "        <sex>female</sex>\n" +
                "    </student>");
        System.out.println(document1);
        System.out.println("-------------------------");


        //解析网络资源（后面的是解析所需要的时间）
        Document document2 = Jsoup.parse(new URL("https://www.baidu.com"), 8000);
        System.out.println(document2);
    }
}

Document

xml的dom树对象

常用方法：

Element getElementById(String id)：根据 id 获取元素

Elements getElementsByTag(String tagName)：根据标签名获取元素

Elements getElementsByAttribute(String key)：根据属性获取元素

Elements getElementsByAttributeValue(String key,String value)：根据属性名 =属性值获取元素。

Elements select(Sting cssQuery)：根据选择器选取元素。

package com.baizhan.xml.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;

public class Demo3 {
    //Document
    public static void main(String[] args) throws IOException {
        String path = Demo2.class.getClassLoader().getResource("com/baizhan/xml/jsoup/student.xml").getPath();
        Document document = Jsoup.parse(new File(path),"utf-8");

        //根据id获取元素
        Element element1 = document.getElementById("a1");
        System.out.println(element1.text());
        System.out.println("-----------------------");
        
        //根据标签获取元素
        Elements age = document.getElementsByTag("age");
        for(Element element:age)
        {
            System.out.println(element.text());
        }
        System.out.println("-----------------------");
       
        //根据属性获取元素
        Elements number = document.getElementsByAttribute("number");
        for(Element element:number)
        {
            System.out.println(element);
        }

        System.out.println("-----------------------");
        
        //根据属性名=属性值获取元素

        Elements elements2 = document.getElementsByAttributeValue("number","baizhan_0001");
        for(Element element:elements2)
        {
            System.out.println(element);
        }

        System.out.println("-----------------------");




        //使用css选择器获取元素
        Elements element3 = document.select("#a1");
        System.out.println(element3);
        System.out.println("----------------");

        Elements elements4 = document.select(".hh");//类选择器
        System.out.println(elements4);
        System.out.println("----------------");

        Elements elements5 = document.select("name");
        System.out.println(elements5);
        System.out.println("----------------");

    }
}

Element

元素对象

常用方法：

String text()：获取元素包含的纯文本。

String html()：获取元素包含的带标签的文本。

String attr(String attributeKey)：获取元素的属性值。

package com.baizhan.xml.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;

public class Demo4 {
    public static void main(String[] args) throws IOException {
        String path = Demo2.class.getClassLoader().getResource("com/baizhan/xml/jsoup/student.xml").getPath();
        Document document = Jsoup.parse(new File(path),"utf-8");

        Elements elements = document.getElementsByAttributeValue("number", "baizhan_0001");
        for(Element element:elements)
        {
            System.out.println(element.text());
            //String text()：获取元素包含的纯文本。 
           
            System.out.println(element.html());
            //String html()：获取元素包含的带标签的文本。 
            
            System.out.println(element.attr("number"));
            //String attr(String attributeKey)：获取元素的属性值。
        }

    }
}

Xpath解析

XPath 即为 XML 路径语言，它是一种用来确定标记语言文档中某部分位置的语言。

使用方法：

导入 Xpath 的 jar 包
获取 Document 对象
将 Document 对象转为 JXDocument 对象
JXDocument 调用 selN(String xpath)，获取 List对象。
遍历 List，调用 JXNode 的 getElement()，转为 Element 对象。

处理 Element 对象。

package com.baizhan.xml.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.nodes.Element;

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

public class Demo5 {
    public static void main(String[] args) throws IOException, XpathSyntaxErrorException {
        //Xpath
        
        //2.获取Document对象
        String path = Demo5.class.getClassLoader().getResource("com/baizhan/xml/jsoup/student.xml").getPath();
        Document document = Jsoup.parse(new File(path), "utf-8");


        //3.将Document对象转为JXDocument对象
        JXDocument jxDocument = new JXDocument(document);

        //4.JXDocument调用selN（String xpath），获取List<JXNode>对象

//        List<JXNode> jxNodes = jxDocument.selN("//name");
//         List<JXNode> jxNodes = jxDocument.selN("//student[@number='baizhan_0002']");

        //想拿到baizhan0001的年龄
        List<JXNode> jxNodes = jxDocument.selN("//student[@number='baizhan_0001']/age");

        
        
        //5.遍历List<JXNode>,调用JXNode的getElement(),转为Element对象

        for(JXNode jxNode:jxNodes)
        {
            Element element = jxNode.getElement();

            
            //6.处理Element对象
//            System.out.println(element.text());
            System.out.println(element);

        }


    }
}

XML案例

1.使用Jsoup完成网页爬虫

网络爬虫（web crawler）：自动抓取互联网信息的程序。

Jsoup 可以通过 URL 获取网页的 HTML 源文件，源文件中包含着网站数据，我们可以

解析 HTML 源文件的数据来获取我们需要的信息。

步骤：

引入 jar 包。

1.使用 Jsoup 获取网页 HTML 源文件，转为 Document 对象

2.通过 Document 对象，获取需要的 Element 对象

3.获取 Element 对象的数据。

4.设置循环自动爬取

package com.baizhan.xml.crawler;

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.nodes.Element;
import org.jsoup.select.Elements;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.List;

public class CrawlerDemo {
    //爬虫

    public static void main(String[] args)  {
        int min = 0;
        int max = 0;
        try {
            //2.解析XML配置文件，加载XML文件到内存，转换成Document对象
            String path = CrawlerDemo.class.getClassLoader().getResource("com/baizhan/xml/crawler/Crawler.xml").getPath();
            Document document1 = Jsoup.parse(new File(path), "utf-8");

            //3.获取XML配置文件的配置信息
            JXDocument jxDocument = new JXDocument(document1);
            try {
                List<JXNode> minNodes = jxDocument.selN("//min");
                List<JXNode> maxNodes = jxDocument.selN("//max");

                Element minElement = minNodes.get(0).getElement();
                Element maxElement = maxNodes.get(0).getElement();

                String maxStr = maxElement.text();
                String minStr = minElement.text();

                min = Integer.parseInt(minStr);
                max = Integer.parseInt(maxStr);

            } catch (XpathSyntaxErrorException e) {
                e.printStackTrace();
            }

        } catch (IOException e) {
            e.printStackTrace();
        }



//设置喜欢自动爬取
        for(int i = min;i<=max;i++)
     {
         try {
             //2.使用Jsoup获取网页HTML源文件，转为Document对象
             Document document = Jsoup.parse(new URL("http://daily.zhihu.com/story/"+i), 8000);
//        System.out.println(document);

             //3.通过Document对象，获取需要的Element对象
             //获取头图，标题，作者，正文
             Elements headerImgEle = document.getElementsByAttributeValue("alt", "头图");
             Elements headerEle = document.select(".DailyHeader-title");
             Elements authorEle = document.select(".author");
             Elements contentEle = document.select(".content");

             //4.获取Element对象的数据
             String headerImg = headerImgEle.get(0).attr("src");
             String header = headerEle.text();
             String author = authorEle.text();
             String content = contentEle.text();
             System.out.println(headerImg);
             System.out.println(header);
             System.out.println(author);
             System.out.println(content);
         } catch (IOException e) {

         }

     }
     }
    }

2.使用XML配置爬虫程序的参数

爬虫程序有一些参数需要配置，如果直接将参数写在 JAVA 程序中，则修改参数非常不

方便，所以此时我们将参数写在 XML 配置文件中，通过解析 XML 文件获取参数的配置信

息。

步骤：

写爬虫程序的 XML 配置文件
解析 XML 配置文件：加载 XML 文件到内存，转为 Document 对象。
获取 XML 配置文件的配置信息
将配置信息应用于爬虫程序中

//写爬虫程序的XML配置文件
<?xml version="1.0" encoding="UTF-8" ?>
<Crawler>
<min>9734820</min>
<max>9734946</max>
</Crawler>

package com.baizhan.xml.crawler;

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.nodes.Element;
import org.jsoup.select.Elements;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.List;

public class CrawlerDemo {
    //爬虫

    public static void main(String[] args)  {
        int min = 0;
        int max = 0;
        try {
            
            //2.解析XML配置文件，加载XML文件到内存，转换成Document对象
            
            String path = CrawlerDemo.class.getClassLoader().getResource("com/baizhan/xml/crawler/Crawler.xml").getPath();
            Document document1 = Jsoup.parse(new File(path), "utf-8");

            //3.获取XML配置文件的配置信息
            JXDocument jxDocument = new JXDocument(document1);
            try {
                List<JXNode> minNodes = jxDocument.selN("//min");
                List<JXNode> maxNodes = jxDocument.selN("//max");

                Element minElement = minNodes.get(0).getElement();
                Element maxElement = maxNodes.get(0).getElement();

                String maxStr = maxElement.text();
                String minStr = minElement.text();

                min = Integer.parseInt(minStr);
                max = Integer.parseInt(maxStr);

            } catch (XpathSyntaxErrorException e) {
                e.printStackTrace();
            }

        } catch (IOException e) {
            e.printStackTrace();
        }




        for(int i = min;i<=max;i++)
     {
         try {
             //2.使用Jsoup获取网页HTML源文件，转为Document对象
             Document document = Jsoup.parse(new URL("http://daily.zhihu.com/story/"+i), 8000);
//        System.out.println(document);

             //3.通过Document对象，获取需要的Element对象
             //获取头图，标题，作者，正文
             Elements headerImgEle = document.getElementsByAttributeValue("alt", "头图");
             Elements headerEle = document.select(".DailyHeader-title");
             Elements authorEle = document.select(".author");
             Elements contentEle = document.select(".content");

             //4.获取Element对象的数据
             String headerImg = headerImgEle.get(0).attr("src");
             String header = headerEle.text();
             String author = authorEle.text();
             String content = contentEle.text();
             System.out.println(headerImg);
             System.out.println(header);
             System.out.println(author);
             System.out.println(content);
         } catch (IOException e) {

         }

     }
     }
    }

源码位置：「XML技术Src」https://www.aliyundrive.com/s/rQv8P8PiVdJ 点击链接保存，或者复制本段内容，打开「阿里云盘」APP ，无需下载极速在线查看，视频原画倍速播放。