Overview | Package | Class | Tree | Deprecated | Index | Help
| Spring Web Flow
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## 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
`FlowArtifactFactory()`

Method Summary
`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, 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, 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,
                                    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,
                                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

Overview | Package | Class | Tree | Deprecated | Index | Help
| Spring Web Flow
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD