Rating: 
Summary: A Solid Update to an Excellent Book
Review: Core Patterns begins by introducing patterns in general, then presents common J2EE AntiPatterns and proceeds to discuss the refactored solutions to these bad practices along with pointers to the relevant area of the J2EE Pattern Catalog. This allows a straight-through reading for those unfamiliar with patterns or use as a reference guide for experienced pattern users. Two years ago when the first edition of this book came out, I purchased it and read it. Immediately I recognized areas where I could improve my J2EE designs as well as a new vocabulary for describing common solutions to recurring problems.In all J2EE applications I have developed since then I have used the patterns and refactorings presented here to great benefit. In addition, the common vocabulary allows my project teams to discuss potential designs much more quickly and unambiguously, since we understand exactly what someone has in mind when they say something like "We should use Business Delegates in our Struts Actions to access our business services, and we should use Transfer Objects to pass data between the tiers, and use Data Access Objects to access our data stores." The Second Edition brings updates to the original patterns plus several new patterns and the concept of micro-architectures. In addition to the updated and new patterns, this edition also discusses many patterns in the context of widely-used frameworks such as Struts and JSTL. For example, the book notes that the Struts ActionServlet is a Front Controller which hands the request to the Struts RequestProcessor, which implements the new ApplicationController pattern. Understanding and applying the patterns and refactorings is certain to make your application designs more robust, clean, and maintainable. In addition you will be able to talk about J2EE refactoring and design at a much more abstract and concise level while simultaneously being able to cover a lot more ground much more quickly since everyone will know exactly what is meant by the patterns you are discussing. Along with the GoF's Design Patterns and Fowler's Refactoring books, Core J2EE Patterns is a must-have guide that every J2EE developer and architect should own.
Rating:
Summary: Second Edition Is Still An Essential J2EE Patterns Handbook
Review: First of all, I would like to congratulate the authors(Deepak Alur, John Crupi, and Dan Malks) for all hard work that led to this second edition. All I can say is that it is much better(content and look-and-feel) and I am satisfied and happy with my purchased decision[I admitted that I often makes wrong decisions when buying Java-related books, but hesitatedly to get rid of them :-)]. I still remembered how very enthusiastic I were when the first edition of Core J2EE Patterns released in August 2001 on Amazon.com. During the year of 2001, I voted for myself that "Core J2EE Patterns" was one of top two Java-related books of the year 2001(the other book is "Effective Java" by Joshua Bloch). So what's news with this second edition of Core J2EE Patterns? 1. The new look-and-feel and revised content are terrific, thus make it more readable. One of the most wonderful chapters is the chapter 4: J2EE Refactorings. This chapter has been revised and updated and I believe it continues to do the jobs that Fowler's Refactoring left for J2EE world. The new hardcover convinced me that it has been upgraded the status to where "Desing Patters" by GoF has been. Yes, GoF's Design Patterns is still a pattern handbook, but I wish to see a second edition as well. 2. The six new patterns were added to this second edition that reflects current changes in the J2EE world with regards to Web Services and serviced-based architecture and thus the importance of integration's needs. The Presentation Tier gets two new patterns(Application Controller and Context Object). The Business Tier adds two new members(Application Service and Business Object), while the Integration Tier welcomes two new patterns(Web Service Broker and Domain Store). These new patterns in the Integration Tier are very important for any J2EE developer investigating the fuzzy web-service business. 3. I voted the last section of the book(Epilogue): Web Worker Micro-Architecture is the most significant thing that the authors added to this second edition. I really love it because I think it is the real strength of design patterns: How to combine them to solve larger problems and the combinations create a new force that is stronger than any individual pattern can create[I still like the book: Design Patterns Explained by Alan Shalloway and James Trott because it shares with me (and help me of course) the frustration of how to identify, use, and combine patterns to solve larger problems.] And what I want more from this book is of course: More new patterns and more new real scenerios. At first, I thought that I would like to be like other reviewers want: More Code!! But then I step way and think about it: Core J2EE Patterns should be presented at the higher level than coding stuff....Yeah! Read it as shared design ideas and roll up sleeves to code and test it for yourself if you're considered yourself a real programmer. I'm looking forward to finish the whole book and then....who knows? I'm waiting for the third edition, maybe. Once again congratulate and thank you the authors for excellent work so other J2EE developers (like me) to have something to learn and talk about.
Rating:
Summary: Great Book, a Must have book for J2EE Experts
Review: Hi, Already having a number of Core J2EE and Gang of 4 pattern books. But this book I find still the best to understand and follow. Best thing I liked about this book was that this is the first book which captures not only best practices but describes bad practices too. Authors have used very easy to understand examples but without missing the depth of the subject. Great work of writing.
Regards,
Sanjay Barnwal.
Rating:
Summary: Need solutions ? Wan't to avoid mis-developpement
Review: Hi, I found this book very usefull. Why ?
"Good judgement comes from experience, and experience comes from bad judgement !"
In the J2EE world, you don't have enough time to make enough "bad judgments" to avoid all big mistakes in your current project.
This book then is very usefull :
- With a very clear presentation you 'll find usefull solutions to common or less common prossible problems.
- Each problem is explained and the solution is always easy to apply and understand.
- Please not that you have to be familiar with UML. I won't recommend this book to new developpers in the java world
as you still need some developpement background and practice. For foreign readers, the english used here is not of an high technical level Thanks for this book
Rating: 
Summary: Good book but needs cleanup
Review: I found this to be an excellent guide to some very usefull J2EE patters that are applicable in a broader context also. However, the printing that I had was in desperate need of some reviewing: it contained *a lot* of typos, incorrect image references, code sample errors, layouting problems and other such errors. No big problem but it does detract from an otherwise excellent book!
Rating:
Summary: Second Edition is much improved
Review: I got my SCEA using the first edition and am now writing up an in-house course based on the second, so I'm seeing the updates in great detail. The authors put a lot of work into clarifying the examples, and it shows. They also added a few new patterns and "Design Notes" sidebars. Worth the price for J2EE mavens, even if you already have the first edition.
Rating:
Summary: This book is now part of our company J2EE toolbox
Review: I have been working on a J2EE web application for the past year and we have made extensive use of the patterns catalog. The ServiceLocator, Session Facade, Business Delegate and other patterns have sped up our development and helped us meet our customer's schedule for delivery. The new book is even better and is helping us move towards web services. As a result, a copy of Core J2EE Patterns is required reading for anyone in our company and is handed to new employees on day one!
Rating:
Summary: Highly recommend this book.
Review: If you're designing Enterprise J2EE applications and you want to do it right the first time, then you need to read Core J2EE Patterns. There are very few technical books that can provide so much value to an organization as this one can. Our senior architects have adopted and utilize the information in Core J2EE Patterns to such a degree that it has become the most reused artifact in our repository. I'm personally excited about the hardcover 2nd edition - besides the six new patterns, refactorings, and new micro architecture - it allows for greater emphasis when we bang our heads against it while asking, "Why didn't we just read the book first?" This book will have a significant impact on your organization!"
Rating:
Summary: A good sequel to Fowler's "Refactoring"
Review: Martin Fowler's "Refactoring" book quickly became a classic on the subject of improving an existing body of java code. The patterns were described at a general enough level that you could hope to apply them against code, regardless of its application, be it scientific, business or whatever. But one of the boundaries was that Fowler did not discuss patterns when java is used in a narrower but very important context - enterprise computing. This covers cases where you have a web server using java for dynamically generate web pages, and it interacts with a backend database in a multitier structure. Various extensions to java have been made to handle these - servlets, Java Beans, Enterprise Java Beans, Java Server Pages, Data Access Objects. Typically, each has grown in power and complexity such as to have books dedicated solely to its explication. Much more specialised than generic java. The authors of this book discovered that when you code using these enterprise extensions, often similar problems or patterns recur. They ask, can these problems and solutions be systematically elucidated in a form akin to a taxonomy? Their answer is yes, and that answer is this book. It assumes that you already have a fairly high level of competence in the enterprise extensions like EJBs. For example, the book often mentions HttpServlet in the context of JSPs. You need to know what this is. The book wastes no time in describing such things. There are perfectly adequate other texts that do so. At the level of treatment in this book, those are mundane details. The value added by this book is in describing how to optimise the design when you combine the various enterprise extensions into a real product. It has the flavour of Fowler's Refactoring, and in the context of J2EE, may be just as influential.
Rating:
Summary: the Best
Review: Once I started reading this book, it was VERY hard to stop. It tells you all about overal architecture of a J2EE application,
howTo and howNotTo. A must have.
| 
