Spring Web Flow 3.0.1-SNAPSHOT API

Spring Web Flow logo
The public Java Documentation for the Spring Web Flow project.

Spring Web Flow facilitates building web applications that require guided navigation -- e.g. a shopping cart, flight check-in, a loan application, and many others. In contrast to stateless, free-form navigation such use cases have a clear start and end point, one or more screens to go through in a specific order, and a set of changes that are not finalized to the end.

A distinguishing feature is the ability to define a flow definition consisting of states, transitions, and data. For example, view states correspond to the individual screens of the flow while transitions are caused by events resulting from the click of a button or a link. Data may be stored in scopes such as flash, view, flow, and others. Scoped data is cleared when it is no longer in scope.

In REST terms a flow represents as a single resource. The same URL used to start the flow is also the URL used to step through the flow (there is also an execution key uniquely identifying the current flow instance). As a result of this approach navigation remains encapsulated in the flow definition.

Some key benefits of using Spring Web Flow:

  • A flow abstraction to model "long conversations" in web applications
  • Proper encapsulation for navigation rules
  • Multiple scopes in which to keep data
  • Automatic use of the POST/REDIRECT/GET pattern to avoid browser warnings
  • Impossible to return to completed flow sessions via browser back button
  • Rapid prototyping of flow requirements
  • Development mode in which flow definition changes are detected on the fly
  • IDE visualization for flow definitions
  • Much more...
Collection related classes usable by other packages and systems.
Core services for converting objects from one type to another.
Common Converter implementations.
Contains the implementation of the type ConversionService.
Core expression language abstraction for parsing and evaluating expressions.
Support for Spring's BeanWrapper implemented by the BeanWrapperExpressionParser.
Support for the Unified Expression Language (EL) implemented by the ELExpressionParser.
Support classes commonly used by ExpressionParser implementations.
Core services for formatting objects into a string form for display in a UI.
Support for mapping data between objects.
The default data Mapper implementation.
Possible Mapping results.
A system for recording and tracking locale-specific messages to display in a UI.
Custom method binding support for invoking methods on objects.
Common validation interfaces.
Configuration support for the Spring Faces custom XML namespace.
Extended implementations of JSF-specific data structures such as DataModel.
Conversion support for JSF-specific data structures.
Support for JSF integration with Spring MVC.
Development and debugging support for working with JSF.
The integration layer between Spring Web Flow and Java Server Faces (JSF).
Common action implementations invokable by flow definitions.
High-level flow system configuration support within a Spring environment.
The external context subsystem for accessing the environment of a client that has called into Spring Web Flow.
Contains the ServletExternalContext implementation for calling into Web Flow from a Servlet environment.
Shared classes used with Servlet or alternative ExternalContext implementations.
The conversation subsystem for beginning and ending conversations that manage the state of user interactions.
Conversation manager implementations.
Foundational, generic types usable by all other packages.
Core element collection types used within Spring Web Flow.
Core, stable abstractions for representing flow definitions.
The flow definition registry subsystem for managing collections of executable flow definitions.
The implementation of the web flow execution engine.
The FlowBuilder subsystem for building and assembling executable flow definitions.
Contains a FlowBuilder that builds Flow instances from a FlowModel.
Support classes for implementing FlowBuilders.
The implementation of Spring Web Flow's flow execution engine, based on finite-state machine.
Defines a configuration model for Flow instances.
The FlowModelBuilder subsystem for building FlowModels, a configuration model for a Flow instance.
Defines the XmlFlowModelBuilder, for building FlowModels from XML-based resources.
The registry subsystem for managing collections of flow models.
Support implementations the engine uses internally.
Core, stable abstractions for representing runtime executions of flow definitions.
Supporting types often used by flow execution factory implementations.
The flow execution repository subsystem for saving and restoring managed flow executions.
Contains the concrete flow execution repository implementations provided by the framework.
Support for repositories that take flow execution snapshots to support backtracking.
General purpose implementation assistance for flow execution repositories.
High-level executors for driving the execution of flow definitions.
Web Flow integration with the Unified EL API.
Support for configuring Spring MVC-based ViewFactory implementations when building a Flow.
The integration between Web Flow and Spring MVC, Spring's web application platform.
Support for rendering Spring MVC-based Views within Web Flow.
Flow-managed persistence with Hibernate and JPA.
Web Flow custom bean scopes allowing access to scoped-beans from a Spring ApplicationContext.
Support for securing flows using Spring Security.
Support for testing flows and their associated artifacts.
Support for testing the execution of a flow definition.
A migration tool to convert Web Flow version 1 flow definitions to the version 2 format.