Customer Reviews

EJB Design Patterns: Advanced Patterns, Processes, and Idioms

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

 

 

I have already read a lot of books about best practices regarding
J2EE and EJB development. In my opinion EJB Design Patterns from
Floyd Marinescu is one of the best references for EJB Design Patterns
which covers all important topics about Pattern-Driven EJB development.

Floyd is Principal at "The MIDDLEWARE Company" and one of the founders
of TheServerSide, the reference Portal for the J2EE community.

The book involves standard patterns like the Session Facade and
DTO (Data Transfer Objects) as well as extensions like a pattern
for asynchronous communication (Message Facade) between a client
application and the service layer in the middle tier.

The layered EJB architecture which includes the application, service,
domain, and persistence layer are discussed in detail. Useful hints
for the EJB development process and system design complete the book.
The book is a good choice for EJB developers and enterprise
architects.

One of the big advantages of the book are the chapters "From
requirements to Pattern-Driven Design" and "EJB development with
Jakarta Ant and unit testing with JUnit" which are dealing with
the solution of real world problems.

The chapter about Entity Beans vs. Java Data Objects (JDO) is a
must for every domain developer.

Floyd's book is well written and easy to understand for experienced
developers and architects. The Java source code examples of the book
are well documented and useful, if one desires a complete impression
of EJB development.

To be honest, the book is one of the favourites in my bookshelf and
I consult it whenever possible to learn more about that important
technology.

The book also includes a nice poster that shows the EJB Design
Patterns and an additional text to avoid pit falls. It's nice to
stand in front of this poster and think about that great server
side Java technology.

First thing first, I'll come to the review of this book but before that some advice for you... if you are a J2EE architect/developer you'd need to use the contents of this book time and again, but this book is so badly organized and fluffy one can hardly survive the frustration of reading it twice, so make notes the first time you take the pain of going thru this book... following are mine
- the importance of DTOs have come down following EJB2.0 release
- reduce network chattiness, consider following options
-- Session facade: remember not to create a God class, group relevant functions together in each Facade
-- Consider message facade for asynchronous processing of requests where an immediate response is not required
-- consider Command pattern only for prototyping
-- use HashMaps or Value objects for transferring Entity EJB data over indiv get/set methods
-- use LocalHomes for Session Bean to Entity Bean comm
- create a business interface, a superinterface which both the remote and the Bean itself can implement
- strongly recommend RowSet (JDBC 2.0 optional/JDBC 3.0 core) for tabular data transfer
- depending on requirement, strike a balance between Domain Data Objects (Entity EJB data copies) and custom data objects (what the customer wants to see in one shot), remember to make Custom DOs read only
- consider Fast Lane Reader pattern, pretty neat... Consider JDBC for Reading pattern for read-only data
- Dual Persistent Entity Beans, toggle between BMP/CMP EJB by modifying the deployment descriptors
- skip Chapter 4, use 'Service Locator' pattern with caching option for locating and caching EJB homes
- need to generate primary keys, mostly use UUID generation technique discussed in case database's sequences are not enough
- Part 2 of the book is mostly fluff, it discusses everything but 'Best Practices for EJB design and Implementation', which coincidentally is the heading for part 2
- using ANT and jUnit, you call them best practice? No, they are standard practices
- model domain/persistence/services/clients in that order
- in discussing alternatives to Entity EJBs author laudes JDOs too much, I suggest you check out the 'Hibernate' project, looks more intuitive than JDO (to me)
- Chapter 9 (EJB design Strategies, Idioms and Tips) is actually pretty good, probably because this is the only chapter that's not fluffy, thank you Floyd
-- don't use Composite Entity Bean Pattern, good suggestion Floyd
-- field validation on Entity beans? Use (define and implement) get/set-XXXfield methods since you can't implement the get/set-XXX methods
-- prefer scheduled updates to real-time computations
-- Message Beans - use serialized classes to enable type checking
-- call setRollbackOnly and NOT Rollback, when App exceptions occur
-- limit parameters for EJB create, don't pass DTOs
-- don't use XML as a DTO mechanism, good eye-opener for XML fans

Okay, now the review comes...

Many of us J2EE developers and architects alike encounter a large decision tree while architecting/modeling enterprise-class systems with the help of EJBs, it becomes very difficult to weigh all the options available and all the customized treatment of EJBs on different J2EE containers over and above the minimum req or what's provided in SUN's reference implementation, most of us recognize a need for performance improvement in this area and a need to recognize the best practices or patterns to be used to help solve the frequent and recurring problems. For this very reason this book 'could have' been such an invaluable asset to the J2EE community, but alas this should have remained a bulky chapter in Ed Roman's 'Mastering EJB (2nd Edition)' book, the content has been fluffed beyond repair in this book and that's the last thing one needs in a patterns book, keep it short and organized.

The Author has not found a way to organize the pattern contents in a logical manner, due to this most of the chapters look like one loooooong paragraph each, organize. Author defines and talks about patterns and antipatterns in the same tone. The code examples I gather would be helpful for beginners.

All in all, this book contains a lot of content I would not advise people to miss, but the book is not worth buying, download and read it from the website, theServerside.

In addition, I suggest
- J2EE Design patterns: Deepak Alur et al
- Design Patterns: Eric gamma et al... read it only if you are a pattern gung-ho

I think it is a nice book.
Hornestly speaking, the patterns in this books are hardly original. For those who read Core J2EE Patterns, you may found this book like another query for the same set of the data.
What makes this book a good book is:
1)For each patterns, it honestly list pros and cons, which may or may not have been in your mind. It helps you to considerate the problem more objectively and more deeply.
2)Not like some fundamentalists, the author also honestly analyze the EJB technologies with a balanced view. Give you the pros and cons, leave you the space to make a decision.
3)It does provide a pretty long list of patterns you may want to know with EJB development. And like what the author said, many of these ideas are not limited to EJB, so if you can understand the terminologies in EJB's world, it is a good reference book for system designers.

What could have make you dissapointed with this book is:
1)Like I said, patterns in this book are hardly original. You can find most of them from Core J2EE paterns or Matering EJB 2nd and this book published months after them. The author also honestly list links after each patterns. If you have read those books first, you may feel a little dissappointed.
2)Like many other EJB GURUs, the author did not give readers informations on the problems people will face when they apply the EJB technologies to a complicated business system. The hands on experience the book based seems to come from a online forum ... which originally has only one seesion bean and lately revised to be a couple more as the author mentioned. However, what most EJB developers found in their real world development is that they have to face much more complicated system.
Anyway, like reading many other book. You can learn a lot, but you still have to keep your mind open. The best pratice is not something officially define by this or that company, but the one which solve your problems.

The author of "EJB Design Patterns" acknowledges that EJB is a work in progress and this makes a lot of difference. In fact, it's only by approaching the subject as a volatile one that the author can often talk about issues related to previous EJB specifications and how they are addressed by the current one. Likewise, alternative proposals to solutions offered by the current specification are also discussed. Readers are invited to keep their minds open as the EJB specification, currently in version 2.0, is not mature enough.

Just to give a couple of examples, Chapter 9 brings to the reader's attention the fact that a pattern broadly applied in EJB 1.x days, known as "Composite/ Aggregate Entity Bean", is no longer appropriate under EJB 2.0. Chapter 8, on the other hand, discusses a number of alternatives to entity beans, by far the most controversial aspect of the EJB specification. Since one of them is a competing technology from Sun Microsystems itself, there's a chance it will blend with or even replace entity beans in the future.

Such an approach highlights the mutable nature of the EJB specification and helps the reader focus on what is really important: the concepts, strategies and patterns behind EJB. After all, learning how to design distributed applications is more valuable than just knowing how EJBs are built today. Tomorrow, there will be a different way, but software engineers will still be developing distributed applications.

That's true, some patterns, like "JDBC for Reading", are actually workarounds to EJB performance issues. There are also those designed to handle open conceptual issues related to the EJB specification, like "Business Interface". There are patterns, however, which stand as proven variants of the classical GoF patterns, like "Session Facade".

Overall, "EJB Design Patterns" manages to teach how to work with an ever-changing technology while exposing the reader to concepts which will outlive that technology as we know it.

In EJB Design Patterns Marinescu pulls together an exceptional toolkit for J2EE developers. The design patterns are clean and concisely described. His idioms and architectural ideas make sense.

Beyond the patterns and architectural content, Marinescu provides excellent Ant and JUnit examples and tips--something decidedly lacking in most J2EE development books. He has succeeded in building a book that should be valuable to any team developing EJBs. This is the book I've been looking for to give to EJB developers to start them off on the right course.

I would also like to applaud Marinescu and The Middleware Company for their public review process on theServerSide.com. The feedback from theServerSide.com community made an already exceptional book even better.

Ed Roman's Mastering EJB has been my Bible on EJB, and now Marinescu is going on the shelf right next to Roman. The book goes beyond Roman to cover a bunch of difficult programming problems, more than any other book I've run across. No EJB library would be complete without it.

For those that are just getting a handle on EJB technology and would like to avoid the common pitfalls when design EJB enterprise applications, this book is must read. Knowing the the classes of EJB and how to extend and deploy them is not enough - knowing how they all work in a multi-tiered architecture that advocates maintainability as well as performance in a balanced way is the true challange. This book will provide you will all the knowledge you need when design your J2EE applications.

For those that already have a handle on J2EE and have used it for some time, this book offers an excellent catalog of design patterns and perhaps you'll learn a few new ones too. The Strategies on the development process when working with EJB are also great for newcomers that would like to know the best practices to avoid making too mistakes with this technology.

Great book and concrats to the author making it compact, easy to read and full of wonderful information from beginning to end. Excellent!

I saw that this book was developed on the author's ServerSide.com site with a lot of input from other developers, and it shows. And Marinescu gives you the code, which made it a lot easier to implement the solutions. Definitely five stars, and thanks!

This book along with the Mastering Enterprise JavasBeans 2nd Edition book by Ed Roman should form the core of every J2EE bookshelf. Roman and Marinescu are the principals of The Middleware Company. They run the theServerSide.com which is merely the best website on J2EE, EJB particularly.

Where does this book depart from the crowd of EJB books? Real-world expertise. Marinescu tells you what the best-practices are for EJB and why. He even tells you what the viable alternatives are. He devotes an entire chapter to alternatives to using Entity EJB beans (basically JDO) which has to be a first for an EJB book!

Another thing which pleasantly surprises is that this is in no way a rehash of the GOF 'Design Patterns' series. I'm not sneering at this kind of book (Applied Java Patterns is a favorite), but these are fresh patterns very much tailored to EJB experience.

I'll buy a book if a single chapter adds to my understanding of something important. But I will be reading and re-reading every single word of this one.

Just finished reading the PDF version of Floyd Marinescu's book... and can only say how enormously I enjoyed reading it. It is definitely a must-read and even must-have for anyone working in the J2EE field!

What sets it off is not only the clear style used to present the patterns in Part One, but also the excellent Part Two on Best Practices for EJB Design and Implementation, which not only shows how to use the patterns in real projects but also how important it is to set up a proper development environment using tools such as Ant and JUnit.