Review by Thomas Paul for Core J2EE Patterns: Best Practices and Design Strategies (2nd Edition)
Rating:
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. Developers working with poorly designed J2EE applications will find this section especially helpful. Part 2 is the collection of the design patterns and strategies. Each pattern is described in the expected level of detail. The format will remind you of the GoF book. Since this has become the standard format for presenting design patterns this should not be a surprise. The patterns are well thought, 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. Using the strategies in this book will make your applications more robust, make you more productive, and make your code easier to understand and maintain. Anyone designing, architecting, or coding with J2EE will find this book to be extremely useful.

Review by Scott Leberknight for Core J2EE Patterns: Best Practices and Design Strategies (2nd Edition)
Rating:
Core Patterns begins by introducing patterns in general, then presents common J2EE AntiPatterns and proceeds to discuss the refactored solutions to these bad practices along with pointers to the relevant area of the J2EE Pattern Catalog. This allows a straight-through reading for those unfamiliar with patterns or use as a reference guide for experienced pattern users. Two years ago when the first edition of this book came out, I purchased it and read it. Immediately I recognized areas where I could improve my J2EE designs as well as a new vocabulary for describing common solutions to recurring problems.In all J2EE applications I have developed since then I have used the patterns and refactorings presented here to great benefit. In addition, the common vocabulary allows my project teams to discuss potential designs much more quickly and unambiguously, since we understand exactly what someone has in mind when they say something like “We should use Business Delegates in our Struts Actions to access our business services, and we should use Transfer Objects to pass data between the tiers, and use Data Access Objects to access our data stores.”The Second Edition brings updates to the original patterns plus several new patterns and the concept of micro-architectures. In addition to the updated and new patterns, this edition also discusses many patterns in the context of widely-used frameworks such as Struts and JSTL. For example, the book notes that the Struts ActionServlet is a Front Controller which hands the request to the Struts RequestProcessor, which implements the new ApplicationController pattern.Understanding and applying the patterns and refactorings is certain to make your application designs more robust, clean, and maintainable. In addition you will be able to talk about J2EE refactoring and design at a much more abstract and concise level while simultaneously being able to cover a lot more ground much more quickly since everyone will know exactly what is meant by the patterns you are discussing. Along with the GoF’s Design Patterns and Fowler’s Refactoring books, Core J2EE Patterns is a must-have guide that every J2EE developer and architect should own.

Review by Vinit Carpenter for Core J2EE Patterns: Best Practices and Design Strategies (2nd Edition)
Rating:
The 2nd edition of the J2EE development bible, Core J2EE Patterns: Best Practices and Design Strategies is out and the authors do not disappoint. I had given the first edition of this book 5 stars as the authors of the book had taken lessons learned from their experiences in developing and deploying J2EE applications and distilled all that knowledge into fifteen different design patterns. Even if you own the first edition, I would recommend you get the 2nd edition as original 15 patterns have been completely revised and updated, including new implementation strategies and updates relating to the changes in the J2EE specification. J2EE application development is a fairly complex process and just knowing the API does not enable you to write good software. Most people spent several years writing software and learn good design techniques with experience based on what’s worked in the past and what hasn’t worked. Another reason to buy this book is the whole Refactoring section. The authors take Martin Fowler’s refactoring idea to the next level and bring it in the J2EE arena. I feel the price of the book is worth it, just for that section.In addition to the 15 patterns, the authors introduce 6 design patterns to the J2EE pattern catalog…The new patterns include Context Object and Application Controller for the Presentation tier, Application Service and Business Object for the Business Tier and Domain Store and Web Service Broker for the Integration Tier. I highly recommend this book to anyone doing any J2EE development. This book is very easy and light read and it really belongs in your library. I bet anyone that reads even parts of this book will end up writing better, more manageable code that’s cleaner, modular, reusable, and loosely coupled. As Martin Fowler says in the foreword, ‘Don’t build an enterprise bean without it (this book)’. Can Martin Fowler be wrong? If you are looking for a ‘cookbook’ type book that overwhelms you with 200 pages of Java code, this is not it. Instead if you want to learn how to architect simple, flexible and easy to maintain systems, you need to buy and read this book.

Review by for Core J2EE Patterns: Best Practices and Design Strategies (2nd Edition)
Rating:
Wow! This book will become a classic like the GoF book. I agree with the other reviewer.
I had the first edition of this book which I bought with great interest at that time. I did learn quite a few things even though I consider myself a seasoned J2EE developer. I made sure that all my development team members got a copy of this book.
When I saw that the second edition was released, I was skeptical about buying it since I had the first edition. However, after browsing through the contents and reading other reviews, I decided to go for it. And it was a decision I am not regretting. The new edition is so much better in that I wish this was the first edition! The authors seem to have updated all the patterns content. A quick comparison of the patterns between both editions indicates that the content has been more or less revised completely. Almost all the text has been revised and almost all the UML diagrams seem redone to give a better understanding of the pattern. I found the first edition UML diagrams a bit lame compared to the second edition. The new edition seems to have corrected most of the discrepencies in the first edition. So if you have the first edition, dump it and get this one fast!
I also found that there were 6 new patterns in the 2nd edition. The presentation tier added Context Object pattern and Application Controller pattern, Business tier added Business Object pattern and Application Service pattern. The integration tier added Webservice Broker pattern and Domain Store pattern.
Having built a couple of custom persistence frameworks, I found the Domain Store interesting.
One thing lacking in this edition is that the other interesting part of the book (Design considerations, Bad Practices and J2EE Refactoring) remains almost the same as in the first edition with minor exceptions. I would have liked to see the design considerations expanded. I also would have liked to have more J2EE refactorings and bad practices in the 2nd edition. Perhaps, in the next edition?
Another intriguiging part of the book which I haven’t gained a good understanding of yet is the Epilogue titled “WebWorker Micro-Architecture”.Overall, if you are into J2EE, just get the book no matter what. It is a must have & must read!

Review by William A. Dudney for Core J2EE Patterns: Best Practices and Design Strategies (2nd Edition)
Rating:
Summary:This is a must have book for any J2EE developer or architect, even if you already own the first edition it is well worth the $ to get this 2nd edition. The patterns documented in the book are the vocabulary of J2EE development.Content: The first 100 pages or so is dedicated to educating the reader on various design practices for each of the tiers as well as cross tier considerations. The authors also cover what not to do in the ‘bad practices’ sections of each chapter. This is especially useful to developers new to J2EE since it will help them to see what others (me included) have done wrong in the past and why it does not work. The end of this section is concluded with a great set of refactorings to make your applications that are stuck in the bad design practices better. While I wish that some of the refactorings were a bit more detailed over all I really liked this chapter as well.The next section is on the actual patterns and they too are divided up into tiers. I especially like the J2EE Pattern Roadmap in Chapter 5, it gives a nice over view of how everything fits together. The rest of the section covers the patterns in detail. All the classics are there as well as several new ones that are sure to become as much a part of our vocabulary as Session Facade is now.Finally the future of pattern work is partially revealed in the form of ‘Micro-Architectures’. The Web Worker M-A is sort of a pattern for using patterns. Or in other words it provides specific guidance on how to put the patterns in the book together to achieve the specific goal of integrating work-flow into your J2EE application. I’m looking forward to hearing more about this topic from the authors in the future.Physically:The book is much better than the first edition. With a hard back it will last a lot longer through the many, many sessions you will have with this book.