Customer Reviews

Pro Jakarta Struts, Second Edition

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

 

 

This book offers too much discussion of general software engineering. I suppose an enty-level developer might find that useful. I just wanted a book that teaches Struts, from "Hello, world" to the dirty details. If you already know the benefits of n-tier applications, much of the text is a waste. If you already know the value of design patterns, and how to apply some, then much of the text is a waste.

I found the Wrox book, Professional Jakarta Struts, to be much more focused and useful. That book sticks to the topic, and provides very good reference information on the configuration file and tag libraries.

Having said that, I did find the chapter on XDoclet to be useful.

Pro Jakarta Struts, Second Edition by John Carnell with Rob Harrop is the best book on developing Struts-based web applications I've read. (I've read at least five or six others.)

The title of the book is a bit of a misnomer, as it covers much more than just Struts 1.1 fundamentals. This book aims higher, including chapters on web application Patterns and Antipatterns, XDoclet, Velocity and ObjectRelationalBridge, along with the good explanations of various Struts-specific topics.

Pro Jakarta Struts, Second Edition is a pretty thick book at 578 pages. I didn't notice a single page wasted to printing some API. It isn't really a technical cookbook to be placed on a nearby shelf for quick reference during development to look up the basics of using some technology. Instead, the authors focused on good practices used when developing web applications, including explanations of why a technology should be used and how to use it, recurring problems that others have experienced (Antipatterns) and what to do instead (Patterns), and other pieces of advice designed to get the reader's brain thinking in web applications.

If you're in the market for a book on Struts-based web applications, get this one. It covers Struts 1.1 well, but it doesn't stop where Struts leaves off.

If you are the kind of person who needs all the basics and details before reading how to use them this book may not be for you. I like a book that has a quick intro on the basics and then gets to the real meat of things and this is that kind of book.

This is one of the best programming type books I have read in quite some time. Many books show you so many light weight examples and never develop anything but the basics. This book uses the same web app throughout the book, adapting it as you go. The app has many pieces and you can get a good feel for all of the pieces of the Struts framework.

Not only does he give good examples of how and why on implementing an app using Struts but he provides you with why not to do it other ways. He also provides a lot of advice on how not to integrate your app too tightly within the Struts framework making it flexable to use your code outside of a web app.

I work maintenance on several web apps and know how hard it is to integrate new funcationality into an existing application that is poorly written. The anti-patterns describe the systems I work on all too well so to have explanations of how to remedy these situations is helpful.

I work in a small consulting company and when our "Struts" expert moved to Minnesota I thought I had better get a book on Struts to brush up because I knew it would be only a matter of time before I needed some Struts knowledge. I scoured the reviews of the various Struts book s here at Amazon.com and finally settled on this book. And I am very happy I did.

The first chapter of the book gave me a few concerns. The wording seemed a bit naïve, but I got past that chapter and found a real gem. The reminder of the book was well written. The chapters were laid out in a logical progression. The examples had enough depth to convey their point, but not so complicated that you would get lost. And there were a minimum number of typos (I think I found only one in all the source code). A single application is developed through the entire course of the book applying the newly gleamed knowledge as you go so your understanding is constantly being reinforced.

I think the most significant positive about this book was its thoroughness. When the authors had presented a solution that worked they didn't stop there. They identified what would need cleaning up and what could be improved. And then they showed how to achieve it by continuing the example! The cleanup was often performed utilizing common design patterns and best practices. They even spent considerable effort pointing out when anti-patterns were rearing their ugly heads and what you could do to avoid/minimize them or eliminate them.

I don't think this book made me an expert in Struts, but I am very comfortable now. I feel like I have a good understanding of how Struts works and where I would turn if I needed more help. I think a more advanced book on Struts is in my future, but this was truly one of the better computer/programming books I have read. And I have read quite a few!

If you are looking for an introduction to Struts then I would highly recommend this book. If you already know Struts and are looking for an in-depth reference book, I don't think this is the right book. This book is definitely slanted more towards the beginning Struts developer.

Well done!

This book is fantastic because every example and scenario is given from the an excellent context: Each tool or idea is presented as a way to achieve proper OO and system design.

There are no stupid examples, which would never be a good base for real development.

There are no laundry lists of classes' APIs, whether the method calls are relevant or not.

The authors seem to understand that in the real world, knowing what the various methods of a framework do is only half the battle. Knowing how to use it is the other half.

Even if you don't need the education in design patterns, they are the context for all the information, and so really tell a working developer what she / he needs to know.

The motivation for this book is that for web server applications, several antipatterns have emerged. The authors term these Concern Slush, Tier Leakage, Hardwired, Validation Confusion, Tight Skins and Data Madness. Quite colourful and succinct. Apart from anything else, they should be commended for the terminology.

They suggest that the knowledgeable use of Struts can prevent these antipatterns. For example, they devote an entire chapter to showing with a detailed case study how you can validate an HTML form using Struts framework. As another example, a different chapter deals with the Data Madness antipattern. They demonstrate how to access your SQL database with a tier that isolates the specific properties of that database from the rest of your code. Far easier to switch or upgrade the database, if you desire.

Throughout the text are many instances of how the Struts XML configuration files gives you a simple declarative means of assembling your application. You still have to write actual code, of course. But the XML gives you a modular, extensible way to then plug the parts together.

Oh yes, they also emphasise another attraction of Struts. It is free and open source.

This is my third Struts book and I like it the best. The main reason is that it focuses more on the best way to use Struts and not on the basics of what it is an how to use it. Of course, the fundimentals are covered well in a chapter near the beginning, but what I found much more helpful were the specific best practices outlined in later chapters.

The authors go into detail on the best way to validate forms, manage business logic using J2EE patterns and EJBs, data access stategies (with almost a whole chapter devoted to O/R mapping).

In addition, there are chapters on more advanced Struts development like Tiles, Dynamic Forms and using the Struts Validator framework, using XDoclet and using Velocity.

Overall I found the book well written. There were the usual typos I find in all computer books, but not as many. Overall the code examples in the book were readable and clean.

Bottom line, if you are a Struts developer and you are looking for a book that expands the way you think about your archetecture and design, this book is for you. Enjoy

I believe this book is full of good Struts information however the idea that you will learn it by building a sample application is just not true. After setting up a development structure in chapter two the author leaves you on your own to figure out where to put the files your creating or modifying. Although you can figure this all out on your own it detracts and distracts you from focusing on the real details he is trying to teach you. Also there is no readme.txt in the downloads from the apress site as is written in chapter two. All in all this is only an average text for learning struts due to the lack of direction with the examples.

The book provides a good introduction to Struts and a starting point for more advanced topics & design patterns which may be found on-line. It does cover simple scenarios for extending the stuts framework. May be usefull for those who are not familiar with related technologies such as
xdoclet, commons logging, and OR mapping. Overall it is not an advanced book.

The book packages developer commonsense as patterns and anti-patterns with some flashy names such as Tier Leakage, Data Madness etc. Nothing much of value here. Looking for serious Struts stuff? Just move on.