Customer Reviews

Spring Web Flow 2 Web Development

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

 

 

As somebody already mentioned here, this book is at a very basic level, but also with a lot of missing parts. If you are already familiar with Web Flow and you are looking to improve your knowledge, you shouldn't waste your money. So far, I couldn't find a good book on Spring Web Flow, since this is a niche framework.

The reference documentation that is listed on the springsource website is much valuable and well organized.

This book was largely a rehash of Spring Web Flow XSD's and Configuration files. The author started by introducing a fairly simple login application with a basic Web Flow. The author skimmed over explaining this basic application. I fully expected the author to continue to build on this example and further explain how to setup and configure a flow and use the power of Spring WebFlow to build a modern JSF based web application. Instead I was presented with page after page of XSD samples and configuration file snippets. The author did a very poor job explaining Web Flow concepts and how all this works together. I will have trouble even using this book as an adequate reference book to augment the online Spring documentation. I definitely would not recommend this book.

Spring Web Flow 2 Web Development by Sven Lüppken and Markus Stäuble is the currently only available book on Spring Web Flow 2.0. The book covers all the components that are part of the Spring Web Flow distribution such as:

* Spring Web Flow
* Spring Faces
* Spring JavaScript

Additionally, the book also provides an overview of Spring Security. The book comes with example code for many of the chapters.

The provided examples, however, could have been a little more consistent. The main source example in this book is covered in chapter 5 (A simple bug tracker). I liked the given example, as it does not require a database. This makes it easy to understand the Spring Web Flow specific problem domain. However, considering the fact that the authors also talk about Spring Security in other chapters, it would have been nice, if they had used the bug tracker example throughout the book in order to create a "complete" application, that ties together Spring Web Flow, the persistence layer and Spring Security. Unfortunately, the code examples given in later chapters don't refer back to the bug tracker example. Instead, chapter 6, for example, uses a shopping cart example.

A further minor annoyance is that the source code for 2 of the chapters still contain the eclipse project files used by the authors. This may be confusing for some users as these project files still point to Microsoft SQL Server drivers on a windows D: drive. I, for instance, use a Mac...

In chapter 2 the book discusses on 4 pages Ant and Maven. I think it might have been simpler for the understanding of the book and the provided source code, if only one build system was used, e.g. Maven. Some of the code examples provide Ant and Maven build scripts but some other ones provide support for Maven, only.

Another anomaly was, that the book describes the installation of the Spring IDE plugins for Netbeans and Eclipse on 7 pages but then the authors mention in passing only that they are using Microsoft SQL Server as underlying persistence store for their example. As many Java developers may not have a MS SQL Server license, it may have been better to use open-source Databases such as MySQL or PostgreSQL.

The example in Chapter 3 uses HSQLDB for its database but earlier (Chapter 2) the authors use MS SQL Server. For consistency and simplicity reasons the book could have stuck with one database.

Chapter 4 deals with Spring Faces. The authors should have mentioned JBoss Seam, since Seam solves a similar problem as Spring Web Flow but having a default focus on JSF.

The book provides an entire chapter on JSF integration (Chapter 4). As JSF is a widely used framework and Spring Weblow provides native support for JSF. It would have been nice though, if support for other frameworks such as Struts 1 and 2 would have been illuminated.

As part of chapter 5, the book also provides information on Spring JavaScript. While it is part of the official Spring Web Flow distribution it is not necessarily essential for the working of Spring Web Flow and even its spec lead Keith Donald mentioned at the Atlanta Java Users Group (AJUG) meeting in November'08 that it maybe extracted into its own project in the future.

The section in chapter 5 which starts on page 165, the Web Flow Configuration, felt repetitive to parts of Chapter 3 (pages 53) and should have probably merged with that section. Chapter 5 also contains a larger section on Apache Tiles integration. One thing that I did not understand was how Tiles matters in terms of mastering Spring Web Flow. Generally I don't mind explaining additional pieces of information around the edges of your problem domain but if that happens on 5 percent of the book, it needs to matter within the context of the targeted subject. On a site-note: Take a look at SiteMesh for your templating needs. I strongly prefer it compared to Tiles.

In chapter 6 the testing of your Spring Web Flows is explained. This was an informative chapter and I particularly liked mentioning of EasyMock.

In chapter 7 the book primarily details Spring Security. In my opinion, it provides too much Spring Security centric information. For example, the chapter describes how to create and write your own AccessDecisionVoter. In my opinion it does not help and is unnecessary for the understanding of Spring Web Flow. At most I would have chosen an example that uses a DB-backed security implementation using default Spring Security functionality.

To me, chapter 7 was a bit strange. It provides 16 pages of information introducing Spring Security but the actual integration of Spring Web Flow with Spring Security is accomplished in merely 4 pages. Most interestingly, that's where the book simply ends. I missed something like a wrap-up, that summarizes what the book covered and where to continue on.

In Appendix B the authors provide an overview of Springsource's dm Server. Personally, I think that dm Server is an interesting offering. However, I don't understand why this appendix even exists in this book. It is neither important for the understanding of Spring Web Flow, nor do the authors explain why this appendix exists.

Here are some further thoughts: Throughout the book, I like the use of Maven for building the examples. It certainly makes it easy to understand the examples' structure.

I think for the understanding of Spring Web Flow, it unnecessarily complicates things, if you present examples that require JNDI for establishing database connectivity. Furthermore it binds you to a concrete application server, which in this case is Tomcat.

Except for a for a very brief mentioning on page 224, the book never talked about the applicability of Spring Web Flow in the context of RIA frameworks such as GWT, Flex etc. Is there a use case for Spring Web Flow e.g. for coarse grained server state for large, complex applications?

It would have been nice if the book provided an overview of other frameworks that handle conversational state such as JBoss Seam. Additionally, since the books was published in March 2009, it could have described some of the planned conversational state management support planned for Spring 3.0.

Furthermore, it would have been great if the book had also mentioned how Terracotta can be used to back Spring Web Flow conversations. Terracotta provides an interesting reference application detailing that possibility.

Anyway, the book follows generally the Spring Web Flow documentation. The question is how much more value does the book add compared to the reference documentation. Overall, I have a quite conflicted opinion about this book. I think, if you are interesting in JSF integration or the bulk of the additionally discussed technologies (E.g. Spring JavaScript), then this book may add enough information for you. It certainly provides some useful information regarding Spring Web Flow 2.0.

Unfortunately, it contains quite a few inconsistencies and it is overall not an easy read. However, it is the only currently available book dealing with Spring Webflow 2.0.

The sample and document that you get when you download the Spring Web Flow from Internet is far better than this book. These documents are located in docs/spring-webflow-reference in html and pdf formats.

The book contains pieces and parts of that document but it is worse due to the many missing parts.

Intended Audience
This book is intended for Java web application developers who wish to learn about Spring Web Flow 2. A base knowledge of the Spring Framework and its associated MVC is advised, however most examples in the book provide sufficient detailing of the surrounding technologies and their integration points. This allows the reader to follow the examples without looking up details from other reference sources.

Chapter 1 - Introduction
The first chapter of this book provides a general introduction to Spring Web Flow 2 including some of the basic terminology. For those familiar with Spring Web Flow 1, there is a useful section detailing the major changes introduced in Web Flow 2. Having not used Spring Web Flow in over a year, I found the summary provided enough information to reacquaint myself.

Chapter 2 - Setup for Spring Web Flow 2
Chapter 2 details how to get Spring Web Flow setup in a Spring web application. Details on where to find the source code and examples provides a good starting point for users who wish to see Web Flow in action before delving into the details. An explanation of tooling support, such as setting up Eclipse to visualise flow, is a helpful addition especially with the prevalent screenshots.

Chapter 3 - The Basics of Spring Web Flow 2
As expected, this chapter covers the necessities for building a Web Flow, focussing on defining the flow using XML. This is by far the most important and useful chapter of the book. The chapter is just over 50 pages long, but is well worth the read as most sections are fundamental in using Web Flow, topics include: flow descriptors (including a diagram), flow scoped persistence, the newly supported EL expression language, scope levels, @Autowired behaviour gotchas, inputs & outputs, subflows and end states.

Chapter 4 - Spring Faces
Not being a JavaServer Faces (JSF) user, I skimmed over this chapter, however it is available as a sample chapter.

Chapter 5 - Mastering Spring Web Flow
This chapter contains a mix of topics. The first section includes further information on the usage of subflows, however I feel the explanation is a little brief.

The next section talks about integration with the Spring Javascript project. Spring Javascript is explained as being an abstraction layer on top of existing toolkits (only Dojo supported so far), but the example given has a hardwired dependency on dijit.form.DateTextBox. I'm not sure if this is just a bad example or if that is how Spring Javascript works. An introduction to the Tiles framework is then given and tied in nicely with an explanation of how to load page fragments using Spring Javascript.

The final section in this chapter covers advanced configuration of flows. I would advise using this section purely as a reference as it is heavy on detail.

Chapter 6 - Testing Spring Web Flow Applications
Being a bit of a testing zealot, this was the section I was really hanging out for. The opening sentence reads, "Testing is an important aspect in every software development process". Off to a good start, unfortunately this chapter didn't live up to my expectations.

The Web Flow specific test setup and assertions are explained well, for example calls such as context.setEventId("login"), this.resumeFlow(context) and assertFlowExecutionEnded().

The example then introduces EasyMock to help isolate and focus the unit tests. However this example has a glaring issue; it creates a mock of the wrong object. The example models a user login using a UserService to fetch a user by username. You would expect the mocked object in this case to be the UserService, but the example mocks out the underlying EntityManager. As a result the unit test for the flow ends up setting expectations on Hibernate HQL, thus polluting the flow's unit test with database queries that should really be tested at the service or DAO layer. If you change the way users were fetched in the DAO (or you moved away from Hibernate) you wouldn't expect your Web Flow tests to be affected.

My advice when reading this chapter is to skip to the section titled More testing with EasyMock. This section shows correct usage of EasyMock and demonstrates a test driven approach to testing.

Chapter 7 - Security
The final chapter covers the integration of Spring Security, the only real option for security in Spring. The details in this section are largely not specific to Spring Webflow, however they are important for developing any non-trivial application and are well explained with examples.

Conclusion
I would recommend this book to any developer new to Spring Web Flow. The concepts and much of the implementation between Web Flow 1 and 2 remains the same, meaning this isn't an essential read for existing Web Flow users.

Note, this is a copy of the original review from my blog: http://www.rapaul.com/2009/06/11/review-spring-web-flow-2/

I was approached by one of the editors at Packt Publishing about doing a review of Spring Web Flow 2 Web Development. I obviously said yes, the title of this post *is* "Review of Spring Web Flow 2 Web Development" :) Plus, I really don't have much experience with Spring Web Flow 2 (SWF2) and felt doing the review made perfect sense.

For those of you that appreciate my short, don't-hold-back, opinions, I'll start there:

Spring Web Flow 2 Web Development is both a great "getting started" book for people wanting to learn SWF2 and serves as a good high-level "getting started" with web programming using Spring / Java EE. Definitely worth the time and money.

Now my detailed review:

Again, I really liked how Spring Web Flow 2 Web Development serves as both a jump-start on SWF2 and also covers technologies outside of SWF (Spring Security, build tools, Apache Tiles, etc). The book isn't a detailed reference manual, that leaves you feeling you still don't know how to use the technology, but gives the right amount of walk-through examples and framework documentation.

When finished with the book you will understand how to install SWF2, how to build and use the examples. You will have numerous, feature-rich examples the authors build throughout the book. You'll know how to use SWF2 in a request-response Spring MVC app and also with a JSF application. You get a solid tutorial on using Apache Tiles (kind of odd in a SWF book), a very detailed explanation of Spring Security and integrating Spring Security with SWF. You also will understand how to test your flow definition and SWF application while also learning about EasyMock.

Here are my bulleted notes chapter by chapter:

ch 1:
Very short, brief intro to Spring Web Flow 2.
High level terms and definitions

ch 2 setup and example app:
install swf2
discuss the distribution
discuss the example apps and how to build from src
covers build systems (ant, mvn, ivy)
eclipse and spring ide
then a thorough example app
-flow definition
-service layer
-dao with jpa impl

ch 3
web flow documentation
detailed look at flow definition (.., scopes, states)
least favorite chapter
hard to read, not enough example tying concepts together

ch4
spring faces
starts with intro to jsf
I'm not interested in jsf

ch 5
sub flows - built on ch2 and ch3
spring javascript abstraction
oddly placed apache tiles tutorial for combining swf, spring js, and tiles
reference for web flow configuration

ch 6 testing swf apps
covers use of AbstractXmlFlowExecutionTests
short intro to EasyMock
tests subflows

ch 7
really good intro spring security
spring security and swf

Spring Web Flow 2 Web Development (Sven Lüppken (Author), Markus Stäuble - [..] Amazon)

Table Of Contents
[...][..]
1. Introduction to Spring Web Flow
2. Setup of Spring Web Flow 2
3. The basics of Spring Web Flow 2
4. Spring Faces (Downloadable for free!! :[...])
5. Mastering Spring Web Flow
6. Testing Spring Web Flow Applications
7. Security
Appendix A : flow.trac:The Model for the Examples
Appendix B : Running on the SpringSource dm Server

For those who would like to choose a web framework, this book deserves a glance.

From the documentation, Spring Web Flow is the module of Spring for implementing flows. The Web Flow engine plugs into the Spring Web MVC platform and provides declarative flow definition language.

The book directly dives into the details of the Spring Web Flow and where it stands as compared to the other layers of Spring like MVC. It has covered Spring Web Flow 2.0 in great depth and gets the Version 1 users up to speed with "whats changed". Chapter 2 deals with the development environment and with this the book makes an exception from the (in)famous Hello World example into something more sophisticated. Now this is big in Spring where the web site lists simple one liner examples (most of them from the older versions - I have personally submitted bugs :-( )

I like the way they explain the initial setup like
1. Build tools : Ant, Maven
2. The IDE configuration in Eclipse with "Spring IDE plugin" and Netbeans "Spring MVC plugin" is covered. Although IntelliJ and the Spring Source Tool Suite is missing.
There is also a quick start tutorial with examples (example applications provided within the Spring distributions), service and database layers, deployment description and dependencies (web flow, beans, views DispatcherServlet)
Spring Web Flow 2 release effort addresses two major themes: Integration and Simplicity. It focuses on providing the infrastructure for building and running rich web applications. As a Spring project, Web Flow builds on the Spring Web MVC framework to provide:

* A domain-specific-language for defining reusable controller modules called flows
* An advanced controller engine for managing conversational state
* First-class support for using Ajax to construct rich user interfaces
* First-class support for using JavaServerFaces with Spring



Modules of Spring Web Flow 2 :
[...]
Spring Web Flow
Spring Faces
Spring JavaScript
Spring Binding

The book is written in a very simple understandable language in a step by step manner interlacing the code, explanation and example to create a running application in the end. Chapter 3 delves into the basics of Spring web flow including the elements of flow, entry point, section data, states, exit point, section footer and configuration (FlowRegistry, FlowExecuter etc..) There is a little bit about validation.

After the flows it moves to Spring Faces (integrates rich user interface with support for JSF) to deliver the GUI of the web application. Just the basics of JSF are explained to bring others up to speed. There are good details about the configuration (enabling Spring Faces support, ResourceServlet, application context) and the integration with other JSF component libraries like JBoss RichFaces and Apache MyFaces. There is a detailed listing of all the tags available in Spring Faces and a complete example of create input page, handling errors, actions of buttons, display of results. Note: the code is interspersed in the explanation. An important part of Chapter 4 is the explanation of the integration of RichFaces (richfaces is a component library for JSF).

Further the book goes deeper into Spring Web Flow with subflows, Spring JavaScript and AJAX. This is the most interesting section of the book. Apache Tiles integration and configuration is also covered although the book does introduce Apache Tiles 2. Detailed listing of all XML configuration elements of Spring Web Flow is defined with sample code.

Spring Web Flow has good support for unit test and the book has an exhaustive discussion on testing web flows including MockExternalContext, startFlow(), assert(), resumeFlow(). It explains how to test your flows, subflows, persistence contexts and also gives a short introduction to EasyMock, which helps you to create mock implementations of your interfaces to test services. There is a sample example and explanation of how to integrate a test-driven development approach.

The last chapter deals with integration of Spring Security in the Spring Web Flow - how to set it up, web.xml, application context configuration and advanced configuration, the different types of AccessDecisionManagers, AccessDecisionVoter, how to define roles and authorities and SecurityFlowExecutionListener. The example given shows how to retrieve users from a database and secure parts of a webpage or a method and changing user's password.

And finally I read an interesting aspect of buying books from Packt publishing which is their commitment to open source. A great way to give back to the Open Source ecosystem.
"Packt Open Source Project Royalties"
When we sell a book written on an Open Source project, we pay a royalty directly to that project. Therefore by purchasing Spring Web Flow 2 Web Development, Packt will have given some of the money received to the Spring project.

In summary, I believe this is the good book for Spring Webflow. Through this book developers will be able to design, develop, and test your web applications using the Spring Web Flow 2 framework. They will also learn about the integration of JavaServer Faces (JSF) with Spring Web Flow, and how to organize and manage the storage of data inside their web applications. There is nothing about web services or GWT. Java developers will learn about the essential modules of the Spring Framework stack, and will be shown how to manage the control flow of a Spring web application. They will be introduced to Spring Faces, Spring JavaScript, and Spring Binding, and will learn how to improve the handling of the web flow. The functioning of the Testing, which is an important aspect of the software development process, is covered in this book, thus teaching developers how to go about using it in their Spring applications. In addition to this, users will also be ale to secure their web applications using Spring Security and Spring Web Flow. The chapters have enough code samples which helps you to setup an web project based on Spring Webflow.

Here is what thw authors have to say"In my opinion our book is different because it does not only explain how to create flows with Spring Web Flow, but also shows the integration with other technologies like JavaServer Faces, EasyMock, Hibernate, Spring Security and, additionally, how to use the powerful Spring JavaScript library (which is included with Spring Web Flow) to create compelling user interfaces. As written in the book, it is not designed to replace the reference documentation, but it includes step-by-step instructions which get you started with Spring Web Flow really quick. "

Who can use the book:
Any beginner who wants to use the power of Spring web flow. It assumes prior basic knowledge of Spring and configuration. If you get into details you would need to know the basics of specific techniques like JSF, security before you can go though the chapter although there are some starting points.

The source code for the book can be downloaded at [..]
Paperback: 272 pages
Publisher: Packt Publishing (March 20, 2009)
Language: English
ISBN-10: 1847195423
ISBN-13: 978-1847195425
Product Dimensions: 9.2 x 7.5 x 0.7 inches

About the Authors (As on the site)
Sven Lüppken
Sven Lüppken has a degree in computer science, which he passed with distinction. He is currently employed as Java Software Developer at one of the leading broadcasting and production companies in Germany. Sven started programming in C and C++ at the age of 16 and quickly fell in love with the Java programming language during his studies.

When he got the chance to write his diploma thesis about object-relational mapping technologies he accepted at once.
Since then, he has integrated Hibernate and the JPA in many projects, always in conjunction with the Spring framework.

Markus Stäuble
Markus Stäuble is currently working as CTO at namics (deutschland) gmbh. He has a Master degree in Computer Science. He started programming with Java in the year 1999. After that he has earned much experience in building enterprise java systems, especially web applications. He has a deep knowledge of the java platform and the tools and frameworks around Java.

Spring Web Flow 2 Web Development is a great read for developers who want to take a hands-on approach to learning a great technology. By following and working with the examples, you can experience the basic principles of Spring Web Flow 2 and how it integrates with JSF, Spring Security and AJAX. This book is great for Java developers who are already using the core Spring Framework and now want to involve Spring in the presentation tier of a Web application.

Within the first few chapters, the authors present a good overview of Spring Web Flow 2. Chapter 2 starts with the installation of Spring Web Flow 2 and some help with running the examples packaged within the distribution. Chapter 2 also goes over putting together a development environment that is based on some pretty standard open source technologies like Ant, Maven, Ivy, Eclipse (Spring IDE) and NetBeans. The "Support for Developers" section of chapter 2 is a great feature of this book because if you are not already familiar with the aforementioned technologies, you get exposure to some great open source development tools. After learning a little more about how everything works together, the authors throw in a little JPA and by the end of chapter 2, you have completed your first example.

The focus of chapter 4 is Spring Faces. In my opinion, if you are going to work with JSF, focus on this chapter because Web Flow 2 is what is missing from JSF. I am not a big fan of some of the JSF implementations I have used in the past, but Web Flow 2 makes working with JSF and Facelets a bit nicer and the Spring Faces tag library is very helpful. Combine chapter 4 with chapter 5's sections on Subflows and AJAX and you will have a good foundation for creating rich Web applications with Web Flow 2.

Chapter 6 illustrates Spring Web Flow 2's testing support. A very important part of the development process is testing. Too many developers overlook the importance of testing especially when it comes to Web applications. Web Flow 2 comes with great testing support and as the book points out, testing support is part of the framework rather than an after-thought for developers.

Some Web applications require some level of security and most enterprise Web applications have to incorporate support for authentication and multiple levels of authorization. Chapter 7 discusses the integration of Web Flow 2 with Spring Security, formerly Acegi Security. This chapter provides a great high level view of Spring Security configuration and how to lock down access to parts of a Web page and even method level security.

Overall I enjoyed reading this book and learning Spring Web Flow 2. The authors, Markus Stäuble and Sven Lüppken, did a great job in presenting the core concepts of the technology in only 200+ pages. Prior to reading the book, I had little knowledge of the technology, but now I would be comfortable working on a project that is utilizing Spring Web Flow 2. More information about the book and authors can be found at [...].

copied from original post at:
[...]