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

Amazon.com® Reader Reviews (Ranked by Helpfulness)

Average Amazon.com® Rating:  Based on 52 Ratings

Acceptable, but could have been much better - 2003-06-09
Reviewer Rating:
I've been programming in Java for a number of years, including J2EE development, and saw this book as a great opportunity for me to learn more about design patterns in J2EE. The great reviews about this book pretty much sold me on it. After reading the book, I have mixed feelings and would probably only recommend parts of it.

THE GOOD: The authors emumerate many design patterns and describe how they are related. In particular, there is one great picture that shows how all of the patterns can work together. Just knowing what the patterns are, capsule summaries of each, and how they interrelate is pretty worthwhile. On rare occasion, an example is useful because the applicability of the pattern is clear enough - even without an example.

THE BAD: The examples need a lot of work. A couple of other reviewers has also spotted this and I join them in this critique. The authors would do much better if they started the book with a one or two larger, more complete examples (say, a banking application or a bookstore application) and then relate the patterns to the implementations of those applications. Without good examples, the patterns lose credibility.

Another general point: because the content is light, much of what I gleaned from the book was "decouple as much as possible, up to a reasonable granularity". This came accross most prominently in the refactoring parts of the book. This is not new information and I would suggest that for the next edition, the authors just come out and say this and then start showing examples of where decoupling and replication of components makes the most sense.

*THE* guide to applying patterns in J2EE projects - 2003-04-02
Reviewer Rating:
this book is very well-written and loaded with practical advice. excellent design patterns are illustrated thru concise and relevant examples. one of the virtues of programmers is laziness. reading this book and applying the design pattern solutions can save us a lot of work in head-starting an architecture for a project. think in high-level design patterns instead of low-level details of finding the right data and methods, your life will be better off!

Great Design Book, Finally! - 2003-04-02
Reviewer Rating:
I just bought this book and think it is great! Before, I wrote this review I read an earlier review which talked about the examples being light. I really liked the samples. While I would have liked to see more, I thought they were really helpful.

I have been waiting for a J2EE design book for quite a while and was happy to see this one. I primarily work on EJB and found session facade and business delagete very helpful.

This is a great book to help with EJB design.

The best book ever - 2003-07-10
Reviewer Rating:
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.

Great design solutions for J2EE - soon to be a classic - 2006-07-14
Reviewer Rating:
This is a really great book of design and architecture best practices as they apply to J2EE. It contains the solution to many common Java design problems.

It's really nice to have these solutions all in one place with great documentation
- why you need it (e.g. reduce maintenance, separate model from view etc.)
- what problem does it solve
- how to implement it and
- Design and architecture consequences of your choices.

These patterns cut across data, middle and presentation tiers.

It's a MUST-read for Java developers who have been senior developers for a while and/or are making the leap to principal developer / technical lead. Architects too, if they don't already know these patterns, will find a lot of value.

Very much worth reading for those taking SCWCD or SCEA exams.

Browse Similar Topics

Top Level Categories:
Programming
Software Engineering

Sub-Categories:
Programming > Java
Java > J2EE
Software Engineering > Design Patterns