Applied Java Patterns (Sun Microsystems Press Java) (Paperback)

by Stephen Stelting (Author), Olav Maassen (Author)

Editorial Reviews

Product Description
Increasingly, Java developers are recognizing the value of patterns in helping to build more robust, effective software systems -- but most books on patterns are either generic or focused on other languages. Now, the creators of Sun's own course on Java patterns have written the definitive book for working developers. Replete with working code, this book offers practical help with all types of patterns, in every facet of development -- from individual classes to overall system architecture. First, the authors introduce the fundamentals of patterns, presenting a high-level overview of how they can be used most effectively in Java development, and introducing each key type of pattern: creational, behavioral, and structural. Next, they present specific techniques for using patterns with core Java APIs (including security, event, JavaBeans, and Swing APIs); and in advanced distributed development with JDBC, RMI, CORBA, JNDI, and JavaSpaces. The book concludes with detailed coverage of pattern use in enterprise systems built with servlets, JSP, and other J2EE infrastructure technologies.

From the Back Cover

A hands-on guide to design patterns for Java platform developers.

• Pattern-based solutions for every stage of the development lifecycle
• Documents 30 patterns, including the 23 core patterns for the Sun Certified Enterprise Architect exam
• Describes pattern use within the Java APIs—including patterns for reflection, security, AWT/Swing, RMI, JDBC, J2EE, and more

Increasingly, developers are recognizing the value of design patterns in helping to create more robust, scalable, reliable, and maintainable applications. Now there's a book that can help you bring the power of patterns to your Java-based projects.

Sun Microsystems experts Steve Stelting and Olav Maassen bring together today's best pattern-based techniques and demonstrate pattern use for a variety of business systems. This practical guide features proven techniques for all types of patterns, from system architecture to single classes

After briefly reviewing the fundamentals of design patterns, the authors describe how these patterns can be applied effectively to the Java platform. Next, they provide a pattern catalog, organized into four major categories—the creational, behavioral, structural, and system patterns. In addition, they identify patterns and present techniques for pattern use in the core Java APIs as well as the APIs for distributed development.

APIs covered include:

• Event handling
• Collection API
• JDBC
• RMI
• CORBA

Applied Java Patterns also features a section on pattern use in systems built with J2EE and JINI technologies, and coverage of the servlet, JSP, EJB, and JavaSpaces APIs.

Without a doubt, this accessible and up-to-date guide can help you enhance your Java platform programming skills.

See all Editorial Reviews

Product Details

• Paperback: 608 pages
• Publisher: Prentice Hall PTR; illustrated edition edition (January 5, 2002)
• Language: English
• ISBN-10: 0130935387
• ISBN-13: 978-0130935380
• Product Dimensions: 9.1 x 7 x 1.4 inches
• Shipping Weight: 1.8 pounds (View shipping rates and policies)
• Average Customer Review: 3.5 out of 5 stars See all reviews (21 customer reviews)
• Amazon.com Sales Rank: #508,529 in Books (See Bestsellers in Books)

Customer Reviews

Most Helpful Customer Reviews

39 of 41 people found the following review helpful:

3.0 out of 5 stars Think twice about adding this to your cart!, February 26, 2002

By	Jeff Damukaitis (McKinney, TX USA) - See all my reviews

I purchased this book with the intent of broadening my knowledge of patterns after reading the GOF book (about 3 times), the Mark Grand series and Java Design Patterns [Cooper].

In one of his first examples Abstract Factory, a structure diagram is presented in canonical form; i.e. class a, class b, class c.... This didn't bother me except that his example code was a bit trivial and was not presented in terms of the structure diagrams. OK, I can read and figure things out, but if you are going to present the diagram and working examples, at least put the example code into the presented structure diagram, fair enough?

The next pattern that really bothered me was his implementation of Factory Method. He once again presents a generic structure diagram and does not present his own code in the same format.
The reason is that his sample code does not fit into the diagrams presented. This to me is a red flag! He does however provide explanations behind his implementation of the pattern. In the case of Factory Method his Contact class is both a concrete creator and concrete product. This I initially found confusing! I had to turn to the back of the book to figure out what he was trying to accomplish.

So in short several pattern start with a structure diagram and example code that doesn't fit into the presented diagram. I would remove the generic structure diagrams and provide ones in context of the examples. Make my job, as a reader, simple! Unless you have a way of reverse engineering the code, you're stuck with pen and paper.

I believe I have griped enough, here are some reasons to buy the book. He does present some nice explanations of the patterns, they are implemented in Java and it will help broaden your knowledge of design patterns.

Would this book be my first choice if I were shopping a design patterns book for Java? Answer: NO! There is a new book coming out "Design Patterns Java Workbook" by Steve Metsker that I have previewed. In my very humble opinion, the author has a much better understanding of design patterns and the examples are in the context of an entire application; which is actually very amusing to follow. In contrast, all of the examples are presented with precise UML diagrams in terms of the code snippets provided.

9 of 9 people found the following review helpful:

4.0 out of 5 stars GoF Patterns in Java, January 21, 2002

By	David Tatum - See all my reviews (REAL NAME)

UPDATE: If you're looking for a good (but not great) Java version of GoF Design Patterns, this is the best on the market. Some of the examples aren't very good, but other than that and the problems mentioned below, it isn't a bad book. I'll give 3.5 stars, and round up to 4. However, if you're looking for "applied Java patterns", look elsewhere. There's nothing "applied" about this book. I'm still looking for a book that delivers what this book promised. Sadly "Applied Java Patterns" would have been a great title for that book.

My previous reviews follow:

I still haven't finished reading the book, but I heard from one of the authors. He said they included the full source code of the examples because there wasn't a CD-ROM, and they wanted to keep the pattern section uncluttered. I still don't agree with the decision, but I'm upping my rating to 4 stars based on that explanation. Also, for what it's worth, here are the approximate page counts: GoF patterns - 200 pages; "System" patterns in chapter four - 70 pages; Patterns in the Java APIs of part two - 60 pages; Full code examples - 220 pages.

My original review follows:

I haven't finished reading this book, but I already know it gets at most 3 stars. I have 2 major problems with this book. First of all, the title and book cover description are misleading. The majority of the book is a rehash of the GoF patterns with examples written in Java. I expected examples of real-world Java systems implemented using patterns. Secondly, the last 200+ pages of the book are the complete code listings of the examples. I hate when publishers do this. I can't think of a reason to do this other than increasing the page count to justify a higher cover price. Especially when there are relevant code examples at the end of each pattern section. Why repeat these examples in the Appendix? Page count. Why include the extra, unrelated GUI code used by the examples? Page count.

13 of 15 people found the following review helpful:

4.0 out of 5 stars For Java programmers who need patterns, look no further, February 28, 2002

By	Michael Ernest "JavaRanch Sheriff" (San Rafael, CA) - See all my reviews (REAL NAME)

A number of my instructor colleagues have commented for years that someone should write a Java patterns book. None of us took up that challenge, obviously. Stephen and Olav did; their book finally brings to new and intermediate programmers a gentle but stimulating introduction to the subject. If your programs compile and run, but you have a feeling there are better, more sophisticated ways to compose Java, you're right: read this book and find out about them.

The patterns catalog in this book walks through the feature development of a Personal Information Management (PIM) program. Patterns are used to impose a general problem domain to each feature described (e.g., conference scheduling). The authors then show how the classic pattern might be modelled and implemented in Java. If you've never gone from a problem statement to a language-neutral design solution to code-writing before, this process can be slow going the first few times. The authors address this by separating features so you don't have to read the catalog in order.

There's no CD-ROM, so the source code is printed in full in the back of the book. Bad publisher, no biscuit. Just give me the CD, alright? Yes you can download the code by ftp, but my network life is controlled by firewall [people]. I need an HTTP tunnel, please.

I take the complaints that professional methodologists will have with this book with a grain of salt. This book was not written for their review and consensus; it's written for people who want to learn this subject and who allow the view that methodology is an art, not science and certainly not rooted in absolutes. That said, you may some day disagree with a design interpretation or two in this book, but you'll see them nonetheless applied thoughtfully to practical examples.

Another nice touch: the authors point out several examples in the JDK where these patterns have been applied, so if you want pointers to real-world examples using 'production' source code, there's no better place to look than the JDK. It's some of the most intensely scrutinized code ever.