Rating: 
Summary: No Code, same as what is at java.sun.com
Review: I was really disappointed in the book because I wanted to get the source code. I had expected to get some more useful tools. A major part of this book is already on the java.sun.com website. A real waste of money if you are already familiar with design patterns and have gone to the java.sun.com website and seen these design patterns explained there.
Rating: 
Summary: Good attempt at a great subject
Review: I would rate this book a 3 1/2 stars. It definitely takes a stab at proposing different design patterns useful for j2ee applications. But I find it a bit basic. Though I would recommend this book for anyone new to j2ee development I am sure anyone who has implemented application in j2ee must have already used more scalable and complex patterns than those listed in the book. I am sure we will see more books coming out on the same subject.
Rating: 
Summary: A good book, but with a shorter book trying to get out.
Review: I'll be honest, I was really was looking for a book called something like "Enterprise Java for an Architect who knows a lot about Microsoft DNA but not much about Java". This is the closest I've found. It is a very good presentation of how the different elements of the J2EE stack are meant to fit together, common problems and patterns which address them.There are some very good things about this book. It really tries to explain the design forces which lead to good and bad solutions, and does try to put all the different patterns into the context of a "roadmap" so you can see how they link together. One of the best ideas in the book is actually in the epilogue, where the authors introduce the idea of building an architecture via a UML diagram built from stereotypes for the patterns. I can see this being widely adopted as a useful technique. The big problem with the book is it is dreadfully repetitive. It's not sure whether it's a textbook, a reference book or a design tutorial, so it tries to be all three. The same text gets repeated over and over again, not only between sections but even within a section. By attempting to make each pattern, and each "strategy" within a pattern self-sufficient there's an awful lot of repeated text, sometimes even on one page. Some patterns almost exact copies of one another and should arguably be strategies for a single pattern. Text is often repeated between the "Problem", "Forces" and other sections of the same pattern, where a better trade-off would be references to a single list of more detailed descriptions. At the same time there are too many self-references in the text, even back to the start of the same section! I found the repetition and overlap between the "design considerations", "bad practices" and "refactoring" sections confusing - it would be better if they all formed part of a single roadmap with the main set of patterns. There's an established concept of "Anti-patterns", which could easily serve for bad practices and refactoring ideas, and these could also be reflected as part of the "forces" for the patterns. Adopting all of these patterns could lead to a very complex layer structure, with a great many classes involved in the simplest task. Several patterns seem to be about wrapping the complexities of J2EE, and you wonder whether there ought to be a more systematic solution to this. The book doesn't discuss "managing complexity in the design", but if it did it might come up with some simplifications. While I'm not aware of an equivalent book with a Microsoft focus, with a little effort you could also apply many of these patterns in the Microsoft world. However, there are some good Visual Basic patterns books which show how this should have been written. A provocative idea - does the difference between this and equivalent VB books reflect the difference in productivity of the languages? My advice? If you need a good J2EE design pattern reference buy this book, but don't try to read it cover to cover. ...
Rating: 
Summary: Great book for learning (or reviewing) J2EE Patterns
Review: I've been designing J2EE architectures for a few years now and I was really impressed with this book. It has collected and published in one place things that I've slowly learned (often the hard way) over the years. For that reason I think it's a great resource. That said, it's a little high level and the authors repeat themselves quite often. But I think that is OK when using the book as a reference but when reading straight through it gets annoying. But that doesn't take away from a great book. If you're designing J2EE architectures, you should know all the patterns in this book.
Rating:
Summary: Acceptable, but could have been much better
Review: I've been programming in Java for a number of years, including J2EE development, and saw this book as a great opportunity for me to learn more about design patterns in J2EE. The great reviews about this book pretty much sold me on it. After reading the book, I have mixed feelings and would probably only recommend parts of it. THE GOOD: The authors emumerate many design patterns and describe how they are related. In particular, there is one great picture that shows how all of the patterns can work together. Just knowing what the patterns are, capsule summaries of each, and how they interrelate is pretty worthwhile. On rare occasion, an example is useful because the applicability of the pattern is clear enough - even without an example. THE BAD: The examples need a lot of work. A couple of other reviewers has also spotted this and I join them in this critique. The authors would do much better if they started the book with a one or two larger, more complete examples (say, a banking application or a bookstore application) and then relate the patterns to the implementations of those applications. Without good examples, the patterns lose credibility. Another general point: because the content is light, much of what I gleaned from the book was "decouple as much as possible, up to a reasonable granularity". This came accross most prominently in the refactoring parts of the book. This is not new information and I would suggest that for the next edition, the authors just come out and say this and then start showing examples of where decoupling and replication of components makes the most sense.
Rating:
Summary: Acceptable, but could have been much better
Review: I've been programming in Java for a number of years, including J2EE development, and saw this book as a great opportunity for me to learn more about design patterns in J2EE. The great reviews about this book pretty much sold me on it. After reading the book, I have mixed feelings and would probably only recommend parts of it. THE GOOD: The authors emumerate many design patterns and describe how they are related. In particular, there is one great picture that shows how all of the patterns can work together. Just knowing what the patterns are, capsule summaries of each, and how they interrelate is pretty worthwhile. On rare occasion, an example is useful because the applicability of the pattern is clear enough - even without an example. THE BAD: The examples need a lot of work. A couple of other reviewers has also spotted this and I join them in this critique. The authors would do much better if they started the book with a one or two larger, more complete examples (say, a banking application or a bookstore application) and then relate the patterns to the implementations of those applications. Without good examples, the patterns lose credibility. Another general point: because the content is light, much of what I gleaned from the book was "decouple as much as possible, up to a reasonable granularity". This came accross most prominently in the refactoring parts of the book. This is not new information and I would suggest that for the next edition, the authors just come out and say this and then start showing examples of where decoupling and replication of components makes the most sense.
Rating:
Summary: Well Organized & Written
Review: If you are green or seasoned this book can server you well. If you are new at Java Enterprise and want to obtain a comfort level with the technology and how to use it properly this book can deliver. The book walks you through many of the configurations of technology you are likely to encounter in real life scenarios (e.g. n-teir enterprise, how to implement sessions with a container server, when to use Session and EJB's and in what configuration, etc.) It also details -- with easy to follow graphics, many of the common patters you do well to use such as Session Facade, Data Access Objects, etc. But the real power comes in with the authors decision to bind patterns, anti-patterns, and troubleshooting tips all together. In the early parts of the book bad practices are detailed along with the suggested refactoring solution. You don't have to use their solutions but do make a compelling argument why not to use the bad practice -- which are more common than most think. This book makes a very hand reference guide to a seasoned professional. Especially, when trying to explain concepts to less knowledgeable coworkers or managers. I highly recommend getting a copy.
Rating:
Summary: Good J2EE Desing Patterns Book
Review: If you are looking for design patterns to apply to your site (hopefully before you build it!), then this is a book you will want to consult.
It defines and analzyes the strengths and weakness of many different patterns for the three tiers (presentation,business, and data)
Some readers have mentioned a lack of code examples...I also feel that the book would have been better if it had more annotated code examples than it does (hence the 4 star rating), but on the other hand this is not really a beginners book in the sense you need to know design patterns as defined in the GoF book...This should not be your first book on patterns, or if it is, you will need to read concurrently a text like "Design Pattens Explained" which is 5 stars all the way.
A well designed and architected site will save many hours in maintenance and extension coding...This book is, in my opinion, a good place to start your design efforts.
Rating:
Summary: Core J2EE Patterns
Review: If you are looking for the best practices of J2EE development, I definitely recommend this one. The author have done a great job on writing and explainning. The book describes closely with the technical blueprint provided by Sun. This book is good for designing, architecturing your application. It is a must have technical book for technical managers, technical leads, and developers. It is not a book for Java and J2EE entry level programming.
Rating:
Summary: Good Basic Coverage of J2EE Patterns
Review: It covers the basic patterns involved in developing J2EE applications from the presentation, business and the integration or data tier. Since it covers all tiers of a J2EE application, it can't be too details to cover a wider area, otherwise the book will just be too thick. It's a great book for those starting to develop J2EE application. With the combination of "EJB Design Patterns" as the dessert, it would make a more complete meal.
| 
