Agile Java Development with Spring, Hibernate and Eclipse |  | Author: Anil Hemrajani
Publisher: Sams
List Price: $49.99
Buy New: $13.93
as of 3/19/2010 01:14 CDT details
You Save: $36.06 (72%)
New (30) from $13.93
Seller: horizonbb
Rating:  45 reviews
Sales Rank: 193010
Media: Paperback
Edition: 1
Pages: 360
Number Of Items: 1
Shipping Weight (lbs): 1.2
Dimensions (in): 8.9 x 6.9 x 0.8
ISBN: 0672328968
Dewey Decimal Number: 005.133
EAN: 9780672328961
ASIN: 0672328968
Publication Date: May 19, 2006
Availability: Usually ships in 1-2 business days
| |
| Features:
| • | ISBN13: 9780672328961 | | • | Condition: USED - VERY GOOD | | • | Notes: |
|
| Also Available In:
|
| Similar Items:
| |
| Editorial Reviews:
Product Description
Agile Java™ Development With Spring, Hibernate and Eclipse is a book about robust technologies and effective methods which help bring simplicity back into the world of enterprise Java development. The three key technologies covered in this book, the Spring Framework, Hibernate and Eclipse, help reduce the complexity of enterprise Java development significantly. Furthermore, these technologies enable plain old Java objects (POJOs) to be deployed in light-weight containers versus heavy-handed remote objects that require heavy EJB containers. This book also extensively covers technologies such as Ant, JUnit, JSP tag libraries and touches upon other areas such as such logging, GUI based debugging, monitoring using JMX, job scheduling, emailing, and more. Also, Extreme Programming (XP), Agile Model Driven Development (AMDD) and refactoring are methods that can expedite the software development projects by reducing the amount of up front requirements and design; hence these methods are embedded throughout the book but with just enough details and examples to not sidetrack the focus of this book. In addition, this book contains well separated, subjective material (opinion sidebars), comic illustrations, tips and tricks, all of which provide real-world and practical perspectives on relevant topics. Last but not least, this book demonstrates the complete lifecycle by building and following a sample application, chapter-by-chapter, starting from conceptualization to production using the technology and processes covered in this book. In summary, by using the technologies and methods covered in this book, the reader will be able to effectively develop enterprise-class Java applications, in an agile manner!
|
| Customer Reviews:
Showing reviews 1-5 of 45
 Good idea, bad execution August 3, 2006
Gonzalo G. Braschi
91 out of 97 found this review helpful
I bought Agile Java Development with Spring, Hibernate and Eclipse just because I buy a lot of books. The idea behind it looked very nice. Spring, Hibernate and Eclipse form a very good development platform. I already knew this much. I had even used all of them, but I can always learn more.
The book is, according to the author, based on the development of an example project which is also a very good idea.
The problems begin when transforming those ideas into the reality of a book.
For starters, the book is poorly written/edited. The author gets ahead of himself a lot. "We'll see more on this later" - he says, and later can be a good eight to ten pages. Section and subsection titles seem to have random importance and chapters are strangely structured, as if you were listening to a presentation where the speaker hadn't bothered to order things.
"Now, I will explain this", "Now, I'll do that"... "Oh, and by the way, I hadn't said anything about this other thing. I'll mention it now even if it doesn't fit here".
The next *big* problem is the code. The book relies a lot on the code, but instead of inserting the code within context, it just comments a couple of selected lines and you're expected to follow along with the downloaded code on your computer.
This is a big turn off for me. I don't usually read books by the computer.
Then there's that thing about the author. Don't get me wrong. This is the first I've read from Mr. Hemrajani but I'm sure he's a great developer. But a good book, more so a book like this, should be about Agile Development, about Java, about Spring, Hibernate and Eclipse.
Sure, I do like an author who can express and convey his own views and opinions, his experience and know-how. But reading this, there's a feeling that this is all only about how _he_ does this or that. There're too many mentions on "this particular piece I wrote years ago about...", too many self-references and details which ultimately do not seem to be all that relevant.
To sum it up: The idea is very good, and you may still get good bits from the book. But it *needs* a very thorough re-write and editing work.
 Mixed Bag of Info.... January 8, 2007
Francis Wong (Ashburn, VA)
11 out of 11 found this review helpful
Like a lot of other reviewers on Amazon - I was disappointed by this book. Granted -- its going to be difficult to cover multiple major topics like Spring, Hibernate, and Eclipse all in a single book...but this one tries.
I enjoyed Anil's stories about his real-world experience with Java technologies. But the level of detail in the book ranges wildly from 50,000 feet to 10 feet. At times, he is flying over concepts so quickly - its hard to realize they are important (ex: JUnit), and at other times, he gives step-by-step mouse clicks through an eclipse wizard as if the reader is a Freshman in High School.
I'm a software developer - and have been using eclipse for 4 years - and I never needed a manual to figure out how to use eclipse. I did however, need to read online docs and books in order to use the Spring Framework, Hibernate, and other topics such as Ant and JUnit effectively.
This book balances concepts differently than I expected. For example, the book spends 53 pages on Eclipse (chapter 8), but only 16 pages to Spring core (chapter 6), 34 pages to Spring MVC (chapter 7), and 32 pages to Hibernate.
He also categorizes Logging (log4j and JDK logging), and eclipse debugging (yes, even more pages about eclipse!) as "Advanced Features"
Personally - I find his distribution of coverage completely inverse to what a reader would expect. There's just too much time spent on no-brainer topics, and not enough time spent on real-world topics (hibernate, spring, junit). Counting pages isn't exactly a scientific way to review a book -- but it gives you a good idea of what the author was choosing to emphasize.
Jack of three technologies, Master of none July 4, 2006
George Jempty (Atlanta, GA)
8 out of 8 found this review helpful
Agile Java Development would seem to be the natural successor to 2004's "J2EE Development without EJB". That volume's author, Rod Johnson, the creator of Spring, even contributes a one page forward to Anil Hemrajani's 2006 effort. "Agile Java Development" however is at best a "lite" version of it's predecessor. 300 pages just cannot do the topics justice; Mr Johnson' book was 500 pages and the current volume could have benefited from some more meat. There are very few source code examples in the book and while this is arguably better than page after page of code, it however crippled the book's usefulness when read while travelling and away from an internet connection.
Of the three technologies covered, Spring, Hibernate & Eclipse, I have the least experience with Hibernate, and even after finishing this volume, I feel like I know almost nothing about it. With regard to Eclipse, this book's coverage is significantly deficient when compared to just the 60-page first chapter of the second edition of "Eclipse: Building Commercial-Quality Plug-ins." Lest that comparison seem unfair, in a volume as slim as "Agile Java Development", the author more than once commits the cardinal sin of repetition. Sure I learned about a couple of useful keystroke shortcut combinations for Eclipse, but I certainly didn't need to read about them twice in a 300-page volume.
This volume at best provides the barest of overviews of the covered technologies and processes, and is best suited for junior developers and managers.
 Wonderful Intro to Eclipse, Spring, Hibernate, and Agile development June 5, 2006
B. Buxton
6 out of 6 found this review helpful
If you are unfamiliar with any of the technologies listed, then this is a good book to help you get up to speed. Nowadays, it's hard to stay current on Java and the magnitude of open source frameworks available. Any of the technologies are too big to cover in one book. Anil gives you a short concise introduction on each that allows you to start your journey using these technologies. It's enough so that you know where to dig to find more information. Along the way, he gives lessons about agile development and how these technologies help support that. I've been loaning this book out to fellow team members and it's been great to get everyone up to speed.
The writing style is straightforward and honest. Anil gives his candid opinions along the way on development. I found this refreshing. You might not like everything he says and that's OK. They're more like recommendations and advice. I appreciated that they were included.
If you approach this book as a way to get up to speed on Eclipse, Spring, and Hibernate, then you will not be disappointed. It's much too short to give you all the details, but like is stated in the introduction: it's a roadmap.
A great book, too bad you need to read it twice. October 7, 2006
B. Bottema (Leeuwarden, Friesland Netherlands)
8 out of 9 found this review helpful
I've read a lot of books, of which many are conceptual, academic or technical or just hands-on cookbooks. The problem with "Agile Java Development with..." is that it fits none of the above categories. It feels like an attempt to a hands-on experience kind of book (there's a lot of "Let's get to the action!" phrases and then fails to deliver and just discusses another subject), but Raj delivers mostly academic unstructured comments on every aspect of the subject matter. Don't get me wrong, the book has all the information you need to get started and learn tons more from references Raj gives you, but the problem is: there's no structure to his story telling. For example, In every chapter when he's discussing a subject, he tends to reference/compare to other subjects that haven't been covered yet; he even adds a "(as covered in Chapter X)". Seriously, you actually have to have read the book in order to understand many of the comparisons and references he makes.
Also, he expects you to know a lot already, like packages that can be integrated with Spring, like Struts or Websphere. He expects you to a). know each every reference to such third-party software, or b). that you will look it up instantly or c). that you just don't care for the moment (and he makes a lot of these references). He also expects you to know what for example an Application Server is and that JBoss is one. Or what an EJB is and why you would need an Application Server for that. In my opinion, these are pretty fundamental subjects that you need to know in order to understand why Spring works and is popular. He could've covered those things shortly in a single paragraph or page, or even a sidebar.
Instead, he uses sidebars to express his personal opinion on something, often saying he disagrees with something and why. He even mentions those sidebars are subjective and you can ignore them if you want, but it's still annoying if you run into one.
Something Raj does what I find very annoying is that literally every 5 sentences on the average he adds a "(as we'll discuss in the next Chapter)", or Chapter X. I don't mean the reference itself, but the sheer number of times that he ads his sub comments like that. Even if you can understand some of his text, it's incredibly annoying to be interrupted all the time by his '(..)' all the time.
Aside from the annoyance and lack of proper structure, I agree with the other persons view that Raj depends on the external provided code too much. He often references code from the zip file you have to get yourself (which isn't necessarily a problem), but in his examples he picks out a code fragment utterly out of context and forces you to look and understand the entire code file/context in order to grasp the tiny fragment Raj picked for his example.
another thing that bugged me about his code is how he expects to magically understand his explanation, which in my opinion isn't nearly enough many of the times. Sometimes he'll show you some XML for ANT for example and says, "As you can see", or "Obviously, the bean depends on this or that", but he doesn't explain (or has explained) why something like that would be obvious (you just need to know it apparently). what I mean is, implicitly Raj expects you to read the Ant reference in between his chapters, just as he implicitly expects you to follow all the references of all other subjects before you read on in his own book. Very frustrating and makes you feel you're getting nowhere.
One last thing I'd like to mention about his dependency on external code. He often refers to the code which is ok, but he only provided the code to the final product, which you can only understand and run/compile after you read ALL chapters in principle. There's just no way you can go ahead and fiddle with some Hibernate code or XML file to see how it changes the program, because you don't have the faintest idea yet how to run/install/use Spring, Ant or JUnit. I wished he had made the code available for each step, compileable and runnable so we can experiment as he provides the context in his chapter about the subject (ie. Hibernate). I would even have been grateful if he provided an appendix with all installation steps so I can setup the entire program just to figure out how it worked. I'm at chapter 6 now and I still haven't run a single piece of code, because I just don't know how without reading tons of external references.
Granted, in his introduction he mentioned he wrote this book in such a way you could read a single chapter, or a subject that covered several chapters at once, or just as entire book. Unfortunately he wrote it single-chapterly way too much, hence the army of "(covered in Chapter X)" and external references.
He doesn't mention in his introduction what's in the source files. He does mention structure and packages/classes as he goes through the chapters, but not why there are two versions of his demonstration program. Apparently, somewhere in Chapter 8-10 he makes a second version with improvements. Nagging? Maybe, but I feel left in the dark when reading this book.
Conclusion:
This books has everything you need information wise, but getting it is a slightly different story. I feel like I need to read the book twice to understand everything he says, because of all the references to uncovered material. Reading this book feels like playing an FPS with serious lag and as the other reviewer said, Raj seriously needs an editor to refactor his book.
Showing reviews 1-5 of 45
|
|
|
|
