XML

最新推荐文章于 2023-06-26 14:04:31 发布
最新推荐文章于 2023-06-26 14:04:31 发布
阅读量213 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wuzhangxiong123/article/details/108431307
版权

XML：可扩展标记型语言

一、基本概念

eXtensible Markup Language:可扩张标记型语言

	标记型语言： HTML是标记语言，即使用标签来操作

​ 可扩展：

​ HTML 里面的标签是固定的，每个标签都有特定的含义

​ xml标签可以自己定义，可以写中文的标签<猫></猫>

二、xml用途

​ 1.不同系统之间传输数据

​ 2.充当小型数据库

​ 3.经常用在配置文件，如：配置MySQL数据库

三、语法

xml文档后缀名为：.xml

文档声明：

创建一个xml文件后，第一步就是必须要有一个文档声明

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

**version：**xml版本，必须写

**encoding：**xml编码 （保存时编码和设置打开时候的编码需要一致，否则会出现乱码）

**standalone：**是否需要依赖其他文件 yes/no

标签的定义

注意事项：

1.有始有终：

2.合理嵌套：

3.空格和换行当做内容来解析，所以我们需要注意一些缩进的问题

名称规则：

1.xml代码区分大小写

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

3.不能以xml、XML、Xml等开头

4.不能包含空格和冒号

属性的定义

1.一个标签上可以有多个属性

2.属性名和值之间使用 = 连接，属性值用引号包起来（单引号和双引号都可以）

注释

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

注释不能嵌套，并且不能放到第一行，第一行必须放文档声明

特殊字符

利用转义字符

特殊符号预定义实体特殊符号预定义实体
&&amp;"&quot ;
<&lt ;’&apos
>&gt ;

CDATA区

可以解决多个字符都需要转义的操作

写法： <! [ CDATA [ 内容 ]]>

如

if(a<b && b<c && d<f){}
可以写成：
<!CDATA [<b> if (a<b && B<c && d<f){}</b> ]]>

把特殊字符当做文本内容，而不是标签

XML约束

约束的作用：

如现在定义一个person的xml文件，只想要这个文件里面保存人的信息，比如name age等，但是如果在xml文件中写一个标签<猫>，发现可以正常显示，因为符合语法规范。但是猫肯定不是人的信息，xml的标签是自定义的，需要技术来规定xml中只能出现的元素，这个时候需要约束。

xml的约束的技术：DTD约束 和Schema约束。

DTD约束

1.dtd引入的三种方式

A：使用内部的dtd文件，将约束规则定义在xml文档中

<!DOCTYPE 根元素名称 [
    	<!ELEMENT 	根元素名称 (person+)>
			<!ELEMENT 	person (name,age)>
			<!ELEMENT		name (#PCDATA)>
			<!ELEMENT 	age (#PCDATA)>
]>

B：引入外部的dtd文件

<!DOCTYPE  根元素名称 SYSTEM "dtd路径">

C：使用外部的dtd文件（网络上的dtd文件）

<!DOCTYPE 根元素 PUBLIC "DTD名称" "DTD文档的URL"

例如使用struts2框架 ，使用配置文件时所使用的外部的dtd文件
<!DOCTYPE struts PUBLIC   "-//Apache Software Foundation//DTD
Struts Configuration 2.0//EN"    
"http://struts.apache.org/dtds/struts-2.0.dtd">
2.使用dtd定义元素
<!ELEMENT 元素名 约束>

A：简单元素（没有子元素）

<!ELEMENT name (#PCDATA)>
 
 (#PCDATA)：约束，PCDATA是字符串类型
 	EMPTY：元素为空（没有内容）例如：<sex></sex>
 	ANY：任意

B：复杂元素

<!-- 语法 -->
<!ELEMENT person (id,name,age)> 子元素只能出现一次

<!ELEMENT 元素名称 (子元素)>

<!-- 子元素出现次数 -->
* ：一次多或多次
？：零次或一次
* ：零次或多次

<!-- 子元素直接使用逗号隔开 -->
	表示元素出现的顺序 

<!-- 子元素直接使用 | -->
	表示元素只能出现其中的任意一个
3.使用dtd定义属性
<!-- 语法 -->
<!ATTLIST 元素名称 	属性名称 属性类型 属性约束>

<!-- 属性类型 -->  CDATA：字符串
<!ATTLIST birthday ID1 CDATA #REQUIRED>

<!-- 枚举 -->
表示只能在一定的范围内出现值，但是只能每次出现其中的一个,红绿灯效果
<!ATTLIST age	ID2 (AA|BB|CC)  #REQUIRED >

<!-- ID: 值只能是字母或者下划线开头 -->
<!ATTLIST name 	ID3 ID   #REQUIRED >

<!--属性的约束 -->
#REQUIRED:  属性必须存在
#IMPLIED:		属性可与可无
#FIXED:			表示一个固定值
			#FIXED "AAA" 属性的值必须是设置的这个固定值


直接值
不写属性，使用直接值
写了属性，使用设置那个值
<!ATTLIST sex			ID4 CDATA #FIXED "ABC"		>
<!ATTLIST school			ID5 CDATA "WWW"		>

Schema约束

schema 符合 xml 的语法，一个 xml 中可以有多个 schema ，多个 schema 使用名称空间区分（类似于java包名）dtd 里面有PCDATA类型，但是在 schema 里面可以支持更多的数据类型

后缀名：xsd

引入：
填写xml文档的根元素

引入xsi前缀.  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	表示xml文件是一个约束文件
	
引入xsd文件命名空间.  xsi:schemaLocation="http://www.bwh.cn/xml  student.xsd"
	使用一个使用schema约束文件，直接通过这个地址引入约束文件
	  通常使用一个url地址防止重名
	  
为每一个xsd约束声明一个前缀,作为标识  xmlns="http://www.bwh.cn/xml"

(1) 看xml中有多少个元素

<element>

(2) 看简单元素和复杂元素

<element name="person">
<complexType>
<sequence>
	<element name="name" type="string"></element>
					<element name="age" type="int"></element>
</sequence>
</complexType>
</element>

(3) 被约束文件里面引入约束文件

<person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.bwh.cn/20151111"
xsi:schemaLocation="http://www.bwh.cn/20151111 1.xsd">

			xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
				-- 表示xml是一个被约束文件
			xmlns="http://www.bwh.cn/20151111"
				-- 是约束文档里面 targetNamespace
			xsi:schemaLocation="http://www.bwh.cn/20151111 1.xsd">
				-- targetNamespace 空格  约束文档的地址路径

可以约束属性

A: <sequence>：表示元素的出现的顺序
B: <all>: 元素只能出现一次
C: <choice>：元素只能出现其中的一个
D: maxOccurs="unbounded"： 表示元素的出现的次数
E: <any></any>:表示任意元素

写在复杂元素里面
写在　</complexType>之前

－－
<attribute name="id1" type="int" use="required"></attribute>
	- name: 属性名称
	- type：属性类型 int stirng
	- use：属性是否必须出现 required

XML解析

DOM解析

package xml;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
import javax.imageio.metadata.IIOMetadataNode;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.*;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @author beifeng
 * @date 2020/8/21
 * 解析users xml
 */
public class DomReader {
    private Document document;
//    获取Document对象
    public  void getDocument(){
        try {
//            创建转换器工厂
            DocumentBuilderFactory bf=DocumentBuilderFactory.newInstance();
//            创建转换器
            DocumentBuilder db=  bf.newDocumentBuilder();
//            获取document对象 
            document=db.parse("src/xml/users.xml");
        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        } catch (SAXException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
    public  void selectAll(){
            NodeList users=document.getElementsByTagName("users").item(0).getChildNodes();
            for (int i = 0; i <users.getLength() ; i++) {
                Node user=users.item(i);
                if (user.getNodeType() == Node.ELEMENT_NODE) {
                    Element useEle=(Element)user;
//                    user.getAttributes().item(0).getNodeValue()
                    System.out.println(user.getNodeName()+"\t"+useEle.getAttribute("id"));
                    NodeList shuxing=user.getChildNodes();
                        for (int j = 0; j < shuxing.getLength(); j++) {
                            if (shuxing.item(j).getNodeType() == Node.ELEMENT_NODE) {
                            String name = shuxing.item(j).getNodeName();
                            System.out.println(name + "=" + shuxing.item(j).getTextContent());
                            }
                         }
                }
                System.out.println();
            }
    }
//    修改元素节点
    public  void update() throws TransformerException, FileNotFoundException {
        NodeList upNode=document.getElementsByTagName("user");
        for (int i = 0; i <upNode.getLength() ; i++) {
//            System.out.println( upNode.item(i).getAttributes().item(0).getNodeValue());
            if (upNode.item(i).getNodeType() == Node.ELEMENT_NODE && upNode.item(i).getAttributes().item(0).getNodeValue().equals(i+"")) {
                Element upEle=(Element)upNode.item(i);
                upEle.setAttribute("id","A"+i);
            }
        }
        saveXml();
    }
//  保存xml文件
    public void  saveXml() throws TransformerException, FileNotFoundException {
        //创建转换器工厂
        TransformerFactory tff= TransformerFactory.newInstance();
        //创建转换器
        Transformer tf=tff.newTransformer();
        //设置编码格式
        tf.setOutputProperty(OutputKeys.ENCODING,"utf-8");
        tf.setOutputProperty(OutputKeys.INDENT,"YES");
        //创建DOMSource对象
        DOMSource source= new DOMSource(document);
        //建立输出流
        StreamResult result=new StreamResult(new FileOutputStream("src/xml/users.xml"));
        //将dom写入xml文件中
        tf.transform(source,result);

    }
    //删除节点
    public void delete() throws TransformerException, FileNotFoundException {
        Node sex=document.getElementsByTagName("sex").item(0);
//        根据父节点删除内容
        Node user=sex.getParentNode();
        user.removeChild(sex);
        System.out.println("删除成功！");
        saveXml();

    }
    //添加节点
    public void add() throws TransformerException, FileNotFoundException {
//        添加元素节点
        Element other=document.createElement("other");
//        添加属性节点
        other.setAttribute("name","skr");
//        添加文本节点
        other.setTextContent("otherContent");
        //根据父节点添加内容
        Node node=document.getElementsByTagName("user").item(0);
        node.appendChild(other);
        saveXml();
    }
    public static void main(String[] args) throws TransformerException, FileNotFoundException {
        DomReader domReader=new DomReader();
        domReader.getDocument();
        domReader.add();
//        domReader.delete();

//        domReader.update();
        domReader.selectAll();

    }

}

xml文件

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<users>
        <user id="0">
            <name>Mary</name>
            <age>23</age>
            <sex>Female</sex>
        </user>
        <user id="1">
            <name>Mike</name>
            <age>24</age>
            <sex>Female</sex>
        </user>
        <user id="2">
            <name>Alice</name>
            <age>23</age>
            <sex>Female</sex>
        </user>
        <user id="3">
            <name>Tom</name>
            <age>24</age>
            <sex>Male</sex>
        </user>
    </users>

DOM4J解析

package xml;

import org.dom4j.*;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

import java.io.*;
import java.util.Iterator;

/**
 * @author beifeng
 * @date 2020/8/25
 */
public class Dom4jDemo {
    private Document document;

    //获得document对象
    public void loadDocument() {
        SAXReader saxReader = new SAXReader();
        try {
            document = saxReader.read(new File("src/xml/phones.xml"));
        } catch (DocumentException e) {
            e.printStackTrace();
        }
    }

    //显示手机的品牌和型号
    
   /*  1、创建解析器
       2、得到document
       3、得到根节点  getRootElement() 返回Element
       4、节点.elementIterator 循环遍历xml文件
   */
    public void showPhoneInfo() {
//        获取根节点
        Element root = document.getRootElement();
//        遍历phone元素节点
        Iterator phoneIter = root.elementIterator();
        while (phoneIter.hasNext()) {
            Element phone = (Element) phoneIter.next();
            System.out.println(phone.attributeValue("name"));
            Iterator preIter = phone.elementIterator();
            while (preIter.hasNext()) {
                Element preEle = (Element) preIter.next();
                String message = preEle.attributeValue("name") != null ? preEle.attributeValue("name") : preEle.getText();
                System.out.println(preEle.getName() + ":\t" + message);
            }
        }
    }

    //保存xml文件
    public void saveXml(String path) {
        OutputFormat outputFormat = OutputFormat.createPrettyPrint();
        try {
            XMLWriter writer = new XMLWriter(new OutputStreamWriter(new FileOutputStream(path)),outputFormat);
            writer.write(document);
            writer.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public void addPhone() {
//        <Type name="M8"/>
//        <price>1000&lt;price&lt;5000</price>
        Element root = document.getRootElement();
        Element phone = root.addElement("phone");
        phone.addAttribute("name", "小米");
        Element type=phone.addElement("Type");
        type.addAttribute("name","M8");
        Element price=phone.addElement("price");
        price.addText("1000>price<5000");
        saveXml("src/xml/phones.xml");


    }
    public void update(){
        Element root=document.getRootElement();
        Iterator phone=root.elementIterator();
        while(phone.hasNext()){
            Element element=(Element)phone.next();
            if (element.attributeValue("name").equals("小米")) {
                element.addAttribute("name","xiaoMi");
                element.addAttribute("id","d");
            }
        }
        saveXml("src/xml/phones.xml");
    }
    public void delete(){
        Element root= document.getRootElement();
        Iterator phoneIter=root.elementIterator();
        while(phoneIter.hasNext()){
            Element element=(Element) phoneIter.next();
            if(element.attributeValue("name").equals("小米")){
//                element.getParent().remove(element);
                Iterator  iter=element.elementIterator();
                while(iter.hasNext()){
                    Element attri=(Element)iter.next();
                    if (attri.getName().equals("price")) {
                        attri.getParent().remove(attri);
                    }

                }
            }
        }
        saveXml("src/xml/phones.xml");
    }
    public static void main(String[] args) {
        Dom4jDemo demo = new Dom4jDemo();
        demo.loadDocument();
        demo.update();
//        demo.delete();
//        demo.addPhone();
        demo.showPhoneInfo();
    }
}

xml文件

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

<!--phones 手机-->
<phones> 
  <phone name="华为"> 
    <Type name="U8650"/>  
    <price>price&gt;3000</price> 
  </phone>  
  <phone name="苹果"> 
    <Type name="iphone7"/>  
    <price>1000&lt;price&lt;5000</price> 
  </phone>  
  <phone name="xiaoMi" id="d"> 
    <Type name="M8"/> 
  </phone>  
  <phone name="xiaoMi" id="d"> 
    <Type name="M8"/> 
  </phone> 
</phones>
熊小弟弟弟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
XML关于类型定义
m0_71932896的博客
11-10 119
XML（可扩展标记语言）是一种用于编码文档的标记语言，它定义了一组规则，这些规则使得人类和机器都能读懂的文档。XML的一个重要特性是它允许用户定义自己的标签和文档结构。然而，为了确保文档的一致性和有效性，我们需要一种方式来定义和约束可能的元素和属性。这就是XML类型定义的作用。XML类型定义（XML Type Definitions），通常被称为XML模式（XML Schema），是一种用于定义XML文档结构的语言。它提供了一种方式来描述和验证XML文档中数据的结构和内容。
java 操作xmltype,XmlType
weixin_31082779的博客
03-20 705
将类或枚举类型映射到XML模式类型。用法@XmlType通知可以与以下程序元素一起使用：顶级班枚举类型有关其他常见信息，请参阅javax.xml.bind.package javadoc中的“Package Specification”。映射类类映射到XML模式类型。 类是用于由属性和字段表示的值的数据容器。 模式类型是模式类型的内容模型中的模式组件所表示的值的数据容器(例如，模型组，属性等)。要...
第二章XML
NYLX9527的博客
05-13 200
XMlXML简介XML的文档结构XMl的应用XML解析1.DOM使用DOM 读取XML数据使用DOM维护XML数据2.SAX3.JDOM4.DOM4J使用DOM4j解析XMLXML总结 XML简介 XML的文档结构 1.XML声明 2.XML标签 3.元素 元素由开始标签，结束标签和元素内容组成。元素内容指开始标签和结束标签之间的内容，可以包含子元素，字符数据等。 元素的命名规则如下 名称中可以包含字母数字，或者其他符号。 名称不能一数字或标点符号开始是。 名称不能以字符“”XML“(或者XML，
oracle查询xmltype根节点,关于Oracle的XMLType类型的数据库操作
weixin_29281915的博客
04-15 680
oracle从9i开始支持一种新的数据类型- xmltype，用于存储和管理xml数据，并提供了很多的functions，用来直接读取xml文档和管理节点。下面介绍xmltype的一些基本使用。1.建立含有xmltype数据类型的表create table test (id number,xmldoc sys.xmltype);声明xmltype型字段用:sys.xmltype2.向带有xmlty...
XML文件格式学习
weixin_51958878的博客
10-19 4193
XML文件格式学习
tinyxml2.h tinyxml2.cpp文件
04-07
TinyXML-2，通常以tinyxml2库的形式存在，是一个轻量级的C++库，专门用于解析和操作XML文档。这个库由李·斯坦普（Lee Stemp）开发，设计简洁，易于集成到各种项目中，特别是对于嵌入式系统和资源有限的环境。在给定...
PB 解析XML （代码案例）
03-24
标题中的“PB 解析XML”指的是使用PowerBuilder（简称PB）这一编程工具处理XML数据的过程。PowerBuilder是一款广泛用于开发企业级应用的可视化编程环境，它支持多种数据格式，包括XML。XML（eXtensible Markup ...
XML查看工具
12-20
XML（eXtensible Markup Language）是一种用于存储和传输数据的标记语言，它以其结构化、可读性强的特点被广泛应用于各种领域，如Web服务、配置文件、数据交换等。XML查看工具是专为处理XML文档而设计的软件，它们...
易语言 xml解析 易语言 xml解析 教程 带源码
11-22
易语言XML解析是编程领域中的一个重要主题，尤其对于使用易语言进行开发的程序员来说，理解并掌握XML（可扩展标记语言）的解析方法是至关重要的。XML作为一种结构化数据存储和交换格式，广泛应用于网络通信、配置...
labview读写XML文件
09-16
在LabVIEW中，XML（Extensible Markup Language）文件是一种常用的数据存储和交换格式，因为它具有良好的结构化、可扩展性和跨平台兼容性。本篇将详细讲解如何在LabVIEW中读取和写入XML文件。 一、XML文件简介 XML...
c#操作XML 读取、生成，WEBSERVICE接口
最新发布
11-16
本教程将深入探讨如何在C#中操作XML，包括读取和生成XML文档，并利用Web Service接口进行数据传输。 1. **C#操作XML：读取** 在C#中，我们可以使用`System.Xml`命名空间中的类来处理XML文档。其中，`XmlDocument`...
xml与实体类转换工具
09-28
XML（eXtensible Markup Language）是一种用于标记数据的语言，广泛应用于数据交换、配置文件、文档存储等领域。在Java开发中，将XML数据与Java实体类进行相互转换是非常常见的需求，这有助于简化数据处理和存储。...
PB解析XML字符串 把XML 变为数据窗口
07-12
标题中的“PB解析XML字符串 把XML 变为数据窗口”指的是使用PowerBuilder（PB）这一编程工具，处理XML格式的数据，并将其转换成数据窗口对象的过程。数据窗口是PowerBuilder中的一个核心组件，用于显示、编辑和管理...
TinyXML2使用示例
04-10
TinyXML2是一个轻量级的XML解析库，主要用于读取和写入XML文档。这个库在C++中设计，提供了一种简洁的方式来处理XML数据，适用于小型项目或嵌入式系统。在“TinyXML2使用示例”中，我们可以通过提供的源代码和XML...
C# XmlHelper
04-15
XmlHelper是一个工具类，你可以调用在里面的函式来对XML档案进行Serialize or DeSerialize的存取
XML的基本介绍
2301_78523177的博客
06-26 748
XML（可扩展标记语言）是一种用于描述数据的标记语言。XML文档（也称为XML文件）由标签和展示数据的内容组成。与HTML不同的是，XML没有预定义标签，而是让用户自己定义标签，从而使得XML可以应用于各种不同的场景和领域。此外，XML并没有像HTML那样被用于Web页面设计，而是被广泛用于表示、传输、存储和交换数据，尤其是在各种数据的互操作性方面。
更改XML标注文件中类别名
awdfggg的博客
09-16 307
更改XML标注文件中类别名以及删除某一类别
两个类具有相同的 XML 类型名称。请使用 @XmlType.name 和 @XmlType.namespace 为类分配不同的名称。
03-11 4388
说明： 此问题是在webservice服务通过wsimport指令生成客户端之后，编写测试代码测试时的报错。 问题出现原因： 由于生成客户端时，没有指定路径，因此默认生成的路径还是原先服务端提供的路径。 解决办法： 通过wsimport指令指定路径生成客户端，然后重新加载。 过程详情： 首先，构建一个webservice服务端： package com.learn.Server;...
Exception:两个类具有相同的 XML 类型名称,请使用 @XmlType.name 和 @XmlType.namespace 为类分配不同的名称
weixin_43934363的博客
10-09 2592
解决办法： 改动 @XmlType中的name，让name与下方类名不同，不区分大小写，所有必须输入不一样的字符窜 Exception in thread “main” com.sun.xml.internal.ws.spi.db.DatabindingException: com.sun.xml.internal.bind.v2.runtime.IllegalAnnotationsExcept...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值