- Release Date: 19 February, 2002
- Collectible Price: $35.00
- Used Price: $15.50
- Availability: Usually ships within 24 hours
- Third Party Used Price: $16.69
Author: Floyd Marinescu
Customer Rating: 4.54 of 5 (37 total reviews)
- One of my favourites...
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
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
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.
- Excellent Beginner Reference
A catalog of problem-solution patterns that pertain to J2EE. A great reference for beginners, instructing in some of the do's and don'ts of J2EE development. Much of the material presented has appeared on the Server Side, or in the J2EE core patterns from Sun, but this book presents the material in a concise easy to read format.
General Topics include:
1. use of data transfer objects (DTOs)
2. architecture mechanisms to help promote team development
3. transaction and persistance patterns
4. key generation
5. code interaction patterns to help allevite performance bottlenecks.
6. multi-tier architectures and how to optimize them.
There is also a short chapter on using JUnit and Ant to automate your environment, but they are so brief they really serve as more of a sales point to investigate these technologies rather than giving any real info on how to use them.
Probably the most useful chapter was the last one which covered a number of tips and tricks to make EJB development easier.
All in all as a beginner I got a lot of useful information out of this book. A seasoned developer will probably find a few things of interest, but will likely already know much of the material from the J2EE core patterns and personal experience.
- A book to be polished, condensed, extinguished...
Honestly, the book is not a bad book, it presents an interesting yet hard topic, how to design EJB (or in a broader sense, J2EE application) using design patterns. However, this book has a large intersection with Core J2EE Patterns, which not only includes more patterns (on all layers), but also is written in a more clear and comprehensive way.
Except the patterns presented in both books, (Session Facade, Data Transfer Object(DTO), DTO Factory(Assembler), EJBHomeFactory(Service Locator), Business Delegate...) the author introduced,
"EJB Command" pattern, which in practice(IMO), has limited usage in server side enterprise application, since it distributes the business logic to command objects (usually the client) and thus will cause business rules duplication and more importantly, harder to change the rules later since its distribution;
"Generic Attribute Access and Data Transfer Hashmap" pattern, which is nothing but using map to transfer data. This again will suffer in distributed applications, since both clients and server have to agree on map key protocol and it is harder to add/change the keys later;
"Data Access Command" pattern, which derives from both command and data access object(DAO, presented in Core), not only will this pattern suffer the cons of command pattern usage in enterprise distributed application, but also potential complexity in command processing to make sure dead-lock situations, data integrity, and may end up with a lot of small customized command classes.
Even though the author mentioned the cons of these patterns clearly, I think the risk outweighs the benefit in an entry-mid level enterprise application design book which tries to teach designers how make a good design.
A few good things that were missed out by Core J2EE patterns are "Business Interface", "Version Number", "Dual Persistent Entity Bean", "Primary Key Generation". But these can be find somewhere else, particularly, "Version Number" and "Primary Key Generation" are more in the database/tranaction domain than EJB domain.
Chapter6 "From Requirements to Pattern-Driven Design" is supposed to be a case study, but is presented in a vague and not derived way to step through, it also lacks the normal iterative/refactoring design style, if everything is straightforward and in place to make a perfect design decision, then I would think the example would not be real. Though, I do like the author's layering style definition from Presentation, Application, Services, Domain, to Persistence.
Chaper7 is about development, building, testing, deployment process, it is totally irrelevant to the design pattern topic, and too short to be useful, and there are a lot of good books (instead of only one chapter) in the book store.
Chapter8 is about JDO, again, a single chapter would not make readers' day.
Chapter9 is good, it is about idioms, good practices vs. pitfalls in J2EE application design. However, the list is too short and does not provide how to refactor the bad design to good one compared with Core J2EE Patterns.
Overall, there are limited useful contents presented in this book, and I had feeling that a lot of stuff (unrelated) were stuffed in just to fill up the space to make it a decent-sized book. I would recommend Core J2EE Patterns over this one if you are interested in J2EE application using design patterns. Only one of these two books will stand last...