Customer Reviews

The Struts Framework: Practical Guide for Java Programmers (The Practical Guides)

5 star:		(18)
4 star:		(6)
3 star:		(2)
2 star:		(9)
1 star:		(7)

 

 

I hate to be a party pooper, but I have to completely disagree with the other rave reviews this book has gotten. I bought the book precisely because of those reviews, and I am badly let down.

This book is poorly written and poorly edited. It has only a tiny bit of information in it, and even this is made difficult to find by the authors repeatedly very shallow coverage of all the concepts that she doesn't have space to actually explain. "...outside the scope of this book"

The 126 pages are broken into 11 chapters, each of which has an introduction and a summary. Not a whole lot of space is left for actual meaningful contents. The sample application is trivially simple and avoids any of the interesting challenges that would come up in any real application. Even this oversimplified sample is presented in incoherent chunks, where one code snippet has little or nothing to do with the one that follows it.

The "Struts Development Cycle" that one reviewer praises is all of a half page long; it is a list that goes from "gather requirements" to "develop application business logic" to "build, test, deploy." Duh. This list is followed up with a few pages of explanation, but each item is given at most a half-page explanation. The list is repeated again in the chapter summary.

The "Excellent ready-reference" reviewer gives himself away when he writes "Let one of the other books take the role of reference and tutorial and allow this one to help you out in the pinches." Ah, I see. It's not a reference or a tutorial, it's for... keeping warm when you need extra firewood.

The one UML sequence diagram in the book portrays an Error as an Actor. It 'calls' ActionError when 'some error occurred in model.' ActionError calls ActionErrors to 'Add to ActionErrors collection.' This is typical of the book's ability to muddle rather than clarify.

Two stars for having chapter 8, which although not great is the one section of the book that has real information.

Unfortunately, after reading this book, I still don't know why I should use Struts. The question that the book should have answered first never got answered at all.

Those of us in the high tech industry have become used to buying technical books that can take down a forest. How refreshing to finally have an author who doesn't feel the need to drone on about every ancillary topic there is. This book covered everything I needed to know to get up, running, and productive with Struts 1.1. It is clearly and concisely written and speaks directly to Java developers. No bones about it. My boss had come into my cube on Friday morning and told me that we'd be looking at Struts on Monday for a new project. I purchased this book on overnight delivery, and was able to get through it in its entirety in a single day. This included downloading the sample application and using it. I walked in Monday not only knowing
what I needed to know to thoroughly impress my boss, but also able to make suggestions and comments on how we should go about building our project thanks to this book. With a sub- price tag, it's hard to justify spending 2 and 3 times the amount on another book. If you need a true practical guide, this is it. I've already recommended it to the rest of our development team, cause I don't want to give up my copy!

This is a good book for someone who has never used Struts before. It is fast-paced and uses an example to convey the message. The author sticks to Struts and does not clutter the book with any other technologies. This book is perfect if you want to get up and running with Struts quickly. In the authors own words, the book strives to explain the most common 80% of features of Struts. A basic knowledge of Servlets and JSP is useful, though not required. This is not a good reference book though. Once you have gone through it cover-to-cover, there is no further use for it. Well, I guess that's why it costs less than $20.

Who should buy:

If you have never used Struts before and want to learn Struts quickly, then this is the book for you.

If you have worked on Struts earlier and are looking for advanced features, then this is not the book for you. If you want to learn JSP/Servlets, then this is not the book for you. If you are looking for best practises, pattern and J2EE architecture, then this is not the book for you.

I am a new Struts developer and found the Jakarta Struts site pretty hard to follow to get the information I needed. I purchased this book based on the reviews it has been getting and found it to better than I had expected it to be. It helped me totally understand what all of the Struts 1.1 components are, how
to use them, along with details on how to use the custom tags. This booksaved me days of plowing through source code and javadocs and now I'm ready to start my application development. Good job! I wish more books were written straight to the point and as useful as this one is. I really got a lot more than I paid for, for once in my life. I'll look for more books by this author. It was a real treat to have such a technical subject laid out in such an easy reading format. Bravo

The Struts Practical Guide provides an adequate overview of Struts and some of the many technologies it works with. For the most part it's well-written, and the author has a sense of humor.

However, the book is too short (132 pages) to do justice to the ambitious agenda which it sets out to cover. Rather than focussing strictly on Struts core components (the MVC architecture and the Struts tag libraries) the author tries to introduce us to a host of worthwhile but off-target technologies that end up distracting the reader from Struts itself. As the result, we are left with incomplete coverage and very few examples to help understand the variety of possible relationships between Actions, ActionForms and jsp files, the very heart of Struts. Coverage of the Struts tag libraries is cursory, despite being the topic of the book's longest chapter (26 pages).

The problem actually becomes worse when one examines the sample application that is available from the book's website: so many ancillary technologies have been incorporated into the sample app that the core functionality of Struts is difficult to tease out. Between internationalization, JNDI lookups, unit testing and Log4J, you'll find the Struts-related code if you look hard enough! As the result, a beginning Struts programmer who is not already familiar with these worthwhile technologies will find it difficult to use the companion code as a starting point for their own projects.

I've been trying to learn Struts/JSP/Servlets/Tomcat all at once over the last 4 days by reading 1500+ pages from books and web-resources. (my head really hurts!) Nothing really brought it all together until I picked up this book. At only 128 pages, it quickly got to the heart of Struts and by page 20, half of my questions were cleared up. If you want to learn Struts, this is the quickest most informative read. Then buy Jakarta Struts-Pocket Reference and you'll have 98% of your needs covered. Plus together they cost me under $35 - a great bargain!

After reading one review of this book about how short it was(and not that great a resource), and, after first seeing how small the book was, I was afraid that this review might be correct. But it has turned out to be the exact opposite. It gets right to the classes and configuration specs you need to get at in short descriptions and examples. I read "Programming Jakarta Struts" by Cavaness the week before, and found the content in Spielman's book almost as rich. I would use this book more as a learning tool and Cavaness' book more as a reference. I thought the cdmanager app example code was very good - although the source jar was not organized as required by the build.xml file(about my only criticism).

The book was spectacular in the concise approach to the use of the Struts Framework. The explanations of all of the different areas were well thought out without being verbose. The sprinkling of URL references within the context of the chapter of use was solid and you didn't have to jump back and forth between the chapter and appendix.

The cdManagerSample is a solid fundamental learning experience that has a lot of nice techniques within it for those of us who are totally on our own. I especially liked the web.xml setup with the log4j and database servlets that were included in addition to the cdmanager actionservlet. I liked the package structure, jsp use of the Struts template and comments within the code that explained that it was done for teaching and that in real life, you would use these other specific techniques.

Chapter 11 mentions the useful extensions such as Tiles, Validator and the Jakarta Commons Utilities. This could be the topics for the next book. I would hope that other topics such as application scope caching, a data access object and design patterns would be considered as material for going to the next level.

I found this book's introduction to Struts to be inadequate. I have a very strong understanding of JSP and Servlets and a cursory understanding of the MVC design pattern. After reading the first two chapters I was quite confused about the general workings of Struts. A small, trivial Struts application to introduce the reader to the pieces and how they are inter-related would have increased the understandability ten-fold. However, that might have cut into the author's allowed page count: realize this book is 137 pages soaking wet (including the appendix and index... I don't recommend actually soaking the book). After getting a better understanding of Struts from another source, I came back to learn the details.

The author does an good job of explaining how best to use each part of the Struts Framework (that's where the "practical guide" part comes into play). More importantly she notes the possible hang-ups that normally you'd only learn through a bad experience (Don't use instance variables in your Action classes. Don't worry if you forget this rule now -- after you've read the book, this and other gotchas are tattooed inside your head).

Overall I'd say this is a very good resource. You'll need to go elsewhere to introduce yourself to Struts (find a nicely explained step-by-step tutorial), but after that, this book will be able to take you most of the way to a well-designed Struts implementation.

As an experienced programmer who has bought books where the first half of the book covers the absolute basics of programming and the last quarter of the book is an outdated reference to an API, this book comes as a breath of fresh air.

This is a good inexpensive book for intermediate to advanced JSP and Servlet programmers to get up and running on the basics of Struts 1.1 in no time. It can be terse at times, but if you stay the course and finish the book (it's a short read at 126 pages) everything comes together nicely.

I have seen some negative reviews of this book and I think they stem from unreasonable expectations. This book is not for beginners. This book is not a "cookbook" or a reference book. This book does not cover the advanced features of Struts. For people looking for books like that, I recommend "Programming Jakarta Struts, 2nd Edition" or "Pro Jakarta Struts, 2nd Edition".