Customer Reviews

Struts Survival Guide: Basics to Best Practices (J2ee Survival Series)

5 star:		(15)
4 star:		(6)
3 star:		(3)
2 star:		(3)
1 star:		(1)

 

 

I am the author and publisher of this book.

This is an informational entry to let everybody know that the PDF version of this book is available free from the Publisher ObjectSource LLC - http://www.objectsource.com

While you are there, also grab goodies such as companion workbook for the Struts Survival Guide.

I started reading the ebook version with some skeptisicm as the book is from a first time Publisher. My view has changed since then remarkably. As I read the ebook, I was impressed by the practical coverage in this book - which also convinced me to buy the printed book. The book has some typos but they are really minor and did not distract me much and neither has prevented me from giving five stars to this book.

The book was best value for my money It manages to do justice to Struts and its best practices in a short 225 page and costs just 14.95. The book deserves its subtitle "Basics to Best Practices".
Doesnt matter if you are a beginer or an expert in Struts - You will find this book useful.

The book starts off with an excellent introduction to MVC and how Struts fits into MVC. It then explains the basics of Struts very well and develops a hands-on application in Struts.

The fun starts from Chapter 4 onwards.
Chapter 4 covers advanced Struts concepts and presents some interesting ideas about Struts Action design.

Chapter 6, 9 and 10 were killer stuff. I have three other Struts books with me, yet I found these chapters totally novel concepts found nowhere else.

For example, Chapter 6 explained how to modify the Struts BaseTag, CheckboxTag to handle some scenarios where they dont work out-of-the-box. It provided a thorough coverage of Struts Form submissions with Image Buttons. I was doing it wrong all these time!!. Chapter 6 also covered JSTL and how to use Struts-EL. Probably the crown jewel(s) from Chapter 6 are:

a) How to handle editable List based Forms
b) How to handle Multi page read only lists (by integrating the popular Pageer Taglib from jsptags.com with Struts)
c) A high-performance page traversal framework mechanism

Chapter 7 covers Tiles. Coverage of Tiles elsewhere I read on the net try to cover every feature in Tiles - many of which confuse me. This book sticks to just one way of using Tiles - which I think is the best way to use Tiles.

Chapter 9 is about Exception handling with Struts. I have one word to say "Fantastic" !!! The coverage of Exception handling alone is probably worth the price of the book. It provides a solid framework to handle Exceptions in Struts, log them in a centralized manner and report and alert in a production environment. I plan to use this framework AS IS in the project I am currently working on. Most other books on Struts limit their exception chapter to explaining differences between Checked v/s Unchecked exceptions and telling how the <global-exception> tags work in the struts-config.xml.

Chapter 10 is for folks who want to customize Struts and reap its benefits in design and development of production systems.
It presents three of four examples of how Struts can be effectively customized.
The best among them was how to how to handle duplicate form submissions in a generic manner. We all have to deal with duplicate form submissions in daily life and handle them on usecase basis by using the Synchronizer tokens. The technique illustrated here no doubt relies on the Sync token but uses it a very ingenious manner, presents a generic Action class. I liked this technique.
Other techniques I liked are that the chapter provides a Dispatch Action like functionality for Image based form submission. The DispatchAction in Struts is great, unfortunately I can use it only under certain restrictions. One of them is that the all of the buttons have to have the same name. This technique removes that restriction and opens a world of possibilities for designing cleaner applications while providing enhanced user experience.

If you architect, design and develop Struts based applications for your living, do yourself a favor - Go buy this book. I bet you will not have it in your book shelf but in your hand everyday.

I am avid reader. This is my third Struts book. I went for it since my opinion was "it is inexpensive what the heck". Boy! was I in for a surprise or what...

Since I knew Struts already, I skimmed through the initial introductory chapters. I found some good advice that no other Struts book/online materials offered me so far. Here are some I found (in)valuable:

1) Action Chaining

2) The right way to use Image Buttons for Form Submission

3) Some good JSTL and Struts-EL stuff

4) A great Page Traversal framework.

5) Using Pager Taglib with Struts

6) An expert treatise of Exception Handling that goes far beyond "Here is how you confugure exception in struts-config.xml" and tells
a) When to use Struts declarative exception handling and when not to
b) How Struts exception handling complements Servlet exception handling
c) How to log exceptions in a customer-support friendly way so that they can be cross referenced?
d) How to prevent duplicate logging?
e) Strategies for centralized logging
f) Reporting exceptions

7) Customizing Struts to get some real benefits out of it such as:
a) How to fill the gap between ImageButton and DispatchAction, that's so missing
b) Controlling duplicate form submission in a generic manner rather than dealing with it in a per form basis
c) A pageflow controller
d) A <html:cancel> like functionality when images are used for the cancel button

After having worked almost entirely with back end for nearly 4 years, I am having my second take at web tier development with J2EE. Things have changed a lot since my last stint. I found myself using Struts.

I picked this book because of some of the positive reviews for this book. Plus the lead developer on our project asked me to read this book. This book turned out to be a good one.

I especially liked the Chapter 1 that made a case for Struts very well. By the end of Chapter 2 and 3 I found myself writing simple Struts applications.

Chapter 4 had some intermediate level stuff like Struts Actions and some practical advices on using Struts. I was pretty surprised since this book took me to an intermediate stage in a new technology (for me) in just under 40 pages.

Chapter 6 is pretty cool. It talks about quite a bit of advanced tag stuff like
1) customizing image button tags to isolate the Action changes
2) JSTL and Struts-EL
3) A good scheme for multi page navigation (prev, next etc) when the result set is quite large (I am itching to use this at work)
4) Using Pager Taglib with Struts
5) Editing Form with tables.

One small grouse I have regarding this chapter is that it made me refer back to Struts project doucmentation. The chapter states that in the begining that it doesnt repeat tag related docs available publicly. I think it would have been good if all tag info was in the book (even if it was repetition). This chapter is targetted to working developers. For a beginer like me, it took a while to digest this. But once I was through it, it is good.

Chapter 9 is pretty heady stuff. Exception handling in combination with Struts is covered to the last detail. What I liked about the chapter is that, it talks about the exception handling not just from a Struts application but at the system level. Having developed ejb aplications myself and had to pass on exceptions to web tier, I very much appreciate the picture presented in this chapter. I call it "my concise guide to better production support". The chapter is a dense read however.

Chapter 10 seems to be another goodie. I havent had time to read it yet, but I find the lead developer in our project using some stuff out of this chapter to develop to develop framework in our project.

Overall I must say, I am very pleased with this book.

A lot of us are in hurry to come upto speed with new technology and dont have time to read thick books on Struts that start with introduction to J2EE Servlet specification.

This book was such a relief. I recommend it to anybody starting on Struts.

Struts Survival Guide explains a lot of the Struts platform, and gives many effective code snippets to help guide the learning process. This book is good for someone who is just learning Struts or has previously been exposed to it and wants to learn more about all the bells and whistles. When each concept is introduced it's explained well and then the reason behind why you would or wouldn?t want to use the technique is given. That kind of discussion really helps the reader to understand how they might use it in their own application.

I have two main issues with the book:
* The first is all the grammar and spelling errors that plague the book. At times it gets distracting and makes the book a bit tough to follow. But this problem may be easily addressed in a future printing the book.
* The second is their index (or lack thereof). While reviewing the book I was working on a Struts project and would often grab the book to understand a new tag or a new concept that I'd never used before, but the index rarely listed the concept I was searching for even though I knew the book covered the topic because I'd read about it previously. For this reason, I believe the book is better read cover to cover and not as a desk reference. But the $15 price and the 224-page length makes buying it for that purpose easy to handle.

Lastly, the "Struts-Training companion workbook" offered through the ObjectSource website looks promising (http://www.objectsource.com/). The guide hasn't been completed yet, but seems to offer full-length examples and walk-thrus for each of the topics in the book

I must start by disclosing that I was a beta reader for the first three chapters. By beta reader, I mean - I did not know Struts before I started with this book. Beta reader was a concept that the author introduced to me as it differs from a reviewer. Reviewer is one who knows the technology already and is helping to verify if there are errors in the book.
Beta reader is a beginner who is new to the book's theme and reads the book from learning point of view.

My input from a beginner's perspective has gone into shaping the first three chapters. Within reading the first five chapters of this book - 115 pages in total, I knew all the important things in Struts I needed to confidently and successfully develop Struts application. The style of writing is easy read. And you feel that the author is explaining about Struts in person. It goes smoothly without any bumps.

I used the initial five chapters to overcome the learning curve to come up to speed with Struts. After I learnt Struts from the first five chapters, I moved on to read Struts documentation available at the Struts web site. When this book was later completed by the author, I came back and reviewed the rest of the book in another week. Reviewed is a wrong choice of word - Learnt is the right one since from what I found, this book does not repeat any stuff available freely. I learnt Tiles from the Chapter 7 in this book. I also went "Aha" on Chapter 6, 9 and 10 as they revealed some great strategies that are not available anywhere else. I plan to use them right away on the project I am working

Overall this is a great practical book. At $14.95 it rocks!! I would have bought it even if it was $25.00, but I got a free copy as I was a beta reader. The industry really needs this book.

This is my kind of book. When my boss told me I had to go on a Struts project the following week, I was excited but also scared. I didn't know Struts. I also did not have the time in my hands to read a 500 page book. But I wanted to master Struts fast.

Then I found this book. I devoured this book in its entirety in a week. Now, I not only know the basics of Struts, but also understand best practices and Strategies in Struts. Lucid presentation, Easy read and great stuff. A very practical book. I already find myself using the code from this book in my current project. And my co-workers think I am a smart Struts geek !

I read the O'Reilly book first, so I barely even noticed the grammatical errors in this book. This book is straight to the point and tells you exactly what you need to do to get up and running. On top of that, you learn some best practices right off the bat so you end up with a pretty decent framework. The O'Reilly book has you flipping all over the place trying to figure out when Struts starts and stops. Nothing like flipping to Chapter 11 so you can understand the example in Chapter 3. If you're looking for something that gives you the down and dirty to hit the road running, read this book.

Great book. Found a lot of useful advice.

Of all, I missed this book's advice when I was struggling in my previous project with the List Forms. I did not know the strategy illustrated in this book and devised my own hack.

As one of the review pointed out, I too found chapters 4, 6, 9 and 10 very useful and informative although I knew Struts and using it for over a year now.

So, this one is difficult to describe. First 3 chapters are basics, 1 is boring story about MVC model I and II. Chapter 2 is better, describes struts config, but nothing that you already don't know. Third chapter is hello world. All together for beginners.

Now Chapter 4 is a revelation, gives several very important hints, from security issues (page protection), what goes into action, handling duplicate submissions, and so on. Chapter 5 is also very good but deals with form validation (multiple pages, etc.). These chapters are not for beginners, and that is the reason why some people don't like this book. For the complete tutorial and learning book you should not use this one, although chapters 1-3 are in that way. This part of book acts like a cookbook, and has some great hints and ideas. Programming Jakarta Struts and Professional Jakarta Struts are more for people who need to learn it from beginning.

Finally chapter 6 deals with tag libraries, in a shallow approach, not good. Interesting is Chapter 7, dealing with Tiles, also very short, but tells you the most important things. However you need to purchase some other Tiles book if the Tiles are something you need to know in depth.

I would rate this book with 4 - with the accent that this is a "cookbook" not a tutoring book.

I believe that first 3 chapters should be shorter, perhaps just sheets and hints. More space should given to even more advices like in chapters 4 and 5. Tiles are imporant, but are discussed in way as chapters 1-3 but much condensed, thus better, but too short, many things were skipped. I would like to see a new edition of this book with more hints and more work on it and taking completely a direction of a cookbook not a tutorial.

Anyway, a good book, providing useful information which I couldn't find anywhere else.