Order from a Major Online Bookstore
Ultimate Book Price Comparison Engine
Save Your Time And Money
| AnyBook4Less.com | Order from a Major Online Bookstore |
|
| Home | Store List | FAQ | Contact Us | | ||
| Ultimate Book Price Comparison Engine Save Your Time And Money |
||
 |
Title: EJB Design Patterns: Advanced Patterns, Processes, and Idioms by Floyd Marinescu ISBN: 0-471-20831-0 Publisher: John Wiley & Sons Pub. Date: 19 February, 2002 Format: Paperback Volumes: 1 List Price(USD): $35.00 |
Average Customer Rating: 4.54 (37 reviews)
Rating: 3
Summary: A book to be polished, condensed, extinguished...
Comment: 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...
Rating: 5
Summary: My favorite technical book at the moment
Comment: The book is excellent. Gives you a very good insight not only on the role of EJBs in the modern J2EE architecture but the J2EE architecture itself. Terse but interesting and comprehensive.
I believe every J2EE programmer of a mid to senior level has to read it and understand the Chapter 6, which is kind of a recap of the book. I wish I worked in a team where every developer has read this book - it would be so much easier to communicate and build a well designed enterprise application.
I enjoyed this book better than "Bitter EJBs", although the latter is quite useful too. Now it is time to go for "Core J2EE patterns".
Rating: 3
Summary: unfortunate treatment of a relevant and interesting topic
Comment: 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
 |
Title: Mastering Enterprise JavaBeans (2nd Edition) by Ed Roman, Scott W. Ambler, Tyler Jewell ISBN: 0471417114 Publisher: John Wiley & Sons Pub. Date: 14 December, 2001 List Price(USD): $45.00 |
 |
Title: Core J2EE Patterns: Best Practices and Design Strategies, Second Edition by Deepak Alur, Dan Malks, John Crupi ISBN: 0131422464 Publisher: Prentice Hall PTR Pub. Date: 10 June, 2003 List Price(USD): $49.99 |
 |
Title: Core J2EE Patterns: Best Practices and Design Strategies by Deepak Alur, John Crupi, Dan Malks ISBN: 0130648841 Publisher: Prentice Hall PTR Pub. Date: 26 June, 2001 List Price(USD): $44.99 |
 |
Title: Expert One-on-One J2EE Design and Development by Rod Johnson ISBN: 0764543857 Publisher: Wrox Pub. Date: 23 October, 2002 List Price(USD): $59.99 |
 |
Title: Programming Jakarta Struts by Chuck Cavaness ISBN: 0596003285 Publisher: O'Reilly & Associates Pub. Date: 13 November, 2002 List Price(USD): $39.95 |
Thank you for visiting www.AnyBook4Less.com and enjoy your savings!
Copyright� 2001-2021 Send your comments
