Rating: 
Summary: Can we expect example codes for few, more complex scenarios
Review: I certainly likes the book, since it gives an exhaustive narration of how to implement the various patterns. It's helping me a lot in a present project where I am doing the server side design using EJB2.0. What I'd like to have more is a more detailed listing of example codes. I surely appreciate the codes available alongwith the connecteion site, but it'd have been nice, if it included example pattern implementations for more complicated scenarios. I am writing this just because, when we try to apply the pattern examples listed in a real project, often we have to bring out our own versions of the pattern implementations. This we can surely do, once we understand the basic pattern structure. Still, if the authors themselves could come out with more examples narrating some exceptional scenarios where the patterns are applied appropriately, it will provide a means for other architects and designers to compare their own versions of the implementations with those "authoritative examples" and gain confidence.
Rating:
Summary: A Good Source on Practices and Tactics
Review: I found this book a solid and useful resource on many points. For me however it was not as solid on points I care most about. One Patterns community goal is to establish a vocabulary for designers and architects that makes it easier to communicate. Instead of using source code to give those expressions form, we would rather use visual diagrams to capture compile-time and run-time relationships among the roles, or "object participants,' in a design. In my opnion, few of the J2EE patterns described benefit from this methodology; some class diagrams merely restate a GoF pattern in a J2EE tier context. Some are so trivial (DAO comes to mind right away) they aren't worth diagramming at all. Clearly some things labelled patterns are really just refactorings or idioms. The authors don't deny this odr defend the use of patterns where there really isn't one, but still, blurring the terms is a disservice. The use of the word "strategy" in the catalog bothers me too: another reviewer here suggested calling them "implementation variations." I favor "tactic," or choosing an approach to a more general directive by taking into account lower-level tensions in a problem domain. One example that might influence a tactic without changing a strategy: "We may not develop new tag libraries," or "we must remain open to migrating to declarative security." The book uses the term strategy consistently, and that may be an implied defense of it, but someone with expectations about what "patterns" are supposed to be has a right to feel a bit miffed. That said, this book has several fine lists of bad practices and refactorings to bring existing code into a best practice. I think the book is best used by someone who has identified these problems in an implementation that didn't quite get the intent of J2EE architecture. This book will help clean up fuzzy or naive implementations, as well as help institute better practices for future development. The authors do a fine job of reducing each of their design solutions to short problem statements most people can memorize. And that's the idea: when a designer hears a customer say, "our logging and auditing code is written across all of our web apps," the idea of a Front Controller or perhaps Intercepting Filter should come immediately to mind. As the designer learns more about strategies employed in the existing architecture, the tactics that best fit with their practice should come to mind, and so on. This is the power of conveying ideas quickly and clearly that we're all looking for.
Rating: 
Summary: Excellent book - finally understand patterns
Review: I have been programming Java for several years. I completed my programmer certification in 1999. I had made an attempt to learn patterns by looking at the GoF book. It was a total waste of time. I hear that it is a very good book, but it did nothing for me. This book was totally different. It was a very easy read. Complete and concise. I especially like how patterns that are usually utilized in JSP designs are separated from those usually used for EJBs. It lists the plus/minus for each pattern. It even suggests similar patterns.
Rating:
Summary: Great book on J2EE Design
Review: I have found this book extremely helpful in my work. It describes numerous designs and implementations and includes source code examples.
I very much like the sections on refactoring, as well, and these are my favorite parts of the book.
While some of the discussions are a bit wordy, it's been very valuable to me in my work and I hope to see an expanded edition in the future. Highly recommended!
Rating:
Summary: no discussion of MVC design patteern
Review: I have the edition that was published in 2001. There is a glaring omission: the book does not discuss the MVC (Model-View-Controller) design pattern.
Rating:
Summary: Most useful J2EE book (so far)!
Review: I have worked in Java/J2EE for many years now. I found this book to be the most useful practical J2EE book so far and brings the subject of design patterns into real practice than some academic mumbo jumbo. Using the patterns in this book, I was able to design an archtiecture for any J2EE application I have encountered in my experience. I introduced this book to the junior developers on my team and was pleasantly surprised to see their skills and designs mature quickly. Perhaps the reason is (as authors say about the usefulness of using patterns) that we all used the same vocabulary in our design work and were able to quickly communicate and be "on the same page".
If you are using J2EE or plan to, this is a book you simply cannot ignore. I highly recommend this book.
Rating:
Summary: Great Design Book, Finally!
Review: I just bought this book and think it is great! Before, I wrote this review I read an earlier review which talked about the examples being light. I really liked the samples. While I would have liked to see more, I thought they were really helpful. I have been waiting for a J2EE design book for quite a while and was happy to see this one. I primarily work on EJB and found session facade and business delagete very helpful. This is a great book to help with EJB design.
Rating:
Summary: Great Opportunity to Learn and Grow
Review: I just got my copy of this book after being on the waiting list and let me tell you, it is awesome. You will definitely grow from reading this book. It is very well written and provides a great level of detail as to design and implementation patterns. Do not expect to get great code examples though as this book is written mostly for patterns and design strategies.
Rating:
Summary: The best book ever
Review: I read this book cover to cover and found it to be the best book written for building J2EE applications framework by far. The authors obviously knows J2EE in and out and isn't afraid to share their knowledge. By reading this book you will learn J2EE, how to apply the patterns in what scenarion and strategies for building/refactoring applications to leverage its capabilities.
You will find invaluable implementation strategies, design patterns, and integration best practices for almost all J2EE development scenarios. In short, if you want to implement world-class J2EE applications and gain invaluable insight into J2EE that clearly represents years of real-world experience, then this book is definitely for you.
Rating:
Summary: The best book ever in java design patterns
Review: I really recommend this book for every Java developer, once you start it, you can't put it down. I wanted to give it a five star but the problem was; I needed to have "Design Patterns" book handy while reading this book also sample codes didn't help me that much with this matter. At the end, this book worth the investment.
| 
