Rating: 
Summary: Don't Expect To Learn Struts From Scratch From This Book
Review: The author is knowledgeable but does not present the material in a clear, coherent manner, especially for those new to Struts development (which you probably are if you're reading this book). I never really "got" Struts after reading this book cover-to-cover. That is to say, there's no way I could create even a simple working Struts application from scratch. Here's my two main complaints:1. The book is organized very poorly. For example, although throughout the book we've been seing ActionForms used in code, it's not until page 175 that we get "What Are ActionForms?" The IStorefrontService interface is finally described on page 158, even though it's been seen multiple times previously without any explanation as to what it is. On page 230, the author writes "I've mentioned the UserContainer and ApplicationContainer classes in previous chapters without defining exactly what they are." So the pattern is that things are just foisted upon the reader inside code listings with no explanation and no reference. Sometimes they are finally described hundreds of pages later, sometimes not. In-between are many pages of useful information, but that would have better been left for future chapters. We learn lots about how to extend Struts before we even know how the basics of it work. That makes no sense if you are looking for a tutorial. Needless to say, it's pretty confusing to look at stuff that isn't explained. Terrible. 2. There is no step-by-step creation of a working application here. I made the mistake of thinking there was by skimming the book, but the code is largely given in unconnected fragments, often without a reference to even what file it is supposed to go in (some code relates to no actual project at all). There are two applications presented (a bank account manager, and a shopping cart tool), but again it's almost impossible to create and configure what's in the book into working applications. Sure, you can download completed applications from a web site and try to decipher them on your own, but the fact that only bits and pieces of the code are in the book, with little or no methodology, is lazy. To be fair, there are some pretty good chapters on ancillary topics, such as Business Objects and Object Persistence, Struts Tag Libraries, Tiles, and Logging. This information will be useful, but not before you can build a working Struts app to apply it to. I think it's a shame because with a little more thought from the user's perspective towards organization/editing, this could have been a really good book. If you already kind of know Struts, I would pick it up to augment your knowledge (perhaps in that instance I'd give it four stars), but I cannot recommend it for the Struts beginner. Sadly, I have not found a single Struts book or online tutorial yet that succinctly and sufficiently explains it to someone with no previous experience. I'm almost tempted to try the Tapestry framework instead...even though the documentation is horrible, the product looks easier to use.
Rating: 
Summary: Must buy!!
Review: Struts has quickly become the leading framework for developing Java-based web-applications. This book does a terrific job of discussing the various elements of the Struts framework, from the ground-up. Starting with an introduction to the MVC pattern, the author clearly defines the role of the basic elements of Struts and delves into how to model and extend these components to write real-world applications. For users already familiar with Struts, the book expands beyond the basics and discusses how to use some of the libraries surrounding Struts, such as the Validator framework, Tiles, Logging (Commons, log4j). There are great chapters on using Struts with EJBs, exception handling, internationalization, the various tag libraries that come packaged with Struts, and advanced Struts features (some of which are new to version 1.1). If you are new to Struts or are already using Struts, I have no doubt you will learn plenty from this book. (Like most O'Reilly books) It skips on providing information irrelevant to the technology, and focuses specifically on how to help you build and model clean, maintainable web-applications. Gone are the days of including JSP scriptlet code inside of your HTML (I know I'm tired of looking at it). I've used Struts to build the past two web-applications I've worked on and I have no doubt I'll use it for the next - this book will be right beside me.
Rating:
Summary: Make people bored before really learned anything
Review: The book was not written in a way that people can learn the struts programming step by step. It may provide you a lot of theory, but you can not follow it to even run an example. All the examples provided are always just a small piece of the whole picture. There is no way that you can follow the example and run it to see the struts works. I am in chapter 5 now. I am still very confused. I think this book is good for the person who just want to learn the theory about struts and bost around. You can not tell people that I can write a struts program and show you that it works.
Rating:
Summary: A Great Advanced Guide to Struts
Review: This book is a must have! I've been programming with Struts for about 6 months and I didn't want a beginners guide. This book hits the perfect level with me and covers the stuff that I wanted to know about. It's definitely not a beginners guide, although I think even beginning Struts developers should read it to save themselves time later. Here's why I'm giving it five stars: Chapter 1 - Covers MVC and Model 2 Background and Trivia
Chapter 2 - Covers Request/Response and Forward/Redirect Info
Chapter 3 - Good overview of the framework with the Bank example (All banking code is provided, including Ant scripts) Chapter 4 - A complete chapter on configuring the web.xml and struts-config.xml (Some parameter are missing because of changes after book release) Chapter 5 - A great chapter on explaining the controller of Struts Chapter 6 - The reason to buy this book! Everything you ever wanted to know about how to build the model for Struts Chapter 7 - Dynamic Forms Coverage (Good Coverage)
Chapter 8 - Tags (This chapter could have been better!) Chapter 9 - The explanation of why and how to extend Struts if neccessary for any real Struts applications. Chapter 10 - Great coverage of the declarative and programmatic exception handling Chapter 11 - Coverage of the validator framework. Also covers how to create your own rules and to use it outside of Struts Chapter 12 - Good I18N Coverage
Chapter 13 - Excellent chapter on EJBs and Struts (A must read!!!) Chapter 14 - Tiles, but I've not read this chapter close enough to comment. Chapter 15 - The best information available on Logging in a web application (A must read by all!) Chapter 16 - Solid coverage of using Ant to package Struts. (Ant scripts are included) Chapter 17 - Decent chapter on Performance Overall, each chapter covers exactly what more advanced Struts users want and need. You can't go wrong buying this book!
Rating: 
Summary: Not for beginners
Review: This book shouldn't be your first Strut's book, at least if you are learning by yourself. I think it lacks a full example, step by step.
Rating:
Summary: Agreed... not as good for beginners
Review: This book does an excellent job of laying out the Struts framework at a high level and then explaining each individual component of the framework in detail. It provides clear examples of good design patterns separating the business model from the view/controller of the application, and decent documentation of the use of each parameter in the configuration files. What it does not do is provide easy, step by step, "this is what we just did and this is the result"-style tutorials on building your first Struts application. I read most of the book without attempting to sit down and write any code. When I finished reading, I had a clear understanding of how the framework operated and a good idea about how I wanted to build my first Struts application. However, when I sat down to actually code the application using the book as a reference, I was completely lost. I must say that I am disappointed because the book does seem to market itself to all levels of Struts developers, but I think it's really only useful to somebody who has already gone through a few tutorials. I learned more about building my first Struts application by following tutorials in the MyEclipse IDE, and reading the code and configuration files from existing Struts applications. I give this book 1 star for beginners and 5 for experienced developers - so let's call it a 3.
Rating:
Summary: Great book on Jakarta Struts
Review: Overall Rating: Well done! This book will be a valuable teaching and reference tool.
Teaching Value: Excellent! An essential book on this topic.
Reference Value: A complete reference. I would not need any additional reference on this topic. This book presents an explanation of Struts that is both easy to comprehend and one that follows the design process from beginning to end. It's a complete guide to the Struts project, taking developers through concepts, design and implementation and explains the Model 2 design pattern in depth. Installation and setup are thoroughly documented, and every configuration option is clearly explained. JSP programming within the context of Struts is explored, with tons of practical examples that use both the standard JSP tag libraries and Struts additions. You'll also become adept at programming multitiered applications, interacting with EJBs from struts applications, and handling complex validation and logging through the Struts provided packages and tools. Also covers how to create your own rules and to use it outside of Struts. Whether you've been struggling with Struts, or you want to get started in Model 2 programming, or you're an advanced Struts programmer wanting to fully exploit this powerful framework, overall I'd say this is an excellent resource.
Rating:
Summary: not very good for starters
Review: I agree with one of the previous reviewers that the book is not very good for starters. I found that I value any book by its ability to be a reference after cursory reading (usually we do not have time to examine books in quiet in front of a fireplace). I have 3 books on Struts and never used the book as a reference. The book is recommended as advanced guide to Struts, but I don't agree. Advanced Struts with pitfalls and gotchas is one thing, explaining how the Struts fit into overall good design guidelines is another.
So, I have very mixed feelings about the book. I liked the author's willingness to explain but still...
Well, 3 stars and mixin feelings. Strangely, Beginning JSP 2.0 from wrox got me going on Struts at no time. It is not devoted to Struts, but as kick start was very much helpful.
Rating:
Summary: To learn Struts or "their" example????!!!!!!!!!!
Review: The organisation of this book is not very pleasing. While explaining topics they jump from one to another...I get bored very soon while reading this book. The shopping cart example is also not provided in a user-friendly way. It is scattered all over the book. The way of explaining things is really irritating me.. If you buy this book, download the examples from o'reilly website and keep that open always. Because, if you wish to learn a new topic say DispatchAction class, you should first learn how their StorefrontDispatchAction class is defined!!! To learn this class you should learn some other class and the chain goes on.... The author could have explained it with some simple examples instead of this big example.
Rating:
Summary: Good if you have some Struts knowledge to start with...
Review: Review
In my ongoing efforts to continue my technical education, I decided I wanted to learn more about the Struts framework for web application development. To that end, I picked up a number of Struts books, and among them was Programming Jakarta Struts by Chuck Cavaness. This book by O'Reilly is a fairly comprehensive guide to the framework, as well as a tutorial on how to use it. The author starts with some high-level discussion of web applications in general, and some of the issues faced when building those types of applications. From there, he starts to show how those issues can be handled within the Struts framework, as well as the advantages you gain by implementing it. The rest of the book then goes into the different parts that make up a web application written with Struts, both from a tutorial standpoint, as well as from the perspective of documenting all the different parameters and options of each part. There is a sample shopping-cart type application called Storefront that is used as a running example throughout the book. This is good in that it allows you to see how Struts code would be structured in an actual application. The downside of this approach is that at times the application can become the focus of the writing and not the underlying technology. I struggled a bit in trying to keep straight what was Struts and what was the application logic, but it may have just been my inexperience. If I hadn't read any other books on Struts prior to this one, I might have struggled more than I did. While the framework makes sense once you wrap your mind around it, there are some moments of confusion when you first start out. This book might not be the best "first exposure" to the subject matter. I would recommend you try to find some introductory material on the web or in magazines first so that you have an idea of what things are before you start reading this book. Conclusion
This is a good choice if you're looking for a Struts book that is part tutorial and part reference guide. While the example application might be rather complex, it is a good idea of what can be done in Struts, and you will find all the pieces you need to use in there. But be aware that it could be a little overwhelming if you've never been exposed to Struts in the first place.
| 
