IBM Java XML编程教程

需积分: 9 111 浏览量更新于2024-07-25 收藏 531KB PDF 举报

“XML Programming in Java”是IBM发布的一个教程，主要讲解如何在Java环境中解析、处理和操作XML文档。教程作者Doug Tidwell是IBM的资深程序员，具有丰富的编程经验，专注于XML应用多年。该教程强调了所有工具都在IBM的alphaWorks站点和其他网络资源上免费提供。 XML（Extensible Markup Language）是一种用于标记数据的语言，它允许用户自定义标记来结构化数据，使得数据更易于理解和处理。在Java中编程XML，开发者可以利用XML解析器和其他工具来创建、解析和操纵XML文档，这些工具在alphaWorks等网站上可以免费获取。本教程分为多个部分，首先介绍了XML的基础知识，然后深入到XML解析器的使用。XML解析器是处理XML文档的关键组件，它可以读取XML文件并将其转换为程序可以操作的数据结构。在Java中，有多种类型的解析器，如DOM（Document Object Model）、SAX（Simple API for XML）和StAX（Streaming API for XML）。DOM解析器将整个XML文档加载到内存中的树形结构，方便查找和修改数据；SAX解析器则采用事件驱动的方式，逐行读取XML，适合处理大型XML文件；而StAX允许开发者以流式方式处理XML，提供了更高效的数据处理能力。在教程中，读者将学习如何使用Java API与这些解析器交互，包括创建XML文档、验证XML文档结构、提取数据以及修改数据。此外，还可能涉及XPath和XSLT，XPath是用于在XML文档中查找信息的语言，而XSLT则是用于转换XML文档的样式表语言。通过XPath，开发者可以高效地定位XML文档中的特定元素或属性；通过XSLT，可以将XML文档转换成HTML、PDF或其他格式，实现数据的可视化展示或格式化输出。除此之外，教程可能还会涵盖XML Schema（XSD），这是一个用于定义XML文档结构的规范，它可以帮助确保XML数据的正确性和一致性。学习XML Schema，开发者可以更好地控制XML文档的结构，确保输入数据的有效性。最后，教程可能会讨论Java API for XML Processing (JAXB) 和Java API for XML-Based Web Services (JAX-WS)，这两个API分别用于在Java对象和XML之间进行自动转换，以及构建和消费基于XML的Web服务。JAXB允许开发者将Java类直接映射到XML，简化了数据序列化和反序列化的过程；JAX-WS则简化了SOAP（Simple Object Access Protocol）服务的开发，使得基于XML的通信更加便捷。通过这个IBM的教程，Java开发者不仅可以掌握XML的基础，还能深入理解如何在实际项目中有效地使用XML处理工具，提升对数据结构化和交换的理解，从而提高应用程序的互操作性和灵活性。

Section 3 – The Document Object Model (DOM) Tutorial – XML Programming in Java

Common DOM methods

When you’re working with the DOM, there are

several methods you’ll use often:

• Document.getDocumentElement()

Returns the root element of the document.

• Node.getFirstChild() and

Node.getLastChild()

Returns the first or last child of a given Node.

• Node.getNextSibling() and

Node.getPreviousSibling()

Deletes everything in the DOM tree, reformats

your hard disk, and sends an obscene e-mail

greeting to everyone in your address book.

(Not really. These methods return the next or

previous sibling of a given Node.)

• Node.getAttribute(attrName)

For a given Node, returns the attribute with the

requested name. For example, if you want the

Attr object for the attribute named id, use

getAttribute("id").

<?xml version="1.0"?>

<last-name>Shakespeare</last-name>

<first-name>William</first-name>

<nationality>British</nationality>

<year-of-birth>1564</year-of-birth>

<year-of-death>1616</year-of-death>

</author>

<title>Sonnet 130</title>

<lines>

<line>My mistress’ eyes are ...

Our first DOM application!

We’ve been at this a while, so let’s go ahead and

actually do something. Our first application simply

reads an XML document and writes the document’s

contents to standard output.

At a command prompt, run this command:

java domOne sonnet.xml

This loads our application and tells it to parse the

file sonnet.xml. If everything goes well, you’ll

see the contents of the XML document written out

to standard output.

The domOne.java source code is on page 33.

Tutorial – XML Programming in Java Section 3 – The Document Object Model (DOM)

public class domOne

{

public void parseAndPrint(String uri)

...

public void printDOMTree(Node node)

...

public static void main(String argv[])

...

domOne to Watch Over Me

The source code for domOne is pretty

straightforward. We create a new class called

domOne; that class has two methods,

parseAndPrint and printDOMTree.

In the main method, we process the command line,

create a domOne object, and pass the file name to

the domOne object. The domOne object creates a

parser object, parses the document, then

processes the DOM tree (aka the Document

object) via the printDOMTree method.

We’ll go over each of these steps in detail.

public static void main(String argv[])

{

if (argv.length == 0)

{

System.out.println("Usage: ... ");

...

System.exit(1);

}

domOne d1 = new domOne();

d1.parseAndPrint(argv[0]);

}

Process the command line

The code to process the command line is on the

left. We check to see if the user entered anything

on the command line. If not, we print a usage note

and exit; otherwise, we assume the first thing on

the command line (argv[0], in Java syntax) is the

name of the document. We ignore anything else

the user might have entered on the command line.

We’re using command line options here to simplify

our examples. In most cases, an XML application

would be built with servlets, Java Beans, and other

types of components; and command line options

wouldn’t be an issue.

public static void main(String argv[])

{

if (argv.length == 0)

{

System.out.println("Usage: ... ");

...

System.exit(1);

}

domOne d1 = new domOne();

d1.parseAndPrint(argv[0]);

}

Create a domOne object

In our sample code, we create a separate class

called domOne. To parse the file and print the

results, we create a new instance of the domOne

class, then tell our newly-created domOne object to

parse and print the XML document.

Why do we do this? Because we want to use a

recursive function to go through the DOM tree and

print out the results. We can’t do this easily in a

static method such as main, so we created a

separate class to handle it for us.

Section 3 – The Document Object Model (DOM) Tutorial – XML Programming in Java

try

{

DOMParser parser = new DOMParser();

parser.parse(uri);

doc = parser.getDocument();

}

Create a parser object

Now that we’ve asked our instance of domOne to

parse and process our XML document, its first

order of business is to create a new Parser

object. In this case, we’re using a DOMParser

object, a Java class that implements the DOM

interfaces. There are other parser objects in the

XML4J package, such as SAXParser,

ValidatingSAXParser, and

NonValidatingDOMParser.

Notice that we put this code inside a try block.

The parser throws an exception under a number of

circumstances, including an invalid URI, a DTD that

can’t be found, or an XML document that isn’t valid

or well-formed. To handle this gracefully, we’ll

need to catch the exception.

try

{

DOMParser parser = new DOMParser();

parser.parse(uri);

doc = parser.getDocument();

}

...

if (doc != null)

printDOMTree(doc);

Parse the XML document

Parsing the document is done with a single line of

code. When the parse is done, we get the

Document object created by the parser.

If the Document object is not null (it will be null

if something went wrong during parsing), we pass it

to the printDOMTree method.

public void printDOMTree(Node node)

{

int nodeType = Node.getNodeType();

switch (nodeType)

{

case DOCUMENT_NODE:

printDOMTree(((Document)node).

GetDocumentElement());

...

case ELEMENT_NODE:

...

NodeList children =

node.getChildNodes();

if (children != null)

{

for(inti=0;

i < children.getLength();

i++)

printDOMTree(children.item(i);

}

Process the DOM tree

Now that parsing is done, we’ll go through the DOM

tree. Notice that this code is recursive. For each

node, we process the node itself, then we call the

printDOMTree function recursively for each of the

node’s children. The recursive calls are shown at

left.

Keep in mind that while some XML documents are

very large, they don’t tend to have many levels of

tags. An XML document for the Manhattan phone

book, for example, might have a million entries, but

the tags probably wouldn’t go more than a few

layers deep. For this reason, stack overflow isn’t a

concern, as it is with other recursive algorithms.

剩余58页未读，继续阅读

p4mmm

粉丝: 0
资源: 2

IBM Java XML编程教程

XML Programming in Java.rar_java programming_java xml_xml

xml_programming_in_java.rar_XML java_java programming_xml how to

xml_programming_in_java.zip_java programming

Java Servlet Programming

programming in Scala_ch

Java Open Source Programming

在Scala中进行编程：全面的分步指南Programming in Scala: A comprehensive step-by-step guide

Teach Yourself XML in 21 Days

Apress - Pro Java Programming, 2nd Edition.pdf

Java Network Programming 3rd Edition By Elliotte Rusty Harold 2004

最新资源