XML详解：第三部分 XML解析

声明：原创作品，转载时请注明文章来自SAP师太技术博客：www.cnblogs.com/jiangzhengjun，并以超链接形式标明文章原始出处，否则将追究法律责任！原文链接：http://www.cnblogs.com/jiangzhengjun/p/4290918.html

XML解析... 72

使用DOM解析XML. 73

DOM树中的节点类型... 75

文档节点Document75

元素节点Element77

文本节点Text77

属性节点Attr78

NodeList接口... 78

NamedNodeMap接口... 79

DOM解析器工厂和DOM解析器... 79

使用DOM解析XML文档的实例... 80

遍历文档... 81

添加、删除、修改和保存... 82

使用SAX解析XML. 85

XMLReader（解析器接口）... 85

ContentHandler（内容事件处理器接口）... 85

SAX解析器工厂... 85

使用SAX解析XML. 86

解析并完整输出XML文档... 86

使用ErrorHandler处理解析中的错误

XML解析

如果不同厂商开发的XML解析器提供的API都依赖于自向的产品，那么应用程序要使用解析器，就只能使用特定于厂商的API。假如以后应用程序需要更换解析器，那么就只能重新编写代码了。庆幸的是，目前几乎所有的解析器都对两套标准的API提供了支持，这两套API就是DOM和SAX。

DOM（Document Object Model）的缩写，即文档对象模型，是W3C组织推荐的处理XML的标准接口。SAX是Simple API for XML的缩写，它不是某个官方机构的标准，但它是XML社区事实上的标准。虽然只是“民间”的标准，但是它在XML中的应用不比DOM少，几乎所有XML解析器都支持它。

DOM和SAX只是定义了一些接口，以及某些接口的默认实现（什么事情也不做），一个应用程序要想利用DOM或SAX访问XML文档，还需要一个实现了DOM或SAX的解析器，即实现DOM和SAX中定义的接口，提供DOM和SAX定义的功能。

Apache的Xerces是一个使用非常广泛的解析器，它提供了DOM和SAX的调用接口。SAX的标准解析接口为org.xml.sax.XMLReader，而Xerces中提供的解析接口的实现类为org.apache.xerces.parsers.SAXParser，在应用程序中可以采用如下方式访问XML文档：

org.xml.sax.XMLReader sp = new org.apache.xerces.parsers.SAXParser();

现有一个问题，虽然我们使用的是标准的DOM和SAX接口，但不同解析器的实现类是不同的，如果要使用另外一种解析器，仍然需要修改应用程序，只不过修改的代码量较少。有没有办法让我们在更换解析器时，不用对已发布程序做任何改变呢？JAXP API可以帮我们实现这一点。为了屏蔽具体厂商的实现，让开发人员以一种标准的方式对XML进行编程，SUN制定了JAXP（Java API for XML Processing）规范。JAXP没有提供解析XML的新方法，也没有为XML的处理提供新的功能，它只是在解析器之上封闭了一个抽象层，允许开发人员以独立于厂商的API调用访问XML数据。

JAXP开发包由javax.xml包及其子包、org.w3c.dom包及其子包、org.xml.sax包及其子包组成。在javax.xml.parsers包中，定义了几个工厂类，用于加载DOM和SAX的实现类，JAXP由接口、抽象类和一些辅助类组成，符合JAXP规范的解析器实现其中的接口和抽象类，开发人员只要使用JAXP的API编程，底层的解析器就可以任意更换。

应用程序àJAXP的接口与抽象类àXerces的JAXP实现àXerces的DOM或SAX解析器

有了JAXP，开发人员就可以随意更换解析器的实现，而不需要修改应用程序。

使用DOM解析XML

DOM是独立于程序语言的，W3C组织以IDL（接口中定义语言）的形式定义了DOM中接口。某种语言要实现DOM，需要将DOM接口转换为本语言中的对应结构。W3C提借了Java和ECMAScript这两种语言的实现。

Node对象是DOM结构中最基本的对象，代表了文档树中的一个节点，通常直接使用Node很少，一般使用Document、Element、Attr、Text等Node对象的子对象来操作文档。虽然在Node接口中定义了对节点进行操作的通用方法，但是有一些Node对象的子对象，如Text对象并不存在子节点。

1、  Node接口主要是对它的子节点进行增、删、获取。

2、  Node接口中定义了各种节点的类型常量，可以用它们来判断是哪种节点。

3、  void normalize()：将该节点所有的后代文本节点，包括属性节点，调整为规范化的形式，这仅是以结构（如：元素、注释、处理指令、CDATA段、实体引用）来分隔文本节点，也就是说，在节点所在的这棵树下，既不存在相邻的文本节点，也不存在空的文本节点。

Node节点的getNodeName、getNodeValue 和 getAttributes 的值将根据以下节点类型的不同而不同。


Interface（节点类型）
getNodeName（节点名字）
getNodeValue（节点值）
getAttributes（节点属性）

Attr
与 Attr.name 相同
与 Attr.value 相同
null

CDATASection
"#cdata-section"
与 CharacterData.data 相同，CDATA 节的内容
null

Comment
"#comment"
与 CharacterData.data 相同，该注释的内容
null

Document
"#document"
null
null

DocumentFragment
"#document-fragment"
null
null

DocumentType
与 DocumentType.name 相同
null
null

Element
与 Element.tagName 相同
null
NamedNodeMap

Entity
entity name
null
null

EntityReference
引用的实体名称
null
null

Notation
notation name
null
null

ProcessingInstruction
与 ProcessingInstruction.target 相同
与 ProcessingInstruction.data 相同
null

Text
"#text"
与 CharacterData.data 相同，该文本节点的内容
null

DOM树中的节点类型

XML中最常见的节点类型是：文档、元素、文本和属性节点，在DOM API中对应的接口是Document、Element、Text和Attr。

文档节点Document

文档节点是文档树的根节点，也是文档中其他所有节点的父节点。要注意的是，文档节点并不是XML文档的根元素，因为在XML文档中，处理指令、注释等内容可以出现在根元素以外，所以在构造DOM树时，根元素并不适合作为根节点，于是就有了文档节点，而根元素则作为文档节点的子节点。

4、  通过 Element getDocumentElement()方法得到XML文档的根元素。

5、  通过createXX相应的方法创建不同类型的节点。

6、  Element getElementById(String elementId)：通过给出的ID类型的属性值elementId来查找对应用的元素。一个ID类型的属性值唯一标识了XML文档中的一个元素。除非特别定义，名字为“ID”或者“id”的属性，其类型并不是ID类型。

7、  NodeList getElementsByTagName(String tagname)：以文档顺序返回标签名字为tagname的所有元素。如果参数为“*”，则返回所有的元素。

8、  NodeList getElementsByTagNameNS(String namespaceURI,String localName)：按照指定的名称空间URI和元素的本地名返回所有匹配的元素。如果参数namespaceURI为“*”，则表示所有的名称空间，同样，如果localName为“*”，则匹配所有元素。

元素节点Element

文本节点Text

属性节点Attr

属性实际上是属于某个元素的，所以属性节点不是元素的子节点。因而在DOM中，属性节点没有被作为文档树的一部分，所以在属性节点上调用getParentNode、getPreviousSibling、getNextSibling时返回null。

NodeList接口

Node：

NodeList getChildNodes();

Document、Element：

NodeList getElementsByTagName(String tagname);

NodeList getElementsByTagNameNS(String namespaceURI, String localName);

NamedNodeMap接口

Node：

NamedNodeMap getAttributes();

DocumentType：

NamedNodeMap getEntities();

NamedNodeMap getNotations();

DOM解析器工厂和DOM解析器

在javax.xml.parsers包中，定义了DOM解析器工厂类DocumentBuilderFactory，用来产生DOM解析器。DocumentBuilderFactory工厂类是一个抽象类，在这个类中提供了一个静态方法newInstance()方法，用来创建一个工厂类的实例。

DocumentBuilderFactory是个抽象类，那它的newInstance()产生的是哪个实现呢？采用JAXP编程可以任意更换解析器的关键就在于这个工厂类。DocumentBuilderFactory抽象类的实现由遵照JAXP规范的解析器提供商来给出的。解析器提供商为自身的解析器编写一个从DocumentBuilderFactory类继承的工厂类，然后由这个工厂类实例负责产生解析器对象。

那么DocumentBuilderFactory的newInstance()方法是如何找到解析器提供商给出的工厂类呢？可通过下面3种途径依次查找解析器工厂类：

1、  首先查看是否设置了javax.xml.parsers.DocumentBuilderFactory系统属性。这又可通过两种方式来设置这个系统属性：

System.setProperty("javax.xml.parsers.DocumentBuilderFactory",

"org.apache.xerces.jaxp.DocumentBuilderFactoryImpl");

建议不要使用此种方式，因为如果更换解析器，程序就要修改。另一种是在用java.exe执行程序时，通过-D选项来设置系统属性：

java -Djavax.xml.parsers.DocumentBuilderFactory=oracle.xml.jaxp.JXDocument DOMTest

2、  查找JRE目录中lib子目录下的jaxp.properties文件，如果存在，则读取该配置文件：

javax.xml.parsers.DocumentBuilderFactory=org.apache.xerces.jaxp.DocumentBuilderFactoryImpl

3、  在classpath环境变量所指定JAR文件中，查找META-INF/services目录下的javax.xml.parsers.DocumentBuilderFactory文件，使用这个文件中所指定的工厂类名来构造工厂的实例，这种方式被多数解析器提供商所采用，在他们的发布的包包含解析器的JAR包中，往往会提供这个的文件，我们来看看Apache提供的解析器实现包xercesImpl.jar：

其中javax.xml.parsers.DocumentBuilderFactory文件的内容如下：

org.apache.xerces.jaxp.DocumentBuilderFactoryImpl

如果上面3种途径都没有找到解析器工厂类，就使用平台默认的解析器工厂。从JAXP1.2开始，SUN公司对Apache的Xerces解析器重新包装了一下，并将org.apache.xerces包名改为了com.sun.org.apache.xerces.internal，然后在JAXP的开发包中一起提供，作为默认的解析器。

在得到工厂实例后，就可以通过DocumentBuilderFactory的newDocumentBuilder()方法来创建DOM解析器实例了：

DocumentBuilderFactory dbf =DocumentBuilderFactory.newInstance();

DocumentBuilder db = dbf.newDocumentBuilder();//得到具体厂商的XML解析器

Document d = db.parse("text.xml");//通过解析器解析得到文档对象

DocumentBuilderFactory另外几个重要的方法：

l  public void setValidating(boolean validating)：指定解析器是否难被解析的文档，默认为false。注，该方法只能DTD验证有效。如果使用Schema验证，则可设为false后，使用setSchema(Schema)方法将一个模式与解析关联。

l  public void setSchema(Schema schema)：如果要使用模式对XML文档进行验证，需要使用该方法。Schema对象由javax.xml.validation.SchemaFactory工厂类创建。

l  public void setIgnoringElementContentWhitespace(boolean whitespace)：是否要忽略元素内容中的空白。默认是false。按照XML1.0的推荐标准，元素内容中的空白必须由解析器保留，但当根据DTD进行验证时，解析器可以知道文档的特定部分不会支持空格（如具有元素型内容的元素），所以这一区域的任何空格都“可忽略的”。注，这一标志只有通过setValidating打开验证功能后才有效。

使用DOM解析XML文档的实例

--students.xml

<?xml version="1.0" encoding="GB2312"?>

<?xml-stylesheet type="text/xsl" href="students.xsl"?>

<students>

<student sn="01">

<name>张三</name>

<age>18</age>

</student>

<student sn="02">

<name>李四</name>

<age>20</age>

</student>

</students>

--end

遍历文档

publicclass DOMPrinter {

/**

* 输出节点的类型、名字和值。

*/

publicstaticvoid printNodeInfo(String nodeType, Node node) {

System.out.println(nodeType + "\t" + node.getNodeName() + " : "

+ node.getNodeValue());

}

/**

* 采用递归调用，输出给定节点下的所有后代节点。

* 注：为了简单起见，只对处理指令节点、元素节点、

* 属性节点和文本节点进行了处理。

*/

publicstaticvoid traverseNode(Node node) {

short nodeType = node.getNodeType();

switch (nodeType) {

case Node.PROCESSING_INSTRUCTION_NODE:

printNodeInfo("处理指令", node);

break;

case Node.ELEMENT_NODE:

printNodeInfo("元素", node);

NamedNodeMap attrs = node.getAttributes();

int attrNum = attrs.getLength();

for (int i = 0; i < attrNum; i++) {

Node attr = attrs.item(i);

printNodeInfo("属性", attr);

}

break;

case Node.TEXT_NODE:

printNodeInfo("文本", node);

break;

default:

break;

}

Node child = node.getFirstChild();

while (child != null) {

// 递归调用

traverseNode(child);

child = child.getNextSibling();

}

}

publicstaticvoid main(String[] args) {

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

try {

DocumentBuilder db = dbf.newDocumentBuilder();

Document doc = db.parse(new File("students.xml"));

// Document接口提供了三个方法，分别用于获取XML声明的三个部分：

// 版本、文档编码、独立文档。

// 调用这三个方法需要的JDK版本最小是1.5

System.out.println("<?xml=‘" + doc.getXmlVersion() + "‘ encoding=‘"

+ doc.getXmlEncoding() + "‘ standalone=‘"

+ doc.getXmlStandalone() + "‘?>");

traverseNode(doc);

} catch (ParserConfigurationException e) {

e.printStackTrace();

} catch (SAXException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

}

添加、删除、修改和保存

publicclass DOMConvert {

publicstaticvoid main(String[] args) {

DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

try {

DocumentBuilder db = dbf.newDocumentBuilder();

Document doc = db.parse("students.xml");

// ------------------添加节点------------------

// 创建表示一个学生信息的各元素节点。

Element eltStu = doc.createElement("student");

Element eltName = doc.createElement("name");

Element eltAge = doc.createElement("age");

// 创建<student>元素的sn属性节点。

Attr attr = doc.createAttribute("sn");

attr.setValue("03");

// 创建代表学生信息的文本节点。

Text txtName = doc.createTextNode("王五");

Text txtAge = doc.createTextNode("19");

// 将文本节点添加为对应的元素节点的子节点。

eltName.appendChild(txtName);

eltAge.appendChild(txtAge);

// 将name和age节点添加为student节点的子节点。

eltStu.appendChild(eltName);

eltStu.appendChild(eltAge);

// 为<student>元素添加sn属性节点。

eltStu.setAttributeNode(attr);

// 得到XML文档的根元素。

Element eltRoot = doc.getDocumentElement();

// 将student节点添加为根元素的子节点。

eltRoot.appendChild(eltStu);

NodeList nl = doc.getElementsByTagName("student");

// ------------------删除节点------------------

Node nodeDel = nl.item(0);

nodeDel.getParentNode().removeChild(nodeDel);

// ------------------修改节点------------------

// 注意：NodeList对象是活动的，所以前面删除节点的操作会影响到NodeList对象，

// NodeList中的节点对象会重新进行排列，此时，索引为0的节点是

// 先前节点列表中索引为1的节点。

Element eltChg = (Element) nl.item(0);

Node nodeAgeChg = eltChg.getElementsByTagName("age").item(0);

nodeAgeChg.getFirstChild().setNodeValue("22");

// 输出修改后的学生信息。

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

Element elt = (Element) nl.item(i);

Node nodeName = elt.getElementsByTagName("name").item(0);

Node nodeAge = elt.getElementsByTagName("age").item(0);

String name = nodeName.getFirstChild().getNodeValue();

String age = nodeAge.getFirstChild().getNodeValue();

System.out.println("-----------------学生信息-----------------");

System.out.println("编号：" + elt.getAttribute("sn"));

System.out.print("姓名：");

System.out.println(name);

System.out.print("年龄：");

System.out.println(age);

System.out.println();

}

// ------------------保存修改结果------------------

// 利用文档节点创建一个DOM输入源。

DOMSource source = new DOMSource(doc);

// 以converted.xml文件构造一个StreamResult对象，用于保存转换后结果。

StreamResult result = new StreamResult(new File("converted.xml"));

// 得到转换器工厂类的实例。

TransformerFactory tff = TransformerFactory.newInstance();

// 创建一个新的转换器，用于执行恒等转换，

// 即直接将DOM输入源的内容复制到结果文档中。

Transformer tf = tff.newTransformer();

tf.setOutputProperty(OutputKeys.INDENT, "yes");//缩进

tf.setOutputProperty(OutputKeys.ENCODING, "gb2312");//编码

// 执行转换。

tf.transform(source, result);

} catch (ParserConfigurationException e) {

e.printStackTrace();

} catch (SAXException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

} catch (TransformerConfigurationException e) {

e.printStackTrace();

} catch (TransformerException e) {

e.printStackTrace();

}

}

}

使用SAX解析XML

XMLReader（解析器接口）

SAX解析器接口和事件处理器接口在org.xml.sax包中定义，XMLReader是SAX2.0解析器必须实现的接口（SAX1.0解析器实现Parser接口，该接口已不再使用）。

l  setEntityResolver(EntityResolver resolver)：注册一个实体解析器。

l  setDTDHandler(DTDHandler handler)：注册一个DTD事件处理器。

l  setContentHandler(ContentHandler handler)：注册一个内容事件处理器。

l  parse(InputSource input)：解析XML文档。

ContentHandler（内容事件处理器接口）

SAXAPI定义了许多事件，这些事件分别由事件处理器中相应的方法去响应。在SAX1.0前使用的是DocumentHandler接口，SAX2.0中已被ContentHandler取代。

startPrefixMapping(String prefix, String uri)：在一个前缀URI名称空间映射范围的开始时被调用。

<students xmlns:stu="http://www.sunin.org/students">

…

</stuents>

SAX解析器解析到<stuedents>元素时，就会调用startPrefixMapping方法，将stu传递给prefiex参数，将http://www.sunin.org/students传递给uri参数，然后产生<students>元素的startElement事件。在产生<students>元素的endElement事件后，解析器将调用endPrefixMapping方法。

SAX解析器工厂

与Dom类似，JAXP也为SAX解析器提供了工厂类——SAXParserFactory类。与DOM解析器工厂类不同的是，SAXParserFactory类的newInstance()方法查找的工厂类属性为：java.xml.parsers.SAXParserFactory，如果我们使用Apache的Xerces解析器，可以配置如下：

java.xml.parsers.SAXParserFactory=org.apache.xerces.jaxp.SAXParserFactoryImpl

JAXP中定义的SAX解析器类是SAXParser，获取SAXParser类的实例与获取DocumentBuilder类的实例相似，在得到工厂类的实例后，通过SAXParserFactory 实现类实例的newSAXParser()方法得到 SAX解析器实例：public abstract SAXParser newSAXParser()

你可以调用SAXParser或者XMLReader中的parser()方法业解析文档，效果是完全一样的。不过在SAXParser中的parse()方法能接受更多的参数。可以对不同的XML文档数据源进行解析，因此使用起来比XMLReader要方便一些。

另外，与DOM不同的是，SAX本身也提供了创建XMLReader对象的工厂类，在org.xml.sax.helpers包中提供了XMLReaderFactory类，该类createXMLReader用于创建XMLReader对象。

实际上，SAXParser是JAXP对XMLReader实现类的一个包装类，在SAXPars中定义了getXMLReader()方法，用于返回它内部的XMLReader实例：abstract  XMLReader getXMLReader()

使用SAX解析XML

解析并完整输出XML文档

/**

* 使用SAX解析XML文档，实际上就是编写事件处理器。

* 为了简化事件处理器接口的实现，我们让SAXPrinter类继承DefaultHandler帮助类

*/

publicclass SAXPrinter extends DefaultHandler {

// SAX解析器开始解析文档时，将会调用这个方法

publicvoid startDocument() throws SAXException {

// 输出XML声明。

System.out.println("<?xml version=‘1.0‘ encoding=‘GB2312‘?>");

}

// SAX解析器读取了处理指令，将会调用这个方法

publicvoid processingInstruction(String target, String data)

throws SAXException {

// 输出文档中的处理指令。

System.out.println("<?" + target + " " + data + "?>");

}

// SAX解析器读取了元素的开始标签后，将会调用这个方法

publicvoid startElement(String uri, String localName, String qName,

Attributes attrs) throws SAXException {

// 输出元素的开始标签及其属性。

System.out.print("<" + qName);

int len = attrs.getLength();

for (int i = 0; i < len; i++) {

System.out.print(" ");

System.out.print(attrs.getQName(i));

System.out.print("=\"");

System.out.print(attrs.getValue(i));

System.out.print("\"");

}

System.out.print(">");

}

// SAX解析器读取了字符数据后，将会调用这个方法

publicvoid characters(char[] ch, int start, int length)

throws SAXException {

// 输出元素的字符数据内容。

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

}

// SAX解析器读取了元素的结束标签后，将会调用这个方法

publicvoid endElement(String uri, String localName, String qName)

throws SAXException {

// 输出元素的结束标签。

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

}

publicstaticvoid main(String[] args) {

SAXParserFactory spf = SAXParserFactory.newInstance();

SAXParser sp = null;

try {

sp = spf.newSAXParser();

File file = new File("students.xml");

sp.parse(file, new SAXPrinter());

} catch (ParserConfigurationException e) {

e.printStackTrace();

} catch (SAXException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

}

使用ErrorHandler处理解析中的错误

DefaultHandler既现实了ContentHandler接口，又实现了ErrorHandler接口。

publicclass ErrorProcessor extends DefaultHandler {

publicvoid warning(SAXParseException ex) throws SAXException {

System.err.println("[Warning] " + getLocationString(ex) + ": "

+ ex.getMessage());

}

publicvoid error(SAXParseException ex) throws SAXException {

System.err.println("[Error] " + getLocationString(ex) + ": "

+ ex.getMessage());

}

publicvoid fatalError(SAXParseException ex) throws SAXException {

System.err.println("[Fatal Error] " + getLocationString(ex) + ": "

+ ex.getMessage());

}

/**

* 获取导致错误或者警告的文本结束位置的行号和列号。

* 如果是实体引发错误，还获取它的公共标识符和系统标识符。

*/

private String getLocationString(SAXParseException ex) {

StringBuffer str = new StringBuffer();

String publicId = ex.getPublicId();

if (publicId != null) {

str.append(publicId);

str.append(" ");

}

String systemId = ex.getSystemId();

if (systemId != null) {

str.append(systemId);

str.append(‘:‘);

}

str.append(ex.getLineNumber());

str.append(‘:‘);

str.append(ex.getColumnNumber());

return str.toString();

}

/**

* 输出元素的结束标签，以便于查看不同类型的错误对文档解析的影响。

*/

publicvoid endElement(String uri, String localName, String qName)

throws SAXException {

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

}

publicstaticvoid main(String[] args) {

try {

/*

*  利用XMLReaderFactory工厂类，创建XMLReader对象。

*  注，这里没有使用JAXP中定义的SAX解析器工厂类和解析器类，

*  而是使用了SAX本身定义的XMLReaderFactory工厂类与XMLRader

*  解析器。当然最好是使用JAXP中的工厂类。

*/

XMLReader xmlReader = XMLReaderFactory.createXMLReader();

// 打开解析器的验证功能。

xmlReader

.setFeature("http://xml.org/sax/features/validation", true);

ErrorProcessor ep = new ErrorProcessor();

xmlReader.setErrorHandler(ep);

xmlReader.setContentHandler(ep);

// InputSource类位于org.xml.sax包中，表示XML实体的输入源。

// 它可以用java.io.InputStream对象来构造，更多信息请参看JDK的API文档

InputSource is = new InputSource(

new FileInputStream("students.xml"));

xmlReader.parse(is);

} catch (SAXException e) {

System.out.println(e.toString());

} catch (IOException e) {

System.out.println(e.toString());

}

}

}

如果被解析的XML不符合对应的模式文档（DTD或Schema）或不存在模式文档时，都会报错

时间： 2024-10-14 17:08:53

XML详解：第三部分 XML解析的相关文章

XML详解：第二部分 XML Schema

声明:原创作品,转载时请注明文章来自SAP师太技术博客:www.cnblogs.com/jiangzhengjun,并以超链接形式标明文章原始出处,否则将追究法律责任!原文链接:http://www.cnblogs.com/jiangzhengjun/p/4290897.html XML Schema. 22 全局/局部声明/定义... 23 模式与名称空间... 23 目标名称空间... 23 局部元素和属性的限定... 24 未声明目标名称空间... 26 在XML实例文档中引用Schema

Web.xml详解(转)

这篇文章主要是综合网上关于web.xml的一些介绍,希望对大家有所帮助,也欢迎大家一起讨论. ---题记 一.            Web.xml详解: (一)  web.xml加载过程(步骤) 首先简单说一下,web.xml的加载过程. 当我们去启动一个WEB项目时,容器包括(JBoss.Tomcat等)首先会读取项目web.xml配置文件里的配置,当这一步骤没有出错并且完成之后,项目才能正常地被启动起来. l  启动WEB项目的时候,容器首先会去它的配置文件web.xml读取两个节点: 

logback logback.xml常用配置详解（三） &lt;filter&gt;

转自:logback logback.xml常用配置详解(三) <filter> logback 常用配置详解(三) <filter> <filter>: 过滤器,执行一个过滤器会有返回个枚举值,即DENY,NEUTRAL,ACCEPT其中之一.返回DENY,日志将立即被抛弃不再经过其他过滤器:返回NEUTRAL,有序列表里的下个过滤器过接着处理日志:返回ACCEPT,日志会被立即处理,不再经过剩余过滤器. 过滤器被添加到<Appender> 中,为<

SAX解析XML 详解

JAVA 解析 XML 通常有两种方式,DOM 和 SAX.DOM 虽然是 W3C 的标准,提供了标准的解析方式,但它的解析效率一直不尽如人意,因为使用DOM解析XML时,解析器读入整个文档并构建一个驻留内存的树结构(节点树),然后您的代码才可以使用 DOM 的标准接口来操作这个树结构.但大部分情况下我们只对文档的部分内容感兴趣,根本就不用先解析整个文档,并且从节点树的根节点来索引一些我们需要的数据也是非常耗时的.     SAX是一种XML解析的替代方法.相比于文档对象模型DOM,SAX 是读

转载 logback的使用和logback.xml详解 http://www.cnblogs.com/warking/p/5710303.html

logback的使用和logback.xml详解 一.logback的介绍 Logback是由log4j创始人设计的另一个开源日志组件,官方网站: http://logback.qos.ch.它当前分为下面下个模块: logback-core:其它两个模块的基础模块 logback-classic:它是log4j的一个改良版本,同时它完整实现了slf4j API使你可以很方便地更换成其它日志系统如log4j或JDK14 Logging logback-access:访问模块与Servlet容器集

logback的使用和logback.xml详解，在Spring项目中使用log打印日志

logback的使用和logback.xml详解 一.logback的介绍 Logback是由log4j创始人设计的另一个开源日志组件,官方网站: http://logback.qos.ch.它当前分为下面下个模块: logback-core:其它两个模块的基础模块 logback-classic:它是log4j的一个改良版本,同时它完整实现了slf4j API使你可以很方便地更换成其它日志系统如log4j或JDK14 Logging logback-access:访问模块与Servlet容器集

JavaEE学习之Maven配置文件pom.xml详解(转）

一.引言 (本文转载自:http://blog.csdn.net/longeremmy/article/details/9670619) 使用maven有一些时间了,一直没有好好将pom配置文件每个节点的意义好好了解一番.今天突然想来了解下:pom- project object model 项目对象模型.顾名思义,他是用来描述项目信息的,以及构建方式,依赖等.网上有一篇文章写的很详细,这里就借用一下,以备日后使用. 二.详解 1 <project xmlns="http://maven.

(2) tomcat配置文件server.xml详解

1. 入门示例:虚拟主机提供web服务 该示例通过设置虚拟主机来提供web服务,因为是入门示例,所以设置极其简单,只需修改$CATALINA_HOME/conf/server.xml文件为如下内容即可,本文的tomcat安装在/application/tomcat下,因此$CATALINA_HOME=/application/tomcat. 其中大部分都采用了默认设置,只是在engine容器中添加了两个Host容器. <?xml version="1.0" encoding=&q

C#中的Linq to Xml详解

这篇文章主要介绍了C#中的Linq to Xml详解,本文给出转换步骤以及大量实例,讲解了生成xml.查询并修改xml.监听xml事件.处理xml流等内容,需要的朋友可以参考下 操作之前,需要引入 程序集和命名空间 System.Xml.Linq;  一.生成Xml 为了能够在结构有一定的组织,笔者建议大家新建一个控制台项目,并且新建一个CreateXml类(以下部分都属于该类中). 并在其中写入以下属性: 代码如下: public static String Path { get { Stri

Ant之build.xml详解

Ant的概念 可能有些读者并不连接什么是Ant以及入可使用它,但只要使用通过Linux系统得读者,应该知道make这个命令.当编译Linux内核及一些软件的源程序时,经常要用这个命令.Make命令其实就是一个项目管理工具,而Ant所实现功能与此类似.像make,gnumake和nmake这些编译工具都有一定的缺陷,但是Ant却克服了这些工具的缺陷.最初Ant开发者在开发跨平台的应用时,用样也是基于这些缺陷对Ant做了更好的设计. Ant 与 makefile Makefile有一些不足之处,比如