人工智能uu

这个屌丝很懒，什么也没留下！

热门标签

XML解析_xerces2使用

作者：人工智能uu | 2024-07-13 04:33:28

踩

xerces2使用

XML解析技术概述

XML解析方式分为两种：dom和sax

dom：(Document Object Model, 即文档对象模型) 是 W3C 组织推荐的处理 XML 的一种方式。

sax： (Simple API for XML) 不是官方标准，但它是 XML 社区事实上的标准，几乎所有的 XML 解析器都支持它。

XML解析器

Crimson、Xerces 、Aelfred2

XML解析开发包

Jaxp、Jdom、dom4j

JAXP

JAXP 开发包是J2SE的一部分，它由javax.xml、org.w3c.dom 、org.xml.sax 包及其子包组成

在 javax.xml.parsers 包中，定义了几个工厂类，程序员调用这些工厂类，可以得到对xml文档进行解析的 DOM 或 SAX 的解析器对象。

使用JAXP进行DOM解析

javax.xml.parsers 包中的DocumentBuilderFactory用于创建DOM模式的解析器对象， DocumentBuilderFactory是一个抽象工厂类，它不能直接实例化，但该类提供了一个newInstance方法，这个方法会根据本地平台默认安装的解析器，自动创建一个工厂的对象并返回。

获得JAXP中的DOM解析器

调用 DocumentBuilderFactory.newInstance() 方法得到创建 DOM 解析器的工厂。

调用工厂对象的 newDocumentBuilder方法得到 DOM 解析器对象。

调用 DOM 解析器对象的 parse() 方法解析 XML 文档，得到代表整个文档的 Document 对象，进行可以利用DOM特性对整个XML文档进行操作了。

package cn.itcast.xml;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

import org.junit.Test;

import org.w3c.dom.Document;

public class Demo2 {

public static void main(String[] args) throws Exception {

// TODO Auto-generated method stub

//1.创建工厂

DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();

//2。得到dom解析器

DocumentBuilder builder=factory.newDocumentBuilder();

//3。解析xml文档，得到代表文档的document

Document document=builder.parse("src/book.xml");

}

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

<书架>

<书>

<书名 name="dddd">java web就业</书名>

<作者>张孝祥</作者>

<售价>40</售价>

</书>

<书>

<书名>C++教程</书名>

<作者>自己</作者>

<售价>50</售价>

</书>

</书架>

package cn.itcast.xml;

import java.io.File;

import java.io.FileOutputStream;

import java.io.OutputStream;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.dom.DOMSource;

import javax.xml.transform.stream.StreamResult;

import org.junit.Test;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.NamedNodeMap;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

//使用dom方式对xml文档进行CRUD

public class Demo3 {

//读取<书名>C++教程</书名>

public void read1() throws Exception

{

DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();

DocumentBuilder builder=factory.newDocumentBuilder();

Document document=builder.parse("src/book.xml");

NodeList list=document.getElementsByTagName("书名");

Node node=list.item(1);

String content=node.getTextContent();

System.out.println(content);//C++教程

}

//得到文档中所有标签

public void read2() throws Exception

{

DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();

DocumentBuilder builder=factory.newDocumentBuilder();

Document document=builder.parse("src/book.xml");

NodeList list=document.getElementsByTagName("书名");

Node root=document.getElementsByTagName("书架").item(0);

list(root);

}

private void list(Node node) {

Node child;

if (node instanceof Element)

System.out.println(node.getNodeName());

NodeList nodelist=node.getChildNodes();

for (int i=0;i<nodelist.getLength();i++)

{

child=nodelist.item(i);

list(child);

}

//得到文档中标签属性<书名 name="xxxx">java web就业</书名>

public void read3() throws Exception

{

DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();

DocumentBuilder builder=factory.newDocumentBuilder();

Document document=builder.parse("src/book.xml");

NodeList list=document.getElementsByTagName("书名");

Node node=list.item(0);

if(node.hasAttributes()){

NamedNodeMap nodemap=node.getAttributes();

for(int i=0;i<nodemap.getLength();i++)

{

Node nd=nodemap.item(i);

String strname=nd.getNodeName();

String strval=nd.getNodeValue();

System.out.println(strname+":"+strval);//name:dddd

}

Element node2=(Element)list.item(0);

String str3=node2.getAttribute("name");

System.out.println("__"+str3);//__dddd

}

//<售价>10</售价>

public void add() throws Exception{

DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();

DocumentBuilder builder=factory.newDocumentBuilder();

Document document=builder.parse("src/book.xml");

//创建节点

Element price=document.createElement("售价");

price.setTextContent("59.0元");

//把创建的节点放到第一本书上

document.getElementsByTagName("书").item(0).appendChild(price);

//把跟新后的内容写回文档

Transformer transformer=TransformerFactory.newInstance().newTransformer();

DOMSource source=new DOMSource(document);

FileOutputStream outstream =new FileOutputStream(new File("src/outbook.xml"));

StreamResult reslut=new StreamResult(outstream);

transformer.transform(source, reslut);

outstream.close();

}

//向文档中指定位置上添加节点 <售价>10</售价>

public void add2() throws Exception{

DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();

DocumentBuilder builder=factory.newDocumentBuilder();

Document document=builder.parse("src/book.xml");

//创建节点

Element price=document.createElement("售价");

price.setTextContent("59.0元");

//得到参考节点

Element refNode=(Element)document.getElementsByTagName("售价").item(0);

//得到挂崽的节点

Element book=(Element)document.getElementsByTagName("书").item(0);

//把创建的节点放到第一本书上

document.getElementsByTagName("书").item(0).appendChild(price);

// 往book节点指定位置插值

book.insertBefore(price, refNode);

Transformer transformer=TransformerFactory.newInstance().newTransformer();

DOMSource source=new DOMSource(document);

FileOutputStream outstream =new FileOutputStream(new File("src/outbook2.xml"));

StreamResult reslut=new StreamResult(outstream);

transformer.transform(source, reslut);

outstream.close();

}

//向文档节点添加属性 <售价>10</售价>

public void addAtt() throws Exception{

DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();

DocumentBuilder builder=factory.newDocumentBuilder();

Document document=builder.parse("src/book.xml");

//得到参考节点

Element refNode=(Element)document.getElementsByTagName("售价").item(0);

refNode.setAttribute("addAtrr","new cha ru value");

Transformer transformer=TransformerFactory.newInstance().newTransformer();

DOMSource source=new DOMSource(document);

FileOutputStream outstream =new FileOutputStream(new File("src/outbook3.xml"));

StreamResult reslut=new StreamResult(outstream);

transformer.transform(source, reslut);

outstream.close();

}

//删除 <售价>10</售价>

public void delete() throws Exception{

DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();

DocumentBuilder builder=factory.newDocumentBuilder();

Document document=builder.parse("src/book.xml");

//得到要删除的节点

Element refNode=(Element)document.getElementsByTagName("售价").item(0);

refNode.getParentNode().removeChild(refNode);

Transformer transformer=TransformerFactory.newInstance().newTransformer();

DOMSource source=new DOMSource(document);

FileOutputStream outstream =new FileOutputStream(new File("src/outbook3.xml"));

StreamResult reslut=new StreamResult(outstream);

transformer.transform(source, reslut);

outstream.close();

}

//更新售价

public void update() throws Exception{

DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();

DocumentBuilder builder=factory.newDocumentBuilder();

Document document=builder.parse("src/book.xml");

//得到要更新的节点

Element refNode=(Element)document.getElementsByTagName("售价").item(0);

refNode.setTextContent("1000");

Transformer transformer=TransformerFactory.newInstance().newTransformer();

DOMSource source=new DOMSource(document);

FileOutputStream outstream =new FileOutputStream(new File("src/outbook3.xml"));

StreamResult reslut=new StreamResult(outstream);

transformer.transform(source, reslut);

outstream.close();

}

调虚拟机内存大小

-Xmx83886080 C:\Program Files\Java\jdk1.7.0\docs\technotes\tools\windows\java.html

-Xmx81920k

-Xmx80m

DOM编程

DOM模型(document object model)

DOM解析器在解析XML文档时，会把文档中的所有元素，按照其出现的层次关系，解析成一个个Node对象(节点)。

在dom中，节点之间关系如下：

位于一个节点之上的节点是该节点的父节点(parent)

一个节点之下的节点是该节点的子节点（children）

同一层次，具有相同父节点的节点是兄弟节点（sibling）

一个节点的下一个层次的节点集合是节点后代(descendant)

父、祖父节点及所有位于节点上面的，都是节点的祖先(ancestor)

节点类型（下页ppt）

Node对象提供了一系列常量来代表结点的类型，当开发人员获得某个Node类型后，就可以把Node节点转换成相应的节点对象(Node的子类对象)，以便于调用其特有的方法。（查看API文档）

Node对象提供了相应的方法去获得它的父结点或子结点。编程人员通过这些方法就可以读取整个XML文档的内容、或添加、修改、删除XML文档的内容了。

DOM方式解析XML文件

DOM解析编程

遍历所有节点

查找某一个节点

删除结点

更新结点

添加节点

更新XML文档

javax.xml.transform包中的Transformer类用于把代表XML文件的Document对象转换为某种格式后进行输出，例如把xml文件应用样式表后转成一个html文档。利用这个对象，当然也可以把Document对象又重新写入到一个XML文件中。

Transformer类通过transform方法完成转换操作，该方法接收一个源和一个目的地。我们可以通过：

javax.xml.transform.dom.DOMSource类来关联要转换的document对象，

用javax.xml.transform.stream.StreamResult 对象来表示数据的目的地。

Transformer对象通过TransformerFactory获得。

SAX解析

在使用 DOM 解析 XML 文档时，需要读取整个 XML 文档，在内存中构架代表整个 DOM 树的Doucment对象，从而再对XML文档进行操作。此种情况下，如果 XML 文档特别大，就会消耗计算机的大量内存，并且容易导致内存溢出。

SAX解析允许在读取文档的时候，即对文档进行处理，而不必等到整个文档装载完才会文档进行操作。

SAX采用事件处理的方式解析XML文件，利用 SAX 解析 XML 文档，涉及两个部分：解析器和事件处理器：

解析器可以使用JAXP的API创建，创建出SAX解析器后，就可以指定解析器去解析某个XML文档。

解析器采用SAX方式在解析某个XML文档时，它只要解析到XML文档的一个组成部分，都会去调用事件处理器的一个方法，解析器在调用事件处理器的方法时，会把当前解析到的xml文件内容作为方法的参数传递给事件处理器。

事件处理器由程序员编写，程序员通过事件处理器中方法的参数，就可以很轻松地得到sax解析器解析到的数据，从而可以决定如何对数据进行处理。

阅读ContentHandler API文档，常用方法：startElement、endElement、characters

SAX方式解析XML文档

使用SAXParserFactory创建SAX解析工厂

SAXParserFactory spf = SAXParserFactory.newInstance();

通过SAX解析工厂得到解析器对象

SAXParser sp = spf.newSAXParser();

通过解析器对象得到一个XML的读取器

XMLReader xmlReader = sp.getXMLReader();

设置读取器的事件处理器

xmlReader.setContentHandler(new BookParserHandler());

解析xml文件

xmlReader.parse("book.xml");

package cn.itcast.sax;

import java.io.IOException;

import javax.xml.parsers.*;

import org.xml.sax.*;

public class Demo1 {

/**

* sax解析xml文档

public static void main(String[] args) throws Exception {

//1.创建解析工厂

SAXParserFactory factory=SAXParserFactory.newInstance();

//2.得到解析器

SAXParser sp=factory.newSAXParser();

//3.得到读取器

XMLReader reader=sp.getXMLReader();

//4.设置内容处理器

reader.setContentHandler(new ListHandler());

//5.读取xml文档内容

reader.parse("src/book.xml");

}

//得到xml文档所有内容

class ListHandler implements ContentHandler{

@Override

public void characters(char[] ch, int start, int length)

throws SAXException {

System.out.println(new String(ch,start,length));

}

@Override

public void endDocument() throws SAXException {

// TODO Auto-generated method stub

}

@Override

public void endElement(String uri, String localName, String qName)

throws SAXException {

System.out.println("</"+qName+">");

}

@Override

public void endPrefixMapping(String prefix) throws SAXException {

}

@Override

public void ignorableWhitespace(char[] ch, int start, int length)

throws SAXException {

}

@Override

public void processingInstruction(String target, String data)

throws SAXException {

}

@Override

public void setDocumentLocator(Locator locator) {

}

@Override

public void skippedEntity(String name) throws SAXException {

}

@Override

public void startDocument() throws SAXException {

}

@Override

public void startElement(String uri, String localName, String qName,

Attributes atts) throws SAXException {

System.out.println("<"+qName+">");

for (int i=0;atts!=null && i<atts.getLength();i++){

String attName=atts.getQName(i);

String attValue=atts.getValue(i);

System.out.println(attName+"="+attValue);

}

@Override

public void startPrefixMapping(String prefix, String uri)

throws SAXException {

}

package cn.itcast.sax;

import java.io.IOException;

import javax.xml.parsers.*;

import org.xml.sax.*;

public class Demo2 {

/**

* sax解析xml文档

public static void main(String[] args) throws Exception {

//1.创建解析工厂

SAXParserFactory factory=SAXParserFactory.newInstance();

//2.得到解析器

SAXParser sp=factory.newSAXParser();

//3.得到读取器

XMLReader reader=sp.getXMLReader();

//4.设置内容处理器

reader.setContentHandler(new TagValueHandler());

//5.读取xml文档内容

reader.parse("src/book.xml");

}

//获取指定标签作者的值

class TagValueHandler extends DefaultHandler{

private String currentTag;//记住当前解析器得到的是什么标签

private int needNumber=2;//记住想获取第几个作者标签的值

private int currentNumber;//当前解析的是第几个

@Override

public void startElement(String uri, String localName, String qName,

Attributes attributes) throws SAXException {

currentTag=qName;

if("作者".equals(currentTag))

currentNumber++;

}

@Override

public void characters(char[] ch, int start, int length) throws SAXException {

if("作者".equals(currentTag)&& currentNumber==needNumber){

System.out.println(new String(ch,start,length));

}

@Override

public void endElement(String uri, String localName, String qName)

throws SAXException {

currentTag=null;

}

package cn.itcast.sax;

import java.io.IOException;

import java.util.*;

import javax.xml.parsers.*;

import org.xml.sax.*;

public class Demo3 {

/**

* sax解析xml文档

public static void main(String[] args) throws Exception {

//1.创建解析工厂

SAXParserFactory factory=SAXParserFactory.newInstance();

//2.得到解析器

SAXParser sp=factory.newSAXParser();

//3.得到读取器

XMLReader reader=sp.getXMLReader();

//4.设置内容处理器

BeanListHandler handle=new BeanListHandler();

reader.setContentHandler(handle);

//5.读取xml文档内容

reader.parse("src/book.xml");

List<Book> list=handle.getList();

list.iterator();

}

//把每一本书封装到一个book对象，并把book对象

class BeanListHandler extends DefaultHandler{

private List<Book> list=new ArrayList<Book>();

public List<Book> getList() {

return list;

}

private String currentTag;

private Book book;

@Override

public void startElement(String uri, String localName, String qName,

Attributes attributes) throws SAXException {

currentTag=qName;

if("书".equals(currentTag)){

book=new Book();

}

@Override

public void characters(char[] ch, int start, int length) throws SAXException {

if("书名".equals(currentTag)){

book.setName(new String(ch,start,length));

}

if("作者".equals(currentTag)){

book.setAuthor(new String(ch,start,length));

}

if("售价".equals(currentTag)){

book.setPrice(new String(ch,start,length));

}

@Override

public void endElement(String uri, String localName, String qName) throws SAXException {

if(qName.equals("书")){

list.add(book);

book=null;

}

currentTag=null; //这句有必要

}

DOM4J解析XML文档

Dom4j是一个简单、灵活的开放源代码的库。Dom4j是由早期开发JDOM的人分离出来而后独立开发的。与JDOM不同的是，dom4j使用接口和抽象基类，虽然Dom4j的API相对要复杂一些，但它提供了比JDOM更好的灵活性。

Dom4j是一个非常优秀的Java XML API，具有性能优异、功能强大和极易使用的特点。现在很多软件采用的Dom4j，例如Hibernate，包括sun公司自己的JAXM也用了Dom4j。

使用Dom4j开发，需下载dom4j相应的jar文件。

//读第 2 本书的信息 <书名 name="xxxx">C++教程</书名>

private static void read() throws DocumentException {

SAXReader reader=new SAXReader();

Document document=reader.read(new File("src/book.xml"));

Element root=document.getRootElement();

Element book=(Element) root.elements("书").get(1);

String value=book.element("书名").getText();

String value2=book.element("书名").attributeValue("name");

System.out.println(value +";"+value2);

}

//在第一本上添加一个新的售价

public void add() throws Exception{

SAXReader reader=new SAXReader();

Document document=reader.read(new File("src/book.xml"));

Element book=document.getRootElement().element("书");

book.addElement("售价").setText("111");

//XMLWriter writer=new XMLWriter(new FileWriter("src/book.xml"));

//XMLWriter writer=new XMLWriter(new OutputStreamWriter(new FileOutputStream("src/book.xml"), "UTF-8"));

OutputFormat format = OutputFormat.createPrettyPrint();

format.setEncoding("gb2312");

XMLWriter writer=new XMLWriter(new OutputStreamWriter(new FileOutputStream("src/book.xml"), "gb2312"),format);

writer.write(document);

writer.close();

}

//在第一本书指定位置上添加一个新的售价,更改List集合

public void add2() throws Exception{

SAXReader reader=new SAXReader();

Document document=reader.read(new File("src/book.xml"));

Element book=document.getRootElement().element("书");

List list=book.elements();//[书名，作者，售价]

Element price=DocumentHelper.createElement("售价");

price.setText("309元");

list.add(2,price);

OutputFormat format = OutputFormat.createPrettyPrint();

format.setEncoding("gb2312");

XMLWriter writer=new XMLWriter(new OutputStreamWriter(new FileOutputStream("src/book.xml"), "gb2312"),format);

writer.write(document);

writer.close();

}

//删除上面的节点

public void delete() throws Exception {

SAXReader reader=new SAXReader();

Document document=reader.read(new File("src/book.xml"));

Element price=document.getRootElement().element("书").element("售价");

price.getParent().remove(price);

}

//更新节点

SAXReader reader=new SAXReader();

Document document=reader.read(new File("src/book.xml"));

Element book=(Element) document.getRootElement().elements("书").get(1);

book.element("作者").setText("张三");

OutputFormat format = OutputFormat.createPrettyPrint();

format.setEncoding("gb2312");

XMLWriter writer=new XMLWriter(new OutputStreamWriter(new FileOutputStream("src/book.xml"), "gb2312"),format);

writer.write(document);

writer.close();

//应用xpath提取xml文档的数据,需要包jaxen-1.1-beta-6.jar

SAXReader reader=new SAXReader();

Document document=reader.read(new File("src/book.xml"));

String value=document.selectSingleNode("//作者").getText();//第一个值

System.out.println(value);

Document对象

DOM4j中，获得Document对象的方式有三种：

1.读取XML文件,获得document对象

SAXReader reader = new SAXReader();
Document document = reader.read(new File("input.xml"));

2.解析XML形式的文本,得到document对象.

String text = "<members></members>";
Document document = DocumentHelper.parseText(text);

3.主动创建document对象.

Document document = DocumentHelper.createDocument();
//创建根节点

Element root = document.addElement("members");

节点对象

1.获取文档的根节点.

Element root = document.getRootElement();

2.取得某个节点的子节点.

Element element=node.element(“书名");

3.取得节点的文字

String text=node.getText();

4.取得某节点下所有名为“member”的子节点，并进行遍历.
List nodes = rootElm.elements("member");
  for (Iterator it = nodes.iterator(); it.hasNext();) {
     Element elm = (Element) it.next();
    // do something
}

5.对某节点下的所有子节点进行遍历.

for(Iterator it=root.elementIterator();it.hasNext();){

Element element = (Element) it.next();

// do something
}

6.在某节点下添加子节点.

Element ageElm = newMemberElm.addElement("age");

7.设置节点文字.

element.setText("29");

8.删除某节点.

//childElm是待删除的节点,parentElm是其父节点

parentElm.remove(childElm);

9.添加一个CDATA节点.
Element contentElm = infoElm.addElement("content");

contentElm.addCDATA(diary.getContent());

节点对象属性

1.取得某节点下的某属性
Element root=document.getRootElement();

//属性名name

Attribute attribute=root.attribute("size");

2.取得属性的文字

String text=attribute.getText();

3.删除某属性
Attribute attribute=root.attribute("size");

root.remove(attribute);

3.遍历某节点的所有属性

Element root=document.getRootElement();

for(Iterator it=root.attributeIterator();it.hasNext();){

Attribute attribute = (Attribute) it.next();

String text=attribute.getText();

System.out.println(text);

}

4.设置某节点的属性和文字.

newMemberElm.addAttribute("name", "sitinspring");

5.设置属性的文字

Attribute attribute=root.attribute("name");

attribute.setText("sitinspring");

将文档写入XML文件

1.文档中全为英文,不设置编码,直接写入的形式.
XMLWriter writer = new XMLWriter(new FileWriter("output.xml"));

writer.write(document);

writer.close();

2.文档中含有中文,设置编码格式写入的形式.

OutputFormat format = OutputFormat.createPrettyPrint();

// 指定XML编码

format.setEncoding("GBK");

XMLWriter writer = new XMLWriter(newFileWriter("output.xml"),format);

writer.write(document);

writer.close();

Dom4j在指定位置插入节点

1.得到插入位置的节点列表（list）

2.调用list.add(index,elemnent)，由index决定element的插入位置。

Element元素可以通过DocumentHelper对象得到。示例代码：

Element aaa = DocumentHelper.createElement("aaa");

aaa.setText("aaa");

List list = root.element("书").elements();

list.add(1, aaa);

//更新document

字符串与XML的转换

1.将字符串转化为XML

String text = "<members> <member>sitinspring</member></members>";
Document document = DocumentHelper.parseText(text);

2.将文档或节点的XML转化为字符串.

     SAXReader reader = new SAXReader();
Document   document = reader.read(new File("input.xml"));
Element root=document.getRootElement();

String docXmlText=document.asXML();

String rootXmlText=root.asXML();
Element memberElm=root.element("member");
String memberXmlText=memberElm.asXML();

XML Schema

XML Schema 也是一种用于定义和描述 XML 文档结构与内容的模式语言，其出现是为了克服 DTD 的局限性

XML Schema VS DTD：

XML Schema符合XML语法结构。

DOM、SAX等XML API很容易解析出XML Schema文档中的内容。

XML Schema对名称空间支持得非常好。

XML Schema比XML DTD支持更多的数据类型，并支持用户自定义新的数据类型。

XML Schema定义约束的能力非常强大，可以对XML实例文档作出细致的语义限制。

XML Schema不能像DTD一样定义实体，比DTD更复杂，但Xml Schema现在已是w3c组织的标准，它正逐步取代DTD。

Schema约束快速入门

XML Schema 文件自身就是一个XML文件，但它的扩展名通常为.xsd。

一个XML Schema文档通常称之为模式文档(约束文档)，遵循这个文档书写的xml文件称之为实例文档。

和XML文件一样，一个XML Schema文档也必须有一个根结点，但这个根结点的名称为Schema。

编写了一个XML Schema约束文档后，通常需要把这个文件中声明的元素绑定到一个ＵＲＩ地址上，在XML Schema技术中有一个专业术语来描述这个过程，即把XML Schema文档声明的元素绑定到一个名称空间上，以后XML文件就可以通过这个URI（即名称空间）来告诉解析引擎，xml文档中编写的元素来自哪里，被谁约束。

Schema入门案例

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

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"

targetNamespace="http://www. itcast.cn"

elementFormDefault="qualified">

<xs:element name='书架' >

<xs:complexType>

<xs:sequence maxOccurs='unbounded' >

<xs:element name='书' >

<xs:complexType>

<xs:sequence>

<xs:element name='书名' type='xs:string' />

<xs:element name='作者' type='xs:string' />

<xs:element name='售价' type='xs:string' />

</xs:sequence>

</xs:complexType>

</xs:element>

</xs:sequence>

</xs:complexType>

</xs:element>

</xs:schema>

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

<itcast:书架 xmlns:itcast="http://www.itcast.cn"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation=“http://www.itcast.cn book.xsd">

<itcast:书>

<itcast:书名>JavaScript网页开发</itcast:书名>

<itcast:作者>张孝祥</itcast:作者>

<itcast:售价>28.00元</itcast:售价>

</itcast:书>

</itcast:书架>

名称空间的概念

在XML Schema中，每个约束模式文档都可以被赋以一个唯一的名称空间，名称空间用一个唯一的URI（Uniform Resource Identifier，统一资源标识符）表示。在Xml文件中书写标签时，可以通过名称空间声明（xmlns），来声明当前编写的标签来自哪个Schema约束文档。如：

<itcast:书架 xmlns:itcast=“http://www.itcast.cn”>

<itcast:书>……</itcast:书>

</itcast:书架>

此处使用itcast来指向声明的名称，以便于后面对名称空间的引用。

注意：名称空间的名字语法容易让人混淆，尽管以 http:// 开始，那个 URL 并不指向一个包含模式定义的文件。事实上，这个 URL：http://www.itcast.cn根本没有指向任何文件，只是一个分配的名字。

使用名称空间引入Schema

为了在一个XML文档中声明它所遵循的Schema文件的具体位置，通常需要在Xml文档中的根结点中使用schemaLocation属性来指定，例如：

<itcast:书架 xmlns:itcast="http://www.itcast.cn"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation=“http://www.itcast.cn book.xsd">

schemaLocation此属性有两个值。第一个值是需要使用的命名空间。第二个值是供命名空间使用的 XML schema 的位置，两者之间用空格分隔。

注意，在使用schemaLocation属性时，也需要指定该属性来自哪里。

使用默认名称空间

基本格式：

xmlns="URI"

举例：

<书架 xmlns="http://www.it315.org/xmlbook/schema"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation=“http://www.itcast.cn book.xsd">

<书>

<书名>JavaScript网页开发</书名>

<作者>张孝祥</作者>

<售价>28.00元</售价>

</书>

<书架>

使用名称空间引入多个XML Schema文档

文件清单：xmlbook.xml

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

<书架 xmlns="http://www.it315.org/xmlbook/schema"

xmlns:demo="http://www.it315.org/demo/schema"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.it315.org/xmlbook/schema http://www.it315.org/xmlbook.xsd

http://www.it315.org/demo/schema http://www.it315.org/demo.xsd">

<书>

<书名>JavaScript网页开发</书名>

<作者>张孝祥</作者>

<售价 demo:币种=”人民币”>28.00元</售价>

</书>

</书架>

不使用名称空间引入XML Schema文档

文件清单：xmlbook.xml

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

<书架 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:noNamespaceSchemaLocation="xmlbook.xsd">

<书>

<书名>JavaScript网页开发</书名>

<作者>张孝祥</作者>

<售价>28.00元</售价>

</书>

</书架>

在XML Schema文档中声明名称空间

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"

targetNamespace="http://www. itcast.cn"

elementFormDefault="qualified">

<xs:schema>

targetNamespace元素用于指定schema文档中声明的元素属于哪个名称空间。

elementFormDefault元素用于指定，该schema文档中声明的根元素及其所有子元素都属于targetNamespace所指定的名称空间。

本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/人工智能uu/article/detail/817639