All Classes and Interfaces
Class
Description
Base action that provides assistance commonly needed by action implementations.
Model support for actions.
Base class for flow integration tests that verify an externalized flow definition executes as expected.
Abstract base implementation of a flow builder defining common functionality needed by most concrete flow builder
implementations.
A base class for
@Configuration classes to configure
Spring Web Flow.Abstract base class for flow execution repository implementations.
Base class for tests that verify a flow executes as expected.
Trivial flow handler base class that simply returns null for all operations.
Model support for mappings.
Contains basic merge functions that can be utilized by other models.
Base view implementation for the Spring Web MVC Servlet frameworks.
Base class for mvc view factories.
Base class for repositories that take flow execution snapshots using a
FlowExecutionSnapshotFactory.Model support for states.
Model support for transitionable states.
Base class for
Scope implementations that access a Web Flow scope from the current request.Base class for flow integration tests that verify an XML flow definition executes as expected.
A command that executes a behavior and returns a logical execution result a calling flow execution can respond to.
A view factory implementation that creates views that execute an action when rendered.
Thrown if an unhandled exception occurs when an action is executed.
A simple static helper that performs action execution that encapsulates common logging and exception handling logic.
An ordered, typed list of actions, mainly for use internally by flow artifacts that can execute groups of actions.
Resolves the method to invoke on a resolved Web Flow Action instance.
Spring EL Property Accessor that allows invocation of methods against a resolved Web Flow action, typically a
MultiAction in expressions.A transitionable state that executes one or more actions when entered.
Model support for action states.
A transition criteria that will execute an action when tested and return
true if the action's result is
equal to the 'trueEventId', false otherwise.Strategy interface that encapsulates knowledge about a client-side ajax system and how to communicate with that
system.
View resolver that provides special view resolution for Spring Javascript Ajax requests.
An interface to be implemented by objects that are annotated with attributes they wish to expose to clients.
An action proxy/decorator that stores arbitrary properties about a target
Action implementation for use
within a specific Action execution context, for example an ActionState definition, a
TransitionCriteria definition, or in a test environment.A base class for all objects in the web flow system that support annotation using arbitrary properties.
An immutable interface for accessing attributes in a backing map with string keys.
Holder for information about the binding or unbinding event in an
AttributeMap.Causes an object to be notified when it is bound or unbound from an
AttributeMap.Model support for attributes.
Thrown if a conversation id could not be parsed.
Thrown when an encoded flow execution key is badly formatted and could not be parsed.
Spring EL PropertyAccessor for reading beans in a
BeanFactory.A bean-factory backed variable value factory.
Model support for bean imports.
A JSR-303 (Bean Validation) implementation of
ValidationHintResolver
that resolves String-based hints to a Class<?> array.Contains the information needed to bind model to a view.
A binding that provides the information needed to connect an element of the view to a property of the model.
Model support for the view-state binder element.
Model support for binding elements.
Makes the properties of the "model" object available to Spring views during rendering.
A utility class for working with attribute and parameter collections used by Spring Web FLow.
An action that will execute an ordered chain of other actions when executed.
A flow execution key that consists of two parts:
A executionId, identifying a logical
FlowExecution that is running.A flow execution listener loader that stores listeners in a list-backed data structure and allows for configuration
of which listeners should apply to which flow definitions.
Internal
Conversation implementation used by the conversation container.A service interface for working with state associated with a single logical user interaction called a "conversation"
in the scope of a single request.
Container for conversations that is stored in the session.
The root of the conversation service exception hierarchy.
An id that uniquely identifies a conversation managed by a
ConversationManager.A normalized interface for conversation locks, used to obtain exclusive access to a conversation.
An exception occurred within the conversation locking system.
A service for managing conversations.
Simple parameter object for clumping together input needed to begin a new conversation.
Conversation
scope implementation.A simple transitionable state that when entered will execute the first transition whose matching criteria evaluates
to
true in the context of the current request.Model support for decision states.
Default
AjaxHandler implementation.The default document loader strategy for XSD-based XML documents with validation enabled by default.
The default flow execution repository implementation.
A flow definition holder that can detect changes on an underlying flow definition resource and refresh that resource
automatically.
A flow model holder that can detect changes on an underlying flow model resource and refresh that resource
automatically.
The default FlowUrlHandler implementation for Spring Web Flow.
Default method resolver used by the MultiAction class.
A transition target state resolver that evaluates an expression to resolve the target state.
Transition criteria that tests the value of an expression.
Delegates to a configured view resolver chain to resolve the Spring MVC view implementation to render.
A generic strategy interface encapsulating the logic to load an XML-based document.
A state that ends a flow when entered.
Model support for end states.
Exception thrown to veto the entering of a state of a flow.
An action that evaluates an expression and optionally exposes its result.
Model support for evaluate actions.
Signals the occurrence of something an active flow execution should respond to.
A convenience support class assisting in the creation of
Event objects.Model support for exception handlers.
A facade that provides normalized access to an external system that has called into the Spring Web Flow system.
Simple holder class that associates an
ExternalContext instance with the current thread.An action that sends an external redirect when executed.
A file name based
FlowUrlHandler implementation that is an alternative to the standard
DefaultFlowUrlHandler.Flash
scope implementation.A single flow definition.
A director for assembling flows, delegating to a
FlowBuilder to construct a flow.Base class for attribute mapping failures.
Builder interface used to build a flow definition.
Provides services needed to a direct a flow builder through building a flow definition.
Generic implementation of a flow builder context, suitable for use by most flow assembly systems.
Exception thrown to indicate a problem while building a flow.
A simple holder for configuring the services used by flow builders.
A builder for creating
FlowBuilderServices instances designed for programmatic
use in @Bean factory methods.The adapter between the Spring MVC Controller layer and the Spring Web Flow engine.
The definition of a flow, a program that when executed carries out a task on behalf of a single client.
Thrown when a flow definition was found during a lookup operation but could not be constructed.
A holder holding a reference to a Flow definition.
A runtime service locator interface for retrieving flow definitions by
id.An action that sends a flow definition redirect when executed.
A container of flow definitions.
A builder for creating
FlowDefinitionRegistry instances designed for programmatic
use in @Bean factory methods.A generic registry implementation for housing one or more flow definitions.
An abstract representation of an externalized flow definition resource.
A factory for creating flow definition resources that serve as pointers to external Flow definition files.
Root class for exceptions thrown by the Spring Web Flow system.
An execution of a flow definition.
Base class for exceptions that indicate a flow execution could not be accessed within a repository.
Provides contextual information about a flow execution.
Base class for exceptions that occur within a flow while it is executing.
A strategy for handling an exception that occurs at runtime during an active flow execution.
A typed set of state exception handlers, mainly for use internally by artifacts that can apply state exception
handling logic.
An abstract factory for creating flow executions.
Default implementation of FlowExecution that uses a stack-based data structure to manage spawned flow sessions.
A factory for instances of the
default flow execution implementation.A key that uniquely identifies a flow execution in a managed
FlowExecutionRepository.A factory for creating flow execution keys.
Interface to be implemented by objects that wish to listen and respond to the lifecycle of
flow
executions.Deprecated.
Strategy interface that determines if a flow execution listener should attach to executions of a specific flow
definition.
Static factory for creating commonly used flow execution listener criteria.
A strategy interface for loading the set of FlowExecutionListener's that should apply to executions of a given flow
definition.
A pessmistic lock to obtain exclusive rights to a flow execution.
An outcome returned by a flow execution when it ends.
Central subsystem interface responsible for the saving and restoring of flow executions, where each flow execution
represents a state of an active flow definition.
The root of the
FlowExecutionRepository exception hierarchy.Thrown when the flow execution with the persistent identifier provided could not be restored.
A value object providing information about the result of a flow execution request.
A snapshot that can be used to restore a FlowExecution using a
FlowExecutionSnapshotFactory.A factory for creating different
FlowExecutionSnapshot implementations.A group of flow execution snapshots.
A strategy used by repositories to restore transient flow execution state during execution restoration.
A enum used internally by
FlowExecutionImpl to track its status.The central facade and entry-point service interface into the Spring Web Flow system for driving the executions of
flow definitions.
A builder for
FlowExecutor instances designed for programmatic use in
@Bean factory methods.The default implementation of the central facade for driving the execution of flows within an application.
A controller helper used for customizing access to a single flow definition in a Servlet enviroment.
A custom MVC HandlerAdapter that encapsulates the generic workflow associated with executing flows in a Servlet
environment.
Implementation of
HandlerMapping that follows a simple convention for
creating URL path mappings from the ids of registered flow definitions.Thrown when flow input mapping fails.
Model support for flows.
Builder interface used to build a flow model.
Exception thrown to indicate a problem while building a flow model.
A holder holding a reference to a Flow model.
A companion to
FlowModelLocator for access to the FlowModelHolder
wrapping the FlowModel.A runtime service locator interface for retrieving flow definitions by
id.A container of flow models.
A generic registry implementation for housing one or more flow models.
Thrown when flow output mapping fails.
Custom EL resolver that resolves the messages from the active flow's
MessageSource.Creates Spring-MVC Internal Resource view to render a flow-relative view resource such as a JSP template.
Flow
scope implementation.A single, local instantiation of a
flow definition launched within an overall flow execution.A interface for parsing and generating flow URLs.
A value object that defines a specification for a flow variable.
Spring EL PropertyAccessor that enables use of the following reserved variables in expressions:
A Web Flow flavor of the familiar Spring MVC View Resolver interface.
Multi-action that implements common logic dealing with input forms.
Convenience helper that encapsulates logic on how to retrieve and expose form objects and associated errors to and
from a flow execution request context.
A simple flow execution key implementation.
Simple flow attribute mapper that holds an input and output mapper strategy.
A
FlowExecutionListener that implements the Flow Managed Persistence Context (FMPC) pattern using the native
Hibernate API.View state history policies.
Map backed by the Servlet context for accessing application scoped attributes.
Map backed by the Servlet HTTP request attribute map for accessing request local attributes.
Map backed by the Servlet HTTP request parameter map for accessing request parameters.
A Shared Map backed by the Servlet HTTP session, for accessing session scoped attributes.
Helper class that adapts a generic
AttributeMapBindingListener to a HTTP specific
HttpSessionBindingListener.Model support for if elements.
Resolves "implicit" or well-known flow variables; for example "flowScope" in an expression like #{flowScope.foo}.
Model support for input mappings.
A conversation lock that relies on a
ReentrantLock within Java 5's util.concurrent.locks
package.A
FlowExecutionListener that implements the Flow Managed Persistence Context (FMPC) pattern using the
standard Java Persistence API (JPA).A generic, mutable attribute map with string keys.
An immutable parameter map storing String-keyed, String-valued parameters in a backing
Map implementation.An attribute map that exposes a mutex that application code can synchronize on.
Exception indicating that some Thread was interrupted during
processing and as such processing was halted.Thrown when a lock could not be acquired after a timeout period.
Spring EL PropertyAccessor for reading from
MapAdaptable and writing to MutableAttributeMap.
Spring EL PropertyAccessor that resolves messages from the
MessageSource of the active Flow.A trivial stub action implementation that can be parameterized to return a particular action execution result.
Mock implementation of the
ExternalContext interface.A stub flow service locator implementation suitable for a test environment.
A stub implementation of the flow execution context interface.
A simple flow execution key implementation.
Trivial flow execution key factory implementation that returns a mock flow execution key each time.
Mock implementation of the
FlowSession interface.A extension of parameter map that allows for mutation of parameters.
Mock implementation of the
RequestContext interface to facilitate standalone flow artifact (e.g.Mock implementation of the
RequestControlContext interface to facilitate standalone Flow and State unit
tests.Interface defining models.
Action implementation that bundles two or more action execution methods into a single class.
Strategy interface used by the MultiAction to map a request context to the name of an action execution method.
An interface for accessing and modifying attributes in a backing map with string keys.
Spring MVC external context implementation.
Returns
view factories that create native Spring MVC-based views.Thrown when no transition can be matched given the occurence of an event in the context of a flow execution request.
A singleton lock that doesn't do anything.
Thrown when no logical conversation exists with the specified
conversationId.Thrown when no flow definition was found during a lookup operation by a flow locator.
Thrown when the flow execution with the persistent identifier provided could not be found.
Thrown when no flow model was found during a lookup operation by a flow locator.
Transition criteria that negates the result of the evaluation of another criteria object.
Model support for output mappings.
An interface for accessing parameters in a backing map.
Thrown when access to a flow execution was denied by a repository.
Model support for persistence context elements.
An action that sets a special attribute that views use to render partial views called "fragments", instead of the
entire view.
Model support for render actions.
A context for a single request to manipulate a flow execution.
Custom EL resolver that resolves the current RequestContext under the variable
RequestContextELResolver.REQUEST_CONTEXT_VARIABLE_NAME
.Simple holder class that associates a
RequestContext instance with the current thread.Mutable control interface used to manipulate an ongoing flow execution in the context of one client request.
Request
scope implementation.A strategy for creating an
Event object from an arbitrary object such as an expression evaluation result or
bean method return value.Helper that selects the
ResultEventFactory to use for a particular result object.Result object-to-event adapter interface that tries to do a sensible conversion of the result object into a web flow
event.
Registers the Spring Web Flow bean scopes with a
ConfigurableListableBeanFactory.Custom EL resolver that searches the current request context for variables to resolve.
Spring EL PropertyAccessor that searches through all Web Flow scopes.
An enumeration of the core scope types of Spring Web Flow.
Model support for secured elements.
Flow security integration with Spring Security
Encapsulates the rules for comparing security attributes
A snapshot implementation that is based on standard Java serialization, created by a
SerializedFlowExecutionSnapshotFactory.A factory that creates new instances of flow execution snapshots based on standard Java serialization.
Provides contextual information about an HTTP Servlet environment that has interacted with Spring Web Flow.
The Spring Web Servlet MVC view implementation.
Creates Servlet MVC views.
Simple implementation of a conversation manager that stores conversations in the session attribute map.
An action that sets an attribute in a
scope when executed.Model support for set actions.
An interface to be implemented by mutable attribute maps accessed by multiple threads that need to be synchronized.
An id that uniquely identifies a conversation managed by a
ConversationManager.A factory that creates new flow execution snapshot instances that simply wraps an underlying
flow execution instance.Thrown when a continuation snapshot could not be taken of flow execution state.
Thrown when a flow execution snapshot cannot be found This usually occurs when the client references a snapshot that
has since been removed.
Thrown when a FlowExecutionContinuation could not be deserialized into a FlowExecution.
EL resolver for resolving Spring Beans accessible by a flow's bean factory.
A point in a flow where something happens.
A step within a
flow definition where behavior is executed.A simple flow execution listener loader that simply returns a static listener array on each invocation.
A strategy interface used by a subflow state to map subflow input and output attributes.
A transitionable state that spawns a subflow when executed.
Model support for subflow states.
Default implementation of the resultObject-to-event mapping interface.
A strategy for calculating the target state of a transition.
Factory that encapsulates configuration of default flow builder services for a test environment.
Abstract superclass for states that can execute a transition in response to an event.
A state that can transition to another state.
Strategy interface encapsulating criteria that determine whether or not a transition should execute given a flow
execution request context.
An ordered chain of
TransitionCriteria.A transition takes a flow from one state to another.
A flow execution exception handler that maps the occurrence of a specific type of exception to a transition to a new
State.Model support for transitions.
A typed set of transitions for use internally by artifacts that can apply transition execution logic.
A helper class the encapsulates conventions to invoke validation logic.
A strategy for resolving String-based hints to Objects such as validation
groups against a JSR-303 provider.
A strategy that encapsulates the source of a flow variable value.
Model support for var elements.
Allows a client to participate in flow execution.
Holder class for passing Spring MVC view action state through a redirect.
A factory for a view that allows the client to participate in flow execution.
Simple adapter that adapts a view factory render cycle to the action interface.
A factory for ViewFactory objects.
Thrown if a IO exception was thrown during view rendering.
View
scope implementation.A view state is a state that issues a response to the user, for example, for soliciting form input.
Model support for view states.
A variable scoped to a particular view.
Flow URL handler that implements the default Web Flow 1.x URL format.
NamespaceHandler for the webflow-config namespace.Allows for Unified EL expressions in a FlowDefinition.
Message Codes Resolver that implements the default Web Flow 2.x algorithm.
A sub-class for
SpringELExpressionParser that registers Web Flow
specific Spring EL PropertyAccessors.Converts Web Flow 1 flow definitions to the version 2 syntax.
Transition criteria that always returns true.
Builds a flow model from a XML-based flow definition resource.
FlowExecutionListenerhas default methods (made possible by a Java 8 baseline) and can be implemented directly without the need for this adapter.