Despite the size of the book, it covers so many technologies that it cannot be the authoritative reference on any of them. Thus if you want to become a real expert on J2EE then you need the Wrox Professional J2EE book, or if you want to become an expert on JSP Wrox have a big fat book on JSP (recently updated) . Don't buy it if you don't like large chunks of program code within the text, it is physically rather heavy to carry around.
Pros
High level coverage of a wide range of related Java technologies by people who appear to have actually worked with them on real world projects. The authors seem to have actually used the technologies in the real world rather than just read the documents and played with a few toy applications. It gives gives you enough to evaluate how and where you would use each of the technologies and examples of how people have used it in real projects.
Should you buy it?
If you want to be aware of what technologies are available and find out how they can be applied then this is an excellent buy. If you want to start to learn and implement any of the topics mentioned from scratch, you would be better off buying a book that caters specifically for that topic. I will post a more detailed review in the book review forum.

First of all, the purpose of this book is to describe the big picture of an Enterprise Application in a very simple way. The MVC fundamentals are the basis for this goal and are applied in a perfect manner.

It's a great overview of the APIs involved in J2ee, and it also gives you an idea of the tools that can be used to simplify your work. It doesn't go deep into any topic, but as the title says, it's a book about designing and that's what it covers. It goes over all the existing tiers, explaining in detail the design concepts for each one. I recommend this book to people who have knowledge of the technical aspects but can't figure out how to best apply all these topics together in a large application, and/or have to review a summary of the concepts involved in developing large scale applications.

Each chapter is written by a different author, all Sun experts who lead teams on the subjects they cover, so there we get the added value of an explanation of how the creators think we have to apply the tools they design. Some aspects are out of date, for example the small coverage on xsl, but nothing really crucial.

A new acronym is born every week. JAXP, JAXB, JAXM, JAXR, SOAP, JAXRPC, JDOM... and the list continues. You have heard them all; you have probably played with them too. Perhaps you are even eager to start using them in your application, but not sure where to start. In the grand scheme of things, it becomes rather confusing how these technologies juxtapose and work in synergy to solve a problem.

This book helps you understand, appreciate and most importantly start using XML support offered by J2EE. It begins with an introduction to various ways XML can be used in a plain Java application - parsers, the all new JAXPack, parsing with JAXP, XML messaging with JAXM, data-binding with JAXB, transformations etc. With this background readers are quickly whisked into the realm of distributed computing.

The subsequent chapters present the readers a plethora of opportunities for using XML in a typical J2EE enterprise application for improving robustness and manageability. Facilitating component interaction and collaboration in a distributed environment using protocols such as XML-RPC and JAXM, implementing SOAP and Webservices, XML based persistence, Java collections with JDOM, and even XML for MVC based user interface programming. Every concept is explained with a concise example illustrating its intended use and scope.

Benefits offered by XML are too expensive to ignore. This book is your survival guide to understand the repertoire of XML based technologies and adopt them in your existing enterprise system.

"J2EE Unleashed" covers the major aspects of the Java 2 Enterprise Edition. The three main pieces (servlets, JSPs, and EJBs) are each well covered with good examples. JNDI, JDBC, JavaMail and JMS are each given a chapter and XML is also covered. The strength of the book, though, is its coverage of designing J2EE architectures. For example, servlets are explained but then the authors go beyond the explanation to show how servlets fit into an overall J2EE architecture. Model 2 controller architecture is covered and Apache Struts is discussed as an example of using servlets as controllers. According to the publisher, "The goal of this book is not to teach the J2EE specification but to illustrate the best practices for developing J2EE applications." In fact, it does both. The example application which is used throughout the book is well designed to cover all the pieces of J2EE. I do have two complaints about the book. First, it concentrates too much on the SilverStream Application Server getting down to the level of showing screen shots of deployment wizards. Second, the book could have used some editing to give it a better flow. J2EE architecture is explained before any of the pieces that make up the architecture are discussed. EJB session beans are used to demonstrate how to use JDBC, before EJBs are covered. Overall, however, the book is well done and can stand up against any of the books covering this complex topic.

This book takes an interesting approach to using J2EE technology. Rather than concentrating on a single aspect (servlets, JSPs, etc) or spending hundreds of pages explaining all technologies in detail, the author has chosen to lightly cover all the important aspects. In a sense, this book is an "executive summary" of J2EE. The readers who would probably get the most from this book are architects who need to understand J2EE but don't need to write much code and developers who are unfamiliar with J2EE and need an introduction to the technologies. This is especially helpful to developers who have completed the Java Programmer Certification but are unfamiliar with server-side development. There are two things that make this book unique and especially valuable to those new to server side development. First, the book covers the complete end-to-end solution. The author spends several chapters explaining the architecture of web applications. All the basics of server side development are discussed (JSP, Servlets, EJBs, JMS, JDBC) but the author also covers other important issues such as the HTTP protocol, web services, database design, and SQL. Second, the author explains which issues are likely to have an impact on the scalability and performance of your web applications. The entire book is under 400 pages and is very readable. Code samples are interspersed throughout the book to help explain the topics. If you are new to J2EE and are looking for a well written introduction then this book is very good choice.

This book thoroughly covers the Java 2 Enterprise Edition. For those that need to learn about a specific topic each chapter in itself can almost stand-alone and be read independently of the others or with minimal reference to other chapters in the book. The first part of the book gives a brief introduction to enterprise application development to put the reader in the right frame of mind. Along with a down and dirty SQL primer to make the JDBC section more meaningful. There are plenty of code examples throughout the book that further clarify the text and give more substantial examples of the topic being discussed. Some of the explanations seemed to cover some of the less used classes/methods in a little more detail than was warranted whereas a more thorough coverage of the basics would have been better served.

The CD includes all of the full-length programs from the book as well as a collection of evaluation software from various companies.

The stated audience is right on target too, if you have no prior Java experience this book isn't for you, but for those looking to reach the next level and gain some knowledge of enterprise development then this is a good starting point. All in all this is a very good book and if not so big would make a handy reference.

Professional Java Server Programming, J2EE 1.3 Edition, updates the older J2EE 1.2 edition of the same book. A few chapters have been added, a few have gone, and a lot of details have changed, but the seams between the old material and the new generally don't show.

The book is huge! Between its 1250 pages and 13 authors, it covers every important J2EE API, from JDBC to Connectors and Web services. It also discusses architecture, packaging and design patterns. You can start out with little more than some solid (J2SE) Java knowledge; it will be hard work, but by the time you've worked your way through, you will have a comprehensive knowledge of the J2EE platform.

There are disadvantages. This is not a book that takes you from cover to cover with a seamless development of material. There is some overlap between the chapters. The core J2EE topics (Servlets, JSPs and tags, EJBs) are discussed in a depth, with lots of code examples that can occasionally be too detailed for my taste, but many others (e.g. JNDI, JDBC, Connectors) barely scratch the surface and remain a bit theoretical. Ideally architectural and design considerations would have gotten a bit more, and more consistent, coverage throughout the book.

This will not be the only J2EE book you own; you will want the specifications, something with a stronger design focus such as Core J2EE Patterns, and maybe some specialised books. But it is an excellent place to start.

In a perfect world, on the day you started working with J2EE you would be handed a book that contained everything you needed to know about the subject. This is very close to being that book. This book is for experienced Java developers who are working with Java enterprise technologies. That does not mean servlets and JSPs, although those topics are covered. This book covers much more than just the basics of J2EE. Naming services, directory services, messaging services, transaction services, DCOM, RMI, CORBA, XML are all covered in some depth. You might think that a book covering so much would need to cover each topic only briefly. In this case, you would be wrong. CORBA has more that 150 pages, JDBC has 120 pages, RMI has 100 pages, XML has 60 pages and so on. Other topics which are often skimmed over in other books (security, cryptography, network communications) are given good coverage here. A case study is covered throughout the book showing how each technology could be used in a single application. The end result is a book that is huge with over 1400 pages. However, the book does have some weaknesses. It is light on the most popular topics of servlets and JSPs. It is also light on helping the developer to determine when to use one technology instead of another. If you are looking for a comprehensive guide to J2EE beyond servlets and JSPs, then this book may be the resource you need.

The words "A Case Study" added to the title of this book would more clearly explain what this book is about. This book doesn't really work as a stand-alone introduction to J2EE development but should be thought of as a companion to your favorite J2EE book. The premise of the book is a case study of an imaginary company (Pizza2Go) which wishes to take its current applications and migrate them to a J2EE internet application. The migration goes through stages as the developers first move to JSPs and servlets followed by the edition of various Enterprise JavaBeans. Following sections include integrating a J2EE application with an ASP application, messaging using JMS, and adapting an application to handle wireless devices. The last section discusses how to thoroughly test your application including stress testing. The case study is the heart of the book and is both the book's strength and its weakness. The book features an enormous amount of code but in some places little discussion of that code. Without some knowledge of servlets, JSPs, and J2EE this book would be difficult to follow. However, if your complaint about other books is that the examples are too simplistic or not realistic then this book may be just what you want. Although the book does discuss topics within BEA WebLogic Server, there is little if anything that can not be adapted to any J2EE server. Overall, I found this book to be a very helpful and interesting case study.

One of the best things about the Java Enterprise CD Bookshelf from O'Reilly is the search feature for this collection of seven Java Enterprise books that I find myself looking through time after time. It's nice to have both electronic and print versions of books and this collection provides some good electronic Java Enterprise books on CD-ROM in HTML format. After arrival of the CD Bookshelf, I was able to jump into my favorite web browser and start reading the books right off the CD (no installation required). I was also able to search for text not only in the book I was viewing but all the books in the collection at once. The applet based search feature allows (AND/OR) operations and helps make this electronic "bookshelf" an excellent on-line guide for a Java Enterprise developer. In addition to the electronic books, this collection also comes with a print copy of Java Enterprise In A Nutshell: A Desktop Quick Reference. Unfortunately this printed book was written before Sun announced J2EE. However, the text still covers the useful basics of JDBC, RMI, JNDI, EJB and Servlets. Lastly, although this collection contains Java in a Nutshell (Third Edition), I don't consider this the best introductory book to Java. For this series, it is useful if you are already pretty familiar with Java. Overall, a good Java Enterprise developer on-line reference set.

In a world where people and machines get more and more connected everyday, it is reasonable to consider the network as being an intrinsic part of nature. No matter whether it is wired or wireless, the network is ubiquitous and it wouldn't be exaggerated to state that 99.9% of all human activities heavily depend on it. Take the network down and get ready to experience chaos! On one hand, such a vision might trigger the scariest nightmares. On the other hand, this massive dependence justifies that we take network concerns very seriously and adopt a mindset that forces us to consider networking as a vital aspect of any information system.

This fully revised edition includes all updates introduced by the latest Java 5 release into one of the most complete and comprehensive reference about Java network programming available today. In order to show you what kind of support Java provides for making sense of all those bytes transiting on the network, the author first discusses some basic network and web concepts and then delves into more specific topics, such as streams, threading, URIs, client and server datagrams and sockets, asynchronous I/O, protocol and content handlers, RMI, the JavaMail API, and many other attractive subjects illustrated by relevant pieces of code.

Whether you consider yourself a novice or advanced Java programmer and you are willing to build network aware applications, don't wait any further and rush to your local store. You won't regret it!

I bought this book a year and a half ago. It's good, but outdated. The author, Elliotte Rusty Harold is a good writer and has been on the Java scene a long time. His web site Cafe au Lait is one of my favorites. He must update the site a few times a day. Back to the book review: I do still look stuff up in this book. Mostly things involving network ports, etc. But now I have other books that do a better job of that. It would be great if a second edition of this book came out that included more on RMI and other modern Java network stuff.

This book is old (1997) but still relevant and VERY helpful. Harold emailed me a one-word response to this message I sent: "Will there be an updated version"? His response: "yes". I've been too embarrased to write back and ask my second question..."when"?

UPDATE - Second edition (August 2000) A brand spanking new copy of an old favorite. Mr. Harold always seems to write books that are way ahead of their time. Then things change, his book becomes outdated and he never updates it. This is the first exception (that I know of). He has an excellent writing style, so the concepts in this book are easy to digest. I've read most of it already and forsee getting a lot of mileage out of this book.

Java Enterprise in a Nutshellby
David Flanagan, Jim Farley, William Crawford,
David Flanagan, Jim Farley, William Crawford,
David Flanagan, Jim Farley, William Crawford

O'Reilly
third edition
November 2005
892 pages

Reviewed by Jeanne Boyarsky, January 2006
(9 of 10)

"Java Enterprise in A Nutshell" preserves the spirit of the Nutshell series, but weighs in a t 837 pages. Each chapter covers a different technology in a nutshell. Many of J2EE technologies, such as EJBs and JNDI. Others are J2SE technologies, such as JDBC and XML. There are also chapters on open source tools including Struts, JUnit and Hibernate.

Each chapters aims to be both a short tutorial to the topic containing the most important details. It isn't a complete reference because it is a nutshell, but the chapters still serve as a reference for common tasks. The appendencies contain a more detailed reference on certain topics, such as EJB-QL.

The authors are good about walking you through configuration files and the steps to do common tasks. Conceptual topics and terminology are also included, such as the servlet lifecycle and J2EE security. There are many code examples throughout. In addition to noting best practices, the authors explain when techniques are debated among developers.

The book moves at a fast pace for beginners, but I recommend it for any experienced developers who want a tutorial on different technologies. The only downside is that so many topics are covered, the book can't go into enough depth on each one.

This most recent in a nutshell offering from O Reilly hardly seems like it ll fit into a nutshell, at least not any nutshell I ve ever seen. Despite the increase in size (almost double the size of the 1st edition), this book still manages to deliver a concise introduction to Enterprise Java. Part of the increase is the addition of chapters on JSP, XML, JMS, and Java Mail. Many of the chapters carried over from the 1st edition have been updated to the most recent specifications; JDBC 2.0, Servlets 2.2 and 2.3, and JSP 1.2. The entire book is an excellent reference to Enterprise Java, I would not advise it as the only book you have on the subject because it is very concise and an alternative source with different explanations would be very helpful (you can say that about almost any programming book though, so that is hardly an failing). The condensed API at the end of the book is very helpful and its expanded explanations of the different APIs makes it easier to understand them, as opposed to going straight from the Java Docs. Packed with both snippets and full length, compilable code, the examples are very helpful and help to illustrate all of the key concepts of Enterprise Java and go along way to improving the readers understanding. Even if you already have the first edition the additional, and updated content made this second edition a valuable edition to my reference collection.

One of the seemingly endless "in a Nutshell" series from O'Reilly, this book follows the basic series format. A few chapters of concise introduction followed by a detailed, if compressed, API reference. In this case the book covers a lot of ground - all the Java APIs which form part of the Java 2 Enterprise Edition: JDBC, RMI, CORBA, JNDI, Servlets, EJB as well as some material on JMS. The edition reviewed is beginning to date a little, as it only covers version 2.1 of Servlets with no JSP, but the vast majority is still solidly useful. I was worried when I bought this book that they were attempting to cover too much, but I think they have done a remarkable job. This book really is the most readable introduction to J2EE I have found so far. It's small enough to carry about (unlike the massive Wrox tomes), and the API reference can help to keep it useful after you've absorbed the introductory material. It even has a basic SQL reference, which you don't get in some JDBC books!

This book is one of those huge co-authored Wrox books on a broad area In this case the topic is Enterprise Application Integration (EAI) - getting old and/or incompatible "legacy" systems to work together. As with many such books, the content varies in quality, detail and usefulness.

EAI is a tough area, and the overview and strategy sections are very good. From any other publisher they would be a separate book. The section on EAI process is almost as good, but it just presents a process with no discussion of shortcomings or alternatives.

The rest of the book is taken up with technical sections, mostly about the various J2EE APIs which can help an EAI project. It's in this area that the book is weakest. Some of the material is effectively redundant (the EJB, Servlet and JSP APIs are covered much better in many other books, for example) or lacks detail (the key area of client emulation and "screen scraping" gets lots of mentions but nothing about how to do it, etc.). In general this section of the book tends to gloss over the "hard stuff".

I was disappointed to find no bibliography or references for further reading. A book like this is just an introduction to the topic. You'll need to look elsewhere to actually make things work.

Despite the negative points, this is still a valiant attempt to cover a large, and often overlooked, area. If you are integrating legacy systems it's well worth the price.

"The Java EE 5 Tutorial" is the official tutorial covering all the Java EE technologies.

"As part of Sun's 'The Java Series' this book has the same content as you can find online. Why buy a book you can get for free? Convenience!! You can take it anywhere and read it anytime." - Dave Vick - JavaRanch Review of the J2EE 1.4 version of this book. They eliminated the best part of a hardcopy! At 1300 pages, The Java EE 5 book is too heavy to carry around conveniently. (the 1.4 edition was less than 600 pages) I think it is time to split this book into two volumes. Maybe right after the 500 pages on the front end.

Other things I disliked:
It wasn't clear what was new in Java EE 5.
As in past editions, it reads better online than printed.
There are extensive forward references and lots of repetition. For example, chapter 16 repeats the six steps to open a NetBeans project 12 times!
Many examples didn't explain how/why to do something? like whether to call a web service directly from a JSP.
Most examples used Java 5 syntax inconsistently. It looked like Sun recommends using generics for collections, but precious little else from Java 5.

There were good diagrams and charts and good case studies along with several excellent chapters. Overall, I would say to read the pieces you are interested in online and spend your money on a different book.

As part of Sun's 'The Java Series' this book has the same content as you can find online. Why buy a book you can get for free? Convenience!! You can take it anywhere and read it anytime.

The content of the book is thorough and covers the uses of the various J2EE parts in depth. The book excels above other Enterprise books in describing the deployment process and how the different J2EE concepts all work together.

The authors give very detailed, step by step, instructions on how to use the deploy tool to create the various deployment files (WARs, JARs, etc.)

The book references a complete sample project (on the CD) that makes it easier to understand concepts and how they all tie together. As opposed to other books that use separate examples for each topic and never show the technologies together. The only noticeable lack in the tutorial is the code samples presented are usually snippets and can not be used alone to practice and play with.

At times the flow of the book was hard to follow and only after reading part of a chapter or section did I understand the direction. This may be a result of having multiple authors.

Readers can get the most use out of the book in learning the details of the deployment process along with other related concepts and steps. You won't find useful code samples to play and experiment with but, those can be found in most other books.

Topics in the book "JBoss Administration and Development", range from J2EE basics, J2EE as presented in the JBoss server and a low-level exposure to the JBoss server components.

The coverage of J2EE first principles is impressive and is as good an introduction as you're likely to find. Unfortunately, it doesn't go deep enough to be directly useful as a source for learning J2EE.

The book is not about administration and development USING JBoss as much as it is about administration and development of the JBoss server ITSELF. Again the selection and coverage of topics is impressive, but there isn't the exploration that would make this the only source required for any of the subjects. In addition, the amount of 'padding', such as code listings, outputs and large pictures, was highly distracting and accounted for almost a third of the content.

Overall, the best points about the book are that each topic includes source code that will get you started, and that it isn't just a repeat of existing documentation for JBoss. Unfortunately it tries to cover too many topics and none to enough depth to be definitive in any particular area. In addition, the organisation of material is not designed for use as a reference tool, which will make it difficult when used to diagnose and solve specific problems.

"JBoss Administration and Development" is an important and worthwhile addition to the JBoss documentation, but is not enough to stand on its own.

Enterprise Java Programming with IBM WebSphere is a solid overview of J2EE technologies and a great tutorial for using IBM's top-notch IDE for developing J2EE applications.

The authors (all 9 of them) go through the whole J2EE architecture from JavaServer Pages to Enterprise JavaBeans to Web Services one element at a time, including "bonuses" here and there, such as testing certain types of J2EE components, the Apache Struts framework, building a presentation layer using XML and XSLT, and mapping objects to data sources.

Each chapter includes a brief introduction to the technology, starting from the basics, and proceeds through the development steps in WSAD using lots of nice screenshots (which are mandatory for such a topic) and plenty of example code. Although some of the plain text is simply describing the wizards and dialogs of WSAD, the why's are always explained.

My biggest glitch with this book was in fact how the code snippets are rendered. Besides the mandatory typos and occasional weird wordings, the code snippets were often badly formatted and double-spaced which made them unnecessarily difficult to read at times.

The book comes with a 3 CD set of software, including trial versions of WebSphere Studio Application Developer, DB2 Personal Edition, WebSphere Application Server, and all of the book's source code. I had some trouble installing the software but that was most probably because I tried to customize the installations quite a bit

Over 800 pages of "let's walk this through together" type of tutorial is an admirable goal and the authors have done a good job making it a pleasant experience. The book has a lot of content and a lot of it is some of the finest text I've read about J2EE best practices. As one could expect, the trade-off is that none of the topics/technologies are really covered in complete detail. All things considered, I'd say this is a great first or second book about J2EE if you're going to use WebSphere Studio. I really can't say whether it should be the first or second, but I know it makes a great companion for a more in-depth technical reference.

In its 500 pages, this book contains a focused and thorough discussion of enterprise Java development using IBM Websphere and VisualAge. The accompanying CDs contain the timesheet application case study used to develop and illustrate the topics discussed, and evaluation versions of the tools and the DB2 database.

The first few chapters on J2EE architecture are tough going with lots of heavyweight terminology. Fortunately, things clear up as the book moves on to servlets, JSPs, and the case study. The entire second half of the book is dedicated to EJBs. Each of these areas is first introduced at a fairly elementary level, and then covered by a hands-on demonstration of development using WebSphere and VisualAge, working code examples from the case study, and chapters on design considerations and advanced topics.

The way an understanding of the technology, its design issues, and the IBM toolset is developed in parallel is definitely the highlight of the book. It is a refreshing change from volumes that leave you with some understanding of a sprawling pile of technologies but only a vague notion how to apply them. On the flip side, the writing style is fairly dry, JSP 1.1 and tag libraries (supported since v3.5.2) get a perfunctory discussion, and Web services none at all. The authors could also have focused a bit less on EJBs and fleshed out the topic of web-tier-only applications, as these are often more efficient, easier to develop, and perfectly adequate.

This book is a nice introduction to an expansive topic. The book is divided into six sections that cover introductory material, streams, the java.net package, some alternatives to java.net such as CORBA, message streams, and an appendix containing networking information. There is a good amount of example code and the authors walk you through a number of larger examples in each area.

I especially liked the small diagrams placed throughout the book to illustrate concepts and what the code is doing. The book does have the problem of presenting too much information already available in the API's javadocs. Overall, a good introduction to Java networking.

A quick way to describe Java (tm) 2 Platform, Enterprise Edition: Platform and Component Specifications (The Java (tm) Series) would be to say it lays out the specifications of the architecture and inner workings for developing Java 2 Enterprise (J2EE) applications. It provides for example, a good overview on how a Java 2 Enterprise Edition (J2EE) Enterprise JavaBean (EJB) server is built.

Anyone who would like the specifications for each of the J2EE components in hard copy form should look to this text. Developers who are interested in understanding some of the underlying building blocks of EJB and Servlet technology or need to provide engines that conform to the specifications would find this text beneficial.

Details from security down to the basic information needed to write your own application server can be found in these pages. The book is organized well and it is interesting to read the specifications from these authors involved with Sun. This text lays out the Java Specifications for the Java 2 Platform, Enterprise Edition (version 1.2 is covered), Servlets (version 2.2 is covered), JavaServer Pages (JSP) (version 1.2 is covered), and finally, EJB (version 1.1 is covered).

The book is not meant to be a beginning J2EE users guide. It does not make a good starter or introductory book to J2EE. This is an advanced Java book which makes a nice programmers reference if you are interested in the inner working details of J2EE.

Based on the well known Java Blueprints and Java Petstore application published by Sun, this book offers a quick tour of key technologies supported by J2EE platform such as Servlets, JSP, EJB, and JDBC API. Different aspects of a typical system development exercise are introduced using the sample application as a prototype. It attempts to cover all of the typical J2EE components and facilities such as connector architecture, internationalization, localization, packaging and deployment, security, issues with database access and design guidelines for a successful J2EE initiative.

No doubt, this book can be an excellent companion for those considering a transition to J2EE platform, but unfortunately, the content is not deep enough to help someone develop an actual J2EE application. They should have added "Introduction to" in the beginning of the title. The treatment of the topics is at best academic and is sure to disappoint any developer who is looking for some practical advice. The design strategies and architectural guidelines presented are superficial and inadequate to confront the challenges faced in real life application scenarios.

Having included several individuals from the actual J2EE Blue Prints team from Sun, they could have done a better job than simply trying to paraphrase the Blue Prints.

Would you believe that there is a Java Server book that has almost nothing to do with Servlets, JSPs, and Enterprise JavaBeans? If you are an advanced Java programmer and have felt a need to write your own application server then this may be the book for you. The author starts off with a well written discussion of class loaders and then goes on to show how to design your own application server using your own class loader. For most developers this may be interesting but of little real value. The thread chapters will provide little new information for anyone who has studied for the SCJP. The next few chapters discuss RMI, sockets, persistence, serialization and other issues that are required for the application server that the author is developing throughout the book. Servlets are briefly discussed but mostly on how they can be used to replace sockets and RMI within the application server framework. This is followed by a discussion of modeling business objects that seems somewhat out of place. The middleware section is very interesting and covers a wide array of topics from JMS to CORBA. The JNI section will probably not be used by many Java developers. Although the book is interesting I am left with the feeling that the author has missed the point. Why would a team of developers spend tens of thousands of dollars developing a service framework when inexpensive and robust application servers are readily available on the market.

My main problem with this book can be summed up on one word -- code. This book is very code-oriented, to the exclusion of all else. For instance, the very first chapter shows code on the 3rd page, and by the 10th, you're into a full-blown example. But you never learn WHY you want to do the example. That's continued throughout the book. They cover the mechanics of JMX in depth, but never tell you the reasons why you should care about any of it.

As an example, there is a case study that discusses how JMX is used in the JBoss EJB server. It's the very last chapter, long after most readers have lost interest. Do they tell you why they chose JMX? What advantage it gives JBoss? No -- instead they give you 5 pages of XML metadata.

What's more a lot of the code is of the "do-nothing" variety. We don't need to see how to implement unused methods of an interface 10 times. IMHO, you should give this book a pass. Hopefully one of the other books on JMX will give you a better understanding of the architecture, and why you should care...

When I started this book, I was looking forward to an explanation of how to use Convergent Architecture to create a J2EE application. What I found was a vague, confusing, and repetitive discussion that often reads as if it was in a tragic accident with a thesaurus. The idea behind the Convergent Architecture is not that complicated. We need to create a model driven architecture above UML that can link design and actual code development. Too often the Convergent Architecture is not explained in terms of what it is but rather how it is like designing cathedrals, diesel engines, or jet planes. The author tells us that using the Convergent Architecture can reduce time up to 70% and that these numbers are endorsed by neutral parties but he gives us no information about these neutral parties. And he doesn't tell us what the 70% is actually compared to making these numbers useless for doing any evaluation. The book promises to be a "step-by-step" guide but instead reads like a corporate white paper designed to sell a product. And there is a product in here that the author is selling. He is the founding director of the company that makes a product that takes up the last two chapters of the book. The only part of the book that is "step-by-step" is the tutorial on how to use the author's product. Overall, I was very disappointed in a book that I looked forward to reading.

This book attempts to cover a lot of ground and it does cover the whole breadth of J2EE and more. However, somewhere along the line, it seems like that the authors were pretty busy writing but never seem to have reviewed or even proof-read the technical content.

Personally I cannot accept refering to variables as "x" in the code and "X" in your explanation of the program. As a developer, I assume you are referring to different variables here. Yeah, yeah I know Microsoft Word does that...but nah I wouldn't go there. And the two words "right" and "write" (read the authors website) in English (at least the one I know) have different meanings.

Anyways, there are some good topics that I liked especially RMI. The book does explain snippets of code, while the bulk of the source code is on the CD-ROM which is handy. I think the authors could do a lot better and I definitely was expecting more. I don't mind having this book for a secondary reference but I wouldn't add this to the list of essential books on my shelf. For the same money I think there are better books on the market.

It is a pity that this book might end up being labeled out-of-date because it uses the now already "outdated" VAJ as its IDE.

I requested to review this book because I hoped that I would get the updated book using WSAD 5.0. But after reading the book I realized there was no need to have the updated book. Sure it teaches how to implement certain solutions with VAJ 3.5 and Websphere, but that is not what this book is about. It teaches one what to THINK about when creating web based enterprise solutions, it teaches one to understand what J2EE is all about !!!

What this book also did for me is finally to understand what patterns are all about and why they are needed in the Java world. I for one will start digging into patterns thanks to this book.

It is a well-written book by professionals that clearly know what they are talking about and I highly recommend it. Even though the software the book uses is out of date the knowledge it imparts surely is not.

This is the first of three volumes that will cover the entire process of building Enterprise applications with Java(tm) technology. This volume on architecture discusses the database, persistence and business layers. I have mixed feelings about this book. I like that the author makes a point to give reasons for making each design decision. But I think that he could have balanced the discussion better by citing more pros for the design options that he didn't go with. There is good coverage of accessing LDAP services with Java. However, discussion about other architectural issues apart from managing users and permissions are brief at best. After giving an overview of the sample application to be built, the first hundred pages covers detailed database design (which I thought was unusual for a Java book on architecture), LDAP setup and a few select EJBs. The last hundred pages, a good third of the book, is comprised of code listings and platform-specific instructions to get the sample application to work. This leaves the remaining hundred or so pages in the middle for discussion of Java code to access directory services and manage users and permissions and, briefly, message-driven beans. Other shorter discussions that you might find useful are EJB adapter classes and schemes for generating EJB primary keys. Apart from this, you will probably find this book a little disappointing. Hopefully, the next two volumes will pick up the slack.

Finally, a JMX book you'll love! Unlike other JMX books I've read (even those purporting to be based on "Real-world" experience) this book is firmly grounded with examples and explanations as to why JMX is useful and necessary.

Starting from the first chapter (which is the best architectural overview of JMX I've read) the authors provide clear, easy-to-understand explanations of both the how and the why of JMX. The code examples are readable and clearly explained (the authors specifically call out the relevant parts of each example) making you want to grab an editor and start coding!

They cover all of the major parts of JMX very well, including details on each of the different types of Mbeans. Likewise, their coverage of JMX notification is the best I ve seen. And, since the book is based on the Sun JMX Reference Implementation with detailed instructions on building and running the examples, it s easy to try this yourself.

There are a few minor snags that don t affect the book much. They don't start using UML early enough (the first large-scale example left me scratching my head) and they build a few marginally useful things (a Jini connector, for instance). Also, a bit more detail on other JMX implementations would have been nice. However, it s still the best of the available JMX books. Buy it if you need to use or build Mbeans!

J2EE 1.4 Essentials by Aaron E Walsh gives a very high level overview of the entire J2EE platform. First of all, let me explain what this book does and what it doesn't do. This book does provide a very high level overview of the wide spectrum of technologies involved in the J2EE platform. However, it doesn't go into depth in any of them. As a developer, I felt I was given just enough information to get me interested, but not enough information to accomplish anything. In addition, I found that the writing was remarkably accurate, albeit quite dry in style. Coupled with the amazing number of acronyms used to describe the various technologies involved, the writing style doesn't lend itself to easy reading. In fact, I found that I needed to be fairly familiar with the technologies or I'd end up rereading large sections. As this book is to be an introduction to J2EE technologies, the excessive use of acronyms is very awkward. Some of the redeeming qualities of the book, however, include accuracy of content and very few editing errors. Also, throughout the book, there are a great number of references to web sites for more information and even extra material available via the Internet. All in all, if you're looking for a brief overview of J2EE technologies, this book isn't bad, but if you're looking to do something with J2EE, you'll probably find yourself looking for another book soon.

This book was rushed and it shows. The first six chapters are really good. They are packed with solid information on topics such as installation and using JSPs, Servlets, and XTP. I found the XTP chapter particularly informative because I had not used the feature before.

The book starts to go down hill after that. The XDoclet chapter was too brief an introduction for a book with the word "Mastering" in the title. The typos started to become more common after that, as well. Part III, Resin Administration, didn't offer anything that can't be easily found in the documentation.

Overall, I'd say wait to see if the second edition fixes many of the problems.

Did you ever have the feeling that there was something wrong with your application design but you just couldn't put your finger on the problem? The authors of this book have taken their own experience developing J2EE applications and produced a book that will help you avoid many mistakes in application design. The book is geared toward helping the experienced designer/developer produce robust, maintainable applications and fixing applications that are not robust and not easily maintained.

The book covers most of the J2EE spectrum. There are sections on JSPs, Servlets, Entity and Session Beans, JMS, and Web Services. There are also sections on general J2EE architecture including distribution, scaling, and persistence. Each chapter gives a background on a specific antipattern, discusses the typical symptoms of the antipattern, and then covers various refactorings that can be used to correct the antipattern. Some of the antipatterns discussed may sound familiar ("too much code in JSPs") but the list of refactorings will provide useful information for even these obvious coding errors if you happen to be supporting an application that suffers from that antipattern.

The authors have done a great job of clearly explaining each antipattern, both explaining why it is an antipattern and what you can do to fix the problem. Each refactoring is demonstrated with code samples as well as with UML diagrams where appropriate. Overall, this is an excellent book that should be on the shelf of anyone involved in designing J2EE applications.

J2EE AntiPatterns is a must read for any developer that wants to improve their architectural skills. If understanding basic design patterns in software development is necessary then so is the understanding of patterns that are detrimental to overall performance, scalability and maintainability.

Each AntiPattern is presented with a synopsis of aliases, scale, refactorings, refactor type, root causes, unbalanced forces (forces that work with the root cause to realize the AntiPattern) and anecdotal evidence (what a development team may say when stuck in the AntiPattern). Background info, general form, symptoms and consequences, typical causes, exceptions, refactorings, variations, an example and related solutions are provided for each AntiPattern.

The only problems I noted with the book were a few typos and it seemed that some of the AntiPatterns were duplicated under different technologies. This is a reference that all serious J2EE architects should keep along with their copy of the GOF patterns.

Security is like spinach - it's good for you but not too many people like it. Most security books bore me to tears with page after page of description accompanying three lines of code. This book is different. This book is geared towards actual developers who are looking for not just explanations of security but useful examples showing how to make security work in their applications.

The first section of the book is an introduction to security in general and Java security in particular. The next section looks at the basic technologies and APIs used for encryption, authentication, and authorization. This section starts with a look into cryptography and covers JCA and JCE. It continues with coverage of digital certificates and then looks at controlling access to resources by using policy files. This section ends with a look at SSL and securing XML messages. The final section examines using these technologies in various J2EE applications such as RMI, Servlets, EJBs, and Web Services.

The explanations throughout the book are clear and easy to follow with plenty of code samples to demonstrate how to use the various APIs associated with security in Java programs. The best part of the book is the many code samples provided and the detailed descriptions accompanying these code samples. In addition, the author has provided a group of tools to assist with security development. Over all this is one of the best J2EE security books on the market.

Developing J2EE Applications with Websphere Studio is targeted at two types of readers -- those that are studying for the IBM certification (test 287) and those that are building J2EE applications with WSAD. Since I've not taken the certification, I can't comment upon how useful it is for the former. However, the certification objectives are presented well and there are test yourself sections at the end of each chapter so that you can recap what you have learnt. Each chapter seems to cover the exam objectives in some depth so everything you need to know for the test should be in the book.

From my perspective, I've read the book as somebody that has built J2EE applications before, albeit not using the IBM product set - I was fairly new to WebSphere Application Server (WAS) and WebSphere Studio (WSAD). In terms of the content, the book seems to have pretty much everything covered - from JSPs, Servlets and EJBs to J2EE clients, JCA, packaging and application profiling. There's undoubtedly something in here for everybody and the range of topics is impressive, with the second half of the book going into great amounts of detail.

There are a couple of things that I didn't like about the book though. The first of these is that it does feel slightly disjointed in places, partially due to the number of authors but also because the levels of detail vary from chapter to chapter. The second is that there sometimes doesn't seem to be much information about WSAD, although this isn't the case towards the end of the book. Essentially the authors have done a great job in covering many of the technologies, techniques and tools used in building J2EE applications, particularly as this is such a huge area.

At 600+ pages, it's a fairly hefty book and this is reflected in the price, although you do get a CD-ROM. Overall, this book has some excellent information and if you are new to WAS and WSAD then it comes recommended. For me, I'd like to see the book split because there are two really great books waiting to get out -- one on the certification and one purely focused on using WSAD, helping readers to use the tool in their day to day work.

This book is written to serve two goals. First, it is a guide for anyone using WebSphere Studio to develop enterprise applications. Second, it is a study guide for those intending on taking IBM Certification Test 287. Due to the dual nature of these goals there may be certain parts of the book that someone studying for the certification test is already familiar with especially when it comes to knowledge of the basics of WebSphere Studio. However, the excellent coverage of the test objectives makes this a minor issue.

For the person looking for a guide to enterprise development using WebSphere, this book will get them quickly up to speed. The various pieces of J2EE are explained briefly while how they are programmed using WebSphere Studio is very well explained. The book does not serve as a complete primer on Servlets, JSPs, EJBs, etc but it does serve as an excellent guide to programming these in WebSphere Studio and installing them in WebSphere Application Server. For the person looking to study for the IBM certification exam, they will find an excellent guide that clearly identifies each objective of the test and points to which chapter covers which objectives. The one thing missing however is sample test questions. Although some sample questions are available on the IBM web site, additional questions and study advice would have been helpful.

Overall, I can recommend this book for either those using WebSphere Studio for development or those intending on taking the certification exam.

The book's goal is stated to be a comprehensive BEA Weblogic Server book. It meets that goal. The book is over 1300 pages. Each chapter is relatively short and concise but cover the intended topic well.

The book covers all aspects of J2EE development as related to Weblogic. It covers both the development and server maintenance aspects of Weblogic development.

The authors do a good job of covering a topic without over covering them. Most chapters are either stand alone so readers can go to topics of interest to them or grouped with like chapters to get full coverage.

The book contains many screen shots and code snippets to highlight a topic. Complete examples are contained on the accompanying CD.

Instead of going on a WSAD course that costs you in access of $1500, rather purchase this book, it has everything you need to learn the basics for WSAD. I liked Igor's writing style and found easy to understand and follow.

Having said that, this book has some shortcomings though. It suffers from, "code bloat", code that doesn't get discussed and adds nothing to the teaching process. I also found that the format left a bit to be desired, at one place for instance, one is shown how to build the container relationship between two entity beans whilst the project has not even been built. Why not simply "do" the project first ??

The book falls short of Igor's wish of it becoming a "Websphere Bible", but I do recommend it, if you are starting out with WSAD.

This book is a nice, general, "white paper" type overview of security in Java. The authors demonstrate a good, solid understanding of J2EE security. However, they don't provide enough in the way of actual implementation examples. I feel this is a major shortcoming of the book.

The book starts with a general overview of security and then moves on to using applets with RMI through a firewall. The next section deals with Servlets, JSP, and EJB security and shows us some deployment descriptors and a few code samples but not enough to get a firm grasp on how to implement security. Part 3 discusses the basics of Java security. Part 4 discusses cryptography. The final part discusses advanced topics including a way too brief chapter on web services.

In general the book spends too much space discussing security topics and not nearly enough space demonstrating how to use the information provided. The book tends to be too technical in ways that are generally not interesting to Java developers. For example, does a developer really need this: "One straightforward application of the one-way function to DH is to have two entities to publicly agree on a point P on an elliptic curve E over a finite field, where p is a very large prime number."

I think this book may be very useful in combination with another book that is much more example driven, "J2EE Security for Servlets, EJBs, and Web Services" by Pankaj Kumar.

Security is a topic which often seems to be given too little thought. This book gives a hand for the J2EE developer new to security on a Java platform and, especially, on the J2EE platform.

The book has been split into five parts. I have gathered my thoughts about each in their separate paragraphs below.

Part I discusses about the needs of enterprise application security in general, and how these needs are associated with the J2EE components on a two or three-tier architecture, illustrated with pretty pictures of firewalls etc. The discussion is high-level in nature and acts mainly as a smooth entry into the mind-set of implementing security into your application.

Part II takes the focus inside J2EE and shows what kind of handles the J2EE architecture provides for security-related services such as authentication and authorization. Basically, this part of the book explains the programmatic and declarative security for web applications and Enterprise JavaBean components. The writing is very easy to understand but I would've liked to see one or two complete examples of a deployment descriptor instead of just small snippets. To me, seeing a full example would seem like a great way to tie things up in the context.

Part III, titled "The Foundations of Java 2 Security", is something I'm sure I'll come back to when I have to deal with J2SE security. The authors describe the whole shebang from class loaders to security managers and the horde of different types of permissions. This part also includes a chapter about the Java Authentication and Authorization Service (JAAS), which is top-notch amongst those I've seen about the subject. Clear writing combined with precise and illustrative examples. The one topic that could've deserved some concrete usage help were the command-line utilities such as keytool and jarsigner. Also, applet security was only mentioned in passing (the word "applet" can't even be found from the index), which may or may not be significant for the reader.

Part IV is dedicated to the art of cryptography. After presenting the basics of cryptographic algorithms, secret and public-key cryptography, the authors continue by discussing how the selected algorithms affect the confidentiality, integrity, authenticity, and non-repudiation properties of data. The chapters also discuss digital signatures, certificates, and key distribution on a high level. The rest of the fourth part shows how the JCA and JCE frameworks are built (i.e. how the pluggable implementation architecture works) and how the relevant APIs are used. The Java Secure Socket Extension (JSSE) for SSL is also presented with a couple of very nice examples including server and client authentication.

The fifth and final part talks about "advanced" topics such as web services security and some security considerations for container providers (which seems a bit out-of-place in this book). The subjects are covered only very superficially, which is understandable because the area of web services security admittedly requires a whole book to discuss in detail.

I can recommend this book as a solid source of information for J2EE security topics. Accompanied with vendor-specific documentation on deployment and configuration issues, you probably won't need anything else for your security needs. Its biggest weakness, in my opinion, is the lack of more complete sample code which could've at least been published online.

Open Source J2EE platforms can be great: due to the standards imposed by J2EE, you can develop using open source platforms, then implement on any J2EE compliant platform. But how do you choose which open source projects to use, and how do you integrate them all together? This book goes a long way to answering these issues.

The authors explain the use of each of the major technologies in J2EE, what it can do for you, and what you should look for in an open source project that provides the requisite services. They then detail several open source alternatives, and finally they show how to integrate at least one of the chosen projects with other J2EE projects, and develop a sample application to demonstrate it working. The end of the book has a complete application demonstrating the entire J2EE platform in operation.

The introductions to what each technology can offer will be useful to those who are unfamiliar with the capabilities of J2EE. And those new to J2EE, and new system architects will find the explanations of what to look for in each product, and how to compare them very useful. However the best benefit in my opinion is having a simple demonstration of how to integrate the products together - this will save countless hours of trying to integrate open source projects manually.

I found this a clear, informative, and easy to read book, and have no hesitation in recommending it to anyone considering developing or deploying using J2EE.

Tapestry is a web development framework that is radically different than most other frameworks used for web development. The author of this book, Howard Lewis Ship, is the principal architect of Tapestry. It is often the case that an expert is not necessarily the best person to write about a topic as they often forget what it is like to be a novice. The book starts with this problem but fortunately after the first couple of chapters the book improves greatly.

Chapter one is an introduction to Tapestry. The explanation is far from clear so if you don't know what Tapestry is when you start this chapter, you will still not know what it is when you finish. Chapter two is our first exposure to a Tapestry application but the author chooses a sample (a hangman game) that is complicated and is not a typical web application.

Chapters three through five discuss HTML forms and form components, showing how to use and validate them in a Tapestry application. The next three chapters show how to build your own form components and the last two chapters show how to build a complete Tapestry application. Starting with chapter three the book takes a turn for the better. If you were lost at the beginning of the book, it will all make sense by the time you get to the end.

I can strongly recommend this book to anyone interested in Tapestry whether they are a novice or an experienced Tapestry developer.

JavaServer Faces is a new J2EE framework from Sun. It's an exciting new technology that offers rapid J2EE application development focusing on the view and has features similar to Swing as it is event driven and utilizes component trees.

"JavaServer Faces Programming" was written not only before the Final release of the JSF specification, but before the beta specification was even released.

None of the examples in the book would work with the newest specification. Which is somewhat trivial as converting them to the new specification was not that difficult.

The main problem with this book was not knowing how much of it held water with the new spec. Reading through it I kept wondering what changed. I kept having to bounce back and forth between the book and the specification from Sun for comparison to see if what I was reading was still accurate.

There are other books on JSF and a lot of books that still haven't been released yet that should be at the very least consistent with the current JSF specification. If I had this book 6 months ago it would have been gold. Now, I just can't recommend it to anyone.

The author should have been wiser and more patient. Anyone paying attention to what was going on could have seen the specification changing and should have put the press on hold.

JSF Programming would have been a good book, but it was outdated before it could get off the ground.

Old wine in a new bottle. Put simply there's nothing new in this book.

If you are just beginning to wade through the vast land of J2EE, you will find plenty of introductory material to help you get started. The preface pronounces the audience as Java-aware readers who may not be fluent with J2EE technology stack. Beginners will appreciate the slow pace, logically ordered chapters, thoroughly descriptive background information on every pattern presented and an entire chapter dedicated to UML. However, if you are familiar with the core J2EE patterns published by Sun, there aren't a lot of things in this book that will interest you. Some things worth mentioning are - strategies for content caching, Serialized entity strategy for rapid development, and use of soft references for being thrifty on memory usage. The chapter on Enterprise Messaging Patterns is particularly interesting since it is an area that has attracted some interest lately.

Why another book on patterns? The bookshelves are already packed with several noteworthy titles on this subject and it is only natural to expect to see something new in new titles. This book is a far cry from "CoreJ2EE Patterns" or even the "Java Enterprise Best Practices" from the same publisher.

They could have done a better job by cutting down on teaching the basics and including all of Core J2ee patterns. ACID transaction pattern isn't a pattern at all, but just a fundamental concept. The selection of best practices covered seems arbitrary at best.

I have mixed feelings about this book. On the one side I was disappointed with it, I expected it to give me design guidelines for JMS applications, and on the other side I was pleasantly surprised, notably the coverage on SSL.

It's a pity the author did not take a complete JMS application and code it firstly using Simple Old Java Programs and then move on to the Websphere (WSAD) implementation. I think it would have greatly improved the learning process. But having said that the Websphere examples are great.

Personally I think the author could also have spent more time explaining JNDI. It's my experience that most JMS programmers do not understand JNDI adequately enough. Don't expect to get a deeper understanding of JNDI because of this book.

If you are starting of with JMS for IBM Websphere I can highly recommend this book, if however you are an advanced JMS (Websphere) programmer don't expect to learn much more, but if you have spare money lying around get it anyway.

According to many sources, software infrastructure is becoming increasingly and needlessly complex to develop and hard to manage. Moreover, the effective management of software and its underlying resources is even harder when dealing with systems operating in highly distributed environments. As a consequence of this sad reality, software maintenance and development costs are skyrocketing in proportions never seen before.

The primary goal of Pro JMX is to expose the value proposition of the Java Management Extensions (JMX) and to demonstrate how JMX can solve the aforementioned issues in both the desktop and enterprise Java worlds. Initially, the author starts by introducing some basic concepts about system resource management and then delves deeper into the three-level model of JMX (instrumentation, agent, and distributed services) by presenting the different types of MBeans and how they are exposed by agents to remote clients. Advanced topics, such as, remote lookups, security, and distributed management system design are also handled. Finally, a comprehensive list of many free and commercial JMX products is given.

Even though I have found this book to be an excellent resource about JMX, my only complaint would be that some parts could have been written in much simpler terms. This detail aside, my advice to all those who find remote software management to be a pain in the neck is to jump off your Aeron chair, grab a copy of Pro JMX at your local bookstore and stick yourself deep into your La-Z-Boy for a relaxing reading experience.

I wasn't completely new to JMX when I picked up this book. Yet, I felt uncomfortable with how fast the author dove into details that would be relevant to someone who's about to write a JMX implementation, not to a regular user of the technology.

The book's structure is also a bit inconsistent, in my opinion. For example, the author jumps into describing the history and patterns of distributed management system design in chapter 5 -- after two introductory chapters and two very code-focused chapters.

As an advanced manual to itty bitty details of how connectors etc. are implemented, this book is excellent. It's too bad that the back cover doesn't give any indication of this focus. If you're looking for a guide to learn or "just" use JMX, I'd suggest looking elsewhere.

JSF is a new technology designed to simplify the task of creating Java web applications by making them work more like typical GUI event driven applications. There are a lot of changes to the web framework for JSF and this book does a very good job of clearly explaining these changes. The book starts with an introduction to JSF that compares it to both Struts and Swing. The authors explain both the architecture and the main patterns used in JSF, which helps to make clear how JSF works. UML diagrams are used to help explain how the various pieces of JSF interact. The middle section of the book covers all the main points of JSF at a nice leisurely pace: configuration, UI components, navigation, event handling, and data conversion and validation. Plenty of code samples are provided and all the code is clearly explained. The final section of the book covers building a complete JSF application, designing custom components, and converting an application from Struts to JSF.

This book is a nice introduction and tutorial on JSF. For many developers, this will be all they need. Others may be looking for a book that can serve as a reference or will cover more detail and this book will not fill that need. If you are looking for a book to help you learn the basics of JSF and to get a good understanding of how to properly implement a JSF application, then this book will serve you very well.

This is a book that could have been a lot better. The main goal of the book, and one at which it generally succeeds, is to give you an overall view of what J2EE is and how it fits into an overall IT strategy. The advantages and disadvantages of each piece of J2EE are discussed. There is very little code in the book (and what is in there could have easily been left out without any loss of clarity) so if you are looking for a book to show you how to write programs then this is not the book for you.

The book has some serious drawbacks. First, the authors of this book are trying desperately to reach some level of geek coolness with mentions of The Simpsons, Buffy the Vampire Slayer, and Pulp Fiction, and with the use of deliberate (at least I think it is deliberate) poor grammar and spelling. But after awhile it just gets annoying. The book is probably twice as long as it needed to be because of the authors' desire to try to make the book fun. But unlike the Head First books, the "fun" here just gets tedious and turns short discussions into long and confusing discussions. (Why is a J2EE server like a dolphin? Does it like fish?) The book is also repetitive. For example, the discussion of session beans on page 48 is repeated almost verbatim (including the same picture) on page 139. The book does not cover JavaServer Faces and makes only a minimal mention of Struts. None of the other open source frameworks are discussed at all.

Overall, the information in the book is accurate and there is really no other book on the market that covers the material at this level (which is why it is getting 4 stars and not 3). The authors apparently know their stuff but the book could have been a lot better.

Whether you are an expert in Java or not, this book will tell you what exactly you want to learn and know about J2EE.

This is a must have book for anyone who is working as a Java programmer.

You will learn all the J2EE concepts, which you will not get even if you go for a 3-day intensive training on J2EE.

I very much enjoyed every chapter of this book even though some topics have been repeated. This book explains all the components under J2EE in a very simple but effective way. Each chapter also has a brief summary of what it's going to cover and its also addressed well later. Java Server Faces is not covered.

When a book makes me miss my stop on the bus, I know it's a good book. "IBM WebSphere Deployment and Advanced Configuration" is the WebSphere 5 book I have been waiting for. It is the final one in a series of three, but stands alone if you are familiar with J2EE. (The first book in the series is Kyle Brown's WSAD book -- also excellent and they complement each other well.)

Four IBM WebSphere specialists write the book. They manage to explain everything in a way that is easy to understand, yet detailed. After explaining the WAS (WebSphere Application Server) architecture, the book focuses on major J2EE components. The authors include best-practices and recommendations throughout. Even an appendix on Web Services.

The first three parts of the book cover the portion of WAS applying to all versions. The fourth part covers the Network Deployment version and its specific features. There is also an incredibly useful problem solving section.

While this is not a development book, the authors do highlight deployment decisions that should be made in the development phase and describe the ideal development/testing environment. Except for a few pages, the book is IDE neutral. However, WSAD users will find many things can be done on the IDE or the server.

In the week and a half I've had this book, I have used it as a reference many times. It has already helped me solve several problems. I only wish I had it sooner.

I found this to be a very well written book, with the authors clearly having very good knowledge of the tools they presented.

While I expected the book to cover a few of the better know Java Open Source technologies, I was pleasantly surprised to find that also included were many of the "glue" tools which are practically a requirement to get a complete solution working. For example, any book with this scope is going to mention Ant and JBoss, but the authors took it several steps further, and included information on other tools to help you manage JBoss, and tools to help you generate your code (XDoclet and MiddleGen).

On the downside, there were several occasions where the book could have mentioned alternative open source products (e.g. other EJB containers than just JBoss) - this was not consistent as in some cases multiple products were described. I also feel that the book would have benefited from some suggestions on how different tools could be compared. The other concept I didn't like was the huge example application they presented - it is essential to download the source code, as there is no way such a large example application could be described in the book.

I would recommend this book to anyone considering using Java within their enterprise that would like to learn about some of the open source options available.

"Effective Enterprise Java" is similar in format and quality to "Effective Java". It is written at a higher level as it applies to J2EE systems, rather than the Java language. The 75 items include architecture/design (batch SQL to avoid server round trips) and coding level (serialverUID) tips. They do lean toward the architecture/design level tips as the author refers to "Enterprise Java" for more lower level ones.

The tradeoffs of various techniques are highlighted rather than just relying on best practices. For example, "use object-first persistence", "use relational-first persistence" and "use procedural-first persistence" are all included as tips. Obviously, you wouldn't want to do all of these at once. However, the discussion of when to use each is extremely valuable.

All the trips are grouped by topic. Where appropriate, code snippets are used quite effectively (no pun intended.) Examples and anecdotes prevent the material from getting dry. This book is destined to become a classic. I highly recommend it for any J2EE developer, designer or architect.

As anyone who has programmed using Servlets, JSPs, and EJBs knows, the complexities of integrating multiple layers of code can drive you to distraction. If you aren't careful, you can create an application that performs poorly under load, is difficult to maintain, and is impossible to port from one platform to another. The tricks that a programmer needs to avoid these problems often come painfully with experience. The author has taken his experience and given us a book that is well-written, easy to understand, and provides excellent advice to help you produce superior applications. The best part is that the advice you get is practical advice from someone who has actually experienced the pain and suffering of J2EE development. This book deals in the reality of development and not pie-in-the-sky theory.

The book contains seventy-five items of discussion covering a wide range of topics from the broad, "Keep it simple" to the specific, "Never cede control outside your component while holding locks." The items cover everything from architecture to coding. Even if a particular item is not of interest to you, there will be plenty of other items that will be of interest.

This book is not a tutorial or beginner's book. It is expected that the reader already has experience with J2EE. If that describes you, get this book to avoid more pain and suffering. You will end up a better developer and your applications will be cleaner and easier to maintain.

Hibernate is a popular object-relational mapping (ORM) system for Java programmers. As any Java programmer who has worked with a SQL database knows, trying to link Java objects to a relational database is not a trivial exercise. Hibernate simplifies the task by providing the functionality to generate Java classes and link seamlessly to a database.

The book starts with an introduction to Hibernate including some details on installation. The author looks at how Hibernate can generate a database schema or generate Java classes depending on where you are starting to build your application. XDoclet is discussed with the author pointing out some of the issues with using class annotation. Next, the author gives a good explanation of the details of Hibernate. The remaining chapters look at performance, caching, design issues and other advanced topics. Throughout the book there are many code samples that help to further explain the use of Hibernate.

Complaints... Although performance is discussed, the cost of using Hibernate on performance is not.

I would have liked to see some comparisons of Hibernate versus stored procedures, for example. Also, the weaknesses of an ORM are not discussed. Anyone who has worked with an ORM knows that at a certain level of complexity they start to fall apart and make an application overly complicated. It would have been nice for the author to discuss these issues and at least point towards solutions.

Overall, the book serves as a well-written and clearly explained basic introduction to Hibernate.

"IBM WebSphere Application Server for Distributed Platforms and z/OS" from IBM Press targets WAS admins. The book covers WAS 5.0 and 5.1, highlighting differences. It covers almost every OS: UNIX, Linux, Windows and Z/OS. A differentiating factor from other books is that the authors focus on Network Deployment throughout, starting with chapter 2.

One thing to note is that there is a lot of duplicated information. Five (out of 26) chapters have separate chapters for distributed and Z/OS. The remaining 16 chapters, sprinkle distributed and Z/OS differences within. In a way, it is two books in one. However, if you are only using one type of OS, the book is thicker and more expensive than necessary.

The authors are quite thorough in discussing most options. They also refer to the InfoCenter, papers and redbooks for more details. There are also many tips and gotchas in each chapter. The step-by-step instructions and screenshots are very helpful.

A running example shows the steps for deploying, configuring and maintaining a sample application. The app is of sufficient complexity to seem real. Tools such as MQ, ASDK and wsadmin are shown in parallel.

The authors intend for each chapter to stand alone. As a result, there is a fair amount of repetition. Aside of one dependency on a future chapter, the book reads well linearly too. This book serves a good reference and I recommend it to those maintaining both distributed and Z/OS systems.

There's been a bit of a rush of books about the Spring Framework recently with a number of publishers releasing their own titles one after another. Without having read those other books, I feel confident in saying "Spring in Action" won't let you down. It's a wonderful introduction to the framework and a handy reference for those desperate moments with the Spring configuration files.

What I especially like about "Spring in Action" is the style of writing. The book is largely about how to configure this and that and still I read most of the book in one sitting. The text flows well and the humor sprinkled throughout adds a nice touch. The other good things about this book include a good coverage of the Spring Framework itself. Only some parts of the Acegi security framework have been left out, as far as I can tell, and those features (ACL's and run-as) are not what I'd call essential so it didn't bother me much. In addition, the authors give a good comparison (brief, but a good overview) of Spring and other technologies and frameworks such as EJB, Struts, WebWork, Tapestry, PicoContainer, HiveMind, etc. Furthermore, the authors show you how to integrate with these other frameworks (except for the other IoC containers) and view technologies like JSP, JSF, Velocity and FreeMarker. Add to that, the index looks very comprehensive which is an important detail for a book that one might use as a reference afterwards.

So, what separates this book from perfection? For one it had a lot of little typos, the text did exhibit a bit of repeat (didn't I just read this sentence on the previous page?) here and there, and I feel like mixing multiple ViewResolvers was covered too lightly. I don't consider these to be big issues, though, and I won't hesitate for a second in recommending "Spring in Action" for someone looking to get started with the framework.

The In Action series always seems to be the best material for Java development. The Hibernate/JPA book, Ajax, and also the JQuery In Action books are the must have books on their subjects.

Spring in Action follows that logic. It is the best book out there on the subject of Spring in Action, but for Spring 2.0 version. If only they updated it for Spring 2.5.x

But don't fret, this book is still very relevant, in many ways. A good 80-85% of the material all still work in 2.5 and is still the way to develop in 2.5. Core Spring with Dependency Inject, and AOP are must reads.

Also, if you are starting to work at a company that has a Spring project already in production, it is highly likely to see code as you see in this book.

Craig, we are waiting for the next version. We already know it will be another masterpiece

Looking at "Pro Spring", one can immediately see that it packs a lot of information. The page count almost reaches 800 and the table of contents does indeed seem to cover pretty much anything there is to know about the Spring Framework. The first parts of the book introduce the Spring Framework on a bird's eye level, the sample application used throughout the book as a playground for the examples, and explain some basic concepts like Inversion of Control and Spring's basic bean-wiring facilities. After page 150 or so, it's all about digging deep inside the vast number of features and modules under the Spring umbrella.

The Spring AOP framework is introduced quite well, starting from the fundamentals like what is a pointcut, what is a joinpoint, etc. One really understands what the framework is about after reading through the AOP chapters. The data access part, which no doubt is of high interest to most readers, also does a good job on showing how the Spring JDBC framework works. It also presents a very nice "tutorial" on integrating Hibernate with Spring, although it's certainly not by any means a complete resource for learning Hibernate itself. The data access part also covers the iBATIS SqlMap framework for object-relational mapping (and actually uses more pages on that than for the Hibernate integration) which, on the other hand, was a nice surprise. Then again, the authors had decided not to cover Spring's JDO integration at all (only a brief mention somewhere near the beginning) which I would've expected. I gather JDO is not that widely used to date so maybe that isn't a problem (and the Hibernate stuff is very close to what the JDO integration looks like anyway). One specific thing I especially liked about the Hibernate chapter was that the authors had gone through the trouble of actually showing the SQL being generated for the different kinds of mappings. That's not really relevant for Spring but it was such a nice surprise that I felt like mentioning it anyway.

The heart of the book then covers "Spring in the middle tier", i.e. transaction management, integrating J2EE components such as Enterprise JavaBeans, job scheduling, sending email, and remoting with the various protocols supported by Spring. The technologies and APIs are not all there is to this part, though. Chapter 11 provides a more thorough discussion on good design practices and common pitfalls. Actually, the authors have managed to sprinkle these also elsewhere in the book in smaller amounts. The only thing that's really missing here is security, partly because the Spring core project doesn't provide much support for authentication and authorization (that's being handled either by custom frameworks or by the Acegi Security Framework project).

The last 100 pages before appendices have been dedicated to using Spring in web applications. The Spring MVC framework itself was described quite nicely, although I was left hanging a bit trying to wrap my head around the different base classes for controllers, resolvers, and so forth. Then again, I've had the same feeling with all (2) Spring books I've read so far. In addition to the standard JSP view, integration with the Velocity template engine and other alternative view technologies such as XSL transformations, the Tiles framework, PDF generation with iText, and Excel generation with the POI library are briefly demonstrated with JSP tags and Velocity macros getting most of the attention. One short chapter has also been dedicated for presenting the integration between Struts and Spring--a topic that many have struggled with.

Finally, the appendices showcase the Spring Rich project for building rich clients on top of Spring, the Spring IDE Eclipse plugin, and some features that are coming (or have already by now) soon such as JMX integration. Perhaps the most important appendix is, however, the one titled "Testing with Spring", which gets you going with unit and integration tests that use the Spring bean container. I would've loved to read more about this topic but even these few pages are a big help for a beginner since the first steps are often the most critical ones and having someone show initial direction can save the day.

In summary, "Pro Spring" is a good book and a valuable reference in learning Spring. It's not a book you'll want to carry around too much but it does include plenty of sample code (with just a few obvious typos that are easy to figure out) both Java code and the corresponding configuration elements. It's not the be-all-end-all reference for Spring but it's pretty close. A second edition with JDO and Acegi covered could be a full 10 horseshoes.

Unless you have been living in a cave over the past 18 months, you have most certainly heard of the Spring Framework, the next generation lightweight framework, which integrates numerous widely supported technologies into a well-designed and extensible infrastructure that finally makes J2EE accessible to any frustrated expert and novice developer.

Aside from its impressive set of technical features, Spring's second invaluable asset is incontestably its extensive documentation and examples suite. However, note that Pro Spring is not a blatant clone of the supplied documentation. Instead, it takes a different route in that the authors gracefully introduce Spring by adopting a very pragmatic approach based on their real-world experiences with the framework. What you will read in this book is not theory at all. Fasten your seatbelts and get ready to see Spring at work in all its splendor. The authors spend over 700 pages showing you how to use Spring in practice when dealing with inversion of control, data access with JDBC, Hibernate and iBATIS, AOP, transaction management, EJB, JNDI, JMS, e-mail, Struts, MVC, and much more. Once you'll get through this book, you'll confess that Spring truly is an impressive framework and you'll even ask yourself how you could manage to develop your applications without it.

Finally, note that to get the most out of this book, you should be comfortable with J2EE concepts and the Java platform in general as the authors deliberately stay focused on Spring and its novelties.

Who else would give you an insight to Mrs Gates and her plights at the Gates Mansion? And introduce the most revolutionary computer game to ever be conceived.

Who is Verity Stob? Good question I have never heard of her before. But, I think that is because I live in the US. And I really don't/didn't read EXE, Dr Dobbs, or The Register. But those are the exact publications Verity has written these columns for.

This book is a collection of Verity's best works, some more hilarious than the others. It really shows us a history of the computer world through a funny satirical eyes of Verity. Some of the stuff goes back to a time where the world invented the wheel, and not living back then, their humor gets lost on me, but some of it still hits the funny bone, even today. The Borland stuff itself is worth getting this book.

I really enjoyed reading this book, it is great to read a computer book that didn't bore you with all that technical stuff.

"An Introduction to IBM Rational Application Developer - A Guided Tour" is a good beginners book. The book does not assume you know J2EE. For example, it walks you through what a Servlet is. Each chapter begins with an overview of the technology, which is even more useful for advanced topics like JMS.

The authors walk you through tutorials for the common RAD tasks. If you are already using WSAD, some of the tutorials are overkill. However, the advanced ones are still useful. The authors also provide tips of things that would be good to experiment with. I also found the example projects on CD to be extremely useful.

This IBM Press book doesn't contain much IBM slant. The book uses many common databases including db2, Oracle and SQL Server in each example. Tons of screenshots and code snippets are provided. The authors provide tips on the tool throughout that make you a more efficient developer.

Each chapter stands alone, making the book a good one to read before you try out a new part of RAD. I recommend this book to people new to the WSAD/RAD family of tools or those who want a detailed walkthrough of how to create a basic application in new technologies.

In its own ethics this is a very unique book.
Though there are tons of internet sites listing the j2ee interview questions, the author of this book has taken great effort and care to list the questions and answers.
The book leaves no topics un-turned. Gives very clear and short explanations for every topic and questions and goes through in-detail if needed.
The answers were followed by neat images if necessary, which many other site/book doesn't.
This book will certainly help both the interview host and attendee.
I liked the chapters related to Design patterns, WebSerivces and Testing, which you may not find other books/sites.
Very well organized for quick interview preparation as well.
The advantages and disadvantages of each piece of j2ee are discussed.
Section 3 of this book "how would you go about..." is very well written and each question were the real ones that you will come across in technical interview.
Reading this book will sure give you confidence for answering the questions that were not covered in this book for brevity reasons.
A best bet for preparing j2ee technical interview and its worth buying.

While many of the top notch Spring books offer reasonably thorough coverage of the Spring MVC framework along with other core Spring modules, there's not much printed material on Spring Web Flow. This book gives the Spring community a fix that'll keep us satisfied for the time being.

The authors do a good job at introducing in just a dozen pages enough fundamental concepts that a Java web developer needs in order to be ready for the rest of the book. In other words, no long-winded descriptions of the XML configuration files needed for configuring Spring, no detailed descriptions of how to wrap your beans into proxies, etc. Instead, you're taken straight down to business.

The core of the book starts out by first describing the Spring MVC architecture, including the role of controllers and views. Followed by the description of the architecture, the authors take the reader to a rollercoaster ride through the Spring MVC processing pipeline, including how to customize URL mappings, for example.

The chapter on controller components covers everything I can think of and the chapter on views and different view types does a great job at showing how to configure alternative view resolvers, how to internationalize your application's message resources, and how to render alternative content types such as PDF and Excel sheets in addition to covering the mainstream templating languages used for generating HTML, including JSP and JSTL as well as open source frameworks such as Velocity and FreeMarker.

An extra bonus point goes to the authors for including a section on testing Spring applications, even though the focus is mostly on unit testing controllers which is kind of a low-hanging fruit anyway. On the other hand, while topics such as validation and internationalization are discussed, the equally essential aspects of authentication and authorization are not given any attention.

The last two chapters, approximately 60 pages, are devoted to the brand new Spring Web Flow framework. I was glad to see the authors' pragmatic approach to stating the sweet spot for using Web Flow rather than proposing it as the "golden hammer" as they say. The explanation of the Web Flow concepts as well as the examples the authors use for guiding the reader through them are easy to understand.

As a summary, I thoroughly enjoyed reading this book and got a lot out of it. The only reason I'm not giving this book the absolute best rating possible is that there's a couple of security-related topics missing that I consider essential for any book dedicated to developing web applications.

This is a very good book for learning the Spring MVC framework. While the authors explicitly state that the book is not an introduction to Spring, they do provide a chapter to introduce Spring as a foundation for the remainder of the book.

The purpose for each topic is clearly described, with easy to understand examples provided, then some sample code is presented with explanations.

In the introduction to the book, the authors describe their "aha" moment, where they first understood the ramifications of using this framework. Their desire to share this feeling shows through in their writing without becoming tiring.

I heartily recommend this book to anyone wishing to learn the Spring MVC framework.

When I first saw this title, I thought it was going to teach me how to do JSF and how to hook up JSF to make web pages that use Ajax, so I could create that great app I always wanted. But that is not what this book is about. I just wanted you to know up front.

So what is this book about? It shows you how to create your own custom JSF tags and create some really cool UI widgets. It expects you to have the basic JSF knowledge already, hence the "Pro" in the title. Since I had no JSF background, I had to read another book to get me up to speed.
This book teaches you all about the JSF phases and steps you need to take to create your cool widget. The book uses a Data Picker and a Deck component as their guides, both of which you can use in your own apps. The Deck component is really cool for that MS Outlook Toolbar look and feel. Anyway, I thought they did a great job, I feel confident that I could create my own JSF tags, and that there isn't any other book like it on the market.

First of all, let it be known that I have no working experience with JSF. As such, I could imagine it not being too pleasant a surprise to some readers that the authors start by recommending other, more basic JSF books because the content will dive right into the deep end. It would be quite alright--it is a "Pro" book, after all--except that the graphic on the back cover implies that no prior JSF knowledge is required. Probably not an issue with most readers, but still worth mentioning, I think.

Regarding the book's content, there's a quite robust structure in place where the authors begin by developing a couple of JSF components (a "deck" container and a date field) through chapters 2 and 3, after giving a run-through overview of JSF in chapter 1. Even though the examples are growing in somewhat large leaps, it is helpful to see the components develop rather than getting them "off the shelf"--otherwise chapters 6 and 7 where the authors show us how to Ajaxify the two JSF components (deck and date field) would've likely been too much information in too short a timeframe.

The examples are thorough and come with loads of readable code listings. In addition, many complex topics were further clarified with a good use of graphics.

The book's scope is a bit too scattered, I think. The authors have dedicated chapter 5 for a useful open source add-on called Weblets, which I consider a good decision. I do not, however, agree with the decision to allocate over a hundred pages for Mozilla XUL and Microsoft HTC. XUL, for example, is a nice technology and serves as a good example of an "alternative" render kit for the de facto HTML one. Still, I would've preferred seeing more complex Ajax techniques such as file uploads demonstrated with JSF instead of just talking about them.

To summarize, I consider the strengths of this book being the thorough examples developed through the chapters and the effective use of graphics to illustrate architectures, execution sequences, and class diagrams. On the negative side, the text was rather heavy and thus difficult to keep up with. Furthermore, some of the more "exotic" content should've been traded in for additional Ajax material, in my opinion. All in all, there's a bunch of information packed into these covers that you're not likely to find elsewhere in such a compact format. I'm giving this one 7 horseshoes.

This is a one of a kind book. It is the only one that discusses performance maintenance and optimization for all your Java EE applications, from code to servers.

The first section covers processes that you need to have in the full lifecycle of your application. Starting monitoring and performance tuning early on in the process to make it easier to keep your app performing at its best.

The second part covers performance tuning, where to best tune your application for the biggest bang for your buck, from the JVM, first place to tune, to your pooling and other configurations.

The third part covers tuning your production environment, which should be easy, as long as you have statistics already from your development to test server load balancing.

And finally the last part has tips and tricks.

For just the 10 pages on JVM Heap/Garbage Collection and tuning alone is worth the price of the book.

This book should be your single source of performance tuning and monitoring for all Java EE Applications. It is your bible on performance.

GlassFish is Sun's open source Java EE application server. It's the reference implementation for the Java EE standard. This book is about GlassFish version 2.

The book starts with a chapter about downloading, installing and configuring GlassFish, followed by nine chapters in which the major Java EE 5 technologies and APIs are explained: servlets, JSP, database connectivity using JDBC and the Java Persistence API, JSTL, JSF, JMS, security, EJB and web services. Chapter 11 goes beyond Java EE and describes facelets, Ajax4jsf and Seam. Finally there are two appendices, about sending e-mail from Java EE applications and about IDE integration (NetBeans and Eclipse).

The book is aimed at Java developers with some experience who want to learn Java EE using GlassFish. The book moves at a fast pace, and gives a good overview and some examples of each of the Java EE APIs. It's not a reference manual that describes the APIs into every detail. Because Java EE is so extensive and the book moves so quickly, I can imagine that it can be overwhelming if you've never seen Java EE before.

The book is really focused on Java EE programming, it does not cover setting up and configuring GlassFish in detail, nor does it cover advanced topics such as clustering and high availability.

I would recommend this book to Java developers who want to learn Java EE. It's a good introduction and gives you a good overview of what Java EE is and shows you by example how to program with Java EE. After this book, you'll want a reference manual that goes into all the details.

"Seam in Action" starts with an introduction on Seam, then shows the reader what Seam can provide out of the box via its source generator. Along with Appendix A, this makes it a great tutorial to start using Seam. You'll be touching a lot of different tools and technologies and having basic knowledge on JSF is recommended, but the author never lets you down by always introducing what is necessary to know. Reading the online tutorial on JSF introduced in the book is still highly recommended for anybody who has never touched JSF before.

Part Two on Seam fundamentals, almost 200 pages, may be overwhelming at first, especially Chapter Three. Fortunately, diagrams and code snippets are very helpful to digest this volume of information. Part Three introduces Seam's conversation context, java persistence and Seam's enhancement on java persistence. There is again a lot of information in this part, but Chapter 10 is a great hands-on chapter that allows you to put into practice what was explained in the previous chapters. The book finishes with chapters on business requirements like dealing with security, Ajax, file uploading and much more.

Seam is such a huge framework, it must have been challenging for the author to pack so much information into his book. Some parts are high paced, but still well explained. This book is a gem, highly recommended for any Seam enthusiast. And don't miss the two bonus chapters at the publisher's home page.

"Seam Framework: Experience the Evolution of Java EE, 2nd Edition" reads like a tutorial, and a very good one. It is neither too short, nor too detailed, just enough to make you understand the logic behind Seam. Chapter 1 to Chapter 11 introduces Seam's core capabilities. This framework offers so much to ease web development that it is sometimes difficult to cope with all its features. The authors have kept explanations straight, to prevent the reader from scratching his head all along. These eleven chapters are very well structured, reusing the same little sample and improving it bits by bits.

Chapter 12 to 18 introduce web components and other web related features like bookmarkable web pages or security management. Chapter 19 to 21 tackles with Ajax support in Seam, mainly explaining how to use different kind of libraries supporting Ajax. The rest of the book deals with many different interesting topics like rule-base security, jBPM, testing, performance tuning, Web Beans and much more.

Each chapter is accompanied with a ready-to-use sample, which is downloadable at the authors' web site. I like the fact that the authors did not put to much stress on seam-gen, and use their own small samples to illustrate each chapter. I also like the fact that the authors didn't try to overload the reader with loads of details, redirecting readers to the official documentation when necessary. In the chapters about seam's core, they basically introduce a problem, how seam helps to solve it, how it is done using annotations, and how it can be done using an XML descriptor file. This is a very good book, which can be read very smoothly.

Beginning Spring 2: From Novice to Professional (Beginning from Novice to Professional)by
Dave Minter

Apress
1 edition
December 2007
271 pages

Reviewed by Jeanne Boyarsky, August 2009
(7 of 10)

"Beginning Spring 2 - From Novice to Professional" is a clear introduction to Spring. The book was designed to be readable whether you are new to Spring or have been using Spring 1.X. Chapter one covers the main concepts such as inversion of controller and aspect oriented programming. The description of why they are useful read very nicely.

There was (mostly) a good balance of code to description along with good discussion on tradeoffs. I like how the author included tangential concepts and libraries. I learned about Hessian and Burlap - two reporting tools I hadn't heard of. I was a little surprised there were only two paragraphs on JMS - seems like it would be more popular.

There were a couple of typos, but nothing major. I was a bit disappointed by the testing chapter - one sentence contained four negatives which was awkward to read. A test method was over a page long. Examples are JUnit 3.8 (4.0 was out and well used in 2007.) In fact most of my concerns were in this last chapter. The Swing chapters were better.

I did learn about Spring and that was the goal of the book. I do recommend it.

Francesco's "JBoss AS5 Development" book is a well written and a handy book for developers who use JBoss AS in their development environment and who wish to have a detailed understanding of the server.

The book starts off with introducing JBoss AS and its evolution from the previous AS-4.x version to the current AS-5 version. While doing so, it provides a brief overview of the core architectural difference between these versions. The initial few chapters mainly focus on setting up the development environment which includes JBoss AS, Eclipse (with JBoss Tools Plugin). It's good to see that the author is *not* rushing the readers to coding applications and instead is providing the necessary background to get familiar with the server.

The book covers various other JavaEE technologies including JPA, JSF, WebServices etc... Each major technology has a separate chapter and follows a common pattern where it starts off with a brief introduction of the technology and then moves on, to show how use can develop and deploy applications using those technologies on JBoss.

This book also covers JBoss AS specific configuration files and tools. It provides a good technical overview about the contents of the configuration files, including detailed explanation of important configuration options.

The book is well paced and you won't feel bored or overwhelmed by the information being presented. The author has managed to produce a well written to cover useful information for developers who use JBoss AS.

"The Java EE 6 Tutorial Basic Concepts" is the official tutorial covering all the Java EE technologies. I can't believe it has been 4 years since I read the Java EE 5 version. Last time I remarked 1300 pages was too heavy. Version 6 is split into two volumes which is nice because you can carry it around. The basic concepts one covers web/ejb/jpa/web services.

"As part of Sun's 'The Java Series' this book has the same content as you can find online. Why buy a book you can get for free? Convenience!! You can take it anywhere and read it anytime." - Dave Vick - JavaRanch Review of the J2EE 1.4 version. This benefit is back.

Other dislikes:
confusion between Oracle/Sun.. For example "Oracle web site" docs.sun.com". I'd like to see mention of a transition.
wasn't clear what was new in Java EE 6.
as in past editions, it reads better online than printed.
extensive forward references and lots of repetition. For example, they repeat the six steps to open a NetBeans project 12 times!
many examples didn't explain how/why to do something - like whether to call a web service directly from a JSP.

I did like the walk-through of certain technologies. And the good quality cover paper that doesn't get damaged even if you spill juice on it!

There were good diagrams and charts and good case studies along with several excellent chapters. While I like this version better than #5, I would say to read the pieces you are interested in online and spend your money on a different book.

---
Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch.

"Java 7 JAX-WS Web Services" is a mini-book from Packt Press. This means it is 51 pages and costs less ($20.) While normally, I prefer paper books, I think the e-book is better for min-books because they are so short. And then the price drops to under $10 which makes the short length feel somewhat better.

Which is important because the book only has two chapters. One is on how to install glassfish and netbeans. Which leaves 35 pages of "real content. Chapter two was good though.

I think I would have liked the book better if the title was "My First Web Service with NetBeans." For someone new to NetBeans/Web Services, it is a fine tutorial. It covers the main tags and the major steps.

I emphasize the word beginners - there were 35 screenshots in the book. Some were basics like "file > new file > java class" and some had more use. (Honestly, if you don't know how to create a class in your IDE< you aren't ready to make a web service.)

I suspect other minibooks in the series are better though. This one doesn't feel like enough content for twenty bucks. And you'd have to be new to NetBeans for it to have much value for $10

---
Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch.

NetBeans, a free IDE available at http://www.netbeans.org, is based on donated code developed by Sun. The NetBeans architecture is an open architecture that supports plug-ins for each function of the IDE. This book, which discusses the NetBeans IDE, is made up of two parts. The first part is a description of the IDE designed for the NetBeans user. The NetBeans architecture is described in detail. The book covers each of the different pieces such as editing, compiling, and debugging. The book also covers using the NetBeans GUI editor to design visual components. Integrating NetBeans with CVS and Ant is also covered. The book does a fairly good job in this section of providing a handy manual for NetBeans users. The second part of the book is aimed at those who wish to use the NetBeans open architecture to define their own modules to be added to NetBeans. This part of the book is very well written and will serve as a major resource for anyone interested in module writing. Several examples are demonstrated including building an IMAP email server and client to integrate into NetBeans. The first part of the book is for a general audience and will be useful but it isn't required reading to use NetBeans. The second part of the book has a more limited audience but will be extremely useful to anyone interested in writing NetBeans modules. Overall this is a well-written book with clear explanations and examples.

I was quite impressed with the way this book was presented. While there were some sections that weren't quite right for me, overall the introduction sections and lead up, examples and prose all hit the spot and as such it was an enjoyable book to read.

The book provides a "from the ground and upwards" introduction to Beehive so it does not require any prior knowledge to get started. This isn't too surprising for a framework with a comparatively smaller user base. It also has a very nice introduction to the available Beehive tools so that you can start working efficiently.

While it is not approached as a Beehive marketing exercise (and this was a relief), I was a little confused between the BEA and Beehive offerings in the earlier sections. Maybe it is of worth for people moving to Beehive, but at the point where you're still confused about the starting concepts I found it a bit distracting.

While I wasn't a complete fan of the framework itself, the instructions and examples provided make this a very useful book if you intend to give Apache Beehive a go yourself.

This book is a nice introduction to GWT which is suitable for beginners. I myself being a beginner in GWT found this book as a good starting point to learn GWT. One thing you should know however is that this book covers Ext GWT which can be confusing at first.

The book starts from the basics of creating a GWT project using Netbeans and moves to creating layouts, forms, handling different events, making Ajax calls and deploying a GWT application. Sometimes it feels like there is too much code and very little explanation of how the code is actually working.

The book has many flaws like repetition of similar recipes, and the focus of the book is not entirely on GWT. There are chapters on database design, JPA, JasperReports which is sort of unnecessary. Instead the book could have covered things like how to create a Grid and populating it using GWT. That sort of information would've been more useful.

All said this book is one of the very few beginner level books which covers GWT 2. In spite of its flaws the book can be useful for beginners in GWT.

---
Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch.

I had heard very good things about the first edition of EJB3 in Action, so when I got this book, I was very curious to see how the second edition fares. I have been dealing with EJBs for many years now, since the EJB 2.x days, so the topic being covered in this book wasn't new to me.

The back of the book's cover page states that this is a fast-paced tutorial for Java EE developers. Having now read the book, I can say that it truly is fast paced and I never felt bored while reading through the chapters. Even though it's fast paced, it does a very good job in explaining the various aspects of EJB in a very concise and clear way with relevant code snippets. Unlike some other books, where sometimes the code is just dumped within the chapters, I found that this book does a very good job in just placing the relevant few lines of code snippets thus helping understand whatever is being explained.

The other good thing I liked about this book is that it doesn't isolate itself in explaining just EJBs, instead it does a very good job in explaining EJBs in the context of the whole Java EE ecosystem. For example, it does a very good job explaining how CDI and EJBs can co-exist in a Java EE environment. Personally, I found this aspect of the book to be the best.

I skipped the JPA chapters in this book, since I wasn't too interested about the JPA stuff.

Interestingly, there's also a chapter on WebSockets where the authors explain how EJBs can be injected and used in the server endpoints of a WebSocket, after giving a overview of WebSockets.

The book uses a ActionBazaar sample application through its chapters to explain various aspects of EJBs and Java EE ecosystem. So the readers get to understand how various parts tie in together within the application.

Overall, this is a very good book for anyone who wants to learn EJBs. Not overwhelming and a very concise explanation of EJBs.

Thought "EJB 3 in Action" (first edition) was a great book, so I'm not surprised that I like the second edition as well. In fact a snippet from my first review is on page one of the second edition.

I really liked the story at the beginning comparing 3 reincarnations to the three versions of EJB. The Turtle Shipping Company and Snail Trucking example was also very cute. As were the chicken and frog.

One page 17, the text after the example talks about not needing an interface, but the code example has an interface. There is also a mix of EJBs and EJB's used in the book. I think this comes from having five authors. (The four real authors plus them originally. Because writing is like code in that after a certain point it is like someone else wrote it.) The fact that these are the worst things I can say about the book, is a good thing though.

The explanations were great especially the section on AOP, comparing EJB vs EJB Lite and when to use each session bean type. There are good warnings and caveats throughout. There was also a great intro to Web Sockets.

I thought I knew about the topic and still managed to learn a few things. I learned Seam became CDI, that you can use a constructor in the select clause of queries and about the embeddable container.

---
Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch.

There are two obvious changes between this second edition and the first edition of this book. First, some new patterns have been added mostly dealing with web services. Second, the book has been released as a hard cover book, presumably because the publisher expects this to last on your shelf as long as the original "Design Pattern" book. The new patterns dealing with web services are a welcome addition to the book although anyone who is interested in this subject will probably want more detail such as found in Paul Monday's book.

Part 1 is an introduction to design patterns and the J2EE platform followed by a catalog of design considerations, bad practices and refactorings. Part 2 is the collection of design patterns and strategies. Each pattern is described in a format which will remind you of the GoF book. Since this has become the standard ormat for presenting design patterns this should not be a surprise. The patterns are well thought out, explained clearly, and demonstrated with some good code samples. If you have the first edition you will be very impressed with the improvements made in this new edition. It appears that virtually every pattern has been reworked to make the pattern easier to understand and use.

This is the book that every J2EE architect and programmer should have on their desk. Anyone designing, architecting, or coding with J2EE will find this book to be extremely useful.

Not another line of code for Servlets, JSPs, or EJBs should be written by anyone who hasn't read this book and understood the concepts explained. This book is about best practices in designing and coding J2EE applications. The lessons explained here were developed by the Sun Java Center based on their work in the field. As they developed applications for clients they noticed that the same problems occurred over and over again. This book documents the standard solutions to solve these problems that were built as a catalog of design patterns and best practices.

Part 1 is an introduction to design patterns and the J2EE platform. Part 2 is a catalog of bad practices (the authors describe these as, "less than optimal ways to solve problems"), and refactorings (ways to correct these problems). Developers working with poorly designed J2EE applications will find this section especially helpful.

In Part 3, fifteen separate design patterns and strategies are explained. Each pattern is described in detail with the motivation for using the pattern and the design goals to be achieved. UML class and sequence diagrams are included along with detailed code examples that serve to further clarify the pattern. These patterns aren't theoretical constructs but rather are practical strategies that can be applied to real world applications. Using the strategies in this book will make you more productive and your code easier to understand and maintain.

Anyone designing, architecting, or coding with J2EE will find this book to be extremely useful.

An excellent coverage of Oracle's implementation of JDBC, this book beats your expectations.

Meet the middle ground where the strengths of Java and Oracle work in synergy - the JDBC. Whether making simple database connections or using the Oracle 8i's sophisticated object-relational features, the authors peel the onion very well with detailed information and cleverly written examples. After a brief overview of JDBC, several different types of database clients are discussed in detail - the applets, the Servlets, the Server side internal drivers and those managed by J2EE using JNDI and connection pooling.

A whole section is dedicated to traditional uses of JDBC API such as cursors, submitting prepared statements and ResultSet manipulation. The chapter on Object-Relational SQL covers broad ground on both Weakly Typed Object SQL and Strongly Typed Object SQL.

Enterprise essentials such as Security, locking, transaction management supports for data encryption and SSL issues, performance tuning and testing strategies - are addressed in detail. This book is treasure trove if newer feats of Oracle are of Interest to you. I found immediate application for features such as creating object tables and column objects based on user-defined data types, support for really big streaming BFILEs and LONG RAW data types and batch processing for my project.

Overall, this book has everything you need to learn, know and master in order to leverage the essential two great technologies - JDBC and Oracle. Every serious Java developer should have this at arms reach.

This book is for Java developers who need to get the most out of using JDBC and Oracle (version 8.1.6). Choosing a specific database allows a lot more detail. Other JDBC books may skip database-dependent parts of the API; this book even gives code examples for the hard stuff. It is slow to read end-to-end, but "dipping" works well - there's almost always a helpful code example nearby.

There are problems, though. The author is obviously very familiar with Oracle, but lacks the experience to make comparisons with other products, this book won't help you choose when to use Oracle. Also I noticed other signs of lack of research - he sometimes gets abbreviations wrong, and the Java code is not particularly well-written.

The big problem for me is that the book assumes you only ever use Oracle. There is no consideration of code portability, it offers no wisdom about avoiding proprietary Oracle-specific extensions. The techniques in this book could easily lock your product into Oracle.

The book has minor discussion of extra features in Oracle8i and Oracle9i, but nothing about JDBC 3. It's less helpful if you are using a version older than 8.1.6, too.

If you have already sold your soul to Oracle, get this book. If you might use other databases, get a more generic book, and keep this one for emergencies.

This book presents J2EE design patterns from Sun and TheServerSide.com for developers and architects creating J2EE-based systems. I really like the way the patterns are presented with a fair amount of code to flesh out implementations (or "instances") of each pattern. The patterns are grouped by tier/usage which is helpful if you are looking for patterns in a particular area. The discussions about why you would want to use a specific pattern and items to keep in mind when using it are very nice. My only complaint, and it is a mild one, is that each of the chapters that deal with a tier or aspect could be expanded into a separate book. (Hint to publisher... ;-)) This is a very good introduction to J2EE design patterns. If you want help in designing your J2EE systems in regards to security, scalability, and modularity this book will help you achieve your goals.

Simply put, you can't go wrong with a Martin Fowler book and this one is no exception. If you climbed the mountain to get advice from the IT guru at the top, he'll probably quote from this book.

Born on the web and rarefied by reviews and discussions with Fowler's colleagues and peers, including JavaRanch bartender Kyle Brown, this book is full of ideas that will help you make decisions related to enterprise applications architecture.

Writing in the same easy-to-read style as his past works, Fowler presents over fifty patterns that are mainly focused on layered architectures. And while Fowler readily admits that none of the ideas are new, developers, experienced or otherwise, will nonetheless benefit from the collective wisdom and experience of Fowler and all who contributed to the book.

To get the most out of this book, be sure to read the introductory chapters and understand the author's intent. There are many code examples, mostly in Java with a few in C#. I doubt though that you can use the code without some sort of tweaking; they are all meant to show the core of the pattern. Ultimately, you have the best understanding of your requirements and you have to make the decisions that affect your application's architecture. To paraphrase Fowler, don't use the examples as glorified macros but as a way to stimulate your own thinking. And believe me, this book has more than enough to get you thinking.

It's a patterns book, it's by Martin Fowler, and it's good. But how good is it?

It is actually two books in one. This is discussed in the book, but the second half is a list of patterns including the information required to make them useful. Reasonably standard, except that the patterns are presented in a language neutral manner that gives Java developers a view into the .Net world and vice versa.

The best part is still the first section. There is a general discussion on enterprise applications including common problems and ways to solve them depending on the way it shows up in your application. Not all of it will be new to everyone, but I'd challenge anyone not to learn anything. Even if you don't agree with all the solutions posed, it has very concise coverage of the problems.

There appeared to be the assumption of a respectable level of experience in the reader, so the book may not be useful to programmers with less than 3-5 years under their belts. This isn't necessarily a down side, but it should be considered if you're considering purchasing the book.

Now a small complaint. Although the first section was great, it discussed the patterns from the section in too much detail. There were some patterns I wasn't familiar with and some that I knew by different names, and it made some sections confusing.

Patterns and best practices have been around for a long time. They solve problem domains not directly addressed by the language itself ie., repeatable solutions to family of application development issues -- be it architecture, deployment or testing. For a complex platform like J2EE, use of best practices can make or break a project.

Just what the doctor ordered - Java Enterprise Best Practices is a collection nuggets of wisdoms. It is a compendium of idioms classified based on various enterprise Java areas written the most acclaimed authors in the field (Jason Hunter, Bret McLaughlin, Hans Bergsten et al). Ranging from most widely used EJBs to the latest additions such as JMX and JSTL, each chapter presents the reader with most widely accepted norms of using technologies such as - EJB, Servlets, JDBC, XML, RMI, JMX, Internationalization, JSP, JavaMail. Chapters on XML and RMI are the best of the lot.

I was surprised to note the omission of JMS, given that its popularity when compared with other things such as JMX or JSTL. The last chapter on performance tuning lacks depth and reads more like hastily scribbled notes.

Can best practices be argued? Absolutely! The first chapter of the book says just that. It is important to bear that in mind while you read through the chapters.

While a seasoned J2EE developer idioms may find a few things trivial, it is quite a good reference to keep handy if you are developing real-life applications.

Enterprise Integration Patterns is part of Addison-Wesley's new Martin Fowler Signature Series, which Fowler's Patterns of Enterprise Application Architecture (PoEAA) is also a part of. I was very satisfied with PoEAA and the same can be said about Enterprise Integration Patterns. It has the potential to become a classic.

The authors' writing style is a pleasure to read -- no ambiguous statements, no unnecessary babbling. The book is structured to suit both cover-to-cover reading and a "dive-in" approach for situations where you're looking for a solution to a particular problem. After an introduction to the field of enterprise integration, and a discussion of why the book concentrates on the messaging integration style in particular, the reader is given a hierarchical catalog of patterns revolving around a small set of "core" patterns. The book's coverage is in my opinion very well scoped.

I must also praise the look of the book; besides the layout being familiar from prior works and the proven pattern catalog structuring, the authors have used graphics very efficiently. Not only the authors define a vocabulary for integration patterns, but they have also come up with an expressive visual language for illustrating the patterns using simple notations that can be easily drawn without CASE tools.

I found only two downsides for this book. First, the title can be slightly misleading as the book focuses on messaging as an integration style and only briefly mentions alternatives such as RPC, file transfer, and shared databases. However, I don't know a single person who doesn't read the back cover before buying a book, so I wouldn't count this as a big issue. Furthermore, the reason for focusing on messaging is thoroughly argued in the book. The second downside is the code examples, which are presented using varying languages and products and seem somehow disconnected from the text.

In summary, Enterprise Integration Patterns is a great book. It's worth reading and re-reading if you're working with systems integration projects or writing integration software yourself. Yet another book that makes me think, "I wish I had it back then..."

"Core JavaServer Faces" introduces JSF to programmers only requiring HTML and Java knowledge. The first chapter explains how to setup the examples using Tomcat and Ant. The authors show everything needed to run all the examples, including the directory structure.

Most of the book is also appropriate for experienced web developers. The second half has involved topics. The authors include a few comparisons to Struts and comment on how to combine the two frameworks. The authors keep most of the technical/advanced concepts at the end of the chapters and mark them clearly.

The first half of the book explains JSF. It includes everything you should know to use a framework, such as lifecycle and tags. The second half of the book shows how to use JSF with longer examples. This includes Tiles, custom components, JDBC and LDAP. There is even a chapter of wireless devices and combining JSF with MIDP. The last chapter is 25 "How do I..." questions, like those here at JavaRanch.

The book highlights best practices where possible. It uses some, such as style sheets and message bundles, through the examples. It even mentions cross-site scripting attacks and how JSF can assist in preventing them. I had a copy of the first edition first printing. There were some minor typos and a missing reference, but the authors promise this will be corrected in the next printing. The reference is also on the book's website. Overall, I would definitely recommend this book.

While I am still undecided about some of the virtues of JavaServer Faces, this is easily the best resource that I am aware of for those wanting to pick up the technology.

Part of the problem (in my opinion) with JSF are the changes between versions and the complexity when coexisting with other complimenting technologies like JSP, annotations and even HTML and containers. This is the main strength of this book since it provides a roadmap for navigating the intricacies and gotchas without making the core text illegible. Yes, the text is scattered with side comments but it still allows the knowledge to flow without being too distracting.

I also found the examples perfect in complexity and size. They highlight the points from the text without dominating the book and forcing the user to skip pages at a time. The code could have been reduced if the authors used more code snippets rather than complete listings, but the full code was often useful since the book is aimed at beginner to intermediate users that will benefit from having the big picture provided.

It is a Beginner to Intermediate JSF book, and users of that level will benefit from this book as both a learning and reference resource and in my opinion it is worth a place on the JSF-user book shelf.
---
Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch.

You can save lot of time on browsing Internet on finding tutorials on Struts, yes this book gives you everything that you need to know on programming Struts.

Best buy for both the beginners and the experts, also tips you as a handy reference.

This book serves more than a tutorial on Struts. Even though you can find lot of free short online tutorials, this book made a great deal on putting together explaining every concept of the framework in a precise and down to earth manner.

You don't have to refer other books/sites, because each chapter is fully driven with examples, screen shots of application output framed on a browser, screen shots of webapp directory structure and the code snippets.

I particularly liked the chapters that covered the tasks like file upload, dataacesss,l18n and paging-sorting. I also liked the table listing the attributes, type and a short definition of every tag which is something that every programmer will look for.

The example codes were made ready to use with no complexity on configuring and understanding the package structure. (A little work is needed anyway).

Overall this is one of the effective Struts tutorial available in the market now.

I'm convinced this is and will remain the authoritative book on Struts 2. I know that more are being written but I don't care. You will not find one better.

I've never worked with Struts 2 in the past yet I was able to get a pretty solid understanding of it in a very short amount of time. Granted, I've had plenty of experience with the original Struts, JSF, and other web technologies, but I think even a beginner could pick this up fairly easily.

I let a friend of mine who had used Struts 2 on a project before skim through my copy of Struts 2 Design and Programming to check for any gaping holes or errant information before writing this review. It passed his inspection. (Thanks, Eric!)

I initially was a little skeptical when I saw that this Struts 2 book includes many other topics like DAOs, Velocity, FreeMarker, Dojo, and JFreeChart. These sections actually were quite pleasant to read and were great introductions to those topics without taking anything away from the main topic.

When you start making your way into chapters 5 and 6, feel free to jump around to other chapters. Come back to these chapters every once in a while to chew off two or three of the tags at a time. This tip will add to your reading enjoyment.

Overall, this is a terrific book and I highly recommend it to anyone working with or curious about Struts 2.

This book is unrelentingly practical. This is both its main advantage and its biggest drawback. The book describes, in great detail, how to build and set up an XML-driven e-commerce web site using a single case study. Each of the concepts covered (XML, DTD, Catalog, Shopping Cart, Look and Feel, Surveys, Payment Processing, News feeds etc.) gets a few pages of introduction and a chapter of annotated code. The advantage of this approach is that the reader is never left with hanging questions about just how to implement something - every bracket and semicolon is there. The disadvantage is that hardly any coverage is given to alternative approaches. EJB and XSLT get a few pages, HTML templating gets just one line! The code examples are solid, but seem a little "old fashioned"; there's no use of the Collections API, JDOM or XSLT, for example. Don't let any of this discourage you though - consider these points as options for further study. The code is all on the supplied CD, and you are free to tinker with it. If you are a programmer and unsure what all the e-commerce handwaving really means, or you need to produce a basic e-commerce system in a hurry, you need this book.

"J2EE FrontEnd Technologies" refers to itself as a "programmer's guide" and that is probably the best description of it. While it also claims to be "chock full of code examples" and contains "what you need to know," it falls short in both these areas. What you will find is a fairly detailed and yet limited explanation of the three major J2EE technologies, Servlets, JSPs, and EJBs. Although you will find extensive information for these three areas, there are many details left out and there is little attempt made to tie the three pieces together. For example, you will not find any examples of linking servlets and JSPs other than by using the Struts framework. You will also find no more than a brief mention of message driven EJBs. There are numerous UML diagrams throughout the book but in many cases they add little beyond what you can get from looking at the APIs. The examples in the book tend to be overly simplistic, in some cases wasting many pages to show an example that could have been summarized in a few lines of code. The best section of the book is the section on EJBs. The author's detailed description of EJB deployment descriptors is better than what you will find in most EJB books. This section also features the most complete examples found in the book. Overall this book does contain value, although it fails as an introduction or tutorial on the technologies that it covers.

This book takes a good step by step approach to giving the reader an understanding of struts. Good examples and explanations of each topic covered fairly well. Don't let the title (Mastering Jakarta Struts) deceive you. The book says it is meant as a tutorial on Stuts and that is what it is. So if you already have an understanding of Struts this book won't be right. But if you are looking to get familiar with Struts this book is a good starter.

I would like to give the author James Goodwill a big thumbs up. The source code for the book was not on the Wiley site and James emailed it to me right away.

Struts In Actionby
Ted Husted, Cedric Dumoulin, George Franciscus, and David Winterfeldt

Manning Publications
1 edition
November 2002
630 pages

Reviewed by Matthew Phillips, November 2002
(8 of 10)

Although the title of this book is not descriptive, I cannot deny the author's approach to making the reader a Struts expert is effective.

Section 1 is an introduction to Struts. By the end of the section you have written your first Struts application. This is great for someone with no prior knowlege of Struts.

Section 2 delves into the details of Struts framework. It gets away from a hands on approach to explain the details. It covers Actions, ActionForms, etc. quite well. The sample code accompanying the explanations is not enough to run, but it did help me understand the topics better.

Section 3 continues the same approach to learning as section 2 but concentrates on the presentation layer tools. One of my complaints about this book relates to its coverage of the Struts tag libraries. The chapter is clearly intended to compliment the online documentation at the Struts website and it really doesn't provide much value over it. The coverage of Tiles, validation, and localization are excellent.

Section 4 gets back to the hands on approach to effectively tie everything together. The book's organization lends itself to being a great reference, but I would have liked it to take a more hands on approach and build a large application piece by piece. I still learned more about Struts than I knew existed. I would not hesitate recommending this book to anyone that wants to go from Struts beginner to Struts expert.

The target for the book is any experienced Java developer who is interested in Struts but has little or no experience with Struts. The book starts with an explanation of why Struts is a "good thing" and shows how Struts fits into a web architecture. The author then gives an explanation of each of the pieces of the Struts architecture and demonstrates a simple application. Although the explanations were clear, I felt that the author was making the architecture overly complicated by explaining things out of order. A diagram showing the interrelationships of the different Struts classes and config files would have been helpful. The author covers all the expected topics such as internationalization, exception handling, logging, and the Struts tag libraries. The chapter on the Struts tag libraries could have used more examples to make the explanations clearer. The book concentrates on Struts 1.1 and the author does a nice job of explaining the changes from the 1.0 version and the features available in the new version. The chapter on the new Validator framework is clear and the examples are on target. The chapter on Tiles is short but the author does a great job of explaining how it fits into the Struts architecture. The chapter on performance seemed completely unnecessary since there was nothing in it specific to Struts. Overall this book is a good addition to the Struts library. The book has some shortcomings but it provides a good deal of value.

I found this book's introduction to Struts to be inadequate. I have a very strong understanding of JSP and Servlets and a cursory understanding of the MVC design pattern. After reading the first two chapters I was quite confused about the general workings of Struts. A small, trivial Struts application to introduce the reader to the pieces and how they are inter-related would have increased the understandability ten-fold. However, that might have cut into the author's allowed page count: realize this book is 137 pages soaking wet (including the appendix and index... I don't recommend actually soaking the book). After getting a better understanding of Struts from another source, I came back to learn the details.

The author does an good job of explaining how best to use each part of the Struts Framework (that's where the "practical guide" part comes into play). More importantly she notes the possible hang-ups that normally you'd only learn through a bad experience (Don't use instance variables in your Action classes. Don't worry if you forget this rule now -- after you've read the book, this and other gotchas are tattooed inside your head).

Overall I'd say this is a very good resource. You'll need to go elsewhere to introduce yourself to Struts (find a nicely explained step-by-step tutorial), but after that, this book will be able to take you most of the way to a well-designed Struts implementation.

Hibernate is a subject dear to my heart. It is a database tool that I would not live without. However, it has a steep learning curve. In Hibernate Made Easy, author Cameron McKenzie does a great job in getting someone who is brand new to Hibernate, up and running quickly and understanding the basics of Hibernate to effectively take on its learning curve.

Keep in mind when reading this book, that in order to keep it simple, some alternative solutions are not discussed. This is a book to get you started. So it didn't mention that you can have Hibernate automatically search your classpath for @Entity classes, but used addAnnotatedClass() method calls. This is ok, and might be fixed by the time you buy the book.

Now, there are many pieces to the Hibernate puzzle and Cameron manages to pick the subjects that are the necessary building blocks to move on to the more advanced topics. If you are just learning Hibernate, I highly recommend this book to take you on the path of righteousness.

If you are interested in the no-SQL database systems or in utilizing cloud computing to set up a database, this book will teach you more than enough to get you started.

Mocky Habeeb (the author) demonstrates his mastery of this subject in providing valuable hints throughout the book. These include simple warnings about certain processes that are "high cost", tuning queries, avoiding throttling server side, altering queries depending on local versus remote queries, and so on.

Although the book is primarily a Java centric book, Mocky also provides sample code in C# and PHP. He also provides comparisons between other cloud providers offerings, and discusses some methods of choosing between schema-less databases and SQL databases.

Finally, Mocky builds an API that makes it easier for newcomers to Amazon SimpleDB to use within their Java programs.

This book is well written, and an easy to read and understand introduction to Amazon SimpleDB.

The knowledge and experience of the author is not in question, but it doesn't come out in the text of this book.

"Amazon SinpleDB" is not a large book at a bit over 250 pages and even though it is aimed at developers I was
expecting some coverage of the practical uses or experience but that is not evident. More on the source code later,
but the user tips were often useful but buried in the text and not that accessible.

Sample source code is provided for four languages, Java, PHP, C# and Python but personally the code was niether here nor there.
50 pages worth of the same code covered four times feels like padding, and while it is helpful that each language introduced
a library to simplify interacting with the Amazon Web Services, I kept thinking that at some point the book would directly
address the Web Services.

In my mind this wasn't the book that the author intended and it falls short in so many areas that it feels unfinished
and leaves you wondering what wasn't covered. There are other positive areas about the book but overall for me it was
difficult to recommend an audience for this book.

---
Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch.

8 1/2, but since we only have 8 or 9, I liked it enough to make sure I rounded up instead of down.

I highly recommend this book to learn Core Spring. It is the only book currently out by Dec 08 that covers version 2.5. Other books still only cover 2.0

I found the writing easy to understand, I found that they covered the material very well with good examples. They cover a lot of material and leave you with great in-depth knowledge in each of those Spring technologies.

Now, I don't agree with everything they say in the book, but it isn't that they are wrong, but that I just disagree with certain statements. For example, in a Note section they stated that "They do not encourage the use of annotations on the objects you will persist using Hibernate." Using JPA Annotations, from an ORM tool expert, is a best practice and makes your life so much easier, in my opinion, and many other ORM experts. This note should have been left out of the book, unless they wanted to fully cover why.