亲宝软件园·资讯

展开

java中常用XML解析器的使用

丨Jack_Chen丨 人气:0

(JAXP、DOM4J、Jsoup、JsoupXPath等常用XML解析器的使用)

XML概述

XML(Extensible Markup Language),可扩展标记语言。XML具有标签自定义,语法严格,适用于存储数据与传输数据等特点。

在这里插入图片描述

组成部分

1.文档声明

格式:<?xml 属性列表 ?>
	
属性列表:
	version:版本号,必须的属性
	encoding:编码方式。告知解析引擎当前文档使用的字符集,默认值:ISO-8859-1
	standalone:是否独立 yes:不依赖其他文件 no:依赖其他文件

2.指令

用于结合css:<?xml-stylesheet type="text/css" href="xml.css" rel="external nofollow"  ?> 

3.标签

标签名称自定义,需遵循规则:

名称可以包含字母、数字以及其他的字符 

名称不能以数字或者标点符号开始 

名称不能以字母 xml(或者 XML、Xml 等等)开始 

名称不能包含空格 

4.属性

id属性值唯一

5.文本

CDATA区:在该区域中的数据会被原样展示
    格式:  <![CDATA[ 展示数据]]>

语法

xml文档的后缀名 .xml

xml第一行必须定义为文档声明,可选部分,如果存在需要放在文档的第一行

xml文档中有且仅有一个根标签,是所有其他元素的父元素

属性值必须使用引号(单双都可)引起来

标签必须正确关闭,所有的XML元素都必须有一个关闭标签

xml标签名称区分大小写

XML示例

<?xml version="1.0" encoding="UTF-8" ?>

<students>
    <student id='1'>
        <name>小白</name>
        <age>20</age>
    </student>

    <student id='2'>
        <name>大白</name>
        <age>30</age>
    </student>
</students>

约束

约束是规定xml文档的书写规则。约束分为:DTD(一种简单的约束技术)与Schema(一种复杂的约束技术)共两类。

DTD

students.dtd

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

引入方式:

内部dtd:将约束规则定义在xml文档中
<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE students [
        <!ELEMENT students (student+) >
        <!ELEMENT student (name,age)>
        <!ELEMENT name (#PCDATA)>
        <!ELEMENT age (#PCDATA)>
        <!ATTLIST student name ID #REQUIRED>
        ]>
<students>
    <student name="xb">
        <name>小白</name>
        <age>20</age>
    </student>
    <student name="db">
        <name>大白</name>
        <age>30</age>
    </student>
</students>
外部dtd:将约束的规则定义在外部的dtd文件中

本地:<!DOCTYPE 根标签名 SYSTEM "dtd文件的位置">

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

<students>
    <student name="xb">
        <name>小白</name>
        <age>20</age>
    </student>
    <student name="db">
        <name>大白</name>
        <age>30</age>
    </student>
</students>

网络:<!DOCTYPE 根标签名 PUBLIC "dtd文件名字" "dtd文件的位置URL">

Schema

1.填写xml文档的根元素 <?xml version="1.0" encoding="UTF-8"?>

2.引入xsi前缀  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

3.引入xsd文件命名空间  xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd"

4.为每一个xsd约束声明一个前缀,作为标识 xmlns:mvc="http://www.springframework.org/schema/mvc"
<?xml version="1.0" encoding="UTF-8"?>
<beans 
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:="http://www.springframework.org/schema/beans"
       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/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">


    <bean></bean>

    <mvc:annotation-driven />

</beans>

XML的解析

解析就是操作xml文档,将文档中的数据读取到内存中,再将内存中的数据保存到xml文档中,持久化存储。

解析方式

1. DOM:将标记语言文档一次性加载进内存,在内存中形成一颗dom树。操作方便,可以对文档进行CRUD的操作,但占用内存。

2. SAX:逐行读取,基于事件驱动的,其优点不占用内容,但是只能读取,不能增删改。

常见解析器

1. JAXP:sun公司提供的解析器,支持dom和sax两种思想

2. DOM4J:是一个十分优秀的Java XML API,用来读写XML文件,具有性能优异、功能强大和极其易使用的特点。

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

4. JsoupXPath:XPath即为XML路径语言(XML Path Language),它是一种用来确定XML文档中某部分位置的语言。

JAXP的使用

准备student.xml文件

创建student.xml文件,用于XML解析、写入测试。

<?xml version="1.0" encoding="UTF-8" ?>

<students>
    <student id='1'>
        <name>小白</name>
        <age>20</age>
    </student>

    <student id='2'>
        <name>大白</name>
        <age>30</age>
    </student>
</students>

解析XML文档

解析XML文档的步骤:

使用javax.xml.parsers包下的DocumentBuilderFactory类中的newInstance()方法获得一个解析器工厂对象

使用解析器工厂对象的newDocumentBuilder()方法获得一个解析器对象

用解析器对象的parse(String uri)方法解析指定XML文档并返回一个org.w3c.dom包下的Document对象

使用Document对象的getElementsByTagName(String tagname)方法获得指定标签名的NodeList列表

使用NodeList列表的item(int index)方法得到指定角标的节点对象

使用Node接口中的一系列方法对其进行操作
    public static void main(String[] args) throws Exception {
        String path = ApplicationTests.class.getClassLoader().getResource("students.xml").getPath();

        // 创建解析器工厂对象
        DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
        // 创建解析器对象
        DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
        // 解析指定XML文档返回document
        Document document = documentBuilder.parse(new File(path));
        // 获得指定标签名的NodeList列表
        NodeList students = document.getElementsByTagName("name");
        // 得到指定角标的节点对象
        for (int i = 0; i < students.getLength(); i++) {
            Node node = students.item(i);
            // TODO 使用Node接口中的一系列方法对其进行操作
            System.out.println("node name = " + node.getTextContent());
        }
    }

写入XML文档

写入XML文档的步骤:

创建sex标签节点

创建sex标签对应文本值

对sex标签添加text  

对某个节点添加sex标签节点

通过javax.xml.transform包下的TransformerFactory.newInstance()方法得到一个回写转换器对象工厂

通过回写转换器对象工厂的newTransformer()方法得到回写转换器对象

使用回写转换器对象的transform(Source xmlSource, Result outputTarget)方法将内存中内容回写入XML文档。

       Source参数通过new DOMSource(文档对象)方法获得

       Result参数可以通过javax.xml.tramsform.stream包下的StreamResult(String URL)方法获得
    public static void main(String[] args) throws Exception {
        String path = ApplicationTests.class.getClassLoader().getResource("students.xml").getPath();

        // 创建解析器工厂对象
        DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
        // 创建解析器对象
        DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
        // 解析指定XML文档返回document
        Document document = documentBuilder.parse(new File(path));

        //创建sex标签
        Node sex = document.createElement("sex");
        //创建文本
        Text text = document.createTextNode("男");
        // sex标签添加text
        sex.appendChild(text);
        Node node = document.getElementsByTagName("student").item(0);
        // student标签添加sex节点
        node.appendChild(sex);
        // 得到回写转换器对象工厂
        TransformerFactory transformerFactory = TransformerFactory.newInstance();
        // 得到回写转换器对象
        Transformer transformer = transformerFactory.newTransformer();
        // 将内存中内容回写入XML文档
        transformer.transform(new DOMSource(document), new StreamResult(new File(path)));
    }

dom4j的使用

dom4j是一个开源的XML处理框架,集成了XPath,全面支持DOM、SAX、JAXP和Java平台。是一个十分优秀的Java XML API,用来读写XML文件,具有性能优异、功能强大和极其易使用的特点。

GitHub地址:https://github.com/dom4j/dom4j

Document对象获取方式

解析XML过程是通过获取Document对象,然后继续获取各个节点以及属性等操作,获取Document对象是第一步,总共有三种方式。

1.使用DocumentHelper.createDocument()创建Document对象

Document document = DocumentHelper.createDocument();
//其中students是根节点,可以继续添加其他节点等操作。
Element root = document.addElement("students");

2.建SAXReader对象然后转换成Document对象

//创建SAXReader对象
SAXReader reader = new SAXReader();
//读取文件 转换成Document
Document document = reader.read(new File("XXXX.xml"));

3.读取XML文本内容获取Document对象

String xmlStr = "<students>......</students>";
Document document = DocumentHelper.parseText(xmlStr);

引入依赖

<!-- https://mvnrepository.com/artifact/org.dom4j/dom4j -->
        <dependency>
            <groupId>org.dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>2.1.3</version>
        </dependency>

解析XML文档

public static void main(String[] args) throws Exception {
        String path = XmlTest.class.getClassLoader().getResource("students.xml").getPath();
        //UTF-8编码
        String filePath = URLDecoder.decode(path, "UTF-8");

        //xml解析器
        SAXReader saxReader = new SAXReader();
        Document read = saxReader.read(filePath);
        //拿到根节点
        Element rootElement = read.getRootElement();
        //getNodes(rootElement);
        getALLNodes(rootElement);
    }

    static public void getNodes(Element rootElement) {
        System.out.println("节点名称:" + rootElement.getName());

        //拿到节点属性
        List<Attribute> attributes = rootElement.attributes();
        for (Attribute attribute : attributes) {
            System.out.println("属性:" + attribute.getName() + "---" + attribute.getText());
        }

        //节点名称 <name>大白</name>节点中的值
        if (!rootElement.getTextTrim().equals("")) {
            System.out.println(rootElement.getName() + "---" + rootElement.getText());
        }
        //迭代器遍历
        Iterator<Element> elementIterator = rootElement.elementIterator();
        while (elementIterator.hasNext()) {
            //获取当前节点值
            Element next = elementIterator.next();
            getNodes(next);
        }
    }

    static public void getALLNodes(Element rootElement) {
        System.out.println("根节点名称:" + rootElement.getName());
        //根节点下的节点
        List<Element> elements = rootElement.elements();
        for (Element element : elements) {
            //拿到节点属性
            List<Attribute> attributes = element.attributes();
            for (Attribute attribute : attributes) {
                System.out.println("属性:" + attribute.getName() + "---" + attribute.getText());
            }
            //根节点下的节点的节点
            List<Element> sonElements = element.elements();
            for (Element sonElement : sonElements) {
                //节点名称 <name>大白</name>节点中的值
                if (!sonElement.getTextTrim().equals("")) {
                    System.out.println(sonElement.getName() + "---" + sonElement.getText());
                }
            }
        }
    }

文档写入XML

public static void main(String[] args) throws Exception {
        String path = ApplicationTests.class.getClassLoader().getResource("students.xml").getPath();
        //UTF-8编码
        String filePath = URLDecoder.decode(path, "UTF-8");
        //xml解析器
        SAXReader saxReader = new SAXReader();
        Document read = saxReader.read(filePath);
        createStudentNode(read, path);
    }

    /**
     * 创建新的student节点
     *
     * @param document
     */
    public static void createStudentNode(Document document, String path) {
        try (Writer writer = new OutputStreamWriter(new FileOutputStream(path), "UTF-8")) {
            // 获取根节点
            Element root = document.getRootElement();
            // 添加根节点的子节点  新的student节点
            Element b = root.addElement("student");
            // 创建student节点的各个子节点
            // 添加子节点的属性
            b.addAttribute("id", "3");//原有长度+1
            // 添加子节点的的子节点name
            b.addElement("name").setText("createNode");
            // 添加子节点的子节点age
            b.addElement("age").setText("22");

            // 写入XML
            document.write(writer);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

Jsoup的使用

GitHub地址:https://github.com/jhy/jsoup

官网:https://jsoup.org

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

Jsoup主要功能

从一个URL,文件或字符串中解析HTML

使用DOM或CSS选择器来查找、取出数据

可操作HTML元素、属性、文本

引入依赖

<!-- https://mvnrepository.com/artifact/org.jsoup/jsoup -->
<dependency>
    <groupId>org.jsoup</groupId>
    <artifactId>jsoup</artifactId>
    <version>1.13.1</version>
</dependency>

核心对象

1.Jsoup

Jsoup是一个工具类,可以解析html或xml文档,返回Document。

常用方法:

//解析xml或html字符串
public static Document parse(String html) {
        return Parser.parse(html, "");
    }

//解析xml或html文件    
public static Document parse(File in, String charsetName) throws IOException {
        return DataUtil.load(in, charsetName, in.getAbsolutePath());
    }

//通过网络路径获取指定的html或xml的文档对象
public static Document parse(URL url, int timeoutMillis) throws IOException {
        Connection con = HttpConnection.connect(url);
        con.timeout(timeoutMillis);
        return con.get();
    }    

2.Document

Document是指文档对象,代表内存中的dom树。

常用方法:

//根据id属性值获取唯一的element对象
public Element getElementById(String id) {
        Validate.notEmpty(id);
        Elements elements = Collector.collect(new Id(id), this);
        return elements.size() > 0 ? (Element)elements.get(0) : null;
    }

//根据标签名称获取元素对象集合  
public Elements getElementsByTag(String tagName) {
        Validate.notEmpty(tagName);
        tagName = Normalizer.normalize(tagName);
        return Collector.collect(new org.jsoup.select.Evaluator.Tag(tagName), this);
    }

//根据属性名称获取元素对象集合
 public Elements getElementsByAttribute(String key) {
        Validate.notEmpty(key);
        key = key.trim();
        return Collector.collect(new Attribute(key), this);
    }

//根据对应的属性名和属性值获取元素对象集合
   public Elements getElementsByAttributeValue(String key, String value) {
        return Collector.collect(new AttributeWithValue(key, value), this);
    }

3.Elements与Element

Element是元素对象,Elements是元素Element对象的集合,可以当做 ArrayList<Element>使用。

常用方法:

//根据id属性值获取唯一的element对象
    public Element getElementById(String id) {
        Validate.notEmpty(id);
        Elements elements = Collector.collect(new Id(id), this);
        return elements.size() > 0 ? (Element)elements.get(0) : null;
    }
    
//根据class属性值获取elements对象集合  
 public Elements getElementsByClass(String className) {
        Validate.notEmpty(className);
        return Collector.collect(new Class(className), this);
    }   
    
//根据标签名称获取元素对象集合   
 public Elements getElementsByTag(String tagName) {
        Validate.notEmpty(tagName);
        tagName = Normalizer.normalize(tagName);
        return Collector.collect(new org.jsoup.select.Evaluator.Tag(tagName), this);
    }

//根据属性名称获取元素对象集合
public Elements getElementsByAttribute(String key) {
        Validate.notEmpty(key);
        key = key.trim();
        return Collector.collect(new Attribute(key), this);
    }

//根据对应的属性名和属性值获取元素对象集合
public Elements getElementsByAttributeValue(String key, String value) {
        return Collector.collect(new AttributeWithValue(key, value), this);
    }


//根据属性名称获取属性值
    public String attr(String attributeKey) {
        Validate.notNull(attributeKey);
        if (!this.hasAttributes()) {
            return "";
        } else {
            String val = this.attributes().getIgnoreCase(attributeKey);
            if (val.length() > 0) {
                return val;
            } else {
                return attributeKey.startsWith("abs:") ? this.absUrl(attributeKey.substring("abs:".length())) : "";
            }
        }
    }
    
//获取文本内容
public String text() {
        StringBuilder sb = new StringBuilder();

        Element element;
        for(Iterator var2 = this.iterator(); var2.hasNext(); sb.append(element.text())) {
            element = (Element)var2.next();
            if (sb.length() != 0) {
                sb.append(" ");
            }
        }

        return sb.toString();
    }
    
//获取标签体的所有内容(包括字标签的字符串内容)
    public String html() {
        StringBuilder sb = new StringBuilder();
        Element element;
        for(Iterator var2 = this.iterator(); var2.hasNext(); sb.append(element.html())) {
            element = (Element)var2.next();
            if (sb.length() != 0) {
                sb.append("\n");
            }
        }

        return sb.toString();
    }

解析XML文档

    public static void main(String[] args) throws IOException {
        //根据xml文档获取,获取Document对象
        String path = JsoupDemo1.class.getClassLoader().getResource("student.xml").getPath();
        //解析xml文档,加载文档进内存
        Document document = Jsoup.parse(new File(path), "utf-8");
        //获取元素对象Element
        Elements elements = document.getElementsByTag("name");
        //循环得到每一个element对象
        for (Element element : elements) {
            //获取数据
            String name = element.text();
            System.out.println(name);
        }


        //获取属性名为id的元素对象们
        Elements elements1 = document.getElementsByAttribute("id");
        System.out.println(elements1);

        //获取id属性值为2的元素对象
        Elements elements2 = document.getElementsByAttributeValue("id", "2");
        System.out.println(elements2);

        //获取id属性值的元素对象
        Element elements3 = document.getElementById("2");
        System.out.println(elements3);

        //通过Element对象获取子标签对象
        Elements ele_name = elements3.getElementsByTag("name");
        System.out.println(ele_name);

        //获取student对象的属性值
        String id = elements3.attr("id");
        System.out.println(id);

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

JsoupXPath的使用

GitHub地址:https://github.com/zhegexiaohuozi/JsoupXpath

XPath即为XML路径语言(XML Path Language),它是一种用来确定XML文档中某部分位置的语言。

XPath基于XML的树状结构,提供在数据结构树中找寻节点的能力。

引入依赖

<!-- https://mvnrepository.com/artifact/cn.wanghaomiao/JsoupXpath -->
<dependency>
    <groupId>cn.wanghaomiao</groupId>
    <artifactId>JsoupXpath</artifactId>
    <version>2.4.3</version>
</dependency>

解析XML文档

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

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

        //查询所有student标签
        List<JXNode> jxNodes = jxDocument.selN("//student");
        for (JXNode jxNode : jxNodes) {
            System.out.println(jxNode);
        }


        //查询所有student标签下的name标签
        List<JXNode> jxNodes2 = jxDocument.selN("//student/name");
        for (JXNode jxNode : jxNodes2) {
            System.out.println(jxNode);
        }

        //查询带有id属性的student标签
        List<JXNode> jxNodes3 = jxDocument.selN("//student[@id]");
        for (JXNode jxNode : jxNodes3) {
            System.out.println(jxNode);
        }

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

加载全部内容

相关教程
猜你喜欢
用户评论