Customer Reviews

Mastering Jakarta Struts

5 star:		(16)
4 star:		(11)
3 star:		(12)
2 star:		(8)
1 star:		(5)

 

 

This was a great book. It talks in great depth, not only about Struts, but also about J2EE in general. I would have called myself an upper-intermediate Java programmer when I picked up this book, but an a total newbie to J2EE. I put away my "Core Servlets and JavaServer Pages" (Hall) and "Enterprise JavaBeans (Monson-Haefel) books that were far too difficult to read in favor of this book's simple approach.

It was AWESOME that he went through each and every one of the Struts JSP custom tags, describing their usage, and the attributes of each tag. I found this incredibly useful.

I agreed that the examples in the book were real-world, and I found them effective in helping solidify my understanding. I was especially pleased with the time he spent on database access. This is documentation that is hard to find with Struts (and, frankly, with many Java application frameworks).

But, there were some difficulties about the book that I didn't quite understand:

1. His database-access code is poorly written. He doesn't reuse any of the JDBC code. He isn't writing a book on a JDBC persistence layer API, I realize, but it made things difficult to follow as I focused on the code deficiences. An exercise for the reader to develop, I guess.

2. The code, as it is written in the book (and downloaded from the web site) doesn't execute without exceptions upon deployment to my JBoss container. If you're going to publish code in a book as an example, it really should compile and execute without modification. Otherwise, you should indicate that it doesn't execute unless you first do steps x, y, and z.

3. Chapter 5, on Views covers in good depth how to use the JSP pages as data gathering mechanisms (subheading "JSPs that Gather Data"), but doesn't cover AT ALL how to present that data. I guess he assumes we all know how to present it! In chapter 11, he covers how to use the <html:iterate/> custom tag to iterate over the result sets obtained from a database query, but there is no real detail in the book about it. I would imagine that 98% of us will be using this mechanism HEAVILY, and felt like it deserved a better treatment within chapter 5.

4. He didn't cover ANY of the M of MVC. He lumped all his JDBC code into his Action classes, which doesn't seem like good design to me. Also, it seemed like he made an assumption that Model = Database. This isn't exactly the case.

I feel this is the best book for novice Struts developers eventhough it is not as up to date as some of the others.

This book does a good coverage of extending Struts, and a really good coverage of the inner workings of Struts.

I have all of the Struts books (Sams, KF, Orielly, Manning, and Wiley) etc. This is the first book out of the lot that I could just read (cover to cover). It has good flow, and it is easy to understand. (I read it quite a while back when it first came out).

Areas of weakness is in Tiles framework support and the Validator framework, but currently no Struts book covers Tiles well. Struts in Action does a really good coverage of the Validator book as does the Orielly book.

First get this book as a good tutorial.
Second get the Struts in Action book as a good reference.
Then get the Orielly Struts book (in this order in my opinion).

If you are doing Struts, it can't hurt to have Sue Speilmans book (who covers nested tags well), and the Sams Struts book.

I have all of the books. This is the best tutorial for getting started.

I liked this book and learned a lot from it. It is now the top book on the stack of books on my desk. One of the things I like is
that this book is a great reference. I consult it frequently for explanations of Struts tags, especially because the author included
code samples that show how each tag is used in combination with other tags. I use the bean, logic, and template tag library
references pretty regularly.

The error handling info is great. The info on validating data in your forms is good. The deployment advice is excellent. I also
really like the debugging chapter and found it incredibly useful since Struts isn't the absolute most stable framework I've ever
used. One reviewer said he didn't like the embedded Tomcat example in the debugging chapter, but I learned a lot from
debugging a real app and can apply the concepts pretty easily to my own work.

I read through the internationalization section of this book and am now pretty hyped about putting that functionality in some of
my Struts apps, even if my company doesn't really think its necesary yet. :|

I also like that this book shows you how to build a complete Struts applications. You can see clearly how Struts works with
servlets, jsp, and other serverside technologies. I even learned a few things from the summary of servlets and jsp in the second
chapter.

All around a very useful book!

I found this book to be adequate for understanding the basics of Struts. The book states that it describes Struts 1.1 which is the new beta release, however many important topics are not covered. There is no mention of DynaActionForms and no information about using the validator which is integrated into the Struts framework. Both of these features are great time and code savers. It does describe the RequestProcessor which is new to Struts 1.1.
Overall, this is a good intro to Struts but lacks some very important information about the new features of release 1.1.

I'm a dedicated open source developer and always will be but I have to admit I've spent many days and nights trying to decipher the Struts docs. Not only how to use plugins, datasources, and other elements of the framework, but why and when to use them. The docs are often confusing at best.

This book made sense of Struts for me. It is very clear and just as good, it is concise. The code snippets make great examples, and the full-on sample employee database app really demonstrates how Struts, servlets, JSP, and tab libraries can be used in conjunction to build serious apps.

The book begins with a quick review of servlets and JSP, which was really useful given that Struts implementation of MVC is a little bit different. The servlet life cycle and Struts MVC implementation illustrations are excellent references. The debugging and error management chapters were also extremely helpful.

All in all a great book that has enabled me to move beyond tinkering and begin doing some serious development.

Mastering Struts is clearly written, detailed and full of pragmatic development and deployment advice. I'm surprised at the reviewers who say this book doesn't cover much (or any) 1.1 information. The 1.1 coverage I found very useful includes ActionForm, ActionServlet, ActionsMappings, plugins, RequestProcessor, new 1.1 tags, etc etc.

Other material in this book was far deeper than the Struts docs, including:
* The value of MVC, and when and why to use Struts (amazingly, the Struts docs are very light on these crucial adoption issues)
* I18N. The docs have a couple paragraphs, and this book has a whole chapter--really helped me internationalize my apps in a meaningful way.
* Debugging and error handling
* The tag references add a lot of info not in the docs and give code examples
* Tons of database and JDBC info with MySQL examples. Again, amazing that the docs don't cover much on hooking into databases since 99% of serious webapps connect to one.
* Also there are two, full apps that the author develops in this book that go a long way to showing how a Struts app can/should be built and deployed.

I don't know if I'll buy any of the other books when they come out (I might) but they have a lot to live up to.

The material is written in a clear and understandable manner. It does cover the BASICS on how to develop a Struts application. I CANNOT BELIEVE that this book does not cover DynaActionForms, Validator, or Tiles. These are very much a part of Struts 1.1. I think that the book was written for 1.0 and was slightly modified to incorporate some of the new 1.1 features. This is yet another book that feels they need to spend some 40+ pages on an introduction to Servlets and JSP. Combine this with the 80+ pages of Tag Library Tables in the back.... The book discusses various open source tools, such as SQL and Tomcat and then spends a whole chapter on how to embedd Tomcat into JBuilder(???). The book only covers the basics of Struts and does not cover anything like performance issues or integrating Struts to some sort of Model like JDO or EJB's. Programming...

I was anticipating a book on Struts for a long time. The documentation for Struts (as with many open source tools) is quite lacking. This is the first of several books coming out on Struts and to be honest, the author should have waited a while longer and worked on it some more. It's obvious that the Author is a good writer. In fact, I enjoyed his servlet book a great deal. However, he missed the boat on this one.

There are two main problems that I have with this book. First, there are many teechnical mistakes that should have been caught. It was quite distracting for me. I found myself looking for them rather than soaking up the material. The second problem, which has been pointed out by other reviewers, is that the 1.1 coverage is terrible. Struts 1.1 is leaps and bounds better than 1.0 and the set of new features in 1.1 is what makes Struts more usable in applications. To release the book early like this and not cover those features is a mistake for the publisher. Unless the goal is to quickly publish the next version on 1.1 and rake in a few more bucks, I don't know what the purpose would be.

The short of it is, this book is fine if you want a high-level overview of Struts. However, if you are looking for the "why" and not just a superficial "how", you may be disappointed. For sure, "Mastering" Struts it is NOT.

This is a managerial-level overview of Apache's Struts Framework. When trying to learn how to actually develop an application, I found this book to be completely useless. Buy the O'Reilly book or Husted's instead to get a real guide to Struts that will actually help.

This book was a big disappointment. I purchased this book in hopes of supplementing the information found on Apache's Jakarta Struts page. I shouldn't have bothered.

Much of the information in the book is either wrong or poorly written. Many times the author will spend two paragraphs describing a concept or class, then say in the next paragraph, "Now that you have seen what X can do and understand how to use it, let's see how we can ...." Unfortunately, the two paragraphs haven't explained the concept, nor shown us what it can do, or described even how it fits with the rest of the framework.

The writing was even worse in some parts. Some sections were cut-and-paste text, and blatantly incorrect.

A coworker of mine independently came to the same conclusion about this book and returned his copy. I only wish I had done the same.

I suggest Programming Jakarta Struts or Struts in Action. Both of those books are far superior to this one. Use Apache's website for many good resources - you'll save the cost of this book if you start there first.