Java与XSLT实战：构建动态Web应用

4星 · 超过85%的资源需积分: 10 189 浏览量更新于2024-07-24 收藏 1.99MB PDF 举报

"Java and XSLT - Eric M. Burke - O'Reilly出版社" 《Java and XSLT》是Java开发者必备的书籍之一，由Eric M. Burke撰写，于2001年由O'Reilly出版社首次出版，共528页，ISBN号为0-596-00143-6。这本书主要介绍了如何在Java程序中应用XSLT（Extensible Stylesheet Language Transformations）技术，涵盖了从独立应用程序到Servlet的各种场景。 XSLT是一种用于转换XML文档的语言，这本书首先简要回顾了XML的基础知识，然后深入探讨XSLT。它不仅讲解了XSLT的基本概念，如转换过程，还通过实例展示了如何使用XHTML进行转换。此外，书中介绍了XPath基础，这是在XSLT中选取XML节点的关键工具，以及如何进行循环和排序操作。在进阶部分，作者详细讨论了条件处理，使得开发者能够根据特定条件决定是否执行某段代码。参数和变量的使用是XSLT中的重要概念，书中详细阐述了它们如何帮助实现动态内容的生成。同时，书中还涉及了如何合并多个模板，以处理更复杂的转换需求。对于Web开发来说，XSLT常常用于创建动态网页之外的功能，比如构建讨论论坛、将文档从一种形式转换为另一种形式，甚至生成适用于无线设备的内容。本书适合已经有一定Java基础，希望学习并掌握XSLT技术的读者，无论是在桌面应用还是Web服务中，都能找到实用的应用示例和策略。书中的章节组织有序，遵循学习曲线，采用了一种易于理解的方式解释技术概念。此外，还包含了关于作者的信息、书评、读者评论以及可能存在的错误信息（errata），方便读者查阅和反馈问题。《Java and XSLT》是Java开发者提升技能，尤其是想深入了解XML文档处理和转换领域的宝贵参考资料。通过阅读这本书，读者可以掌握将XSLT集成到Java项目中的技巧，从而提高开发效率和应用的灵活性。

http://www.megginson.com/SAX. Although SAX has been ported to several other

languages, we will focus on the Java features. SAX is only responsible for scanning through XML

data top to bottom and sending event notifications as elements, text, and other items are

encountered; it is up to the recipient of these events to process the data. SAX parsers do not

store the entire document in memory, therefore they have the potential to be very fast for even

huge files.

[2]

One does not generally need to download SAX directly because it is supported by and included with all of

the popular XML parsers.

Currently, there are two versions of SAX: 1.0 and 2.0. Many changes were made in version 2.0,

and the SAX examples in this book use this version. Most SAX parsers should support the older

1.0 classes and interfaces, however, you will receive deprecation warnings from the Java

compiler if you use these older features.

Java SAX parsers are implemented using a series of interfaces. The most important interface is

org.xml.sax.ContentHandler , which has methods such as startDocument( ) ,

startElement( ) , characters( ) , endElement( ) , and endDocument( ) . During the

parsing process, startDocument( ) is called once, then startElement( ) and

endElement( ) are called once for each tag in the XML data. For the following XML:

<first>George</first>

the startElement( ) method will be called, followed by characters( ), followed by

endElement( ). The characters( ) method provides the text "George" in this example.

This basic process continues until the end of the document, at which time endDocument( ) is

called.

Depending on the SAX implementation, the characters( )

method may break up contiguous character data into several

chunks of data. In this case, the characters( ) method will

be called several times until the character data is entirely

parsed.

Since ContentHandler is an interface, it is up to your application code to somehow implement

this interface and subsequently do something when the parser invokes its methods. SAX does

provide a class called DefaultHandler that implements the ContentHandler interface. To

use DefaultHandler, create a subclass and override the methods that interest you. The other

methods can safely be ignored, since they are just empty methods. If you are familiar with AWT

programming, you may recognize that this idiom is identical to event adapter classes such as

java.awt.event.WindowAdapter.

Getting back to XSLT, you may be wondering where SAX fits into the picture. It turns out that

XSLT processors typically have the ability to gather input from a series of SAX events as an

alternative to static XML files. Somewhat nonintuitively, it also turns out that you can generate

your own series of SAX events rather easily -- without using a SAX parser. Since a SAX parser

just calls a series of methods on the ContentHandler interface, you can write your own

pseudo-parser that does the same thing. We will explore this in Chapter 5 when we talk about

using SAX and an XSLT processor to apply transformations to non-XML data, such as results

from a database query or content of a comma separated values (CSV) file.

1.2.4.2 DOM

The Document Object Model (DOM) is an API that allows computer programs to manipulate the

underlying data structure of an XML document. DOM is a W3C Recommendation, and

implementations are available for many programming languages. The in-memory representation

of XML is typically referred to as a DOM tree because DOM is a tree data structure. The root of

the tree represents the XML document itself, using the org.w3c.dom.Document interface. The

document root element, on the other hand, is represented using the org.w3c.dom.Element

interface. In the presidents example, the <presidents> element is the document root element.

In DOM, almost every interface extends from the org.w3c.dom.Node interface; Document and

Element are no exception. The Node interface provides numerous methods to navigate and

modify the DOM tree consistently.

Strangely enough, the DOM Level 2 Recommendation does not provide standard mechanisms for

reading or writing XML data. Instead, each vendor implementation does this a little bit differently.

This is generally not a big problem because every DOM implementation out there provides some

mechanism for both parsing and serializing, or writing out XML files. The unfortunate result,

however, is that reading and writing XML will cause vendor-specific code to creep into any

application you write.

At the time of this writing, a new W3C document called

"Document Object Model (DOM) Level 3 Content Models and

Load and Save Specification" was in the working draft status.

Once this specification reaches the recommendation status,

DOM will provide a standard mechanism for reading and

writing XML.

Since DOM does not specify a standard way to read XML data into memory, most DOM (if not all)

implementations delegate this task to a dedicated parser. In the case of Java, SAX is the

preferred parsing technology. Figure 1-3 illustrates the typical interaction between SAX parsers

and DOM implementations.

Figure 1-3. DOM and SAX interaction

Although it is important to understand how these pieces fit together, we will not go into detailed

parsing syntax in this book. As we progress to more sophisticated topics, we will almost always

be generating XML dynamically rather than parsing in static XML data files. For this reason, let's

look at how DOM can be used to generate a new document from scratch. Example 1-3 contains

XML for a personal library.

Example 1-3. library.xml

* An example from Chapter 1. Creates the library XML file using the

* DOM API.

public class LibraryDOMCreator {

/**

* Create a new DOM org.w3c.dom.Document object from the specified

* Library object.

* @param library an application defined class that

* provides a list of publishers and books.

* @return a new DOM document.

public Document createDocument(Library library)

throws javax.xml.parsers.ParserConfigurationException {

// Use Sun's Java API for XML Parsing to create the

// DOM Document

javax.xml.parsers.DocumentBuilderFactory dbf =

javax.xml.parsers.DocumentBuilderFactory.newInstance( );

javax.xml.parsers.DocumentBuilder docBuilder =

dbf.newDocumentBuilder( );

Document doc = docBuilder.newDocument( );

// NOTE: DOM does not provide a factory method for creating:

// <!DOCTYPE library SYSTEM "library.dtd">

// Apache's Xerces provides the createDocumentType method

// on their DocumentImpl class for doing this. Not used here.

// create the <library> document root element

Element root = doc.createElement("library");

doc.appendChild(root);

// add <publisher> children to the <library> element

Iterator publisherIter = library.getPublishers().iterator( );

while (publisherIter.hasNext( )) {

Publisher pub = (Publisher) publisherIter.next( );

Element pubElem = createPublisherElement(doc, pub);

root.appendChild(pubElem);

}

// now add <book> children to the <library> element

Iterator bookIter = library.getBooks().iterator( );

while (bookIter.hasNext( )) {

Book book = (Book) bookIter.next( );

Element bookElem = createBookElement(doc, book);

root.appendChild(bookElem);

}

return doc;

}

private Element createPublisherElement(Document doc, Publisher pub)

{

Element pubElem = doc.createElement("publisher");

// set id="oreilly" attribute

pubElem.setAttribute("id", pub.getId( ));

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

name.appendChild(doc.createTextNode(pub.getName( )));

pubElem.appendChild(name);

Element street = doc.createElement("street");

street.appendChild(doc.createTextNode(pub.getStreet( )));

pubElem.appendChild(street);

Element city = doc.createElement("city");

city.appendChild(doc.createTextNode(pub.getCity( )));

pubElem.appendChild(city);

Element state= doc.createElement("state");

state.appendChild(doc.createTextNode(pub.getState( )));

pubElem.appendChild(state);

Element postal = doc.createElement("postal");

postal.appendChild(doc.createTextNode(pub.getPostal( )));

pubElem.appendChild(postal);

return pubElem;

}

private Element createBookElement(Document doc, Book book) {

Element bookElem = doc.createElement("book");

bookElem.setAttribute("publisher", book.getPublisher().getId(

));

bookElem.setAttribute("isbn", book.getISBN( ));

Element edition = doc.createElement("edition");

edition.appendChild(doc.createTextNode(

Integer.toString(book.getEdition( ))));

bookElem.appendChild(edition);

Element publicationDate = doc.createElement("publicationDate");

publicationDate.setAttribute("mm",

Integer.toString(book.getPublicationMonth( )));

publicationDate.setAttribute("yy",

Integer.toString(book.getPublicationYear( )));

bookElem.appendChild(publicationDate);

Element title = doc.createElement("title");

title.appendChild(doc.createTextNode(book.getTitle( )));

bookElem.appendChild(title);

Element author = doc.createElement("author");

author.appendChild(doc.createTextNode(book.getAuthor( )));

bookElem.appendChild(author);

return bookElem;

}

public static void main(String[] args) throws IOException,

javax.xml.parsers.ParserConfigurationException {

Library lib = new Library( );

剩余404页未读，继续阅读

wujyc

粉丝: 0
资源: 1

Java与XSLT实战：构建动态Web应用

Java and XSLT.pdf

java程序员必备电子书

XPath and XSLT

Java与XSLT实战：构建动态Web内容

Java与XSLT实战：麻省理工经典教程解析

Java与XSLT：实战指南开发Web应用与文档转换

New Riders - XML, XSLT, Java and JSP--A Case Study in Developing A Web Application

java and xml

（英文0XML,XSLT,Java.and.JSP-A.case.study.in.Developing.a.web.appli

java and xls源码

最新资源