Customer Reviews

Programming Jakarta Struts, 2nd Edition

5 star:		(20)
4 star:		(17)
3 star:		(17)
2 star:		(15)
1 star:		(8)

 

 

I've relied on O'Reilly books to provide the gist for any number of topics but this one disappoints on a number of levels. Too much filler material (if you don't know about EJBs and WARs then you shouldn't be reading this book) and an imbalance of detail. I need to know how to enable debugging in struts-config.xml or how to specify the message properties files in web.xml, not individual attributes to custom tags; I can find those in the javadocs.
Granted it's a relatively new technology but this treatise didn't provide much more than what I could find on-line. There wasn't even decent coverage of the specifics of minLength and other validator features. Trash the fluff and stick to the details which implementors require and you might have a decent book.
Now I'll just have to buy the Husted tome. It's not like I'm made of money, you know? I just can't recommend this book to someone trying to develop a production application in "web time".

I've wanted to write a review for this book ever since I started reading the draft chapters on theserverside.com. I was one of the many who participated in submitting feedback from the very beginning and feel like I've learned so much from the material, but understand how someone might not get it immediately.

This book was written specifically to teach Struts developers how to fish; it wasn't designed to fish for us. This is something the Author mentioned on the list many times. You won't find a million different ways to use a specific tag for example. Instead, I think the coverage is more advanced and attempts to strive higher than just Struts.

So, here's my review for this book. I hope it helps you decide whether this book is for you or not.

First the bad - This book is light on the tags section. If you are looking for every which way to use the iterate tag for example, you won't find it here. Also, the modules coverage could have been better. Of course, I think that's due to the flux that modules was in at the time of release. I don't personally hold this against the Author. The other books (especially the ones that came out before it) have the same issue.

The other topic I would have liked to see covered in the book is Security. It's actually not covered in any of the books very well. Based on the earlier table of contents that the Author published, it was included. However it was posted on the mailing list that the chapter on security was being cut due to size and time. Maybe the 2nd edition will add this (hint, hint).

Now the Good - This book covers so much about how to hook Struts up to a Model architecture; especially Chapter 13 (the one on EJB). I really like this chapter and have learned so much from it. The examples are clear, concise and helpful.

The coverage of exception handling is superb! As is the coverage of logging (using log4j), tiles and the validator framework. The packaging chapter was very beneficial as was the chapter on I18N. However, what I liked about this book the most and what I think is the most valuable is the following:
The Author clearly has built Struts applications for real companies and it's obvious to me (at least) that he's sincerely trying to communicate what's important for the big picture.

So my advice to you if you are considering buying this book is, if you want to see how the tags can be used in every situation, buy another book. Actually you'll probably have to just read the user guide because I don't think the other books cover this any more. On the other hand, if you want to learn the 1.1 features in depth and learn big picture ideas and concepts, then I wholeheartedly recommend this book. It's possible that you won't appreciate all the material in the beginning, but after you work with Struts for 6 months, you most certainly will.

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.

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!

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.

This book was disappointing to me.

It aspired to cover the Struts framework with a great level of detail. But it lacked clarity in presentation. It was constantly flitting between topics. The same material is covered in an overview and in-depth mode. The book was not readable.

<b>Buy the book</b> if
you want an indepth coverage of every struts topic.

<b>Dont buy this book </b> if you want a good tutorial on struts. It will take forever to start writing struts applications. You need to read the whole book and summarize its content to yourself before you can start writing struts apps.

I read the draft chapters of this book and found the coverage to be excellent and the author's style to be very good. The material that was posted to theserverside.com was so helpful and shows that the author is comfortable with his ability to write and teach the topic of Struts.

Reason why this is must have:
- Covers Struts 1.1
- Covers advanced topics
- The exception handling and logging chapters alone are worth the $$$
- Covers how to use Struts with EJB
- Is well written
- I have found no errors so far
- Published by O'Reilly (need I say more?)
- Source code for the storefront and banking apps is available

I also purchased the book by Manning and like it, although I prefer the O'Reilly book a little more. The direction of each book is slightly different and actually complement each other very well.

O'Reilly and the author should should for commended on allowing the chapters to be reviewed before the book is available. That takes guts and confidence. My hats off to both.

Excellent book!

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.

The target for the book is any experienced Java developer who is interested in Struts but has little or no experience with Struts. The book starts with an explanation of why Struts is a "good thing" and shows how Struts fits into a web architecture. The author then gives an explanation of each of the pieces of the Struts architecture and demonstrates a simple application. Although the explanations were clear, I felt that the author was making the architecture overly complicated by explaining things out of order. A diagram showing the interrelationships of the different Struts classes and config files would have been helpful. The author covers all the expected topics such as internationalization, exception handling, logging, and the Struts tag libraries. The chapter on the Struts tag libraries could have used more examples to make the explanations clearer. The book concentrates on Struts 1.1 and the author does a nice job of explaining the changes from the 1.0 version and the features available in the new version. The chapter on the new Validator framework is clear and the examples are on target. The chapter on Tiles is short but the author does a great job of explaining how it fits into the Struts architecture. The chapter on performance seemed completely unnecessary since there was nothing in it specific to Struts. Overall this book is a good addition to the Struts library. The book has some shortcomings but it provides a good deal of value.

This book did a great job explaining to me *what* Struts is and *why* I should use it. However, when I actually sat down to start working I found the book had left me with little idea of *how* to use Struts. I'm going to take a look at Struts In Action by Ted Husted instead.