Customer Reviews

Beginning POJOs: Lightweight Java Web Development Using Plain Old Java Objects in Spring, Hibernate, and Tapestry (Novice to Professional)

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

 

 

Missourians -- residents of the "Show Me State" -- are sure to appreciate this unusual book on lightweight Java development with "Plain Old Java Objects." In a fast-paced 10 chapters, Brian Sam-Bodden builds a single complete application, all the way through. Believe it or else, he starts with a detailed design, then talks about fundamental tools like Eclipse and Ant, and before you know it he's implemented the persistence and business tiers. Screenshots and detailed instructions will help you get your environment installed and set up in no time.

The first five chapters of the book are astonishingly linear as the application is developed to this point, with each technology choice presented as a fait accompli. In this day of political correctness and cultural relativism, many authors bend over backwards to consider all the alternatives to every decision they make, and I felt that Sam-Bodden's approach was incredibly refreshing. Eclipse, Ant, Hibernate, EJB3 on JBoss. Take it or leave it.

I was therefore almost disappointed when, in Chapters 6 and 7, he considers several different alternative implementations of the business and presentation tiers. Still, showing how to use Tapestry and especially Spring offsets the raised eyebrows some of you might have on hearing that a book on POJOs was advocating using EJBs -- even though the radically reworked EJB3 specification does indeed let you use Plain Old Java Objects to implement the business layer.

From this point, the book gets more conventional, with the traditional tacked-on chapter about testing that nevertheless asks you to do testing as an integral part of development.

Although some of the technology choices and development approaches may stretch your personal definition of the term "lightweight," this is still the best book on end-to-end development of modern enterprise applications that I've seen. If you have a hint of the Missourian in you, and you'd like someone to show you how things are done, this book was written with you in mind.

This book seems to be a step backwards rather than a step forward. I may be a bit biased, since I feel that Object Oriented programming is much more beneficial than procedural, but this book harps on exposing all your "objects" (and I use this term lightly here) in order to utilize the frameworks. The book gave little hints as to why you would use some of these frameworks, but i'm hoping that a re-read may enlighten me (hibernate and tapestry I can understand, but the others are unclear to me in regards to his problem domain).

Regarding design and research, this book begins strongly by stating it should be done, and then skips it entirely. It then dives straight into utilizing hibernate, which is a good product if used properly, and then forces you to create data containers with access to all your data. From here you can get a feel as to the next few chapters and their structures; pushing data here, pushing data there.

In the end, I wondered if the book was at all useful in my persuit in finding a better way in working with J2EE-ish frameworks and an alternate solution to its heavy-ness, and in doing so offering an OO solution. This book failed miserably in doing so. I get the idea of JBoss being a lightweight solution, but he states that lightweight is about your coding style and the amount of work needing to be done. His project is grossly complex and would thus require a nightmare of work in maintenance as well as re-engineering when the time came (which it almost always will, especially when developing web based services).

It's possible that I'm alone in this view, but it seems that many developers think that the more advanced frameworks they pull together into a single project the better it becomes. In such, the frameworks used gauges the success of you project. It's about how good the product is and how easily it can be maintained, not by the number of frameworks you can integrate.

In the end, the book enlightened me to other frameworks, and possible ways of NOT using them. The author may have many years of experience, but I feel that this book brings a false hope in building better web-based applications, especially in regard to ongoing maintenance.

I like the style of the book but I found myself having to play around with code to get the examples to work. They seemed to work about 25% of the time without major tweaking. Maybe it is just me but this book needs a newer edition pronto. I'd look elsewhere for more up to date information.

I am a student just leave college for company in China,in my company, Hibernate+Spring+Tapestry are used,the best thing for me is being familiar with the framework soon.Then I found this book 'Beginning POJOS''Which is helpful for me.I am enjoying reading it,and I can do my job now.
Thank you Brian!Great job!

The book begins with a clear overview of software architecture, leading the reader to the vision of building enterprise web apps with ease.
Later chapters delve into details about JBoss, Spring, Tapestry, Hibernate, and Testing. The JBoss chapter contains many many many listings and configuration snippets. I asked myself: If it is that complicated building enterprise web apps, why write positively about it in a book?
There is no comparison between the frameworks discussed. Maybe a short paragraph for Spring vs. Tapestry.
There is no closing chapter nor is there a closing paragraphs at the end of the book.
I strongly state that after reading the book one is not in the position of setting up an enterprise project clearly. Many essential pieces of information needed are missing, in my opinion. Also the case study described at the beginning gave the hope that the book will lead thru the process of building a real app. But that was not the case at all, just fragments were displayed to the reader. And those seemed unrelated to the case study.

I should quote this book, but I really don't want to spend anymore time with it. The buzzword-speak is rife through this book, and it really hinders learning when you have to stop and think, 'Now what is that supposed to mean?'. I haven't learned much, and the only reason I don't give this 1 star is I got it for < $1 from amazon used. It had 3 1/2 stars when I bought it, and my new rule is not to shell out for anything less than 4 1/2.

If you are just starting to see what the lightweight framework application hubbub is about this is the best introductory book on the subject that I have read.

I purchased this book, got distracted by another project and only recently picked it up to read the chapter on Spring. I read the Introduction, became hooked by the authors very natural and readable narrative style and soon I had read the entire book. That is unusual.

The author has chosen a unique Technical Conference Application as a test case and described it's development in various light weight frameworks and applications.
The examples are bit dated by the use of Eclipse 3.1 but everything with the exception of an older version of SQL Explorer runs with Eclipse 3.2. If you are an experienced Spring - ORM developer your mileage may vary but chances are you will learn some new things.

This is a very big little book. Technologies covered in some depth with references are: Eclipse, Spring-MVC, Hibernate, Tomcat, Tapestry-HiveMind, JBoss, SQL Explorer, DynaDTO, Ajax with Tacos, TestNG and AspectJ along with discussions of several patterns and methods of Dependency Injection. The discussion and reasoning behind the use of the techniques is well thought out and insightful.

My only caveat is that the author and I belong to the same Java users group. I plan to leverage that personal contact to encourage Brian to write more books.

This book will give you a new perspective on the topic and will outline how to use some interesting tools and technologies. I enjoyed reading and learning from it.

I bought this book to get understanding of POJOs. To see how they are much simpler to use than EJB, if they really are!!
But this book tries to pack the whole project into it, which makes it hard to remember things after few chapters. It also tries to explain technologies (like Spring and Tapestry) in few pages, omitting the explanations where required. My opinion is, it requires pre-understanding of these technologies before you will find reading this book useful.

Also, I was not convinced with writing style of author. Author tries to use complex words where they can be avoided and twisted sentences where same thing can be explained in plain English statements.

Overall, I guess author has in-depth knowledge but he lacks the ability to express the knowledge in simple words

This is a great book. The author provides a simple and fantastic pattern for developing lightweight Java applications, based on software engineering best practices. This provides a nice foundation for delving deeper into the subject matter covered throughout the text.

The only criticism I have (a minor one) is I would have liked some more meat regarding the JBoss Business Services topic, this is really just a personal preference.

Great job Brian!