欧美日韩亚洲综合一区 ,国产99在线,91精品中文字幕一区二区三区

XQuery动态创建XML Element

weidagang2046 — Thu, 01 Feb 2007 09:06:00 GMT

element {"tag"} {attribute {"id"}{"1"}, "content"}

result:

content

weidagang2046 2007-02-01 17:06 发表评论

A Simple XQuery Case

weidagang2046 — Sat, 13 Jan 2007 16:11:00 GMT

xml version="1.0" encoding="ISO-8859-1" ?>
< bookstore >

     < book category ="COOKING" >
         < title lang ="en" > Everyday Italian title >
         < author > Giada De Laurentiis author >
         < year > 2005 year >
         < price > 30.00 price >
     book >

     < book category ="CHILDREN" >
         < title lang ="en" > Harry Potter title >
         < author > J K. Rowling author >
         < year > 2005 year >
         < price > 29.99 price >
     book >

     < book category ="WEB" >
         < title lang ="en" > XQuery Kick Start title >
         < author > James McGovern author >
         < author > Per Bothner author >
         < author > Kurt Cagle author >
         < author > James Linn author >
         < author > Vaidyanathan Nagarajan author >
         < year > 2003 year >
         < price > 49.99 price >
     book >

     < book category ="WEB" >
         < title lang ="en" > Learning XML title >
         < author > Erik T. Ray author >
         < year > 2003 year >
         < price > 39.95 price >
     book >

bookstore >

book.xml

<names>
{
for $x in doc("book.xml")/bookstore/book
where $x/price > 30
return <name>{$x/title/text()}name>
}
names>

query.xq

<names>
<name>XQuery Kick Startname>
<name>Learning XMLname>
names>

names.xml

weidagang2046 2007-01-14 00:11 发表评论

SAX Parser

weidagang2046 — Sun, 24 Apr 2005 02:04:00 GMT

作�?BR>2003 �q?3 �?

��d��和操�U?XML 文�g的标准方法是 DOM�Q�“文档对象模型”）。遗憄��是，�q�种�Ҏ��需要读取整个文件�ƈ��它存储到树�l�构中，因而效率不高、缓慢，�q�且会过度��用资源�?/FONT>

什么是 SAX
��d��和操�U?XML 文�g的标准方法是 DOM�Q�“文档对象模型”）。遗憄��是，�q�种�Ҏ��需要读取整个文件�ƈ��它存储到树�l�构中，因而效率不高、缓慢，�q�且会过度��用资源�?/FONT>

一�U�替代方法是使用 Simple API for XML �?SAX。SAX 允许正在��d��文档时处理该文档�Q�这避免了在采取操作之前需要等待存储文档的所有内宏V�?/FONT>

SAX 是由 XML-DEV 邮�g列表的成员开发的�Q�Java 版本�?David Megginson �l�护。他们的目的是提供一�U�更自然的方法来使用 XML�Q�这�U�方法不会涉及到使用 DOM 的那�U�开销�?/FONT>

�l�果是基于事件的 API。解析器��事�Ӟ��譬如�Q�元素的开始或�l�束�Q�发送给处理信息的事件处理程序。然后，应用�E�序自己可以处理数据。虽然原始文档保持不变，�?SAX 提供了操�U�|��据的�Ҏ��Q�然后会��该�Ҏ��导向另一个过�E�或文档�?/FONT>

对于 SAX�Q�没有官方的标准�Q�万�l�网�Q�W3C�Q�或其它官方�l�织不维�?SAX�Q�但�?XML �C�֌�中，它是一个事实上的标准�?/FONT>

SAX 处理是如何工作的
SAX 分析�l�过其的 XML ��，�q�非常象老式的自动收报机�U�条。考虑以下 XML 代码片断�Q?/FONT>




UNIX
color

一般情况下�Q�SAX 处理器分析这�D�代码将生成以下事�g�Q?/FONT>


Start document
Start element (samples)
Characters (white space)
Start element (server)
Characters (UNIX)
End element (server)
Characters (white space)
Start element (monitor)
Characters (color)
End element (monitor)
Characters (white space)
End element (samples)

SAX API 允许开发者捕莯��些事�Ӟ��q�对它们�q�行操作�?/FONT>

SAX 处理涉及以下几步�Q?/FONT>

创徏事�g处理�E�序�?
创徏 SAX 解析器�?
��事件处理程序分配给解析器�?
�Ҏ��档进行解析，��每个事件发送给处理�E�序�?

在SAX与DOM之间�Q�如何选择
选择 DOM �q�是 SAX�Q�这取决于几个因素：

应用�E�序的目的：如果必须�Ҏ��据进行更改，�q�且作�ؓ XML ��它输出�Q�则在大多数情况下，使用 DOM。与使用 XSL 转换来完成的��单结构更改不一��P��如果是对数据本��n�q�行更改�Q�则��其应该使用 DOM�?
数据的数量：对于大文�Ӟ��SAX 是更好的选择�?
��如何��用数据：如果实际上只使用一��部分数据，则��?SAX ��数据抽取到应用�E�序中，�q�种�Ҏ��更好些。另一斚w��Q�如果知道将需要向后引用已�l�处理过的信息，�?SAX 可能不是正确的选择�?
需要速度�Q�通常�Q�SAX 实现�?DOM 实现快�?

��C�� SAX �?DOM 不是互斥的，�q�一点很重要。可以��?DOM 来创��Z��件的 SAX ��，可以使用 SAX 来创�?DOM 树。事实上�Q�大多数解析器实际常�怋��?SAX 来创�?DOM 树！

使用 JAXP 来创��析器
接下来我们来看一下JAXP的SAX Parser是怎么样工作的�?/FONT>

首先声明 XMLReader xmlReader。然后��?SAXParserFactory 来创�?SAXParser。正�?SAXParser �l�您�?XMLReader�?/FONT>


import org.xml.sax.helpers.DefaultHandler;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.XMLReader;

public class SurveyReader extends DefaultHandler
{
public SurveyReader() {
}

public static void main (String args[]) {
XMLReader xmlReader = null;
try {
SAXParserFactory spfactory =
SAXParserFactory.newInstance();
spfactory.setValidating(false);	//讄���验证选项,
如果您的XML文�g是有效文档的�?
��׃��用验�?�q�将提高处理速度
SAXParser saxParser = spfactory.newSAXParser();
xmlReader = saxParser.getXMLReader();

} catch (Exception e) {
System.err.println(e);
System.exit(1);
}
}
}

讄��内容处理�E�序
一旦创��Z��解析器，则需要将 SurveyReader 讄��为内容处理程序，以便于其接收事�g�?/FONT>

xmlReader �?setContentHandler() �Ҏ��完成�q�项工作�?/FONT>


...
xmlReader = saxParser.getXMLReader();

xmlReader.setContentHandler(new SurveyReader());

} catch (Exception e) {
...

当然�Q�对于内容处理程序，�q�不是唯一的选项�?/FONT>

解析 InputSource
��Z��Ҏ��件进行实际地解析�Q�需�?InputSource。这�?SAX �c�d��装了所有将要处理的数据�Q�所以不必担心它来自哪里�?/FONT>

现在�Q�准备对文�g�q�行实际解析。应用程序将��装�?InputSource 中的文�g传递给 parse()�Q�然后应用程序会�l�箋�q�行�?/FONT>


...

import org.xml.sax.InputSource;

...
xmlReader = saxParser.getXMLReader();
xmlReader.setContentHandler(new SurveyReader());

InputSource source = new InputSource("surveys.xml");
xmlReader.parse(source);


} catch (Exception e) {
...

可以�~�译和运行该�E�序�Q�但�q�时应该什么也没有发生�Q�因为应用程序还没有定义��M��事�g�?/FONT>

创徏 ErrorHandler
当然��M��有可能在试图�q�行解析�Ӟ��数据有问题。在�q�样的情况下�Q�有一个处理程序来处理错误和内容将是有帮助的�?/FONT>

��如同创建内容处理程序一��P��可以创徏出错处理�E�序。通常�Q�将作�ؓ ErrorHandler 的单独实例来创徏它，但�ؓ了简化该�C�Z��Q�出错处理正是包含在 SurveyResults 中。由于该�cȝ��承了 DefaultHandler 且没有扩�?ContentHandler�Q�所以这�U�双重用法是可能的�?/FONT>

需要关注的事�g有三个：警告、错误和致命错误�?/FONT>


...

import org.xml.sax.SAXParseException;


public class SurveyReader extends DefaultHandler
{

public SurveyReader() {
}
public void error (SAXParseException e) {
System.out.println("Error parsing the file: "+e.getMessage());
}
public void warning (SAXParseException e) {
System.out.println("Problem parsing the file: "+e.getMessage());
}
public void fatalError (SAXParseException e) {
System.out.println("Error parsing the file: "+e.getMessage());
System.out.println("Cannot continue.");
System.exit(1);
}
}
....
xmlReader.setContentHandler(new SurveyReader());

xmlReader.setErrorHandler(new SurveyReader());
//讄��� ErrorHandler

InputSource source = new InputSource("surveys.xml");
....

public static void main (String args[]) {
...

SAX 事�g
以下事�g是常用的�Q�它们都�?org.xml.sax 包的 HandlerBase �c�M��定义�?/FONT>

startDocument 表示文档开始�?
endDocument 表示文档�l�束�?
startElement 表示元素开始。当一�Ҏ��C��的�v始标��C��的所有内容被处理后，解析�?�Ȁ发此事�g。包括了标记名和其属性�?
endElement 表示元素�l�束�?
characters 包含字符数据�Q�类��g�� DOM 的一�?Text 节点�?

�q�有更多�?SAX 事�g�Q?/FONT>

ignorableWhitespace 此事件类��g��我们前面所讨论的无�?DOM 节点。它�?character 事�g的区别，好处�?如果您不需要空格符�Q�您可以通过忽略�q�个事�g来忽略所有的�I�格�W��?
warning、error �?fatalError �q�三个事件表�C�Z��解析错误。您可根据需要来响应它们�?
setDocumentLocator �q�个事�g允许您存储一�?SAX �?Locator 对象。Locator 对象可以用来扑և�在文档中��切发生事�g的地斏V�?

转自�Q?A >http://www-128.ibm.com/developerworks/cn/xml/x-cert/part8/

weidagang2046 2005-04-24 10:04 发表评论

Introduction to DOM

weidagang2046 — Sat, 23 Apr 2005 08:20:00 GMT

Introduction

This tutorial is a simple introduction to DOM. There is a more in-depth and technical coverage of the DOM API in the "Complete DOM" tutorial.

As a Java programmer, once you have some XML documents, you will probably need to access the information contained in them using your Java code. Since the XML document is just a text file, you can write your own text file reader which interprets the information in the XML document in a way that your code can use. It is a very time consuming process to write such an XML document reader, and if you think about it, such code would have to be written over and over again for different programs that needed access to the information in XML documents. The W3C realized that this is the case and they created a standard way to create these "XML document readers" or XML parsers. The good news is that you don't have to write these parsers, free parsers are provided by many companies out there, including Sun, Datachannel and IBM. These parsers are written in Java too, you must use XML parsers written in Java in your Java programs.

What is a DOM XML parser?

A DOM XML parser is a Java program that converts your XML documents into some Java object model. Once you have parsed an XML document, it exists in the memory of you Java Virutal Machine as a bunch of objects. When you need to access or modify information stored in the XML document, you dont have to manipulate the XML document file directly, instead you must access and modify the information through these objects in memory. So the DOM XML parser creates a Java document object representaion of your XML document file.

The parser also performs some simple text processing as it creates an object model of your XML document; it expands all entities used in the file and it compares the structure of the information in the XML document to a DTD (if one is used). Once the simple processing is successful, the parser creates a document object representation of your XML document file. In order to access and modify the information in this document object, you need a reference object (of some class type) in order to call methods on the document object. The W3C has also created a set of Java interfaces called the Document Object Model API, which allow you to access and modify information in a document object created by the XML parser. So instead of accessing this document object with a reference of its implementation class type, the W3C expects you to access the document object with the standard DOM Java interfaces. The document class must implement these DOM interfaces.

DOM is just a set of Java interfaces which have been defined by the W3C, however, no implementations of these interfaces are provided. The XML parser writers must provide the implementations for the DOM interfaces themselves.

Since XML parsers may be written for any platform and language, the W3C has not provided an implementation for the DOM interfaces, and it leaves it up to the XML parser impementor to provide a good implementation. By doing this, another advantage is that your XML documents and Java programs (that you write) are not dependent on any particular parser.

What is DOM?

In order for your Java programs to access the information in XML documents, the parser must read the XML files from the first layer. The parser processes the file by checking the information contained in it for validity (by using a DTD if one is used) and expanding all the entities used in the file. Then this (processed) XML document is converted into an XML document object in memory by the XML parser. This document object contains a tree of nodes that contain the data and structure of the information contained in the XML document. This tree of nodes can be accessed and modified using the DOM API.

DOM is similar to the Swing component models, like TableModel, ListModel and TreeModel. These models are simply interfaces which must be implemented by classes that contain the actual data. For example, if you wish to display information in a 2D array to a JTable, you must create a class that contains the 2D array and then have this class implement the TableModel interface. So the TableModel does not contain the data, it merely allows the JTable to access the underlying 2D data; the data exists in an instance (object) of the class that implements the model. The DOM does not contain the data, but merely allows you to access your underlying XML data from the Java programs that you write. The document object contains the data, the class (of which this document object is an instance of) also implements the appropriate DOM interfaces. The parser has the responsibility of providing the implementation classes for the interfaces and also a way to instantiate them.

So the parser creates some objects, which are instances of some classes that implement certain interfaces defined in the DOM API. These objects are instantiated when the Parser reads an XML document. Now, instead of accessing these objects directly, you rely on using some Java interfaces (defined in the DOM API by the W3C) to access and manipulate these objects. These objects effectively contain the information that is in your XML document, but they only allow you to access and modify this information using the Java interfaces defined in the DOM API. So the Document Object Model is very similar to the Swing models (like TreeModel, ListModel and TableModel) which is just a set of interfaces without the implementation. This entire process is illustrated in Figure 1.

The good news about DOM and XML Parsers is that you don't have to implement the DOM API or write the parser. There are many companies that provide XML Parsers for different languages and they all implement the DOM interfaces.

Overview

The DOM API allows hierarchical access to the information in an XML document. An XML Parser converts the information in an XML document into a tree of nodes after parsing the document. DOM allows you to access this tree of nodes using the Java interfaces defined in the DOM API. The entire XML document, no matter how simple or how complicated, is converted into a tree of nodes, and all the nodes start from one root node, which is called a document object, hence the name Document Object Model. Once a document object tree has been created (by the XML parser, or your own code), you can access elements in that tree and you can also modify, delete and create leaves and branches by using the interfaces in the API. Figure 2 shows how information in an XML document can be represented as a tree of nodes.

In the document object tree, everything is a node. A node may have other nodes inside it and the node itself can hold information, like its tag-name and value and its child nodes (if any). This hierarchical organization of information is similar to a file system, where files and folders are organized hierarchically, a folder may have files in it or other folders, and everything is descended from one root folder. Similarly, a document object is descended from one node, and it may have other nodes inside it. The document object itself is a node.

The DOM API defines a minimal set of (language and platform independent) interfaces for accessing and manipulating the content and structure of information stored in XML documents, in a hierarchical manner.

API Package Names

The interfaces for DOM are required (by the W3C) to exist in the org.w3c.dom package. You have to use the following include statement in your programs that use DOM: import org.w3c.dom.*; . The implementation for the Java interfaces in these packages are provided by the XML parser that you choose to use. The DOM interfaces are also shipped with the XML parser implementation that you use, and you have to put the implementation class files (or jar file) in your CLASSPATH.

However, the code to instantiate DOM objects is dependent on the parser that you are using. Remember, DOM is just a set of interfaces, and interfaces can't be instantiated in Java; only the classes that implement these interfaces may be instantiated. With the parsers used in this book, it only takes one line of XML parser specific code to instantiate a DOM object (using some specific XML parser). Once the XML parser specific object has been instantiated (that implements the appropriate DOM interfaces), you should access these objects only through the DOM interfaces. So, except for the one line of XML parser specific code, all your other code can be completely standards based and portable. If you use the factory pattern to instantiate the objects that implement DOM interfaces, then your classes will be completely portable and won't even have that one line of parser specific code embedded in them.

Important interfaces in the API

An XML document object that is created by the parser (after reading a XML file (contains a tree of Node objects (i.e. instances of some Node interface implementation class). In DOM, everything is a Node. The other interfaces are provided to make things more object oriented, but you can manipulate all your information in DOM by just using the Node interface. Figure 3 shows the inheritance relationships between some of the important interfaces.

The root Node object of the document tree is also a Document object; Document is a subclass of Node. Every DOM object must have a root. Another important interface is the Element interface (which is a subclass of Node); the Element interface can be used to access the elements in a DOM Document object tree.

The Node interface encapsulates access to a lot of information about a node, some of this information is listed in Table 1.

Some information that the Node interface encapsulates
The Node interface allows you to find out the following information about a Node object	Examples
What is the Node's type, tag name and value?	xml@beanfactory.com For this email Node (and Element), the Node type is Node.ELEMENT_NODE. The tag name is email. The Node's value is "xml@beanfactory.com".
What are the Node's children Nodes (if it has any)?	Nazmul Idris xml@beanfactory.com The person Node has two children Nodes, name and email.
Does the Node have any children?	... ... The addressbook Node has children. xml@beanfactory.com The email Node does not have any children.

Figure 4 illustrates a sample XML Document object tree and describes all the Node objects that are contained in it.

You can find out if a Node has children or not by using the hasChildNodes() method. Node is a simple interface and you have to make sure that you follow the rules in Table 2 when using it.

Rules that apply to Node objects
Rule	Example
If a Node object has a value (i.e. it contains some text data) then it may or may not have children elements.	Nazmul Idris The name Node (and Element) does not have children elements, only data.
If a Node object has children then it may or may not have a value	some data Nazmul Idris xml@beanfactory.com The person Node (and Element) may have a value as well as other child Nodes (Elements)
A Node may also have no children or no value.	The indexmarker Node does not have any children and neither does it contain any data.

If a Node has children, then it may or may not have a value. In Figure 4, the person element has children Nodes and a value. The email and name Nodes don't have any children and have values. If a Node has no children, it might also contain no value (like an element with an EMPTY data storage declaration).

The getNodeType() method returns the type of a Node; the type is just a constant int that is used to identify different types of Nodes, for example the Node.ELEMENT_NODE type identifies a Node to be an Element. You can use the getNodeValue() method to get the textual data stored inside a Node.

The Node interface has methods that allow the traversal of a Node tree. The getChildNodes() method is useful for getting all the elements inside a Node. This method returns all Nodes (if they exist) in an object that is a container for Node objects; this object implements the NodeList interface. NodeList is an iterator for a list of Nodes. Figure 5 illustrates how NodeList can be used.

In the "Complete DOM" tutorial, I will cover the DOM API in more depth and explain what all the interfaces do and have plenty of code examples. This tutorial is a simple introduction to the idea of DOM.

转自�Q?A >http://www.developerlife.com/domintro/default.htm

weidagang2046 2005-04-23 16:20 发表评论

weidagang2046 — Sat, 23 Apr 2005 06:34:00 GMT

摘要: JAXB以其方便的XML数据处理能力可能会引起你的兴��。你可能�q�不了解JAXB是什么，惌��知道它到底有什么好处，如果�q�是你需要的�Q�你才会再花旉��ȝ��l�的研究它，或者你只需要��用最基本的功能。然而Sun关于JAXB的文档有80��之多。我惛_��部分人都没有耐心看完�q�样的长��大论。本文以��短的��幅介绍了JAXB的基本��用，��是先睹为快吧。本文附带的代码包括了JAXB1.0 early access版本和本... 阅读全文

weidagang2046 2005-04-23 14:34 发表评论