- Release Date: 26 June, 2001
- Collectible Price: $23.29
- Used Price: $11.20
- Availability: Usually ships within 24 hours
- Third Party Used Price: $18.00
Authors: Deepak Alur, John Crupi, Dan MalksPatterns are basically design solutions for recurring problems, so Core J2EE Patterns contains recurring design solutions for persons using J2EE. The authors break these solutions down into presentation, business, and integration patterns.
As is usual with pattern books, you won't find much code here. The book majors on problem discussions, analysis of the factors you should consider in your design, and strategies for the solution implementation. The authors constantly encourage abstraction, code modularity, non-duplication of code, network efficiency, code maintainability, and solution reusability.
While these are the aims we've been encouraged to pursue for years, too many pattern books operate at such a high theoretical level they fail to appeal to working programmers. In practice, you could use the patterns discussed with any language, but by concentrating on using Java, Core J2EE Patterns is able to take a more hands-on approach.
Okay, so you won't find detail at the level of APIs, but you will find discussion of where to implement functionality to best leverage Java's architecture and which Java mechanisms to use: for example, implementing entity beans as coarse-grained--rather than fine-grained--objects to reduce the transaction overhead. Not the sort of implementation advice you'll find in language-agnostic pattern books.
Core J2EE Patterns enables you to dramatically cut the design time on enterprise-level Java-based projects while increasing the likelihood that the project will reach a timely fruition. Recommended. --Steve Patient, Amazon.co.uk
Customer Rating: 4.43 of 5 (51 total reviews)
- Overall very good, but there are still things to be desired
Overall it's a very good book. It covers many of the design level patterns of J2EE applications.
Many of the previous reviews have covered everything good about the book, I do agree with most of them. I particularly like part 2 of the book - "Design Considerations, Bad Practices and Refactoring".
However, the book also left a few things to be desrired (at least IMO):
1) The Consequences of pattern should have been cleared marked as pros and cons, together with trade-off discussions
2) The last chapter "J2EE Patterns Applied" is way too light
3) I'm not so comforatable of the authors' using of the word "strategy": IMO, calling them "Implementation Variants" would be more appropriate
4) Some of the UML diagrams (especially class diagrams) are rather weak, even confusing at times
5) Lack of discussion of the high level architectural patterns, e.g. MVC
Overall it's still a excellent book, definitely worth reading! Considering there are so many rush/not-well-thought tech book out there, I certainly have no problem giving it 5 stars.
- A Good Source on Practices and Tactics
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.
- The best book ever
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.