Customer Reviews

Real World Java EE Patterns Rethinking Best Practices

5 star:		(6)
4 star:		(2)
3 star:		(1)
2 star:		(2)
1 star:		(0)

 

 

This book is a must read for anyone wishing to master the principles of a Java EE 5 architecture, and develop clean, terse and efficient code using EJB 3 and other modern, annotation-based Java EE specifications.

Many of the things (patterns and best practices) you learned about J2EE, the previous version of the Java EE specification, are now no longer relevant, and Adam's book will help you quickly get up to speed with the new best practices. For those who need to integrate or maintain legacy code bases, there is even a chapter about "EJB 2 Integration and Migration".

This is the book I wish we had when we started developing the Nuxeo 5 open source ECM platform 3 1/2 years ago, on top of the then brand new Java EE 5 platform. It would have saved us many hours of refinement of the initial prototype.

S. Fermigier, founder and chairman, Nuxeo.
[...]

While designing code and architecture you often encounter situations where it would be nice to know how someone else would do it, or "the right way" to do it. That is exactly the kind of gold you will find in this book from start to finish. Make sure to take notes while reading because you won't remember it all. I made about a dozen pages of hand written notes.

It was amusing to see Spring and Guice referred to as legacy technologies now that Java EE 6 has arrived. I think this was mentioned only twice. This book is still very useful to Spring (and maybe Guice) developers since the programming model is practically the same as Java EE 6, and it is a book on design patterns.

This book is self published, and you can tell. There are some spelling mistakes, awkward grammar (the author is German), formatting issues, etc. The book was edited, but probably not by a technical person, so they left some things as-is because they didn't understand it. Since I found this book so helpful, these issues didn't really bother me. I just wish I would have highlighted each issue while reading so that I could mail it back to the author and have him send me a second edition for free.

In courtesy of Pawel Stawicki:
"Real World Java EE Patterns" is a book targeted rather for developers with some experience with JEE. If you are a beginner, you can miss some context. If you have some experience with JEE, in this book you'll probably find solutions to problems that are familiar to you.

Adam Bien is great at explaining difficult topics. Difficult? I didn't find anything difficult in this book ;) E.g. transactions isolation is explained very clearly.

The book is very good catalog of JEE Patterns. Each pattern is described separately in similar manner. Each chapter has subchapters: "Problem", "Forces", "Solution", "Testing", "Documentation", "Consequences" and "Related Patterns". In "Problem" a reader can find short description of a problem the pattern should solve. "Forces" shows features that solution should have. "Solution" contains description of pattern, what classes it consists of and what is their responsibility. Usually accompanied by very clear and simple pieces of code. In "Testing" and "Documentation" author highlights what should we test when we use certain pattern, and what should be documented (quite obvious, isn't it?). In "Consequences" we can read about what are pros and cons of the pattern. "Related Patterns" is self explanatory. Most interesting subchapter is "Solution", and it also has sub-subchapters. One of them is "Rethinking". It is good part for experienced JEE developers. Adam shows why some patterns are obsolete. It doesn't mean you should never use it, but in most cases it is no longer necessary in JEE5 or 6. Some patterns, when moved from EJB2 to EJB3, are not adding any value, but instead are adding layer of abstraction and unnecessary complicating the system.

What I like about Adam Bien is that he is not only writing and talking about programming, but he's also programming. While reading the book, one can feel that the author has real experience with the topic. Sometimes he advices not to use what is common "best practice", when it is not necessary and is not adding any value. Good programmer should be able to balance pros and cons of possible solutions, not just blindly follow common practice.

There are small mistakes in the book, but only editor ones, like misspellings and formatting mistakes, single lines of code on next/previous page etc. Nothing really annoying, but there is room for improvement on this field.

Thank you Adam for this book!

This book has some very good content but I found it almost unreadable due to the extremely poor formatting of thee Kindle edition. A cleanup of the text would make this a good purchase but I cannot recommend it in the present form.

This issue with Kindle formatting is jarring. No table of contents, no chapters, no index, not even a new page to delineate a new topic/chapter. Code formatting (at least on kindle cloud) is not indented.

Kindle edition cannot be recommended.

This book does contain insightful analysis of Java EE patterns, but the writing is humorless, clunky, and at times ungrammatical. The author is not a native English-speaker and this shows up in convoluted yet not illogical sentence structures. I'm surprised such an unreadable text has received so many completely positive reviews, but I guess the content makes it worth struggling with the language and grim tone.

Well,

Definitely I recommend this book for all your projects. If you are a beginner in Java, expert web component developer or ejb architect this book is for you. The analysis between Java 2, EE 5 and 6 is really straightforward, deep, and the possibilities to apply these new concepts are true.

I have developed some enterprise projects using the patterns: Bean Locator, Singleton, Service Facade, Session Facade and so on. Also in internet exist a good documentation and code samples using this new approach.

This is a good book for your enterprise projects!!!

I like it when I get the feeling while reading a book that the author actually knows what he is writing about. This is not the case with all books but with Adam Bien's book about JEE Patterns I am absolutely convinced that he knows his stuff.

With the painful J2EE 1.4 a Java developer had to use many, many patterns to make it usable - a sure sign that J2EE 1.4 was not a good solution.
With JEE 5 and even more with JEE 6 many of those patterns are no longer necessary - and Ruby developers now longer can say that Java only works after using at least 15 patterns.

In this book Adam explains which patterns are obsolete and which are still useful. The writing is clear and easy to follow. The code is easy to understand and also available online.

It was so much fun reading the book that I even put away The Golden Eagle (Poyser Monographs) for a while (which is my favourite book of 2010 - although on a completely different subject).
I learned a lot about how to effectively use JEE 5/6.

The author knows how to write and how to explain stuff and I hope he will write more books about JEE (a book in CDI would be great).

A very good book - well written ( though some places required me to read it a couple of times to get the point ) and the text is to the point in terms of describing the patterns.

Author clearly has done a lot of projects with J2EE5 and Java 6 and knows what he is talking about. It seems all that the author has written down is from his practical experiences with projects in the real landscape.

Some novel techniques and patterns have also been shown towards the end of the book - which are quite invaluable

I was looking for Pattern changes in JEE 5 all over the places and finally found this book.
It really helped me to understand JEE 5 better.
For example pattern which are retired and new pattern are helping to design apps based JEE 5.
I recommend this book for people who are preparing for Sun Certified Enterprise Architect (SCEA) Part 2