Rating: 
Summary: Disappointed
Review: ...I have a few points to make: 1. This publication came late in the game. In most installations that I consulted for, more sophisticated and advanced J2EE Patterns and Strategies were developed. It's too little, too late... 2. It's not an easy thing to write a book about Best Practices, Design and Strategies. The authors did not step up to the task. Patterns and Strategies are often mixed in the book. The authors were not able to explain what Patterns and/or strategies are. 3. The Strategies that the book represents are often being described as "What NOT to do" rather than "What to do". It's a very poor way of representing software strategies. Strategies writing should demonstrate a strong leadership in the field, which did not come across here. 4. Most of the code examples in the first part of the book are presented with JSP code: the book suggests to separate Logical layers from Presentation layers. Most of the samples to support this idea are brought by JSP code, the logical layer is ignored. In addition, the Controller idea is presented by JSP code, where a Controller should be a logical layer. 5. I found a weak link, in the book, between UML and Patterns. This is a very confusing topic... 6. The code examples throughout the book demonstrate poor code style and this is for itself a bad practice. They are function oriented and not object oriented in most cases.
Rating: 
Summary: Very Disappointed
Review: After being tempted at java.sun.com with online version, I figured I would pick this book up to have as a good reference. After all, there's something to be said for having it in print =) Unfortunately, I found the examples *severely* lacking. I returned the book practically immediately when I realized that it didn't fit my learning style. Much like the author of another book on design I own, MEGO (My Eyes Glaze Over) until I see a good example. I understand the patterns, but I would really have liked to have seen at least a *toy* example. Imagine reading GoF and seeing this: +++
Command pattern is blah blah blah. Here's an example: Command comm = getCommand();
comm.execute();
+++ That example really wouldn't tell you how the Command pattern works in context, etc. At the end of each pattern in GoF, there's a really nice example (not in Java, but hey, no one's perfect ;) If this book had that, or at least a pointer inside of a larger example, THAT would have been it for me. I would have given it 5 stars. What they COULD have done was said, "Here's what a Front Controller is. See x.java and y.java inside of PetStore or Adventure for a really good example." The funny thing is that most of the example code is taken up by servlet overhead. Everything calls doProcess, etc. I don't need to see that code 10x. As it stands, I'm giving it a '1' because the examples are so poorly done as to make the book practically worthless to me. I know I don't speak for everyone considering the rave reviews this book has gotten, but it certainly was not a match for my particular learning style.
Rating:
Summary: Very Disappointed
Review: After being tempted at java.sun.com with online version, I figured I would pick this book up to have as a good reference. After all, there's something to be said for having it in print =) Unfortunately, I found the examples *severely* lacking. I returned the book practically immediately when I realized that it didn't fit my learning style. Much like the author of another book on design I own, MEGO (My Eyes Glaze Over) until I see a good example. I understand the patterns, but I would really have liked to have seen at least a *toy* example. Imagine reading GoF and seeing this: +++
Command pattern is blah blah blah. Here's an example: Command comm = getCommand();
comm.execute();
+++ That example really wouldn't tell you how the Command pattern works in context, etc. At the end of each pattern in GoF, there's a really nice example (not in Java, but hey, no one's perfect ;) If this book had that, or at least a pointer inside of a larger example, THAT would have been it for me. I would have given it 5 stars. What they COULD have done was said, "Here's what a Front Controller is. See x.java and y.java inside of PetStore or Adventure for a really good example." The funny thing is that most of the example code is taken up by servlet overhead. Everything calls doProcess, etc. I don't need to see that code 10x. As it stands, I'm giving it a '1' because the examples are so poorly done as to make the book practically worthless to me. I know I don't speak for everyone considering the rave reviews this book has gotten, but it certainly was not a match for my particular learning style.
Rating: 
Summary: A wonderful addition for your J2EE collection
Review: An excellent reference for J2EE programmers and architects. I really enjoyed the chapters on bad practices (ala anti-patterns) in J2EE. It's equally important to identify the "bad smells" in a design as it is to come up with a good design. Having the patterns organized by "layers" was very welcomed. The class and sequence diagrams are printed inline with the text. This is a nice amenity to the book; the design patterns published in the book were originally found on the JDC site in beta form and all the diagrams were scaled down in size. The only way to view them was to click on them and look at them in a new document view. This book will certainly be a mainstay on my desktop at consulting engagements. I just hope the J2EE community can get more of these types of books.
Rating: 
Summary: Excellent book
Review: As a Java programmer new to J2EE I found this very authoritative book an excellent resource. In addition to covering/introducing me to the most important J2EE paterns this book also provided valuable insight into fundamental application design and development. I'm hoping that an update to the book covering any new J2EE 1.4 patters will come out soon!
Rating:
Summary: Excellent Design Book
Review: As an aspiring architect, this book was excellent. It was easy to read, and well ground with Java specific code samples (servlets, JSP, etc). This made the book far more tangible than other design books.
Rating:
Summary: Real world solutions for real J2EE problems - A must buy
Review: Core J2EE Patterns: Best Practices and Design Strategies is a great book and a must for anyone involved in Java development dealing with J2EE technologies. (This book is not meant to replace the Gang of Four Design pattern book) A design pattern is simply a proven solution to a recurring design problem. In the last few years, J2EE technology has matured as the de-facto platform for building Enterprise application in the Java world. With all the technology possibilities comes confusion as to what is the best way. The senior architects from the Sun Java Center have learned from their experiences in developing and deploying J2EE applications and have distilled all that knowledge into fifteen different design patterns. This book offers practical advice that can be applied to real-world problems. The authors take each pattern and describe them in great detail using UML class and sequence diagrams. What makes this book different from other programming books is that the authors take time to explain the thought process and motivation for the solution and the reason for using the particular pattern with the specific problem at hand. This book is a must for any developer or architect involved as this book will help you write or design better code. 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.
Rating:
Summary: An all-star guide for practical J2EE enterprise architecture
Review: Having just completed the initial design and development phase of a J2EE web-based implementation of a major application vendor's product, I bought this book. I don't know whether I was trying to see what I could have done better or what I, hmmm, messed up? A little history ' I have been in the application development field for 25 years, working up from being a coder to a consulting enterprise architect. Having worked with a lot of technologies over the years, I have noticed that while some things change every 18-36 months, some things don't change all that much. I didn't acknowledge this trend as 'patterns' because I called it experience. I've bought a hundred books over the years, from the Martin books back in the 70's to Monson-Haefel in 2000. With very few exceptions, such as Alexander's Timeless Way of Building and a few others, they were trivial or excellently focused on a very small segment of what you need to know (such as EJB) to be a system architect. Or, in attempting to focus on the bigger picture, they show absolutely no practical detail, and in their own way, are useless. Now, after all that BS, I get down to the book. This is an outstanding document of a large number of essential enterprise level patterns applied to the J2EE context. Just as Bruschmann's Pattern-Oriented Software Architecture, A System of Patterns took patterns that, by themselves, are trivial and combined them into architecturally significant frameworks; this book shows architectural patterns that are significant in the light of J2EE and Javasoft's Model 2 reference architecture. Anybody that has worked with Model 2 knows that it is a naïve architecture. It uses practically every part of J2EE because it is there (remember that both were created by Sun) and the patterns of communication and service support really don't work robustly. You will have to significantly enhance the Controller, how the View gets data from the Model, exception handling and propagation, how services are provided and much more. It seems that the authors of this book realize that. Look at the Front Controller, Service to Worker and Dispatcher View patterns. Check out how the Business Delegate, Session Façade and Composite Entity patterns work. For services, the Service Locator and Service activator patterns are significant. If you have any reservations about Entity Beans (more later), check out the Data Access Object. If the View Helper, Composite View, Value Object, V.O. Assembler, Value List Handler are new to you, read this book. As an architect, they shouldn't be new. On Entity Beans, I have to say that the authors did an excellent job. In providing patterns such as Composite Entity and DAO, they help to reduce the triviality of the 1.0 Entity Bean Specification. Within the Composite Entity, the Composite Entity Contains Coarse-Grained Object Strategy and the Composite Entity Implements Coarse-Grained Object Strategy may seem the same, but they are not. They are both powerful ways of leveraging Entity Beans. The Lazy Loading and Dirty Marker Strategies are excellent, also. A few places in the book have what I believe are errors, or at least naïve statements. The introduction to Entity Beans reads like a java marketing hack wrote it. If you've worked with Entity Beans, you might have run into the fact that they are a relatively simple solution to what can be an extremely complex problem. Many people do not even use them. I usually don't. The Synchronizer Token is interesting, but it seems to assume a single VM on a single machine. What happens to this token when you are stateless, in a multiple VM, multiple node load-balanced cluster? You have to address the location transparent, session state management service scheme before you can deal with this. Look at the bad practices. I did, with one hand over my eyes! Luckily, I wasn't guilty. These are things that should be obvious to you as a system architect. If not read them and remember them. All in all, this is one of the best books I have read this decade! In terms of practicality, this is the J2EE architecture book to buy.
Rating:
Summary: I highly recommend this book!
Review: Having read many J2EE books, I must say that this one provides a terrific sampling of expert advice. In many ways, it's quite useful beyond J2EE, as well, though the specific implementation examples for each pattern are targeted at the J2EE platform. I recommend it highly as an addition to your library.
Brad Note: My colleague purchased a copy several months ago and my copy includes an additional foreword by Martin Fowler, which apparently has been added recently. I found this of particular interest, because of my experience with refactoring. (I like the way this book includes sections on refactoring too.)
Rating:
Summary: J2EE Patterns is Great!!!
Review: I am a software engineer, and after reading J2EE Patterns I feel like I'm ready to be a J2EE Architect! This book is a must buy for all software engineers who work with J2EE.
| 
