spring webflow 1.0.4

Collection related classes usable by other packages and systems.

Core services for converting objects from one type to another.

Supporting type converter implementations that are generically applicable and frequently used.

Core expression language abstraction for parsing and evaluating expressions.

Expression abstraction implementations, integrated with BeanWrapper and OGNL.

Core services for formatting objects in string form.

Supporting formatter implementations that are generically applicable and frequently used.

Support for mapping attribute values between data structures.

Method binding support for invoking abritrary methods on target beans.

Common action implementations invokable by flow definitions.

When implementing custom actions, consider subclassing {@link org.springframework.webflow.action.AbstractAction}. Alternatively, you could also subclass {@link org.springframework.webflow.action.MultiAction} to bundle several action execution methods in a single class.

The {@link org.springframework.webflow.action.FormAction} provides powerful input form handling functionality.

Action implementations that define logic specific to flows executing in a JSR-168 Portlet environment.

High-level flow system configuration support within a Spring environment.

This is the highest-layer package in the framework, responsible for providing a clean interface for configuring Spring Web Flow.

This package also defines a Spring 2.0 custom XML namespace for configuring the Spring Web Flow engine in a Spring 2.0 environment.

Portlets are specified in the Java Portlet Standard.

The conversation subsystem for beginning and ending conversations that manage the state of user interactions.

The central concept defined by this package is the {@link org.springframework.webflow.conversation.ConversationManager}, representing a service interface for managing conversations.

This package serves as a portable conversation management abstraction and does not depend on the Spring Web Flow engine. It is used by the flow execution repository subsystem to store conversation related state. It is important to realize that this subsystem does not define a conceptual conversation, it just servers as a technical layer to manage state associated with conversations, as implemented by the SWF engine.

Conversation manager implementations.

This package depends on the root conversation package.

Foundational, generic types usable by all other packages.

Core element collection types used within Spring Web Flow.

This packages defines two primary collection flavors:

1. AttributeMap - for accessing 'attributes' that have string keys and object values.
2. ParameterMap - for accessing 'parameters' that have string keys and string values.

Each map is java.util.Map adaptable.

Core, stable abstractions for representing flow definitions.

Each flow has an indentifier and is composed of one or more states, one of which is the start state. States may be transitionable, and if so define one or more transitions that lead to other states.

With these types a client can introspect a flow definition to reason on its attributes and traverse its structure, perhaps to display a visual diagram. Note that the types defined in this package do not capture the behavioral characteristics of a flow.

The following code shows the beginnings of a basic flow definition traversal algorithm:

    FlowDefinition flow = ...

    // lookup start state
    StateDefinition state = flow.getStartState();

    // traverse to state transitions
    traverse(state);

    public void traverse(StateDefinition state) {
        logger.info("State: " + state.getId());
        while (state instanceof TransitionableStateDefinition) {
            TransitionableStateDefinition transitionable = (TransitionableStateDefinition)state;
            TransitionDefinition[] transitions = transitionable.getTransitions();
            for (int i = 0; i < transitions.length; i++) {
                Transition t = transitions[i];
                logger.info("Transition " + t.getId());
                traverse(state.getOwner().getState(t.getTargetStateId()); 
            }
        }    
    }

The flow definition registry subsystem for managing containers of flow definitions.

You can construct a generic, initially empty FlowDefinitionRegistry, populate it with flow definitions using a FlowDefinitionRegistrar, then lookup flow definitions by id. For example:

    // create registry
    FlowDefinitionRegistry registry = new FlowDefinitionRegistryImpl();

    // populate registry
    FlowDefinitionRegistrar registrar = ..
    registrar.addLocation(...);
    registrar.addLocation(...);
    registrar.registerFlowDefinitions(registry);

    // use registry
    FlowDefinition flow = registry.getFlow("myFlow");

The implementation of the core flow definition artifacts that serve the basis of the flow execution engine.

The engine implementation itself is located within the {@link org.springframework.webflow.engine.impl impl} package. Builders for assembling flow definitions executable by this engine are located within the {@link org.springframework.webflow.engine.builder builder} package.

The flow builder subsystem for building and assembling executable flow definitions.

You construct a Flow using a {@link org.springframework.webflow.engine.builder.FlowBuilder}. This package defines the following flow builder implementations:

• {@link org.springframework.webflow.engine.builder.AbstractFlowBuilder} - A convenience superclass to use when you want to assemble the web flow in Java code.
• {@link org.springframework.webflow.engine.builder.xml.XmlFlowBuilder} - A flow builder that reads an XML file containing a web flow definition and constructs the flow accordingly.

To direct flow construction, use the {@link org.springframework.webflow.engine.builder.FlowAssembler}. This package is based on the classic GoF Builder design pattern.

The XML-based flow builder implementation.

The implementation of Spring Web Flow's flow execution machine.

Support implementations for internal engine-specific types.

Core, stable abstractions for representing runtime executions of flow definitions.

The central concept defined by this package is the {@link org.springframework.webflow.execution.FlowExecution} interface, which represents a single instance of a top-level flow definition.

The following classes and interfaces are of particular interest:

• {@link org.springframework.webflow.execution.FlowExecutionFactory} - An abstract factory for creating new flow executions.
• {@link org.springframework.webflow.execution.repository.FlowExecutionRepository} - A DAO for persisting and restoring existing flow executions.
• {@link org.springframework.webflow.execution.FlowExecutionListener} - An observer interface to be implemented by objects that are interested in flow execution lifecycle events.

Package Usage example:

    // create flow execution
    FlowDefinition definition = ...
    FlowExecutionFactory factory = ...
    FlowExecution execution = factory.createFlowExecution(definition);
    
    // start execution
    ExternalContext context = ...
    ViewSelection response = execution.start(null, context);

This package depends on the definition package.

Supporting types often used by flow execution factory implementations. In particular, this package provides a number of classes facillitating the registration of flow execution listeners with a flow execution during its construction by a flow execution factory.

The flow execution repository subsystem for saving, and restoring managed flow executions.

The central concept defined by this package is the {@link org.springframework.webflow.execution.repository.FlowExecutionRepository}, representing a persistent store for one or more FlowExecution objects that capture the state of user conversations in a form that can be restored on subsequent requests.

Implementation of continuation-based flow execution repositories.

Useful generic support implementations of core flow execution types.

High-level executors for driving the execution of flow definitions.

The central concept defined by this package is the {@link org.springframework.webflow.executor.FlowExecutor}, representing a facade or entry-point for driving the execution of flows. This interface acts as the system boundary into Spring Web Flow most calling systems interact with.

The integration layer between Spring Web Flow and Java Server Faces (JSF).

Support for testing flows and their associated artifacts.

When you want to unit test one of your flows the {@link org.springframework.webflow.test.execution.AbstractFlowExecutionTests} and associated subclasses provide a base you can extend.

When unit testing flow artifacts such as actions in isolation, the {@link org.springframework.webflow.test.MockRequestContext} is of particular interest.

All mock implementations provided by this package are NOT intended to be used for anything but standalone unit tests. They are simple state holders, stub implementations, at least if you follow Martin Fowler's reasoning. These classes are called Mocks to be consistent with the naming convention in the rest of the Spring framework (e.g. MockHttpServletRequest, ...).

Support for testing the execution of a flow definition.