org.springframework.webflow.engine.builder

Class FlowArtifactFactory

java.lang.Object

org.springframework.webflow.engine.builder.FlowArtifactFactory

public class FlowArtifactFactory
extends java.lang.Object

A factory for core web flow elements such as flows, states, and transitions.

This factory encapsulates the construction of each Flow implementation as well as each core artifact type. Subclasses may customize how the core elements are created.

Author:

Keith Donald, Erwin Vervaet

Constructor Summary

Constructors

Constructor and Description
FlowArtifactFactory()

Method Summary

Modifier and Type	Method and Description
State	createActionState(java.lang.String id, Flow flow, Action[] entryActions, Action[] actions, Transition[] transitions, FlowExecutionExceptionHandler[] exceptionHandlers, Action[] exitActions, AttributeMap<?> attributes) Factory method that creates a new action state, a state where a system action is executed.
State	createDecisionState(java.lang.String id, Flow flow, Action[] entryActions, Transition[] transitions, FlowExecutionExceptionHandler[] exceptionHandlers, Action[] exitActions, AttributeMap<?> attributes) Factory method that creates a new decision state, a state where a flow routing decision is made.
State	createEndState(java.lang.String id, Flow flow, Action[] entryActions, Action finalResponseAction, org.springframework.binding.mapping.Mapper outputMapper, FlowExecutionExceptionHandler[] exceptionHandlers, AttributeMap<?> attributes) Factory method that creates a new end state, a state where an executing flow session terminates.
Flow	createFlow(java.lang.String id, AttributeMap<?> attributes) Factory method that creates a new Flow definition object.
State	createSubflowState(java.lang.String id, Flow flow, Action[] entryActions, org.springframework.binding.expression.Expression subflow, SubflowAttributeMapper attributeMapper, Transition[] transitions, FlowExecutionExceptionHandler[] exceptionHandlers, Action[] exitActions, AttributeMap<?> attributes) Factory method that creates a new subflow state, a state where a parent flow spawns another flow as a subflow.
Transition	createTransition(TargetStateResolver targetStateResolver, TransitionCriteria matchingCriteria, TransitionCriteria executionCriteria, AttributeMap<?> attributes) Factory method that creates a new transition, a path from one step in a flow to another.
State	createViewState(java.lang.String id, Flow flow, ViewVariable[] variables, Action[] entryActions, ViewFactory viewFactory, java.lang.Boolean redirect, boolean popup, Action[] renderActions, Transition[] transitions, FlowExecutionExceptionHandler[] exceptionHandlers, Action[] exitActions, AttributeMap<?> attributes) Factory method that creates a new view state, a state where a user is allowed to participate in the flow.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

FlowArtifactFactory

public FlowArtifactFactory()

Method Detail

createFlow

public Flow createFlow(java.lang.String id,
                       AttributeMap<?> attributes)

Factory method that creates a new Flow definition object.

Note this method does not return a fully configured Flow instance, it only encapsulates the selection of implementation. A FlowAssembler delegating to a calling FlowBuilder is expected to assemble the Flow fully before returning it to external clients.

Parameters:

id - the flow identifier, should be unique to all flows in an application (required)

attributes - attributes to assign to the Flow, which may also be used to affect flow construction; may be null

Returns:

the initial flow instance, ready for assembly by a FlowBuilder

createViewState

public State createViewState(java.lang.String id,
                             Flow flow,
                             ViewVariable[] variables,
                             Action[] entryActions,
                             ViewFactory viewFactory,
                             java.lang.Boolean redirect,
                             boolean popup,
                             Action[] renderActions,
                             Transition[] transitions,
                             FlowExecutionExceptionHandler[] exceptionHandlers,
                             Action[] exitActions,
                             AttributeMap<?> attributes)

Factory method that creates a new view state, a state where a user is allowed to participate in the flow. This method is an atomic operation that returns a fully initialized state. It encapsulates the selection of the view state implementation as well as the state assembly.

Parameters:

id - the identifier to assign to the state, must be unique to its owning flow (required)

flow - the flow that will own (contain) this state (required)

entryActions - any state entry actions; may be null

viewFactory - the state view factory strategy

redirect - whether to send a flow execution redirect before rendering

popup - whether to display the view in a popup window

renderActions - any 'render actions' to execute on entry and refresh; may be null

transitions - any transitions (paths) out of this state; may be null

exceptionHandlers - any exception handlers; may be null

exitActions - any state exit actions; may be null

attributes - attributes to assign to the State, which may also be used to affect state construction; may be null

Returns:

the fully initialized view state instance

createActionState

public State createActionState(java.lang.String id,
                               Flow flow,
                               Action[] entryActions,
                               Action[] actions,
                               Transition[] transitions,
                               FlowExecutionExceptionHandler[] exceptionHandlers,
                               Action[] exitActions,
                               AttributeMap<?> attributes)

Factory method that creates a new action state, a state where a system action is executed. This method is an atomic operation that returns a fully initialized state. It encapsulates the selection of the action state implementation as well as the state assembly.

Parameters:

id - the identifier to assign to the state, must be unique to its owning flow (required)

flow - the flow that will own (contain) this state (required)

entryActions - any state entry actions; may be null

actions - the actions to execute when the state is entered (required)

transitions - any transitions (paths) out of this state; may be null

exceptionHandlers - any exception handlers; may be null

exitActions - any state exit actions; may be null

attributes - attributes to assign to the State, which may also be used to affect state construction; may be null

Returns:

the fully initialized action state instance

createDecisionState

public State createDecisionState(java.lang.String id,
                                 Flow flow,
                                 Action[] entryActions,
                                 Transition[] transitions,
                                 FlowExecutionExceptionHandler[] exceptionHandlers,
                                 Action[] exitActions,
                                 AttributeMap<?> attributes)

Factory method that creates a new decision state, a state where a flow routing decision is made. This method is an atomic operation that returns a fully initialized state. It encapsulates the selection of the decision state implementation as well as the state assembly.

Parameters:

id - the identifier to assign to the state, must be unique to its owning flow (required)

flow - the flow that will own (contain) this state (required)

entryActions - any state entry actions; may be null

transitions - any transitions (paths) out of this state

exceptionHandlers - any exception handlers; may be null

exitActions - any state exit actions; may be null

attributes - attributes to assign to the State, which may also be used to affect state construction; may be null

Returns:

the fully initialized decision state instance

createSubflowState

public State createSubflowState(java.lang.String id,
                                Flow flow,
                                Action[] entryActions,
                                org.springframework.binding.expression.Expression subflow,
                                SubflowAttributeMapper attributeMapper,
                                Transition[] transitions,
                                FlowExecutionExceptionHandler[] exceptionHandlers,
                                Action[] exitActions,
                                AttributeMap<?> attributes)

Factory method that creates a new subflow state, a state where a parent flow spawns another flow as a subflow. This method is an atomic operation that returns a fully initialized state. It encapsulates the selection of the subflow state implementation as well as the state assembly.

Parameters:

id - the identifier to assign to the state, must be unique to its owning flow (required)

flow - the flow that will own (contain) this state (required)

entryActions - any state entry actions; may be null

subflow - the subflow definition (required)

attributeMapper - the subflow input and output attribute mapper; may be null

transitions - any transitions (paths) out of this state

exceptionHandlers - any exception handlers; may be null

exitActions - any state exit actions; may be null

attributes - attributes to assign to the State, which may also be used to affect state construction; may be null

Returns:

the fully initialized subflow state instance

createEndState

public State createEndState(java.lang.String id,
                            Flow flow,
                            Action[] entryActions,
                            Action finalResponseAction,
                            org.springframework.binding.mapping.Mapper outputMapper,
                            FlowExecutionExceptionHandler[] exceptionHandlers,
                            AttributeMap<?> attributes)

Factory method that creates a new end state, a state where an executing flow session terminates. This method is an atomic operation that returns a fully initialized state. It encapsulates the selection of the end state implementation as well as the state assembly.

Parameters:

id - the identifier to assign to the state, must be unique to its owning flow (required)

flow - the flow that will own (contain) this state (required)

entryActions - any state entry actions; may be null

finalResponseAction - the state response renderer; may be null

outputMapper - the state output mapper; may be null

exceptionHandlers - any exception handlers; may be null

attributes - attributes to assign to the State, which may also be used to affect state construction; may be null

Returns:

the fully initialized subflow state instance

createTransition

public Transition createTransition(TargetStateResolver targetStateResolver,
                                   TransitionCriteria matchingCriteria,
                                   TransitionCriteria executionCriteria,
                                   AttributeMap<?> attributes)

Factory method that creates a new transition, a path from one step in a flow to another. This method is an atomic operation that returns a fully initialized transition. It encapsulates the selection of the transition implementation as well as the transition assembly.

Parameters:

targetStateResolver - the resolver of the target state of the transition (required)

matchingCriteria - the criteria that matches the transition; may be null

executionCriteria - the criteria that governs execution of the transition after match; may be null

attributes - attributes to assign to the transition, which may also be used to affect transition construction; may be null

Returns:

the fully initialized transition instance