Terra Kaffe - Shop now
Buy used:
$2.29
$3.98 delivery Wednesday, February 26. Details
Used: Good | Details
Condition: Used: Good
Comment: Item in good condition. Textbooks may not include supplemental items i.e. CDs, access codes etc...
Access codes and supplements are not guaranteed with used items.
Kindle app logo image

Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required.

Read instantly on your browser with Kindle for Web.

Using your mobile phone camera - scan the code below and download the Kindle app.

QR code to download the Kindle App

Follow the author

Something went wrong. Please try your request again later.

Core J2EE Patterns: Best Practices and Design Strategies First Edition

4.2 4.2 out of 5 stars 45 ratings

Explains how to leverage Java's architecture and mechanisms to design enterprise applications and considers code modularity, nonduplication, network efficiency, maintainability, and reusability.

There is a newer edition of this item:

Core J2Ee Patterns: Best Practices and Design Strategies
$18.00
(66)
Only 1 left in stock - order soon.

Editorial Reviews

Amazon.com Review

Patterns 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

From the Back Cover

Over the last few years, Java 2 Platform, Enterprise Edition (J2EE) technology has emerged and matured as a standard platform for building enterprise applications. While the platform has matured into a solid offering for developing and deploying enterprise applications, it does offer its challenges. As developers, often we confuse learning the technology with learning to design with the technology. In this book, senior architects from the Sun Java Center, Sun's Java consulting organization share with the reader their cumulative design experience with and expertise on J2EE technology.

The primary focus of the book is on patterns, best practices, design strategies, and proven solutions using the key J2EE technologies including JavaServer Pages (JSP), Servlets, Enterprise Java Beans (EJB), and Java Message Service (J.M.S) API. Other ancillary technologies like JDBC and JNDI are also discussed as relevant to their usage in these patterns. The J2EE Patterns catalog with 16 patterns and numerous strategies is presented to document and promote best practices for these technologies.

In addition to the patterns and strategies, the book offers the following:

  • Presents various design strategies for the presentation tier and business tier design.
  • Identifies bad practices in presentation, business, and integration tiers, and offers directions to remedy them by using certain patterns, strategies, and refactorings.
  • Refactorings for various tiers and mechanics to move away from a bad implementation to a better solution.
  • Sample code and examples for patterns, strategies, and refactorings.

Core J2EE Patterns delivers:

  • Proven solutions for enterprise applications
  • J2EE Patterns Catalog with patterns for JSP technology, EJB technology, and J.M.S.
  • Identifies bad practices and recommends solutions
  • Refactorings to improve existing designs using patterns, strategies, and best practices
  • UML Diagrams illustrate structure and behavior of each pattern

Product details

  • Publisher ‏ : ‎ Prentice Hall Ptr; First Edition (January 1, 2001)
  • Language ‏ : ‎ English
  • Paperback ‏ : ‎ 459 pages
  • ISBN-10 ‏ : ‎ 0130648841
  • ISBN-13 ‏ : ‎ 978-0130648846
  • Item Weight ‏ : ‎ 2.08 pounds
  • Dimensions ‏ : ‎ 7 x 1.5 x 9 inches
  • Customer Reviews:
    4.2 4.2 out of 5 stars 45 ratings

About the author

Follow authors to get new release updates, plus improved recommendations.
Deepak Alur
Brief content visible, double tap to read full content.
Full content visible, double tap to read brief content.

Discover more of the author’s books, see similar authors, read book recommendations and more.

Customer reviews

4.2 out of 5 stars
45 global ratings

Review this product

Share your thoughts with other customers

Top reviews from the United States

  • Reviewed in the United States on March 14, 2002
    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.
    5 people found this helpful
    Report
  • Reviewed in the United States on August 22, 2002
    This book is a must if your are in the J2EE industry and unless you are content to being a head-down coder! All the architects and serious developers, who not only wants to make the sw work but wants to make it efficient and well-structured too, should go thru it, the examples are very helpful and categorizing the patterns in three different tiers provide a intuitive way to look at those.
    Without making this review any longer, what I'll suggest, NOT as a prerequisite, but as a supplement, is the Gang of Four's (Eric gamma et. al.) 'Design Patterns' book...
    7 people found this helpful
    Report
  • Reviewed in the United States on December 12, 2013
    Must be in your rucksack, if you are even thinking about J2EE. Wonderful intro and design tradeoff discussions for all options in J2EE.
  • Reviewed in the United States on February 8, 2003
    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.
    5 people found this helpful
    Report
  • Reviewed in the United States on February 13, 2015
    As expected
  • Reviewed in the United States on March 30, 2003
    After being tempted at java.sun.com with online version, I figured I would pick this book up to have as a good reference. After all, there's something to be said for having it in print =)
    Unfortunately, I found the examples *severely* lacking. I returned the book practically immediately when I realized that it didn't fit my learning style. Much like the author of another book on design I own, MEGO (My Eyes Glaze Over) until I see a good example. I understand the patterns, but I would really have liked to have seen at least a *toy* example.
    Imagine reading GoF and seeing this:
    +++
    Command pattern is blah blah blah. Here's an example:
    Command comm = getCommand();
    comm.execute();
    +++
    That example really wouldn't tell you how the Command pattern works in context, etc. At the end of each pattern in GoF, there's a really nice example (not in Java, but hey, no one's perfect ;) If this book had that, or at least a pointer inside of a larger example, THAT would have been it for me. I would have given it 5 stars.
    What they COULD have done was said, "Here's what a Front Controller is. See x.java and y.java inside of PetStore or Adventure for a really good example."
    The funny thing is that most of the example code is taken up by servlet overhead. Everything calls doProcess, etc. I don't need to see that code 10x.
    As it stands, I'm giving it a '1' because the examples are so poorly done as to make the book practically worthless to me. I know I don't speak for everyone considering the rave reviews this book has gotten, but it certainly was not a match for my particular learning style.
    8 people found this helpful
    Report
  • Reviewed in the United States on August 29, 2001
    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.
    7 people found this helpful
    Report

Top reviews from other countries

  • Andrew Johnston
    4.0 out of 5 stars A good book, but with a shorter book trying to get out.
    Reviewed in the United Kingdom on April 5, 2002
    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...