Customer Reviews

Java & XML, 2nd Edition: Solutions to Real-World Problems

5 star:		(14)
4 star:		(2)
3 star:		(5)
2 star:		(5)
1 star:		(1)

 

 

The buzz is all around. XML and all derivatives are attracting everyone. There are many XML books in the market but few are satisfactory. I like the books which can offer more than tutorials on the web. This is one of those. First of all, the book is well organized and easy to follow. Learn the idea behind SAX, DOM and then JDOM. Having a good understanding of these basics, go on with three main application areas of XML:"web publishing","interoperatibility", and "data binding". This is what XML developers should do, and author follows this order very well. In fact, I remember Brett's one article where he suggested developers not to forget basics of parsing while working with higher level APIs and protocols.

If we look at the details of book... After covering the basics of parsing, Brett introduces some -very good- real world examples: Cocoon(for publishing frameworks), soap, xml-rpc, and web services for communication or interoperatibility and Castor etc. for data binding.

What is missing or not intended in this book is XML data structure design and XSLT. This is understandable since both are very detailed topics that wouldn't fit in a single book. For XSLT there are the O'reilly Java & XSLT or Wrox XSLT books and for XML-Schema... I'm just waiting for a good one.

Especially for those intermediate level XML programmers with Java knowledge.

XML and Java, true to the title, provides detailed and broad coverage of XML programming in Java.

The chapters on SAX, DOM and JDOM provide a strong foundation for selecting and leverage these libraries at a practical level. The coverage of rapidly emerging XML topics including XML-RPC, SOAP and Web Services is timely and reasonably detailed, providing adequate information to allow these to be practically applied.

The author's writing style is easy to read and has a code-centric focus. The numerous examples were intelligently explained without providing detail that someone already familiar with the Java programming language would find verbose and boring.

This title is best suited to for those with some background in Java and a general understanding of XML. Assuming this background, this book can help bridge the gap from being a Java/XML programming novice to being a Java/XML programming expert.

The first edition of this book was considered one of the best on the subject of Java and XML. This new edition has expanded to include the developments in Java and XML over the last year. The author gives a little less handholding on the basics of XML reducing a three chapter introduction in the first edition to a one chapter summary. SAX, DOM, and JDOM all are covered in detail with each topic getting an introduction and an advanced chapter. JAXP 1.1 is covered in sufficient detail. After the introduction to the basic Java/XML APIs, the author moves on to some other interesting topics.

The chapters on web publishing frameworks and XML-RPC haven't changed much since the first edition. New chapters on SOAP, Web Services, and content syndication are welcome additions. The book ends with a look at data binding and JAXB.

The examples in the book are extremely clear and concise, explaining each topic well without being overly simplistic. As with the first edition, the author assumes that you are familiar with Java but unlike the first edition he assumes you have a basic understanding of XML.

If you are a Java developer and you are going to be working with XML then this book is required reading. The coverage of the Java/XML APIs is excellent. As for the other topics, it is a good introduction but for anyone working with SOAP or Web Services, other books will probably be required.

The author has done a great job. This book covers a wide range of XML topics with a very consise writing style. Also, it is a nice balance that the author spends more pages on XML parsing than other topics, since parsing is indeed by far the most useful technology.

However, the book could have been more careful about I18N, especially in the sample codes. As XML is no doubt a hot topic globally, numerous XML documents are processed every day. Although Java is based on Unicode, software almost always need to be retrofitted when expanding into the global market. Therefore, instead of new FileInputStream(new File(xmlURI)), or new FileWriter(file), it is much better, in a sense of education, to write codes like new FileInputStream(new File(xmlURI), "UTF-8") and new OutputStreamWriter(new FileOutputStream(file), "UTF-8"). The reason is that a program relying on default encoding behaves differently on different platforms. Changing your habit right from the beginning saves a lot of your time when you begin to globalize your software later.

I think the author does mention this issue somewhere in the book (in a foot note I guess), but it is the sample codes that really influence the readers.

To be fair, life could have been easier had the API designer insisted that an encoding parameter is mandatory.

One more comment: It will be nice if the author discusses XPath API in the book. For simple applications, the XPath API is far more easier to use than parsing APIs.

This is a very hard book to read. Not because of the subject, but because of the author's writing style and the fact that he introduces subjects and then referring them to the upcoming chapters.

Overall, it covers the essential subjects, like the interaction between Java and XML and covers DOM, SAX, JAXP, but I wouldn't use this book as a learning tool. Might be a good reference.

I would recommend XML Development With Java 2 by Michael Daconta, SAMS Publishing. To learn XML in detail, I would recommend the Professioanl XML, Wrox Publishing.

The author covers some background, but mainly sticks to the business end of dealing with XML using java. The book is set out so you can read the parts that are relevant to getting a particular piece of technology working quickly.

Before reading this book I had never written an XML parser, but within a couple of days I was able to rework a parser to make it work both faster and with a smaller memory footprint by following the guidelines in this book. The details are not covered in great depth, but enough to get a job done, and make this a portabe reference.

Another book worth owning from the O'Reilly press.

This book covers JDOM and XML-RPC very well, with links for downloading the neccessary material and documentation for developing in JDOM or XML-RPC right away.

It's JDOM coverage is very well laid out, as the author is one of the developers of JDOM. JDOM, if you don't know, is a Java implementation of an XML-Document that is completely self contained, and can use any XML parser. The drawback in using JDOM is that it may be slower in loading becuase it must load the entire xml document in memory. XML-RPC is faater, using SAX.

As for its XML-RPC, (Remote Procedure Calling) coverage, this book provides the necessary instruction to make an application using RPC, which sends data to and fro via XML documents that the programmer does not have to deal with. Simpler than RMI, and easy to install and change, unlike RMI, and running on HTTP, RCP can be accomplished with a single servlet, or even a single JSP page, for all your handler classes.

Although this is not covered in the book, if you convert the downloaded servlet to a JSP page, you must arrange the tags so that no return characters are sent back from the JSP page. This is done by deleting all blank lines between tags and putting all the closing tags to the next line just before the next open tag.

The book also covers XML for new people, although the first edition has more chapters on introduction to XML than this second edition. So, if you want to learn the basics of XML, you may want to get both books, although the technology is advancing so rapidly that the first edition is mostly obsolete now.

I am working for a company using Sun's Java WebStart to download an application via a browser that runs on the JVM. Originally I was going to make the application communicate to the server by sending URL-Encoded Name=Value pairs by a Post method, however, now that I have read this book, I changed my strategy to use XML-RPC, by which I can send Hashtable, Vector, String, Integer, Boolean, Double, and byte[] objects to simple classes that receive Hashtable, Vector, String, int, boolean, double, and byte[] as parameters. Everything has gotten a lot easier and more efficient.

This book doesn't have anything I couldn't find by just looking at samples on Sun's site.

Most of all, it's missing security like XML Signatures, and XML encryption.

This book is no doubt good, but is not really worth your money if you dont know a lot of Java and a little bit of XML. I have started with it and I already need a couple of other reference books. If you are a newcomer get a good reference book. This book is a little bit too tough.

There are examples, but they are scarce and too tough to grasp. O'Reilly is surely known for its quality books and it sure is but definetely not for someone new to Java and XML.

Second editions are always great. However, I find that I dont like all of the API reference in the book. I would rather look at APIs electronically and talk concepts in the book.