java中常用XML解析器的使用

目录

• XML概述
• 组成部分
• 1.文档声明
• 2.指令
• 3.标签
• 4.属性
• 5.文本
• XML示例
• 约束
• XML的解析
• JAXP的使用
• 准备student.xml文件
• 解析XML文档
• 写入XML文档
• dom4j的使用
• Document对象获取方式
• 1.使用DocumentHelper.createDocument()创建Document对象
• 2.建SAXReader对象然后转换成Document对象
• 3.读取XML文本内容获取Document对象
• 引入依赖
• 解析XML文档
• 文档写入XML
• Jsoup的使用
• 引入依赖
• 核心对象
• 1.Jsoup
• 解析XML文档
• JsoupXPath的使用
• 引入依赖
• 解析XML文档

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

XML概述

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

组成部分

1.文档声明

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

2.指令

用于结合css： 

3.标签

标签名称自定义，需遵循规则：

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

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

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

名称不能包含空格 

4.属性

id属性值唯一

5.文本

CDATA区：在该区域中的数据会被原样展示
    格式：  

语法

xml文档的后缀名 .xml

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

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

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

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

xml标签名称区分大小写

XML示例

    
        小白
        20
    

    
        大白
        30
    

约束

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

DTD

students.dtd

引入方式：

内部dtd：将约束规则定义在xml文档中

        
        
        
        
        ]>

    
        小白
        20
    
    
        大白
        30
    

外部dtd：将约束的规则定义在外部的dtd文件中

本地：

    
        小白
        20
    
    
        大白
        30
    

网络：

Schema

1.填写xml文档的根元素 

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的解析

解析就是操作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解析、写入测试。

    
        小白
        20
    

    
        大白
        30
    

解析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 = "......";
Document document = DocumentHelper.parseText(xmlStr);

引入依赖

        
            org.dom4j
            dom4j
            2.1.3
        

解析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 attributes = rootElement.attributes();
        for (Attribute attribute : attributes) {
            System.out.println("属性:" + attribute.getName() + "---" + attribute.getText());
        }

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

    static public void getALLNodes(Element rootElement) {
        System.out.println("根节点名称:" + rootElement.getName());
        //根节点下的节点
        List elements = rootElement.elements();
        for (Element element : elements) {
            //拿到节点属性
            List attributes = element.attributes();
            for (Attribute attribute : attributes) {
                System.out.println("属性:" + attribute.getName() + "---" + attribute.getText());
            }
            //根节点下的节点的节点
            List sonElements = element.elements();
            for (Element sonElement : sonElements) {
                //节点名称 大白节点中的值
                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元素、属性、文本

引入依赖

    org.jsoup
    jsoup
    1.13.1

核心对象

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使用。

常用方法：

//根据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的树状结构，提供在数据结构树中找寻节点的能力。

引入依赖

    cn.wanghaomiao
    JsoupXpath
    2.4.3

解析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 jxNodes = jxDocument.selN("//student");
        for (JXNode jxNode : jxNodes) {
            System.out.println(jxNode);
        }


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

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

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

到此这篇关于java中常用XML解析器的使用的文章就介绍到这了,更多相关java常用XML解析器内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！