I bought this book with the hope of getting a better idea of how I should build the Web Flow flows in my Grails ( [...]) application. I know it is my own fault, and that I should have more carefully read the excellent reviews of this book, but I was a little disappointed to discover Web Flow was the topic in just two of twelve chapters when it is approximately 50% of the book's title.

If anyone knows a good source of reference on how to design Web Flow flows so that my web app has a nice natural user experience (e.g. able to use the browser 'back' button having gone though a flow's end state without getting in a mess) then please let me know. I want to aim for the sort of experience I have when using the amazon dot com shopping cart, not the sort of experience I have when using an ERP solution. So far with Web Flow my efforts have tended towards ERP quality :(

The book was great pre-release book, but like most programming books for specific frameworks becomes almost useless within a few months

I completely agree with the reviewer who points out how almost chaotically the information is delivered in this book - for the most part. Generally, you need to skip from section to section and back a few times before you can get all the pieces together. That's unacceptable. It's impossible to use this book as a convenient reference since each example generally provides only partial answers, and you have to scan back and forth through the pages to look for the clarification on the missing pieces. Often, the coverage is quite superficial. The official Spring Reference Guide on the Spring site does not get into too much detail on Spring MVC, leaving out lots of important and interesting details. Nevertheless, much more - and better - information is indeed available on-line today - at no cost. I haven't yet seen a perfect one-stop source for Spring MVC, but this book is definitely a waste of money. It may have been okay a couple of years ago when much less info was available online, but certainly not today.

The only part of this book that is very well written is the chapters on Spring Web Flow. Indeed, it appears that the chapters were written by someone other than the authors of the rest of the book. Someone who understood and appreciated the importance of a very thoughtfully organized FLOW of any sequence of logical steps, be it a software application, or a flow of information such as an instructions manual, or a tutorial. That's why Colin Yates, the apparent main contributor to Chapters 11 and 12 (on Spring Web Flow), does a much better job than the rest of the authors. Unfortunately, those Web Flow chapters are largely obsolete today. Some code in the book won't work. You'll immediately see that the classes in the org.springframework.webflow.test package you get with your latest Webflow distribution differ from the ones used in the book's examples. What's even worse is that the flow configuration XML files in the examples apparently use the old/obsolete XML schema. That means you shouldn't use them as examples for your own code. Just compare the code from the latest Spring [on-line] Reference Guide and the examples in the book and you will instantly see the difference.

For a very good introduction to Spring Web Flow, see the Spring Reference Guide (http://static.springframework.org/spring-webflow/docs/1.0.x/reference/introduction.html) and the article by the author of Spring Web Flow at http://www.ervacon.com/products/swf/intro/index.html, which is excellent.

Do not waste money on this book! Honestly. ;)

The book provides really good information and I was able to build out an application after reading it. The only problem is the editing and I hope a 2nd edition is released with fixes and updates for Spring 2.0. There are good PDF presentations out there that give a quick overview and one good tutorial that's a working example. I would google for those and read them alongside with this book.

As computer books continue their never ending slide into the abyss, Apress and Manning seem to be leading the way. This book is one of the best works of fiction ever written. From incomplete and non-working examples to the many errors, the publishers would be better served by pulling this tome off the market and starting over. There is nothing "expert" in this text nor is there anything the least bit helpful. Well, ok, I will admit the UML diagrams are nice.

Avoid this book at all costs.

Other reviews have mentioned that there are many problems with the examples in this book. I can only reaffirm what they've said.

The other thing that I really didn't like was the disorganized fashion with which the examples were presented. The authors seemed to jump around describing one small section of the problem in great detail, then 3-4 pages later would give you the critical piece of information you needed to understand their example 3 pages before. I am a fan of examples that are logically presented:
First you do x,
Then you do y,
you configure x to point to y
now deploy it, type this in the url field, and there you go, it works.

I found these examples to be more like:
First you do x,
then let me tell you everything there is to know about x.
y is very important as well.
if you wanted to set up y you could do it like this.
of another popular way of configuring y is like this.
and then there's this thing called z.
z is also very important, and here's some more information about z.
But of course, before we can set up z, we need to configure x to point to y.
I'm sure you can figure out how to configure x and y.
that's it, we're done.

So when you're done reading you feel like you have increased your general knowledge of the subject, but you really don't know exactly what you're supposed to do to actually make something that works.

I also would have liked more information about using commons-validator with Spring MVC instead of so much detail on VaLang. This would have been especially helpful for people moving from Struts to Spring MVC.

Those are the negative aspects of the book. On a positive note, it is fairly well written. There is a lot of good information that will increase your general understanding of the MVC and WebFlow frameworks. I do use this book as a reference from time to time, and it has provided me some value in that respect.

Overall though, I do not recommend purchasing this book. I think you can get a better idea of the WebFlow framework just by using the documentation on Spring's website, downloading the framework and walking through the examples. As far as MVC I think this book is better in the MVC chapters than it is in the WebFlow chapters, but with the release of Spring 2.0 even those chapters are now out of date.

Other reviews have mentioned that there are many problems with the examples in this book. I can only reaffirm what they've said.

The other thing that I really didn't like was the disorganized fashion with which the examples were presented. The authors seemed to jump around describing one small section of the problem in great detail, then 3-4 pages later would give you the critical piece of information you needed to understand their example 3 pages before. I am a fan of examples that are logically presented:
First you do x,
Then you do y,
you configure x to point to y
now deploy it, type this in the url field, and there you go, it works.

I found these examples to be more like:
First you do x,
then let me tell you everything there is to know about x.
y is very important as well.
if you wanted to set up y you could do it like this.
of another popular way of configuring y is like this.
and then there's this thing called z.
z is also very important, and here's some more information about z.
But of course, before we can set up z, we need to configure x to point to y.
I'm sure you can figure out how to configure x and y.
that's it, we're done.

So when you're done reading you feel like you have increased your general knowledge of the subject, but you really don't know exactly what you're supposed to do to actually make something that works.

I also would have liked more information about using commons-validator with Spring MVC instead of so much detail on VaLang. This would have been especially helpful for people moving from Struts to Spring MVC.

Those are the negative aspects of the book. On a positive note, it is fairly well written. There is a lot of good information that will increase your general understanding of the MVC and WebFlow frameworks. I do use this book as a reference from time to time, and it has provided me some value in that respect.

Overall though, I do not recommend purchasing this book. I think you can get a better idea of the WebFlow framework just by using the documentation on Spring's website, downloading the framework and walking through the examples. As far as MVC I think this book is better in the MVC chapters than it is in the WebFlow chapters, but with the release of Spring 2.0 even those chapters are now out of date.

I had been developing within Spring MVC for about half a year before I purchased this book. The section on testing Spring MVC was a little sparse, and the authors should have introduced more examples on WebFlow. Otherwise, I think it's a great book with lots of applicable examples.

(One of my co-workers took this book home over the weekend, read this book and got completely up to speed on Spring MVC. He was very impressed with it.)

There were not enough form examples. It is fine if you want to do binding with a text input form only, but if you want to do radio buttons, selects or hidden input boxes that have data already filled in, good luck! The code examples leave much to be desired.

I am so disappointed with this book, to say the least. I think it is very poorly edited.

Or maybe the book is not so bad, but I am unable to get my questions answered on support forums. If I were the author I would at least be monitoring a forum section devoted exclusively to this book, but no such luck.

While the explanation in the book seems OK, It looks like there is a lot left out in the code listings and illustrations. I am starting to think there is a section of chapter 4 missing from my printed copy.

Listing 4-3, page 45, I don't know if the authors wanted to call this class SearchFlights or FlightSearchCriteria. The confusion over the same issue continues in Listing 4-6, page 69, shows List findFlights(SearchFlights search);
when it should probably read List findFlights(FlightSearchCriteria search);

None of the Java listings give package declarations, you don't find out how to package this or what imports you need until you get to page 62, which shows a file layout. Fortunately I have been developing this in Eclipse, which has helped me find the imports.

That file layout on page 62, by the way, is missing the Airport class and introduces JSPs that haven't even been coded yet, nor has the SearchFlightsController Java class been developed yet.

I am not that much of a web development newbie - I've deployed web applications under Tomcat before. But I'm not finding either the book or the development community very helpful at this point.

The book seems to be well written, however one reason I purchase computer books is to go through the examples and actually get the source code to compile. There's an unanswered enty in the Apress forum from July asking if anyone could get the source to compile. As I said it's not answered so apparently no one else could get the source to compile either. As I said in the forum if authors would simply include a jar file with the source this problem would not exist. Since the author used eclipse to generate the examples and since it's a simple mouse click in eclipse to do this, it must be laziness on the authors part. I'll change my rating once (if) the source code compiles.

I am a seasoned Java developer, but not an experienced Web developer and I bought this book because I wanted to bring myself up to speed on Web development using Spring; but I am sobered now.
The book was obviously quickly pieced together from disparate material. Nobody seemed to have worked the examples through before releasing the book; these examples are inconsistent, and I lost a lot of time debugging and searching for the reasons why it did not work. E.g. on page 62 there is a diagram of what you should get when you follow the instructions; but if you follow the instructions, you do not get it. (resp. it makes assumtions about what is availble in the Web server without telling so).
If you are an experienced Web developer, you can probably make up the missing parts by yourself; if you are not, you spend a lot of effort searching for missing parts of the puzzle, instead of learning the thing you wanted.
Its a pitty the autors or editors did not spend the time in order to tediously check the content and make it consistent throughout; I think it could be a good instructional book (despite containing too much vain praise like ".. are highly configurable and extensible ..." instead of hard facts (e.g. useful examples of extensions); so it is only a text book for those already knowledgeable.

What is this book about?

Today, an abundance of MVC frameworks - each with its own pros and cons - plague a web-developers decision to choose one. Out of them, frameworks like Struts, Webwork and Maverick are deemed as request-driven frameworks, where as JSF and Tapestry are deemed as component-driven frameworks. Request-Driven broadly means, that the framework does not hide the HTTP-ness of the web world, but provides absractions that can simplify your job to handle them. Component-Driven means, that the web-framework seeks to hide the HTTP-ness, and provides the developer with an abstraction equivalent to Swing programming. Both types of frameworks have their own advantages and disadvantages. Spring MVC falls into the request-driven web frameworks category.

In my career, i have worked with many web frameworks. Out of all of them, i prefer Spring MVC for the following reasons
1. It has access to the full power of the Spring IoC and AOP container.
2. It is very well architected and brings true seperation of model, view and controller better than any other framework out there.
3. It is highly customizable.
4. It is interface driven, and doesnt force you to extend any framework classes.
5. It is easily testable - both unit and integration tests.
6. It helps apply good OO principles to the web-tier.
7. It provides easy-to-use template implementations of basic workflows.
8. It provides support for various view types(JSP, Velocity, Freemarker, etc) and completely decouples this support from other parts of the MVC.
9. It provides an exhaustive set of interface based hooks that one can customize or freshly implement for their own purposes.
10.And many more...

The above list is by no means exhaustive. So, i sincerely suggest to consider this framework if you are researching on an MVC implementation for your next project.

This book is all about Spring MVC and a sub-project called Spring Web Flow (SWF). Now, that you know what Spring MVC is, and where it fits into the plethora of available web-frameworks, you might be wondering what SWF is. Is it yet another web-framework that Spring supports? Is it a seperate implementation of Spring MVC? Is it something else? These kind of questions might come up, and i had all these questions in mind when spring announced SWF.

Anyways, SWF attacks a different problem. It is a seperate and self-contained framework, where you can define flows. Each flow is potentially a conversation between the user and the server over multiple pages and requests. The flows can be defined declaratively, and integrated with the MVC framework of your choice for execution. Spring MVC, Struts, JSF, Portlet MVC are supported out-of-the-box, but it is easy to implement an integration for your favorite framework.


How this book does it?

There are quite a few spring framework books around, that covers the entire framework. Sadly, none of those books gives Spring MVC enough importance and coverage is decent at best. Those books are geared towards covering the IoC and AOP features in-depth and finally when the book reaches the MVC section, they just breeze past it, not giving us enough practical ways to use it.

That is where this book comes in. This book takes from where other spring books leave and covers the entire Spring MVC framework in-depth. The author's writing skill is fabulous. You will be turning pages, before you even know. Typically, when you learn a new topic, you dont want to get into the details out-right. You want a complete mental picture first, then dive into details. That is exactly what the author does. He takes a topic and explains the overall picture in a couple of paragraphs. This first gives you the idea and scope of that topic. Then the author revisits the topic to explain it in depth with examples. I liked this approach very much. Trust me, I have read many spring books before, this one covering Spring MVC the best.

That said, this book is not for developers who are not familiar with spring. You should know Spring's IoC container, AOP, and other basic features before you can make sense out of this book. The author devotes one full chapter to provide a brief introduction to spring. That may be enough, but to be really confident, it is better if you first learn spring. I would suggest Pro Spring for that. Read my "Pro Spring" review for more information.

While many of the top notch Spring books offer reasonably thorough coverage of the Spring MVC framework along with other core Spring modules, there's not much printed material on Spring Web Flow. This book gives the Spring community a fix that'll keep us satisfied for the time being.

The authors do a good job at introducing in just a dozen pages enough fundamental concepts that a Java web developer needs in order to be ready for the rest of the book. In other words, no long-winded descriptions of the XML configuration files needed for configuring Spring, no detailed descriptions of how to wrap your beans into proxies, etc. Instead, you're taken straight down to business.

The core of the book starts out by first describing the Spring MVC architecture, including the role of controllers and views. Followed by the description of the architecture, the authors take the reader to a rollercoaster ride through the Spring MVC processing pipeline, including how to customize URL mappings, for example.

The chapter on controller components covers everything I can think of and the chapter on views and different view types does a great job at showing how to configure alternative view resolvers, how to internationalize your application's message resources, and how to render alternative content types such as PDF and Excel sheets in addition to covering the mainstream templating languages used for generating HTML, including JSP and JSTL as well as open source frameworks such as Velocity and FreeMarker.

An extra bonus point goes to the authors for including a section on testing Spring applications, even though the focus is mostly on unit testing controllers which is kind of a low-hanging fruit anyway. On the other hand, while topics such as validation and internationalization are discussed, the equally essential aspects of authentication and authorization are not given any attention.

The last two chapters, approximately 60 pages, are devoted to the brand new Spring Web Flow framework. I was glad to see the authors' pragmatic approach to stating the sweet spot for using Web Flow rather than proposing it as the "golden hammer" as they say. The explanation of the Web Flow concepts as well as the examples the authors use for guiding the reader through them are easy to understand.

As a summary, I thoroughly enjoyed reading this book and got a lot out of it. The only reason I considered not giving this book the absolute best rating possible is that there's a couple of security-related topics missing that I consider essential for any book dedicated to developing web applications.

Spring MVC and Web Flow are excellent contemporary web frameworks. We used this book to get up speed quickly (2 weeks) and implement a application using Spring Web Flow within a month of learning the basics. My only gripe is although Web Flow is very new, I wish there were more coverage. Granted you can pour through the javadoc as usual and guess at some things, I would have preferred a larger book that covers more. All in all, for a first book containing Spring Web Flow information it was very good.

I have used Spring for over a year including Spring MVC. This book covers the web framework in depth, I learned several new things. The most pleasant thing about the book is the author's insights into how Spring was designed and how properly constructed OO frameworks look like. The chapters on webflow are also excellent. Every serious developer should read this book even if they are not interested in Spring MVC!

I had already used Spring in my webapps for the "middle-tier": defining transactions, aspect-orientated progamming(logging) and making JDBC-programming in general easier.

But up to now I didn't see Spring as a possible replacement for the "web-tier", where I used Struts: Actions, Forms and Tiles.
Now I do: this is an excellent book about how to use Spring for the "web-tier", including Web Flow(for multi-page forms) and Valang (the Spring validation language for input validation).

The examples are very clear, the book is well written(easy to understand)

I was actually surprised to see this on the bookshelf! The only exposure to Spring MVC documentation I've had was either on www.springframework.org or the book written by the spring authors themselves which doesn't necessarily have much appeal.

This book is extremely well-written and the first three chapters provide a very good overview of Spring and some really good advice on developing a layered application in general. There's tons of information with clear examples. I admit, I'm only just more than halfway through the book, however, what I've seen so far is well worth the price.

I'm definitely going to be designing my web applications using this framework going forward. There are a few errors here and there (nothing major), but overall it's an outstanding book.

I have been working with Spring since the 1.0 release. Mr. Ladd's book definately pushed my skill set forward. I highly recommend this book to active professionals.