Customer Reviews

Learning Jakarta Struts 1.2: a concise and practical tutorial: A step-by-step introduction to building Struts web applications for Java developers

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

 

 

The author goes in to some detail about the philosophy of the book, how he intends to present it as a "action" oriented book, rather than a list of instructions. That's fine, but the actions that he presents are terrible.

I bought this book mostly to see what's changed since Struts 1, which is what I'm familiar with. I'm somewhat familiar with Struts 1.1, I've messed with DynaActionForm and some of the new validation features. So I know what Struts is capable of... and it's not this.

Struts is an excellent controller (the C in MVC), and it has a lot of really handy tags that you can use in your JSP pages. Where the author completely misses the mark is that he concentrates so heavily on the tags and very little on what makes Struts really powerful... its controller. That's not to say that he only concentrates on tags, he goes into great detail about integrating a database, writing a properties singleton, and other garbage that has nothing to do with struts.

He frequently uses a jsp page as the URL to visit to access a page. A good Struts implementation should rely COMPLETELY on Struts as its controller. This means that all of his pages should have been *.do pages. Not only does this allow for pre-render logic, but it means that you can switch out what JSP page you want to use without having to change your URL. It's pretty much the foundation of struts, and yet it's completely lost here.

Another thing I found missing was action-specific forwards. His action tags were almost all single, closed <action/> tags with no content in between. He opted instead to use global forwards for everything.

I'm not a genius, I obviously have something to learn about Struts if I'm still buying books. But Struts is about making things clean, abstracting the Model 1 grossness that JSPs introduced. This book is a piecemeal organization of some capabilities of Struts. Not only is this book lacking on any high-level struts capabilities, but I think it actually teaches bad programming.

If you already have a Java background and are looking to learn how to use Struts for web apps, a good concise tutorial title would be Learning Jakarta Struts 1.2 by Stephan Wiesner.

Contents: Introduction to Struts; Hello Struts; The Struts Shop; Internationalization and Taglibs; Logging and Configuration; Forms; Logic; Exceptions; Controller and Templates; Putting It All Together; Struts Validator and Plug-In Classes; JSTL; Tools and Tricks; Solutions; Glossary; Literature; Index

This is a 200 page tutorial that assumes a basic background in your IDE of choice and Java in general. It's written well, but there's not a lot of hand-holding going on. The author dives right in and brings you up to speed on the concepts you need to know to work with Struts. The associated platform choices are all open source (like Tomcat and MySQL), so it won't cost you anything to get started. Conversely, the coverage of these other software packages aren't covered in great detail. You're told where you can download the software, and quickly how to install it. If you have problems, you'll probably need to check out other sources to fix them. The book follows a common development project throughout (a book store application), so it does a nice job of building on itself as it goes along. Couple that with the exercises sprinkled throughout the book, and you should be able to learn enough to become competent on the basics. For long-term Struts work, you'll probably want to get a Struts reference book or check out the project website. Still, as a first book to learn by doing, Learning Jakarta Struts fairs well...

I enjoyed this book, both Mr. Wiesner’s style of writing, and the way topics were introduced. The chapters are easy to read, and I never felt I was being lectured to. In addition, Mr. Wiesner has kept information relevant to the topic at hand without digressing into background information that might confuse newcomers. From as early as the second chapter you are developing in Struts, using a simple internationalization example. The chapters gradually build up from there, each one introducing new concepts in easy to read sections. By the end of the book, you will have created a simple bookstore application.

Mr. Wiesner assumes knowledge of Java, JSP, and Servlets, and expects you to have set up your JDK, Web Container, and Database before beginning. With this rudimentary knowledge, his introduction to Struts makes sense and examples are given demonstrating the differences between calling standard Java code from within a JSP and using the Struts equivalents.

My only complaints with this book are that the downloadable source code has not been converted into English (while the source code in the book has been) - this does not cause a major problem since the downloadable code is still very readable, but it does mean that the downloadable code does not exactly match the published code. Another issue is that the errata page does not appear to be regularly updated.

All in all, a very good book, and a welcome introductory book to Struts.

I needed to get up to speed on Struts quickly. So when I saw this "concise and practical tutorial", I thought, Perfect. I'll read this to get a basic understanding, do the exercises to reinforce it, and if and when I need more background, theory, or detailed knowledge, I can eventually turn to one of the larger works.

Maybe it's just not possible to adequately cover Struts in such a short space. Or maybe the author just didn't do a very good job. I think it's probably a combination of the two. But in any case, this book just fails to deliver.

To begin with, let me how explain how concise "concise" is. Subtract out the intro, appendices, index, etc. and the book boils down to about 155 pages of content. About half of that is taken up by source code and configuration file samples plus screen shots of browser windows and other images. Another 15 pages are used to describe how to set up Tomcat and MySQL, plus the requirements and database schema for the sample online bookstore. Normally, all this is very welcome. The problem is, this leaves us with only about 60 pages of explanation of Struts itself, in a rather large typeset at that.

It's simply not enough, and the author seems to know it. In many cases, he refers the reader to outside sources for explanation. In a few case, those sources are discussion forum entries dating back to 2002 and 2003! (The book is copyrighted 2005). But even when the book provides explanations, they're often so brief and concise, that I often had to turn to the Strut's online user guide or other sources just to try and figure out what was going on.

To its credit, the book does cover the subjects of Internationalization and Logging early and with *relative* thoroughness. These are 2 features that developers can too easily postpone, and Wiesner's emphasis on designing with these in mind from the start is good advice. But again, it leaves you scratching your head why he puts relatively so little into explaining more core concepts, like the chain of events in a request, how to make non-trivial forms (e.g. with checkboxes or list boxes), proper separation of model and controller, what the RequestProcessor is and how to use it, etc.

I think this could have been a good book. The authors write well enough, but just not enough. Note: this book is translated from the German, which apparently is 264 pages, so maybe that's a better read.

Finally, although the book is entitled "Learning Jakarta Struts 1.2", I see no evidence of any 1.2 features in it. Even the 1.1 features are mostly just addressed at the end, suggesting he initially wrote the book with 1.0 in mind. The version number is not in the German title; it's probably fair to conclude that Packt Publishing put it into the title as a (deceptive) marketing ploy.

Bottom line: pass on this one and find something more thorough.

Jakarta Struts is a framework that helps in developing and maintaining web applications. Struts really shows its potential with larger web applications when multiple developers, UI artists, content specialists are working on an application.

And maintaining a Struts application is a breeze in comparison to JSP/Servlet configuration. The challenge with Sturts is the complexity in understanding the framework - the framework itself is not terribly complex but it makes it seem like a tedious way to develop a web application. Many developers start off learning Struts with a 'Hello World' example and are not terrible impressed by what they have to do to get it going.

Mr. Wiesner's book makes learning Struts much easier - as the benefits are given in examples upfront. Most readers loose interest if the benefits are not demonstrated and that is a great lost to the Struts framework.

This book is suitable for a reader who is familiar with Java/Tomcat and would like a great introduction to Struts. The examples lead a reader through setting up a Java web application and tips on enhancing productivity with Struts.

Please let me know if you have any questions or suggestions regarding the review.