Customer Reviews

Struts 2 in Action

5 star:		(12)
4 star:		(3)
3 star:		(1)
2 star:		(2)
1 star:		(4)

 

 

I had to learn Struts2 quickly since I recently changed jobs and my new team has several web application projects built using Struts2.

Overall, I thought the book was done very well if you are looking for a good introduction to Struts2. The first 8 chapters are very good.

The main negative is the source code for the book's examples. The authors provide one very large war file with all the source code embedded into the war file along with an overall web application divided into sub-applications for each chapter.

This packaging of the source code into the war file made it difficult for me to create individual projects in my development IDE that demonstrated just the material in a specific chapter. I had to spend quite a bit of time breaking down the source code into individual web projects and then figuring out on my own what jars needed to go into each project, what the struts.xml file needed to have, and what ever else was necessary to separate out just that chapter's sub-application so I could run that example and play with it.

Where this really became a problem was in chapters 9 and 10. Chapter 9 is a very advanced introduction to integrating Spring and Hibernate/JPA into Struts2. I never could get this chapter's example to work correctly.

However, chapter 10 on the validation framework then uses the same code as chapter 9, so you really cannot separate out the code for either chapter 9 and 10.

The validation framework is likely something even beginning Struts2 developers will want to use, while Spring/JPA/Hibernate is for more advanced developers and should have been well after the chapter on how to use the validation framework.

Also, the authors really don't give you a good understanding of what Struts2 jars you need to have to build a basic Struts2 application. There is some information about this in chapter 13 (setting up your IDE) but this information should really be at the beginning of the book. Also I don't think the list the authors provide is accurate since my basic HelloWorld (get the user to enter a name, call an Action class, and then display Hello userName in new jsp) worked with far fewer jars. Note there is apparently a new example war that just is a basic Hello World so there may be some information in that war file. That war was not on the manning web site when I purchased the book.

This book is good but be prepared to struggle working with the code examples if you want to work on the examples in your own development environment.

I recommend the authors create separate complete war files for each chapter's example to make it easier for users to just get that chapter's example code into their development IDE.

Lastly, the book does get 4 stars because the author's explanations of the basics of Struts2 (chapters 1-8) is very easy to follow for experienced Java developers. I'm now ready to tackle the Struts2 applications in my new job.

I took a chance and pre-ordered this book because I have recently started a Struts2 project and wanted to learn more about the framework. The book did not disappoint.

The authors explained the concepts behind the framework clearly and used examples that were immediately useful. The book is a little too short and in many cases a few more details would have been appreciated but it seemed to be a deliberate decision to leave out some of the less common use cases to avoid cluttering up the book. Thus, this book is ideal if you are new to Struts 2 but have some prior experience with Java web development.

I like the fact that an entire chapter was dedicated to integrating Spring and Hibernate into the framework. It brings all the bits and pieces from the online documentation together in a cohesive and comprehensive package.

Chapters were also dedicated to validation, internationalization, best practices and migration from Struts classic. The authors spent several chapters on how the Value Stack and the ActionContext worked and how OGNL fits into this framework.

All in all there is enough information in this book to start and to produce a complete Struts 2 application.

First, this book is outdated already. It covers Struts 2.0, and if you use 2.1 (which you should) you will have problems. This is particularly acute because 2.1 uses a lot of newer convention-based mapping to actions, and a lot of the techniques described in the book are now deprecated.

However, this biggest problem with the book is that it's a ponderous read. The author spends countless pages discussing the minutiae of OGNL and type converters ... way more than a beginner needs to know. However, more critical topics like the Struts2 JSP tags are barely covered until Chapter 6. Other important topics like session management are barely covered at all. This book needs a lot of editing and reorganization before it will be useful for most beginners.

Nevertheless, there is some useful information here for those with the patience to dig for it. I thought the discussion of interceptors was very solid. However, much of this doesn't justify the price of the book. I recommend just downloading the Starting Struts 2 docs from the Apache Struts2 website, and working through it. You'll learn a lot quicker through their "bootstrap" tutorial than you will here.

I agree with many of the comments about this being kind of a long winded book, but that's far from it's biggest failing. In spite of what feels like a barrage of numbing verbage at times, the authors still manage to leave out what I consider to be key info for a text like this. A little better editing and a little more economy of language would have a allowed missed points to be covered without expanding the book.

A good example of this in chapter two, where the authors totally whiff on container setup, which is absolutely critical to continue with the book. They spend nearly an entire page explaining that you need a servlet container, but that they're not going to help you with that because "the benefits gained from learning to install a servlet container far outway any short-term gains to be had from any container-specific quick start we might try to provide."

Bull****. The last thing anybody should have to do while they're trying to get through this book is take a detour to figure the whole servlet container thing. This is not a trivial task to wander off and learn on your own with absolutely no guidance. It can be done, but it's not fast or easy and like I said, it's not a detour you want to have to take just to able to get through the book. If I didn't already know how to set up a servlet container, I would have sent the book back for a refund, and I bet this is a major reason for countless readers never finishing it. There are dozens of tutorials, guides, and FAQs on the web that document exactly how to do this in very nearly the same amount of space the authors used for their excuse for not helping. If they really don't want to provide instructions themselves (whether out of ingorance or apathy), they could just point to one of these websites. It is simply unforgivable to abandon the reader at this point under the pretext of 'we"re really helping you by not helping you.'

I don't hold it against the authors because the book is a little out of date. It's almost impossible these days to write a book and get it published before the technology changes - it's a (rapidly) moving target. That said, there are still shops running and developing on the older versions of Struts (1 and 2), so the topic still has an audience.

This isn't the worst technology book I've ever read, but I was expecting much more. I'm like one of the other readers, who wondered what all the 5-star readers were so impressed with.

This is without a doubt the single worst technical book I have read in quite some time. I say this not because I claim the authors don't know their subject but because their method of exposition is torturous. I have picked up and put down this book three times and finally I have given up. Each time I pick it up I say to my self, Sal, try to ignore their style and force your way through so you can get going with Struts 2. However, each time I give up. Why? The authors philosophy seems to be "why use 10 words when you can use 50". Let's tell the poor reader what we are gonna tell them, hardly tell them and then tell them what we hardly told them. Let's concentrate on arcane details and elevate them to the most important status. I don't know exactly where the eleven 5-star reviews came from but trust me, if you really really want to learn struts 2 then use what you can find on the web. Personally, I think you should pass on Struts 2 and look at some of the more light-weight frameworks - see wikipedia page for struts. But I digress.

As an author, I really don't like giving poor reviews because I know writing is difficult. Certainly Manning deserves as much blame for failing to provide any editorial guidance. But the bottom line is this: We all have too little time. We buy technical books because we want to get up to speed quickly and we expect a book with a large number of 5-star reviews to deliver. This one does not and you should know that up-front.

This is a proper "In Action" book. I do strongly recommend it. If you plan to buy only one reference in the subject, look no further this is it! Down Brown is a Struts PMC member and an authoritative voice, among others he is the author of the Struts 2 REST plugin which is a superb addition to the framework from version 2.1.2

The book is very well written and easy to follow. I personally found the explanations very concise and appreciated the most their unique and clear way of breaking down and explaining all code snippets. This is really a great reference.

The first two chapters are a very good introduction to the framework. I am a pure version 2 user and had to learn most of these concepts from online documentation and from the Struts mailing lists.

Among all the topics covered I enjoyed and appreciated the most the coverage of:
- Interceptors
- OGNL and Type Conversion
- Validation! before this book, you could only find the relevant coverage of this topic scattered online in e.g. WebWork articles outdated
..for Struts 2. The authors did an excellent job explaining validation in chapter 10
- Really unique was the coverage of:
..... Unit testing actions
..... Tiles plugin
..... execAndWait interceptor "processing your request, please wait .."
..... UI component templates
..... Writing Struts 2 plugins

On the big plus side, the authors did a superb job keeping the book agnostic to minor versions of Struts 2 i.e. there were several differences from 2.0.x to 2.1.x and I was very happy to see that the examples and explanations were not outdated for the later.

On the down side and as a trade off I can only complain that the book left the Ajax topics out; maybe also because there have been many changes on this topic from minor versions of Struts 2 e.g. the ajax theme of Struts 2.0.x was converted to the dojo plugin in version 2.1.x. In any case, I somehow find the Ajax topic in Struts 2 to be one of the best documented online.

I believe that the Practical Apache Struts 2 Web 2.0 Projects (Practical Projects) book from Ian Roughley is a very good complement to this one. If you want to find coverage on topics like Security and Ajax in Struts 2 you will want that one too. The only issue there is that the coverage of the ajax theme is partially outdated for the newest version 2.1.2 of the framework

I have read some of the other reviews for this book which have high ratings. All I can say is they must be by very experienced Java programmers with years of experience working with other frameworks. If you're still learning Java and want to learn how to use Struts2 this is NOT the book you want to cut your teeth on.

The author seems to be very precise in his descriptions, but they are not very clear to some who does not have experience with the terms he uses and he does not provide a glossary or appendixes to help the newbie (example: his use of container instead of server - if I hadn't had a Murach text that does explained these are interchangeable terms I would continued to struggle to understand the topic the author was describing).

This book does not have nearly enough examples (let alone good ones) and the organization of the book's chapters just adds to the confusion. The book does not use the method of providing simple step-by-step examples to build working code and then circle back to explain what the various components are doing. I prefer that approach because it allows for experimentation and self learning. Instead the author immerses you in overwhelming tedious details, which are useless because you still don't have a point of reference to connect the dots.

Even our professor (who is very experience in web development with Java and other OOP languages) felt the book was too hard to follow and not appropriate for students. Our class was the first time he has taught Stuts2 and he stated he will not use this book again. He says you have to just about read the entire book through, retaining all the confusion, before the pieces start coming together - then go back and start reading the book again.

After using this book, I'll go back to using straight Java servlets and JSP. But, I don't think that's the fault of the Struts2 framework. I know there are not a lot of Strut2 books available, but if this was my only choice I would opted for using online tutorials and blogs. I have learned more that way then from this book (e.g. VaanNila.com).

At work, I kinda inherited a Struts 2 application that was having some problems, and needed to come up to speed on the technology quickly. This book worked as a great reference for me to get past my immediate problem (understanding OGNL, and how the ValueStack uses it to interact with forms). Once I got past my immediate need, I turned to the front of the book and started reading straight through.

It was great.

I loved how the book starts with the basics and quickly builds an example Struts 2 application as it goes through more in-depth topics. Downloading the Struts2InAction.war file from the publisher's website and working through the examples in the book is a great way to get the hands-on practice that is needed to really internalize the technical info presented.

Like all of Manning's "In Action" books that I've read, this book does a great job of working you through the technology from basic to advanced usage, while also presenting the information in a way that will continue to be valuable as reference material. As long as I'm working on Struts 2 applications, this book is going to remain on my bookshelf within easy reach

Way tooooo many words... not enough code snippets... The author was an English major. One code examnple is worth 10 pages of English. I read Jakarta Struts for Dummies and it was a lot better. I hope they have a Struts 2 book soon.

This is another poorly written book of the In Action series. The whole book could have been written in 100-150 pages with better content. I would rate Hibernate Made Easy and Head First Book for Servlets/JSPs as 5-star. With that being the standard, this book is 2.5/3-star rating.

Cons:
1. If you are new to Struts then good luck trying to setup your environment using this book. It does a poor job explaining that. I find the most difficult thing in Java world is the environment setup. That takes most of the time. After that its not so bad. This book and like any other In Action book does a VERY POOR job in explaining that to beginners, even though this book is for learning Struts 2. They should see how well Hibernate Made Easy is written. That's a perfect 5.

2. Examples in the book are hard to follow as they never show complete code. Its like a puzzle with snapshots of code. Very hard for a beginner to figure out how all the pieces (POJO, Xml files, JSPs, etc) are related to each other.

3. It has a chapter for integration with Spring and Hibernate. Again, setup of that environment is challenging. It doesn't mention which version of Spring the example is using. BTW, they use spring 2.5 and the latest one is 3.0. So if you download Spring 3.0 jars, the example provided will not work.

4. If the Complete Reference for Struts 2 is out then you may want to look into that first. I read The Complete Reference for JSF book and it is very well written compared to this crap.

Pros:
1. You don't need to know Struts 1 to learn Struts 2.
2. Struts2 Complete Reference Book is not out yet (as of 06/2011). So I had no other choice but to buy this one. That is one good thing about the In Action series. As soon as a new version of a software is out they write a book for it.