Package org.springframework.webflow.engine.builder

Class FlowArtifactFactory

java.lang.Object
org.springframework.webflow.engine.builder.FlowArtifactFactory
public class FlowArtifactFactory extends 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 Details

    • FlowArtifactFactory

      public FlowArtifactFactory()

  • Method Details

    • createFlow

      public Flow createFlow(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(String id, Flow flow, ViewVariable[] variables, Action[] entryActions, ViewFactory viewFactory, 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(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(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(String id, Flow flow, Action[] entryActions, 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(String id, Flow flow, Action[] entryActions, Action finalResponseAction, 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