Rating: 
Summary: Not only applicable to J2EE applications
Review: We software developers often get ourselves buried in learning new technologies, particularly in J2EE, there are so many things to learn, e.g., JSP, Servlet, JAAS, JSSE, JMS, JavaMail, EJB, JDBC, JDO, etc. just to name a few. With these overwhelming technologies, we often overlook the issue how to "design" "good" systems using these technologies. Knowing the technology itself is one thing, and knowing how to design with it well is another. Technologies are always advancing, it is really the design technique that is the essence or hard-core skill that a software developer should obtain.Patterns, are such essences. They are best practices from experiences on how to design the systems/components at different levels. And Core J2EE Patterns are such collections in the J2EE context. Even though the authors claim that these patterns are used under the J2EE context, I see most of them also application in a more general context. For example, If a remote service is to be provided, it is good practice to use Session Facade (or Remote Facade), and it will provide service by delegating to the Application Service (or Service Layer) or Business Delegate. To facilitate the client to access a remote service, Business Delegate can be applied to hide the remoteness, in which it will use Service Locator to look up the remote service. In this sense, Business Delegate also functions as a proxy of the remote service. To decouple the Business Object from accessing the resources directly, Data Access Object is a good design to be applied. To move the data between the tiers or processes, Data Transfer Object can be use. If studying carefully, you will a lot of patterns and concepts can be applied to non-J2EE applications. And a lot of them can be traced back to the seminal work of GoF (Design Patterns). That is why I said the design skill should be essential to a developer, these techniques are correlated and inter-connected, and accumulated by experience. They are relatively stable (IMO), though the technologies are changing (rapidly). The other good things about book, the authors not only document the best practices (patterns) of J2EE applications to learn, they also list a set of bad practices (anti-patterns) to avoid, in between, they provide a bridge, the refactoring, to go from bad to good. Also, no pattern is an island. All patterns are related, and to form a bigger or higher level of pattern, and these higher level of patterns collaborate with each other and eventually form the whole architecture of the system, that is pattern oriented architecture. In last episode, the authors gave such an example, and they call it a micro architecture. The authors also refer to the work of Martin Fowler's Patterns of Enterprise Application Architecture(which list patterns of more general enterprise application patterns besides J2EE) to clear out some gaps between the two books, e.g., Value Object in 1st edition really means Transfer Object, which is the same pattern listed as Data Transfer Object in Fowler's book. And Value Object is just another pattern in PEAA. The writing style is very smooth, succinct and to the point. The pattern template is classic, with the authors chose strategies for implementation variations. The examples are probably excerpt from real projects, however, there are some errors in the code, which made me doubt that these codes were ever compiled. But, hey, it is the concept that is more important :-)
Rating:
Summary: Excellent - must have for all J2EE developers and architects
Review: Well written, compact in size for its content, easy to understand, great examples, nicely organized with great references between chapters. Highly recommend for beginners and experienced software engineers.
Rating: 
Summary: Good source of J2EE Patterns - With little new additions
Review: With great curiosity, I bought this second edition once again the J2EE pattern gurus made a great attempt to bring this book well updated. This book anchors solid patterns foundation for J2EE components revising some of the existing patterns and also fixed some of the gaps found in the previous edition. The J2EE component design strategies, refactorings and bad practices makes a big impact for any developer and makes this book again a worth buy. One disappointing factor, Except for couple of new Web services patterns the book is not mature enough on defining patterns for J2EE Web services scenarios, which is the focus of upcoming J2EE 1.4 specifications.
Rating:
Summary: Outstanding J2EE Architecture Guide
Review: Without a doubt, the authors have spent a lot of time developing J2EE applications. While I've applied most of the patterns in one way or another in the past, this book brings them all together. If you're looking for ways to improve your existing J2EE architecture, or if you need to start work on a new project and want to do it right, read this book cover to cover first.
Core J2EE Patterns presents real-life examples of how to build web applications: from front-end patterns, to business object patterns, to integration and data access patterns, it's all here. It even presents strategies for refactoring existing applications to take advantage of architectural patterns.
In reality, you'll probably never implement every one of the patterns described in this book in a single application (or you'd be maintaining thousands of classes). But if you don't implement many of them, you're doing it wrong. The authors don't describe every possible J2EE pattern, but the patterns they do cover will undoubtedly make your application easier to design, develop, test, and maintain.
Rating:
Summary: Must Have! A J2EE Classic for sure!!
Review: 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!
| 
