Customer Reviews

Core J2EE Patterns: Best Practices and Design Strategies (2nd Edition)

5 star:		(37)
4 star:		(9)
3 star:		(0)
2 star:		(0)
1 star:		(1)

 

 

We software developers often get ourselves buried in learning new technologies, particularly in J2EE, there are so many things to learn, e.g., JSP, Servlet, JAAS, JSSE, JMS, JavaMail, EJB, JDBC, JDO, etc. just to name a few. With these overwhelming technologies, we often overlook the issue how to "design" "good" systems using these technologies. Knowing the technology itself is one thing, and knowing how to design with it well is another. Technologies are always advancing, it is really the design technique that is the essence or hard-core skill that a software developer should obtain.

Patterns, are such essences. They are best practices from experiences on how to design the systems/components at different levels. And Core J2EE Patterns are such collections in the J2EE context.

Even though the authors claim that these patterns are used under the J2EE context, I see most of them also application in a more general context. For example,

If a remote service is to be provided, it is good practice to use Session Facade (or Remote Facade), and it will provide service by delegating to the Application Service (or Service Layer) or Business Delegate.

To facilitate the client to access a remote service, Business Delegate can be applied to hide the remoteness, in which it will use Service Locator to look up the remote service. In this sense, Business Delegate also functions as a proxy of the remote service.

To decouple the Business Object from accessing the resources directly, Data Access Object is a good design to be applied.

To move the data between the tiers or processes, Data Transfer Object can be use.

If studying carefully, you will a lot of patterns and concepts can be applied to non-J2EE applications. And a lot of them can be traced back to the seminal work of GoF (Design Patterns). That is why I said the design skill should be essential to a developer, these techniques are correlated and inter-connected, and accumulated by experience. They are relatively stable (IMO), though the technologies are changing (rapidly).

The other good things about book, the authors not only document the best practices (patterns) of J2EE applications to learn, they also list a set of bad practices (anti-patterns) to avoid, in between, they provide a bridge, the refactoring, to go from bad to good.

Also, no pattern is an island. All patterns are related, and to form a bigger or higher level of pattern, and these higher level of patterns collaborate with each other and eventually form the whole architecture of the system, that is pattern oriented architecture. In last episode, the authors gave such an example, and they call it a micro architecture.

The authors also refer to the work of Martin Fowler's Patterns of Enterprise Application Architecture(which list patterns of more general enterprise application patterns besides J2EE) to clear out some gaps between the two books, e.g., Value Object in 1st edition really means Transfer Object, which is the same pattern listed as Data Transfer Object in Fowler's book. And Value Object is just another pattern in PEAA.

The writing style is very smooth, succinct and to the point. The pattern template is classic, with the authors chose strategies for implementation variations. The examples are probably excerpt from real projects, however, there are some errors in the code, which made me doubt that these codes were ever compiled. But, hey, it is the concept that is more important :-)

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.

There are two obvious changes between this second edition and the first edition of this book. First, some new patterns have been added mostly dealing with web services. Second, the book has been released as a hard cover book, presumably because the publisher expects this to last on your shelf as long as the original "Design Pattern" book. The new patterns dealing with web services are a welcome addition to the book although anyone who is interested in this subject will probably want more detail such as found in Paul Monday's book.

Part 1 is an introduction to design patterns and the J2EE platform followed by a catalog of design considerations, bad practices and refactorings. Developers working with poorly designed J2EE applications will find this section especially helpful.

Part 2 is the collection of the design patterns and strategies. Each pattern is described in the expected level of detail. The format will remind you of the GoF book. Since this has become the standard format for presenting design patterns this should not be a surprise. The patterns are well thought, explained clearly, and demonstrated with some good code samples. If you have the first edition you will be very impressed with the improvements made in this new edition. It appears that virtually every pattern has been reworked to make the pattern easier to understand and use.

This is the book that every J2EE architect and programmer should have on their desk. Using the strategies in this book will make your applications more robust, make you more productive, and make your code easier to understand and maintain. Anyone designing, architecting, or coding with J2EE will find this book to be extremely useful.

The 2nd edition of the J2EE development bible, Core J2EE Patterns: Best Practices and Design Strategies is out and the authors do not disappoint. I had given the first edition of this book 5 stars as the authors of the book had taken lessons learned from their experiences in developing and deploying J2EE applications and distilled all that knowledge into fifteen different design patterns.

Even if you own the first edition, I would recommend you get the 2nd edition as original 15 patterns have been completely revised and updated, including new implementation strategies and updates relating to the changes in the J2EE specification. J2EE application development is a fairly complex process and just knowing the API does not enable you to write good software. Most people spent several years writing software and learn good design techniques with experience based on what's worked in the past and what hasn't worked.

Another reason to buy this book is the whole Refactoring section. The authors take Martin Fowler's refactoring idea to the next level and bring it in the J2EE arena. I feel the price of the book is worth it, just for that section.

In addition to the 15 patterns, the authors introduce 6 design patterns to the J2EE pattern catalog...The new patterns include Context Object and Application Controller for the Presentation tier, Application Service and Business Object for the Business Tier and Domain Store and Web Service Broker for the Integration Tier.

I highly recommend this book to anyone doing any J2EE development. This book is very easy and light read and it really belongs in your library. I bet anyone that reads even parts of this book will end up writing better, more manageable code that's cleaner, modular, reusable, and loosely coupled. As Martin Fowler says in the foreword, 'Don't build an enterprise bean without it (this book)'. Can Martin Fowler be wrong? :-)

If you are looking for a 'cookbook' type book that overwhelms you with 200 pages of Java code, this is not it. Instead if you want to learn how to architect simple, flexible and easy to maintain systems, you need to buy and read this book.

Wow! This book will become a classic like the GoF book. I agree with the other reviewer.
I had the first edition of this book which I bought with great interest at that time. I did learn quite a few things even though I consider myself a seasoned J2EE developer. I made sure that all my development team members got a copy of this book.
When I saw that the second edition was released, I was skeptical about buying it since I had the first edition. However, after browsing through the contents and reading other reviews, I decided to go for it. And it was a decision I am not regretting. The new edition is so much better in that I wish this was the first edition! The authors seem to have updated all the patterns content. A quick comparison of the patterns between both editions indicates that the content has been more or less revised completely. Almost all the text has been revised and almost all the UML diagrams seem redone to give a better understanding of the pattern. I found the first edition UML diagrams a bit lame compared to the second edition. The new edition seems to have corrected most of the discrepencies in the first edition. So if you have the first edition, dump it and get this one fast!
I also found that there were 6 new patterns in the 2nd edition. The presentation tier added Context Object pattern and Application Controller pattern, Business tier added Business Object pattern and Application Service pattern. The integration tier added Webservice Broker pattern and Domain Store pattern.
Having built a couple of custom persistence frameworks, I found the Domain Store interesting.
One thing lacking in this edition is that the other interesting part of the book (Design considerations, Bad Practices and J2EE Refactoring) remains almost the same as in the first edition with minor exceptions. I would have liked to see the design considerations expanded. I also would have liked to have more J2EE refactorings and bad practices in the 2nd edition. Perhaps, in the next edition?
Another intriguiging part of the book which I haven't gained a good understanding of yet is the Epilogue titled "WebWorker Micro-Architecture".

Overall, if you are into J2EE, just get the book no matter what. It is a must have & must read!

This was the bible I used for a project, I loved the ideas and I named the classes after the names in this book.

However, 3 years later, after reviewing this book, I would say, many ideas in the book are already outdated and over emphasized in the past. Just remember the good old days when EJB was glorious and almost every company went for it.

After the EJB rush, now when we are back to basic, we realized that many Plain Old Design Patterns are real gold. I would suggest you don't rely heavily on J2EE, focus on domain design instead.

Many books provide this advice on domain driven development, such as Design Patterns, Refactoring, Domain Driven Design.

After you read those books, then read this book again. You will agree with this review.

http://www.amazon.com/Books-for-Professional-Java-Developers/lm/R34SZ976NXXD22/ref=cm_lm_byauthor_title_full/104-7074534-4633550

Summary:

This is a must have book for any J2EE developer or architect, even if you already own the first edition it is well worth the $ to get this 2nd edition. The patterns documented in the book are the vocabulary of J2EE development.

Content:

The first 100 pages or so is dedicated to educating the reader on various design practices for each of the tiers as well as cross tier considerations. The authors also cover what not to do in the 'bad practices' sections of each chapter. This is especially useful to developers new to J2EE since it will help them to see what others (me included) have done wrong in the past and why it does not work. The end of this section is concluded with a great set of refactorings to make your applications that are stuck in the bad design practices better. While I wish that some of the refactorings were a bit more detailed over all I really liked this chapter as well.

The next section is on the actual patterns and they too are divided up into tiers. I especially like the J2EE Pattern Roadmap in Chapter 5, it gives a nice over view of how everything fits together. The rest of the section covers the patterns in detail. All the classics are there as well as several new ones that are sure to become as much a part of our vocabulary as Session Facade is now.

Finally the future of pattern work is partially revealed in the form of 'Micro-Architectures'. The Web Worker M-A is sort of a pattern for using patterns. Or in other words it provides specific guidance on how to put the patterns in the book together to achieve the specific goal of integrating work-flow into your J2EE application. I'm looking forward to hearing more about this topic from the authors in the future.

Physically:

The book is much better than the first edition. With a hard back it will last a lot longer through the many, many sessions you will have with this book.

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.

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

Overall Rating: Well done! This book will be a valuable teaching and reference tool.
Teaching Value: Excellent! An essential book on this topic.
Reference Value: A complete reference. I would not need any additional reference on this topic.

The primary focus of the book is on patterns, best practices, design strategies, and proven solutions using the key J2EE technologies including Java Server Pages (JSP), Servlets, Enterprise JavaBeans (EJB) and Java Message Service (JMS) APIs. Written from a programmer's perspective with extensive codes and fully illustrated with UML diagrams.

The book is fully revised and newly documented patterns providing proven solutions for enterprise applications. Material is presented in a logical progression so you can learn at your own pace. And yet there is depth in the book to make this a valuable resource for any professional who knows J2EE and wants to use J2EE to build web services.

The author did a great job describing useful patterns for application architecture and design strategies for the presentation tier, business tier, and integration tier. The section on refactoring is worth reading. This book unites the platform's many technologies and APIs and provides insightful answers to whys, when and hows of the J2EE.