All Classes and Interfaces
Class
Description
Base action that provides assistance commonly needed by action implementations.
Model support for actions.
A simple decorator for a Map, encapsulating the workflow for caching
expensive values in a target Map.
Abstract base class for parsing ${...} style expressions.
Base class for flow integration tests that verify an externalized flow definition executes as expected.
A base class for
@Configuration classes to configure
Spring Web Flow in JSF applications.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.
Trivial helper for concrete expression types that do not support setting their values.
Model support for mappings.
Convenient base class for
MappingResult implementations.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 suitable for subclassing by most
NumberFormatFactory implementations.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.
Special one-way converter that converts from a source array to a target array.
Special converter that converts from a source array to a target collection.
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.An expression that delegates to a
bean wrapper to evaluate or set a property of a context.An expression parser that parses BeanWrapper property expressions.
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 settable expression that adds non-null values to a collection.
A converter that can convert from one collection type to another.
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.Evaluates an array of expressions to build a concatenated string.
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.Base class for exceptions thrown by the convert system.
Thrown when an attempt to execute a type conversion fails.
A command object that is parameterized with the information necessary to perform a conversion of a source input to a
target output.
Thrown when a conversion executor could not be found in a conversion service.
A service interface for retrieving type conversion executors.
A converter is capable of converting a source object of type
Converter.getSourceClass() to a target type of type
Converter.getTargetClass().Produces NumberFormat instances that format currency values.
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.Default, local implementation of a conversion service.
The default document loader strategy for XSD-based XML documents with validation enabled by default.
A generic ELContext implementation.
A factory for a DefaultELContext.
A generic ELResolver to be used as a default when no other ELResolvers have been configured by the client
application.
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.
Generic mapper implementation that allows mappings to be configured programatically.
A single mapping definition, encapsulating the information necessary to map the result of evaluating an expression on
a source object to a property on a target object, optionally applying a type conversion during the mapping process.
Default mapping context implementation.
Default mapping results implementation.
The default message context implementation.
Default method resolver used by the MultiAction class.
Works with a general purpose
DecimalFormat instance returned by calling
NumberFormat.getInstance(Locale) by default.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 factory for creating a EL context object that will be used to evaluate a target object of an EL expression.
Evaluates a parsed EL expression.
The expression parser that parses EL expressions.
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.
Factory to create the
EvaluationContext for a given root Object.Indicates an expression evaluation failed.
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.
An expression capable of evaluating itself against context objects.
Parses expression strings into compiled expressions that can be evaluated.
An expression variable.
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 concrete implementation of
AbstractAuthorizeTag for use with standard Facelets rendering technology.A standard Facelets
TagHandler for performing Spring Security authorization decisions.This class provides static methods that are registered as EL functions and available for use in Unified EL
expressions in standard Facelets views.
Provides helper methods for getting a FacesContext that is suitable for use outside of Web Flow.
Convenient
ConversionService implementation for JSF that composes
JSF-specific converters with the standard Web Flow converters.Parser for the flow-builder-services tag.
Namespace handler for the faces namespace.
A Spring EL
ExpressionParser for use with JSF.A file name based
FlowUrlHandler implementation that is an alternative to the standard
DefaultFlowUrlHandler.Flash
scope implementation.A single flow definition.
The default
ActionListener implementation to be used with Web Flow.Wraps an
Application instance in order to ensure Web Flow specific implementations of ViewHandler and
StateManager are inserted at the front of the processing chain in JSF environments.Custom
ApplicationFactory that ensures the FlowApplication is the first Application in the chain,
which in turn guarantees the install order for other JSF components.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
FlowBuilderServices instances for use in JSF applications.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.
Custom
ELResolver for resolving web flow specific expressions.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.
Custom
ExternalContext implementation that supports custom response objects other than
HttpServletResponse.Custom
FacesContext implementation that delegates all standard FacesContext messaging functionality to a
Spring MessageSource made accessible as part of the current Web Flow request.A Spring Message
Source that originated from JSF.Adapter class to convert a
FacesMessage to a Spring Message.A
FlowExecutionListener that creates a FlowFacesContext
instance when a flow request is submitted and releases it when the request
has been processed.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.
Custom
Lifecycle for Spring Web Flow that only executes the APPLY_REQUEST_VALUES through INVOKE_APPLICATION
phases.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.
Web Flow
PartialViewContext implementation allowing IDs for partial rendering to be specified from the
server-side.A render kit implementation that ensures use of Web Flow's FlowViewResponseStateManager, which takes over reading and
writing JSF state and manages that in Web Flow's view scope.
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.
Resolves Facelets resources using Spring Resource paths such as "classpath:foo.xhtml".
A custom ResponseStateManager that writes JSF state to a Web Flow managed view-scoped variable.
Flow
scope implementation.A single, local instantiation of a
flow definition launched within an overall flow execution.Custom
StateManager that manages ensures web flow's state is always stored server side.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:
Simple
ViewHandler implementation that provides JSF Form's with the correct FlowExecution URL, including the
current FlowExecutionKey, so that postbacks may be properly intercepted and handled by Web Flow.A Web Flow flavor of the familiar Spring MVC View Resolver interface.
Default implementation of the ParserContext interface that has a fluent API for building parser context attributes.
Multi-action that implements common logic dealing with input forms.
A converter for common number types such as integers and big decimals.
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.
Base implementation of a conversion service.
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.
Produces NumberFormat instances that format integer values.
Thrown when a formatted value is of the wrong form.
Thrown when a method key could not be resolved to an invokable java Method on a Class.
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).Ajax handler for JSF 2 requests that can identify JSF 2 Ajax requests and send redirect instructions back to the
client by including a redirect instruction in the content of the response.
An extension of
FlowHandlerAdapter that replaces the default AjaxHandler instance with a
JsfAjaxHandler.A JSF-specific ExpressionParser that allows beans managed by either JSF, Spring, or Web Flow to be referenced in
expressions in the FlowDefinition.
Spring EL PropertyAccessor that checks request, session, and application scopes for existing JSF-managed beans.
ELResolver that checks request, session, and application scopes for existing JSF-managed beans.
Handles a request by delegating to the JSF ResourceHandler, which serves web
application and classpath resources such as images, CSS and JavaScript files
from well-known locations.
Helper class to provide information about the JSF runtime environment such as
JSF version and implementation.
Common support for the JSF integration with Spring Web Flow.
JSF View that renders a transient (stateless) JSF view template.
JSF-specific
View implementation.JSF-specific
ViewFactory implementation.A
ViewFactoryCreator implementation for creating instances of a JSF-specific ViewFactory.Provides a simple implementation of
Lifecycle that can be subclassed by developers wishing to provide
specialized behavior to an existing instance .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.
A
DataModel implementation that tracks the currently selected rows, allowing any number of rows to be
selected at one time.A simple, generic decorator for getting attributes out of a map.
An object whose contents are capable of being exposed as a map.
An
ELResolver for properly resolving variables in an instance of MapAdaptableSpring EL PropertyAccessor for reading from
MapAdaptable and writing to MutableAttributeMap.Maps state between two objects.
Information about a single mapping.
A single data mapping result.
Exposes information about the results of a mapping transaction.
A predicate used to select mapping result objects in a call to
MappingResults.getResults(MappingResultsCriteria).An object of communication that provides text information.
A convenient builder for building
MessageResolver objects programmatically.A context for recording and retrieving messages for display.
Adapts a MessageContext object to the Spring Errors interface.
A predicate used to select mapping result objects in a call to
MessageContext.getMessagesByCriteria(MessageCriteria).A factory for a Message.
Spring EL PropertyAccessor that resolves messages from the
MessageSource of the active Flow.Base class for exceptions that report a method invocation failure.
A helper for invoking typed methods on arbitrary objects, with support for argument value type conversion from values
retrieved from an argument attribute source, and conversion of the result to a desired type.
A helper for resolving and caching a Java method by reflection.
A specification for a method consisting of the methodName and an optional set of named arguments.
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.
A null object implementation of ParserContext.
A factory for
NumberFormat objects.A one-way converter that can convert from any JDK-standard Number implementation to any other JDK-standard Number
implementation.
Special two-way converter that converts an object to an single-element array.
Special two-way converter that converts an object to an single-element collection.
A
DataModel implementation that tracks the currently selected row, allowing only one selection at a time.Model support for output mappings.
A named method parameter.
An interface for accessing parameters in a backing map.
An ordered list of method parameters.
Input provided to an expression parser that can influence an expression parsing/compilation routine.
Base class for exceptions thrown during expression parsing.
Produces NumberFormat instances that format percent values.
Thrown when access to a flow execution was denied by a repository.
Model support for persistence context elements.
Adapts a PropertyEditor to the
TwoWayConverter interface.An evaluation exception indicating a expression that references a property failed to evaluate because the property
could not be found.
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.
PhaseListener that logs the execution of the individual phases of the JSF lifecycle.Request
scope implementation.The "required" error result--indicates a required mapping could not be performed because the source value to map was
empty.
Parser for the resources tag.
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.
A converter that calls the
TwoWayConverter.convertTargetToSourceClass(Object, Class) on a target
TwoWayConverter instance.A conversion executor that doesn't resolve its converter until its time to perform a conversion.
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
Interface for
DataModel implementations that need to track selected rows.Custom
ActionListener that inspects the UIComponent that signaled the current ActionEvent to
determine whether it is a child of any iterator type of component (such as UIData) that uses a
SelectionAware data model implementation.A simple
List-to-JSF-DataModel adapter that is also Serializable.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.
Enum exposing supported message severities.
An interface to be implemented by mutable attribute maps accessed by multiple threads that need to be synchronized.
A simple subinterface of
Map that exposes a mutex that application code can synchronize on.A map decorator that implements
SharedMap.An id that uniquely identifies a conversation managed by a
ConversationManager.Creates
SimpleEvaluationContext, for use with data binding.A factory that creates new flow execution snapshot instances that simply wraps an underlying
flow execution instance.ParserContext for use in data binding scenarios, providing
ExpressionParser
implementations with a hint that they can meaningfully restrict the EL feature set.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.
Indicates an exception occurred accessing the source object to be mapped.
EL resolver for resolving Spring Beans accessible by a flow's bean factory.
A Spring Converter that makes it possible for a Spring Binding Converter to be registered with a Spring
ConversionService.A Spring Binding Converter that delegates to a Spring
ConversionService to do the actual type conversion.A wrapper for a Spring EL
Expression
allowing it to be used under the Spring Binding Expression abstraction.Adapt the Spring EL
SpelExpressionParser to the Spring Binding
ExpressionParser contract.Creates a
StandardEvaluationContext enabling the full power of SpEL.A point in a flow where something happens.
A step within a
flow definition where behavior is executed.A message context whose internal state can be managed by an external care-taker.
A command object that is parameterized with the information necessary to perform a conversion of a source input to a
target output.
A simple expression evaluator that just returns a fixed result on each evaluation.
A simple flow execution listener loader that simply returns a static listener array on each invocation.
Base class for map adapters whose keys are String values.
Converts a String to a BigDecimal.
Converts a String to a BigInteger.
Converts a textual representation of a boolean object to a
Boolean instance.Converts a String to a BigInteger.
Converts a textual representation of a class object to a
Class instance.A formatter for
Date types.Converts a String to an Short using
Short.valueOf(String).Converts from a textual representation to a
Enum.Converts a String to an Short using
Short.valueOf(String).Converts a String to an Integer using
Integer.valueOf(String).Converts a String to a Locale using
StringUtils.parseLocaleString(String).Converts a String to an Long using
Long.valueOf(String).Converts a String to an Short using
Short.valueOf(String).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.
Indicates a successful mapping operation.
Default implementation of the resultObject-to-event mapping interface.
Indicates an exception occurred accessing the target object to be mapped to.
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 converter that can also convert from the target back to the source.
Indicates a type conversion occurred during a mapping operation.
A context for a validator to use to access user data and report validation failures.
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.
An evaluation exception indicating an expression failed to evaluate because the source value could not be coerced to
the target class
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.