Rating: 
Summary: Great Book on J2EE Patterns
Review: Overall Rating: Well done! This book will be a valuable teaching and reference tool.
Teaching Value: Excellent! An essential book on this topic.
Reference Value: A complete reference. I would not need any additional reference on this topic.The primary focus of the book is on patterns, best practices, design strategies, and proven solutions using the key J2EE technologies including Java Server Pages (JSP), Servlets, Enterprise JavaBeans (EJB) and Java Message Service (JMS) APIs. Written from a programmer's perspective with extensive codes and fully illustrated with UML diagrams. The book is fully revised and newly documented patterns providing proven solutions for enterprise applications. Material is presented in a logical progression so you can learn at your own pace. And yet there is depth in the book to make this a valuable resource for any professional who knows J2EE and wants to use J2EE to build web services. The author did a great job describing useful patterns for application architecture and design strategies for the presentation tier, business tier, and integration tier. The section on refactoring is worth reading. This book unites the platform's many technologies and APIs and provides insightful answers to whys, when and hows of the J2EE.
Rating:
Summary: Great Book on J2EE Patterns
Review: Overall Rating: Well done! This book will be a valuable teaching and reference tool.
Teaching Value: Excellent! An essential book on this topic.
Reference Value: A complete reference. I would not need any additional reference on this topic. The primary focus of the book is on patterns, best practices, design strategies, and proven solutions using the key J2EE technologies including Java Server Pages (JSP), Servlets, Enterprise JavaBeans (EJB) and Java Message Service (JMS) APIs. Written from a programmer's perspective with extensive codes and fully illustrated with UML diagrams. The book is fully revised and newly documented patterns providing proven solutions for enterprise applications. Material is presented in a logical progression so you can learn at your own pace. And yet there is depth in the book to make this a valuable resource for any professional who knows J2EE and wants to use J2EE to build web services. The author did a great job describing useful patterns for application architecture and design strategies for the presentation tier, business tier, and integration tier. The section on refactoring is worth reading. This book unites the platform's many technologies and APIs and provides insightful answers to whys, when and hows of the J2EE.
Rating:
Summary: Fantastic Update to a Classic
Review: 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.
Rating:
Summary: The J2EE development bible - A MUST BUY
Review: 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.
Rating:
Summary: Must Read Book
Review: The author describied useful patterns for application architecture and design strategies for the presentation tier, business tier, and integration tier. The section on refactoring is worth reading.
i prefer to read this book if any wants to know more about j2ee patterns..
Rating:
Summary: A must have for J2EE architects/developers
Review: 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.
Rating: 
Summary: Good reference but incomplete code with many errors
Review: This book is a very good guide for a J2EE architect. But, the code examples in this book are either incomplete or have many errors. I would imagine authors could argue that the book was not supposed to give full code. But, they have supported pattern ideas with the help of code (not pseudo code). They could have either written just the pseudo code or taken a little more effort to build a complete code. They have left the readers kind of in between. I wonder how such a popular book can have so many typos, errors and incomplete code! Hope they come up with Ver3.0 soon. Rajesh Zade
Rating:
Summary: Amazing!!
Review: This book is very complete and straight forward!!
Greetings!
Rating: 
Summary: dont buy it - Zero rating
Review: this book's author copies others sources and attempt to sell it as their own.
get it from the source: Fowler's "Refactoring".
at least u dont get the errors with it.
Rating:
Summary: patterns to live by
Review: This is one book you must have in your j2ee collection or you can just forget it. If you don't apply any of these patterns you are not going to have a designed system, much less a well designed j2ee system. These guys have been through the dark and shed light on areas that we don't have to suffer through, like the back button browser solution. Never thought you could solve that one on the back-end and be browser independent. You want to know best practices, here it is, no other book comes close and within so few pages. It's pricey all right, but you'll get all of that back in robust, maintainable code. Can't beat it with a stick.
| 
