Customer Reviews

J2ee and XML Development

5 star:		(0)
4 star:		(6)
3 star:		(0)
2 star:		(2)
1 star:		(0)

 

 

What is all the buzz about XML? Isn't it just HTML with content-based
tags? Why are XML-based web services and application servers thought
to be the power houses of the next generation Internet? How does XML
web services tie into J2EE application servers?

Too many "J2EE and XML" books dive into specific Java APIs for XML
processing without addressing those important questions. Kurt Gabrick
and David Weiss's new book "J2EE and XML Development" (Manning 2002)
is different and it gives us a refreshing look at the big picture: XML
is promising because it can provide a robust integration layer between
applications and between components inside an application. Together
with cross platform J2EE technology, they allow us to create
heterogeneous, flexible, implementation independent and scalable back
end server networks. The book, of course, is more than application
integration. It discusses a variety of architecture and design issues
of J2EE XML applications.

In the book, the authors discuss general concepts and approaches of
various XML-based system integration techniques in the context of J2EE
server side applications. Those approaches include message and RPC
driven web services, and relational database-driven application
servers in the middle/back tier; and MVC-based architecture to
separate tiers. The authors explain the relative merits of different
solutions. XML technologies and their Java handling tools covered in
this book include

* Basic XML validation tools such as DTD and Schema;
* XML to Java data binding tools;
* DAO objects to bridge relational data and Java XML objects;
* XML parsing APIs such as SAX, DOM and JDOM;
* XML query and transformation tools such as XPath, XQuery and XSLT;
* Java APIs to support web services specific XML protocols;
* XML native and XML enabled relational database for persistence.

Background knowledge in distributed computing, J2EE components (such
as EJB. JMS, JSP), specifications of various XML messaging protocols
and XML tools are required to understand most of the examples in the
book. The target audience of this book is mainly senior developers
and system architects. However, beginners can also benefit from the
book by learning the big pictures and general concepts. This book is
written in plain, easy English terms. It is very easy and informative
to read if you do not plan to go into details of the examples and case
studies. (I read it in a relaxing afternoon).

For an excellent example of technology comparison and discussions, you
can read the first part of chapter 4, in which the authors compared
four types integration techniques:

* Data level;
* Message level;
* Procedure level and
* Object level.

The authors went on to explain how different XML technologies can fit
into those four integration scenarios.

Although I enjoyed the book very much, as a developer, I felt
unsatisfied by the level of implementation details given in the book.
The authors try to give short and concise code segment listings
throughout the book to illustrate the most important concepts. But for
readers who are not J2EE experts, it is difficult to see how things
relate to each other without more detailed explanations. The readers
could get in-depth understanding of the techniques if they could study
the source code along with the text. The complete and commented
source code for the examples in each section and the case study are
available on Manning's web site.

Also, most popular relational databases vendors have developed XML
storage extensions to their flagship database products and those
extensions have been widely adopted in favor of native XML databases.
It would be nice if the authors could compare those technologies
against each other and offer their insights of future XML storage
solutions.

Overall, I recommend this book especially to architects and advanced
developers who are interested in adapting their J2EE skills to the new
world of XML based web services. It is also a great book for beginners
who want to see the big pictures and understand why J2EE/XML is a
platform that is worth investing their time and effort.

The title of this book tells the story, except that it should probably include the word "Overview". It is an easy read that provides solid information, but it is by no means a reference. It offers a nice, quick description of several aspects of Java and XML development, but I kept waiting for the meat. If you are new to XML in Java, this book will bring you up to speed on the APIs and uses of XML.

It starts with a review of J2EE architecture and XML development, which is helpful because the authors' perspective on these topics sets the stage for how they suggest using XML in a J2EE project. It covers the various XML-related Java APIs (JAXP, JAXM, etc.), and these are the parts that I found most useful. It also discusses some architectural options, which I expected to be quite helpful, but they needed more detail and discussion.

What I like on this book is that it really is about what the title says: J2EE and XML and do not forget: the development with these techniques.

A lot of books out there are dealing with J2EE and also a lot of books are out there that deal with XML, but this one is really focused on these two things: J2EE AND XML togehter. If you want to learn J2EE, than buy another book (and maybe this one too, because of the price). If you do not know what XML is, go and buy another book, but if you want (or need) to use J2EE AND XML (because you start with WebServices, or you wonder how you could use XML to do appl. development and deployment) than this is the one you should look for. It just gives you new ideas (or did you already look at Cocoon, servlet filters, appl. integration, web publ. frameworks or design patterns?).

If you want to open your mind look at this book. Keep in mind that if you want to specialize in one of the mentioned areas than you have to buy an additional book, but that's the interesting part specially on J2EE.

I can recommend it, because it showed me some things I was not aware of.

Java and XML have a great synergy, they marry together to create a "Write once, run anywhere" with a "platform independent data" paradigm. The nice thing about this is that you can keep the service interface relatively stable (e.g. use XML document instead of a specific data structure). But often what people overlook is, if you choose not to expose/distribute your data model directly (using classic data structure/class), then you have to expose/distribute the meta data of the data model (in XML world, this is called schema). Once the schema is changed (as you change in the data structure/class), you are pretty much facing the same problem as in the classic data model, the communicating parties have to know what is changed and change (the parsing rule at least) accordingly. Particularly, in the internal system, the benefit of using XML interface is dramatically reduced.

The authors of book are trying to push every data model in the interface by using XML document, even the data persistence, along with various X-technologies. That is a very "dangerous mind" if not done carefully, since XML is not a panacea in design and development. Even in modeling data, XML is not one size fit all. So when is it a good idea to use XML for your data? The following is that I quoted from Ted Neward's blog,

When your data is naturally hierarchical to begin with
When exchange with foreign platforms (which is to say, platforms not native to what you're currently authoring in) is important
When pre-existing tool support (XSLT, XML viewers, import/export utilities, etc) is of paramount importance

As you can see, there are some constraints before you decide to go with XML. Not mentioning the performance overhead. Though authors mentioned that designers need to justify the usage of XML by various criteria, but this is a book about promoting XML. :) Don't be trapped.

Overall, the book contains some useful information about various XML related technologies, particularly the chapter 5 "User Interface Development" (which is quite funny for a server side development book). And the information is too general or shallow to be useful in the real world development, you need to dig more into the technology by yourself from this introduction.

There are some examples showing how the concept could be working in the real world. But they are very rudimentary. Some specs the authors used (e.g. JAX-RPC) are already upgraded or changed. As a book on such popular topics regarding J2EE and XML, it sets the bar too low.

Although the coverage of XML is good, I found myself needing much more information especially in light of moving to web services technology. I found Java, The Complete Reference combined with this title as a good blend to get me where I needed to be.

This book gives you a very well-organized and informative tour of what's happening in the XML arena, the problem is this particular area of technology already so wide and so fast-expanding it's very difficult to get into the deep details of all areas, but the authors have done an excellent job of choosing the right technologies of tomorrow and delving into the details of those with sufficient background-story and code examples; in fact I would have given this book 5 stars if it didn't waste the first 40 so pages on explaining the client-server and peer-to-peer architectures and some extremely basic/boring J2EE and other generic topics, which has no place in a techy book like this. I would urge the reader to skip thru Ch. 1 in 4 minutes and dive right into the next ones, which are really very well written.

Beginners may use this book as an invaluable reference, intermediate level developers should only look into area of their interest, even advanced developers might find a few topics of their interest. Some of the topics the authors had to cover in a hurry, I'll say they have done a very good job in taking one specific feature and dissecting it, for example which discussing JSPs, the book lists a working example of JSP tag and explains it well, I'll say overall, the book is very well balanced between providing theoretical and background information on XML technologies and providing actual implementation examples. And yes, they did not miss out on the design patterns which are useful in this context!

Errata
page# 144: Boolean (instead of boolean) has been listed as a primitive type.

First of all, it is out of date.
And, it is not enough for a developer to learn how to use XML in J2EE environment. Yes, it does have some sample code, but not enough.

The book covers a wide range of XML technologies and its implementations in Java. Most of the examples/patterns discussed in the book apply equally well or can be easily adapted for non-J2EE Java application.
Some examples use depreciated APIs, some use APIs that no longer exist in latest packages. It's not a big problem and equivalents usually can be easily found. Just be aware how fast the technologies are evolving.