Ho trovato questo libro molto interessante.

Copre le varie API disponibili per JAVA per gestire file XML: SAX, DOM, JAXP, StAX, JDOM, dom4j. Inoltre vengono trattati anche alcuni argomenti avanzati, utili per apprendere al meglio l'uso di queste API.

Il libro e' colmo di codice ed e' proprio il codice ad essere utilizzato come strumento didattico. Codice e diagrammi UML riempiono tutte le pagine.

E' un libro molto pratico, rivolto ai programmatori. E' necessario avere una piccola infarinatura riguardo l'XML: viene trattato brevemente nei primi capitoli.

E' consigliato a chi ama libri con un approccio pragmatico.

mircha

I'm almost finished with this book, but have yet to determine what its purpose is. There is a lot of code about a lot of APIs, but it is not clear how one should approach Java & XML using this book. I think this book was a product of O'Reilly's "Rough Cuts" program, and it is true the book is very roughly written and all the good stuff got cut. Maybe all the material which would make this a good book is on the website.

I must admit I'm very disappointed with O'Reilly as of late. Their books are going down hill rapidly, and I find I'm looking at other publishers (APress) much more often. I used to go to O'Reilly's website almost daily to see what is coming out next, but now I'm considering removing the Ora bookmark from my browser because of lack of use and to create space for other URLs.

I really wish O'Reilly would get their act together and start publishing some well written and well edited books again.

This edition was published in Dec. 2006, so when I bought it Jul. 2007 it was the freshest book on the topic that I found. There are a lot of different Java XML tools with overlapping funtions SAX, DOM, JAXP, JAXB, Castor, JDOM, dom4j . . . This really help sort them out.

Are you developing with Java and need to use XML? If you are, then this book is for you. Authors Brett McLaughlin and Justin Edelson, have done an outstanding job of writing a book that that cuts through all of the hype about XML and put it to work.

McLaughlin and Justin Edelson, begin with the basics of XML. Then, the authors cover three ways of defining the structure of XML documents. Next, they introduce the Simple API for XML (SAX). They also cover less-used, but still powerful items in the API. The authors continue by covering DOM basics. Then, they discuss the various Level 2 and Level 3 DOM modules like Traversal, Range, Events, Style, HTML, Load and Save, and Validation. Next, the authors examine the Java API for XML Processing. In addition, they also show you how to SAX and how it compares to both SAX and DOM. They continue by examining JDOM, a Java-specific object model API. Then, the authors examine another Java-specific object model API, dom4j. Next, they cover JAXB 1.0 and 2.0, as well as the general basics of data binding. Furthermore, the authors show you how to syndicate content. They continue by looking at a variety of techniques for using XML in the presentation, or visual portion of web applications. Finally, the authors provide some brief overview of technologies not covered in depth in this book.

This most excellent book shows you how to use the APIs, tools, and tricks of XML to build real world applications. Perhaps more importantly, this book offers a new approach to managing information that touches everything from configuration files to web sites.

This book was probably useful back in 2000. Unfortunately, a lot has changed since then, and some of the information in this book is now flat our wrong.

For example the chapter about DOM objects was not updated to include information about recent api releases. So when the book says there is no simple way to serialize a DOM object, that simply is no longer true. You can now do it with the JAXP api.

The book has other problems as well. For example, the section that describes the difference between XSL and XSLT is extremely misleading and not helpful at all.

This is one of the few books that I intend to return

I had purchased the 2nd edition a few years back and I felt it was a great XML book for the times. This year I'm starting to use SOAP and other XML web services so I purchased the 3th edition hoping for updated chapters on the subject. Boy was I surprised to find out chapters on XML-RPC, SOAP and Web Services were dropped from the book. What were they thinking? The other chapters are too basic for the times and very disappointing.

The 2nd edition has 509 pages and the 3rd edition has 465 pages. I am glad O'Reilly is saving trees but I purchase my books for subject matter and information. I think the next editions should have more pages not less.

A note for Brett & Justin: Please add the missing chapters back and you will have a good book, again. (Brett did Justin ask you to remove the chapters?)

I am returning this edition. (Never returned a book before)

[Review of 3rd Edition]

Being able to work effectively with XML is getting to be nearly a requirement for a Java developer. The book Java and XML (3rd Edition) by Brett D. McLaughlin and Justin Edelson focuses specifically on the relationship between those two technologies, as well as what options are available for parsing an XML file.

Contents:
Introduction; Constraints; SAX; Advanced SAX; DOM; DOM Modules; JAXP; Pull Parsing with StAX; JDOM; dom4j; Data Binding with JAXB; Content Syndication with RSS; XML As Presentation; Looking Forward; Appendix - SAX Features and Properties; Index

SAX and DOM parsers have entirely different approaches and uses when it comes to reading an XML file. The book does a good job of explaining those differences, as well as showing coding examples of how those parsing routines would look in Java. The additional coverage of lesser-known parsers like StAX is also appreciated, as you may not always have the choice of which methodology and API you'd like to use. I felt that the combination of code samples and diagrams of hierarchies was done well, and anyone with a good background with Java and XML would have no problem going forward from here. The only part of the book I felt could have been left out, strangely enough, was the introduction and constraints chapter. The book is not a complete introduction to either Java or XML (nor did I expect it to be). If you come in with the prerequisite knowledge I think you'd need, the first two chapters are unnecessary. And if you come in as a complete beginner to both subjects, the chapters don't go into nearly enough detail for you to proceed. While it seems "proper" to have introductory material in a book, in this case I think you could have left those out entirely and just jumped right in to the parser material.

Nitpicking on the first two chapters aside, this is definitely a book that the Java/XML developer will find useful. Most of what you'll need to know can be found here...

It was a real pain going thru the very first chapter. The way the author presented his ideas was not at all intutive. I think though the author is good technically, he needs a language course on writing.This book could as well pass off for the greatest nonsense on java and xml.

Two APIs discussed in the second edition - JDOM and JAXB - saw important changes between the prerelease versions and their eventual final releases. These changes are covered in this latest edition. This book is organized into three sections. The first section, composed of Chapters 1 and 2, is a basic introduction to XML and related standards. However, the introduction is fast-paced, and if you have not seen XML before it probably won't be enough. The second part of the book - Chapters 3 through 11 - explains a wide variety of APIs for creating, manipulating, outputting, and pretty much doing anything else to XML documents. If you already know XML and Java, these chapters are excellent. If not, again, you are going to have difficulty as the material is fast paced. The last section - Chapters 12 and 13 - describes two important applications for XML. Chapter 14 stands alone as a chapter of predictions about the future of XML. The following is a description of the book in the context of the table of contents:

Chapter 1, Introduction, begins with the basics of XML. If you've never used XML before, this chapter will give you all the information you need to understand the rest of the book. It briefly touches on the changes between XML 1.0 and 1.1 before introducing XSLT and XPath.

Chapter 2, Constraints, covers three ways of defining the structure of XML documents: DTDs, W3C XML Schemas, and RELAX NG schemas. It covers how to use these standards to define a structure and how to ensure that a document matches that definition. It also covers how to convert between the various constraint document types.

Chapter 3, SAX, the Simple API for XML (SAX) is introduced in this chapter. The parsing lifecycle is explained, and the events that can be caught by SAX and used by developers are demonstrated via code examples.

Chapter 4, Advanced SAX, covers less-used but still powerful items in SAX. You'll learn how to use SAX features and properties to alter the behavior of the SAX parser, use XML filters to chain callback behavior, use XML writers to output XML with SAX, and look at some of the less commonly used SAX handlers like LexicalHandler and DeclHandler.

Chapter 5, DOM, unlike SAX has its origins in the World Wide Web Consortium. Whereas SAX is public domain software, DOM is a standard just like the actual XML specification. The DOM is designed to represent the content and model of XML documents across all programming languages and tools. In this chapter you learn DOM basics, find out what is in the current specification (DOM Level 3), and how to read and write DOM trees.

Chapter 6, DOM Modules, is about the various Level 2 and Level 3 DOM modules like Traversal, Range, Events, Style, HTML, Load and Save, and Validation.

Chapter 7, JAXP, examines the Java API for XML Processing (JAXP), including the XPath and Validation APIs introduced with JAXP 1.3. JAXP was initially a very small API that handled only parsing. The latest version of JAXP provides everything in SAX and DOM, plus some extras, and JAXP makes vendor neutrality much easier than using DOM or SAX directly.

Chapter 8, Pull Parsing With StAX, concerns The Streaming API for XML (StAX), which is the newest standard Java XML API. You'll learn how to use StAX and how it compares to both SAX and DOM. There is also a brief look at a precursor to StAX named XMLPull, which is still in use.

Chapter 9, JDOM, examines a Java-specific object model API. JDOM provides a means of accessing an XML document within Java through a tree structure, and in that respect is somewhat similar to the DOM.

Chapter 10, dom4j, examines another Java-specific object model API, dom4j. This chapter compares it to both JDOM and DOM. Also examined are features unique to dom4j, like its object-orientated transformation API.

Chapter 11, Data Binding with JAXB, talks about how with data binding, your application code does not concern itself with the details of XML documents, only a Java object model. Sun has developed a standard for XML data binding: the Java Architecture for XML Binding (JAXB). In this chapter, you'll learn about JAXB 1.0 and 2.0, as well as the general basics of data binding and when its use is appropriate.

Chapter 12, Content Syndication with RSS, covers using XML documents to syndicate content. Specifically, the RSS standards are examined along with a brief discussion of Atom. The creation and reading of RSS feeds using other APIs are discussed as well as an RSS-specific API named ROME. A highlight is the creation of your own podcast feed for submission to Apple's iTunes Podcast directory using this tool.

Chapter 13, XML As Presentation, looks at a variety of techniques for using XML in visual portion of web applications. The chapter shows how XML is a key component of the dynamic web application techniques that are becoming more common.

Chapter 14, Looking Forward, provides some brief overviews of several XML technologies. Included topics are XML appliances, XQuery, and Fast Infoset.

Appendix, SAX Features and Properties, details the features and properties available to SAX 2.0 parser implementations.

A good companion to this book is "Processing XML with Java(TM): A Guide to SAX, DOM, JDOM, JAXP, and TrAX" by Elliot Rusty Harold. The book is a little older, so standards have changed, but it does a good job of explaining things at a slower pace than this book. This book is better for the newer standards and applications. If you are working with XML and Java, you should probably have both books.

Two APIs discussed in the second edition - JDOM and JAXB - saw important changes between the prerelease versions and their eventual final releases. These changes are covered in this latest edition. This book is organized into three sections. The first section, composed of Chapters 1 and 2, provides a basic introduction to XML and related standards. However, the introduction is fast-paced, and if you have not seen XML before it probably won't be enough. The second part of the book - Chapters 3 through 11 - explains a wide variety of APIs for creating, manipulating, outputting, and pretty much doing anything else to XML documents. If you already know XML and Java, these chapters are excellent. If not, again, you are going to have difficulty as the material is fast paced. The last section - Chapters 12 and 13 - describes two important applications for XML. The following is a description of the book in the context of the table of contents:

Chapter 1, Introduction, begins with the basics of XML. If you've never used XML before, this chapter will give you all the information you need to proceed with the remainder of the chapters. It briefly touches on the changes between XML 1.0 and 1.1 before introducing XSLT and XPath.

Chapter 2, Constraints, covers three ways of defining the structure of XML documents: DTDs, W3C XML Schemas, and RELAX NG schemas. It covers how to use these standards to define a structure and how to ensure that a document matches that definition. You'll also learn how to convert between the various constraint document types.

Chapter 3, SAX, the Simple API for XML (SAX), the first Java API for handling XML mentioned, is introduced in this chapter. The parsing lifecycle is detailed, and the events that can be caught by SAX and used by developers are demonstrated.

Chapter 4, Advanced SAX, covers less-used but still powerful items in the API. You'll learn how to use SAX features and properties to alter the behavior of the SAX parser, use XML filters to chain callback behavior, use XML writers to output XML with SAX, and look at some of the less commonly used SAX handlers like LexicalHandler and DeclHandler.

Chapter 5, DOM, moves forward through the XML landscape to the next Java and XML API, the Document Object Model (DOM). You learn DOM basics, find out what is in the current specification (DOM Level 3), and how to read and write DOM trees.

Chapter 6, DOM Modules, is about the various Level 2 and Level 3 DOM modules like Traversal, Range, Events, Style, HTML, Load and Save, and Validation.

Chapter 7, JAXP, examines the Java API for XML Processing (JAXP), including the XPath and Validation APIs introduced with JAXP 1.3.

Chapter 8, Pull Parsing With StAX, concerns The Streaming API for XML (StAX), which is the newest standard Java XML API. You'll learn how to use StAX and how it compares to both SAX and DOM. There is also a brief look at a precursor to StAX named XMLPull, which is still in use.

Chapter 9, JDOM, examines a Java-specific object model API. It contains complete coverage of the JDOM 1.0 release.

Chapter 10, dom4j, examines another Java-specific object model API, dom4j. You'll see how it compares to both JDOM and DOM including the features unique to dom4j like its object-orientated transformation API.

Chapter 11, Data Binding with JAXB, talks about how with data binding, your application code does not concern itself with the details of XML documents, only a Java object model. Sun has developed a standard for XML data binding: the Java Architecture for XML Binding (JAXB). In this chapter, you'll learn about JAXB 1.0 and 2.0, as well as the general basics of data binding. The chapter also discusses when it is appropriate to use data binding.

Chapter 12, Content Syndication with RSS, covers using XML documents to syndicate content. Specifically, the RSS standards are examined along with a brief discussion of Atom. You'll see how to create and read RSS feeds using APIs discussed in the earlier chapters as well as an RSS-specific API named ROME. You'll even see how to create your own podcast feed for submission to Apple's iTunes Podcast directory.

Chapter 13, XML As Presentation, looks at a variety of techniques for using XML in the presentation, or visual, portion of web applications. The chapter shows how XML is a key component of the dynamic web application techniques that are becoming more mainstream.

Chapter 14, Looking Forward, provides some brief overviews of technologies not covered in depth in this book.

Appendix, SAX Features and Properties, details the features and properties available to SAX 2.0 parser implementations.

A good companion to this book is "Processing XML with Java(TM): A Guide to SAX, DOM, JDOM, JAXP, and TrAX" by Elliot Rusty Harold. The book is a little older, so standards have changed, but it does a good job of explaining things at a slower pace than this book. This book is better for the newer standards and applications. If you are working with XML and Java, you should probably have both books.

This book did not come up to the expectations that were set by some of the other reviewers and by O'Reilly themselves.

I bought Java & XML a couple of years ago. I diligently read the first couple of chapters, but then found it unhelpful and put it aside. To find out what SAX and DOM are you have to wade through lots of inconsequential information, only to discover that SAX allows you to parse an XML document on the fly, but doesn't retain it in memory; whereas DOM keeps the document in memory and allows you to manipulate it. Big deal. I could have worked this out by doing some Google searches.

I am writing this review because I have just picked up my (dusty) copy from the bookshelf in the hope of finding something interesting. I was surprised to see that the first example on SAX actually includes a JTree, even though McLaughlin says to ignore it, it is typical of the book to include something irrelevant and simply confusing. Why doesn't he just use a simple console example? What he doesn't say is that the JTree code is really there to make the example longer, so that there are more pages in the book that justify a higher price. You're not going to spend 45 dollars on a weedly little manual, are you? You want something chunky for your money.

When reading this sort of book, I get the feeling that O' Reilly, and similar technical publishers, put a lot of effort into inflating their publications into bigger manuals with lots of pages. McLaughlin is obviously an expert, but he is constrained by the O'Reilly house style, which is deliberately conversational and longwinded so that while you feel that it is easy reading, they are really just making it more difficult to learn simple concepts. As I said before they also pepper the pages with unnecessary sections of code.

In my opinion, another two examples are XSLT and XSLT "cooktop": both these O'Reilly manuals could have been condensed into one book by just cutting the waffle.

Don't get me wrong, I don't enjoy dry, academic journals but at the same time I just wish that these manuals would get to the point quicker .