다음 예제는 flow레벨에서 상속된 전역전환에 더해 상태레벨(state level)에서 정의된 전환을 보여준다.

    <flow start-state="state1">
    
        <some-state id="state1">
            <transition on="localEvent1" to="state2"/>
        </some-state>

        <some-state id="state2">
            <transition on="localEvent1" to="state1"/>
        </some-state>
		        
        <global-transitions>
            <transition on="globalEvent1" to="state1"/>
            <transition on="globalEvent2" to="state2"/>
        </global-transitions>
               
    </flow>
    			

이 예제에서 state1는 하나의 전환을 정의하고 global-transitions요소내 정의된 두개의 다른것들을 상속한다. 이 flow내 정의된 다른 상태(state)는 이 전환전역을 상속할것이다.

이 예제는 아래에서 그림으로 보여진다.

전역전환(Global transitions)

ViewState 입력된 ViewState가 org.springframework.webflow.ViewSelector일때, ViewSelection을 만드는 책임을 지는 창조적 전략이다. 이것은 viewName가 계산되는 방법, modelMap가 준비되는 방법, 그리고 리다이렉트가 이슈회되는지를 사용자정의하기 위한 플러그인 지점(plugin-point)을 제공한다. This provides a plugin-point for customizing how the viewName is calculated, how the modelMap is prepared, and whether a redirect should be issued.

Two ViewSelector implementations are provided with Spring Web Flow:

The following example shows a view-state definition in XML that makes a simple view selection when entered, selecting the searchForm view for display and, on resume, responding to two possible user input events (submit and cancel) in different ways:

    <flow start-state="displaySearchForm">
        <view-state id="displaySearchForm" view="searchForm">
            <transition on="submit" to="processFormSubmission"/>
            <transition on="cancel" to="processCancellation"/>
        </view-state>
        
        ...
    </flow>
    			

The following example shows the equivalent view state definition using the FlowBuilder API:

    public class SearchFlowBuilder extends AbstractFlowBuilder {
    	public void buildStates() {
    	    addViewState("displaySearchForm", "searchForm",
    	        new Transition[] {
    	            transition(on("submit"), to("processFormSubmission")),
    	            transition(on("cancel"), to("processFormCancellation"))
    	        }
    	    );
            ...    	          
        }
    }	
    			

The following example illustrates a view-state definition in XML that makes a simple view selection when entered, redirecting to the yourList view for display.

    <flow start-state="displayList">
        <view-state id="displayList" view="yourList" redirect="true">
            <transition on="add" to="addListItem"/>
        </view-state>
        
        ...
    </flow>
    			

The following example shows the equivalent view state definition using the FlowBuilder API:

    public class SearchFlowBuilder extends AbstractFlowBuilder {
    	public void buildStates() {
    	    addViewState("displayList", new SimpleViewSelector("yourView", true),
   	            transition(on("add"), to("addListItem"))
    	    );
            ...    	          
        }
    }	
    			

The following example illustrates a view-state definition in XML that encapsulates typical "form state" behavior.

Consider the requirements of typical input forms. Most forms require pre-render or setup logic to execute before the form is displayed. For example, such logic might load the backing form object from the database, install formatters for formatting form field values, and pull in supporting form data needed to populate drop-down menus.

In addition, most forms require post-back or submission logic to execute when the form is submitted. This logic typically involves binding form input to the backing form object and performing type conversion and data validation.

This "form state" behavior of form setup, display, and post-back is handled elegantly in Spring Web Flow by the capabilities of the view-state construct. See below:

    <flow start-state="displayForm">
        <view-state id="displayForm" view="form">
            <entry-actions>
                <action bean="formAction" method="setupForm"/>
            </entry-actions>
            
            <transition on="submit" to="saveForm">
                <action bean="formAction" method="bindAndValidate"/>
            </transition>
        </view-state>
        ...
    </flow>
    			

This reads "when the displayForm state is entered, execute the setupForm method on the formAction and render the form view. On submit transition to the saveForm state if the bindAndValidate method on the formAction executes successfully."

As outlined, the ActionState is the central state type for invoking one or more actions and responding to their result to drive a state transition. There are also other points within the lifecycle of a flow where a chain of actions can be executed. At all of these points the only requirement is that these actions implement the central org.springframework.webflow.Action interface.

An Action may be annotated with properties by wrapping the Action in a decorator, an instance of org.springframework.webflow.AnnotatedAction. These properties may provide descriptive characteristics, or may be used to affect the action's execution in a specific usage context.

Support for setting several common properties are provided for convenience. These include:

The following example constructs an ActionState definition from XML that executes a single action when entered and then responds to its result:

    <flow start-state="displaySearchCriteria">
        ...
        <action-state id="executeSearch">
            <action bean="searchAction"/>
            <transition on="success" to="displayResults"/>
        </action-state>
        ...
    </flow>
    			

This state definition reads "when the executeSearch state is entered, execute the searchAction. On successful execution, transition to the displayResults state."

The association between the searchAction id and an Action implementation is made by the XmlFlowBuilder at Flow configuration time using a service registry, typically a Spring BeanFactory. For example:

    <beans>
        <bean id="searchAction" class="example.webflow.SearchAction"/>
    </beans>
    			

... associates the searchAction with a single instance of example.webflow.SearchAction.

A simple SearchAction implementation might look like this:

    public class SearchAction implements Action {
        private SearchService searchService;
        
        public SearchAction(SearchService searchService) {
            this.searchService = searchService;
        }
        
        public Event execute(RequestContext context) {
            // lookup the search criteria in "flow scope"
            SearchCriteria criteria =
                (SearchCriteria)context.getFlowScope().getAttribute("criteria");
    	        
            // execute the search
            Collection results = searchService.executeSearch(criteria);
    	    
            // set the results in "request scope"
            context.getRequestScope().setAttribute("results", results);
    	    
            // return "success"
            return new Event(this, "success");
        }
    }
    			

The following example constructs the equivalent action state definition using the FlowBuilder API:

    public class SearchFlowBuilder extends AbstractFlowBuilder {
    	public void buildStates() {
            ...
            addActionState("executeSearch", action("searchAction"),
                transition(on("success"), to("displayResults")));
            ...    	          
        }
    }	
    			

The next example constructs an ActionState definition from XML that executes a single action method on a org.springframework.webflow.MultiAction and then responds to its result:

    <flow start-state="displaySearchCriteria">
        ...
        <action-state id="executeSearch">
            <action bean="searchFlowAction" method="executeSearch"/>
            <transition on="success" to="displayResults"/>
        </action-state>
        ...
    </flow>
    			

This state definition reads "when the executeSearch state is entered, execute the executeSearch method on the searchFlowAction. On successful execution, transition to the displayResults state."

A SearchFlowAction implementation containing multiple action methods might look like this:

    public class SearchFlowAction extends MultiAction {
        private SearchService searchService;
        
        public SearchAction(SearchService searchService) {
            this.searchService = searchService;
        }
        
        public Event executeSearch(RequestContext context) {
            // lookup the search criteria in "flow scope"
            SearchCriteria criteria =
                (SearchCriteria)context.getFlowScope().getAttribute("criteria");
    	        
            // execute the search
            Collection results = searchService.executeSearch(criteria);
    	    
            // set the results in "request scope"
            context.getRequestScope().setAttribute("results", results);
    	    
            // return "success"
            return success();
        }

        public Event someOtherRelatedActionMethod(RequestContext context) {
            return success();
        }

        public Event yetAnotherRelatedActionMethod(RequestContext context) {
            return success();
        }
    }	
    			

As you can see, this allows you to define one to many action methods per Action class. With this approach, there are two requirements:

The following example constructs the equivalent action state definition using the FlowBuilder API:

    public class SearchFlowBuilder extends AbstractFlowBuilder {
    	public void buildStates() {
            ...
            addActionState("executeSearch", method("executeSearch", action("searchAction")),
                transition(on("success"), to("displayResults")));
            ...    	          
        }
    }	
    			

The next example constructs a ActionState definition from XML that executes a single method on your Plain Old Java Object (POJO) and then responds to the result:

    <flow start-state="displaySearchCriteria">
        ...
        <action-state id="executeSearch">
            <action bean="searchService" method="executeSearch(${flowScope.criteria})"
                       resultName="results"/>
            <transition on="success" to="displayResults"/>
        </action-state>
        ...
    </flow>
    			

This state definition reads "when the executeSearch state is entered, execute the executeSearch method on the searchService passing it the object indexed by name criteria in flowScope. On successful execution, expose the method return value in request scope under the name results and transition to the displayResults state."

In this example, the referenced bean searchService would be your application object, typically a transactional business service. Such a service implementation must have defined the the Collection executeSearch(SearchCriteria) method, typically by implementing a service interface:

    public interface SearchService {
        public Collection executeSearch(SearchCriteria criteria);
    }	
    			

With this approach there are no requirements on the signature of the methods that carry out action execution, nor is there any requirement to extend from a Web Flow specific base class. Basically, you are not required to write a custom Action implementation at all--you simply instruct Spring Web Flow to call your business methods directly. The need the for custom "glue code" to bind your web-tier to your middle-tier is eliminated.

Spring Web Flow achieves this by automatically adapting the method on your existing application object to the Action interface and caring for exposing any return value in the correct scope.

This is adaption process is shown graphically below:

Bean->Action adapter

The following example constructs the equivalent action state definition using the FlowBuilder API:

    public class SearchFlowBuilder extends AbstractFlowBuilder {
    	public void buildStates() {
    	    ...
            addActionState("executeSearch", searchAction(),
                transition(on("success"), to("displayResults")));
            ...    	          
        }
        
        protected Action searchAction() {
            AnnotatedAction searchAction =
                method("executeSearch(${flowScope.criteria})", action("searchAction"));
            searchAction.setResultName("results");
            return searchAction;
        }
    }	
    			

The following example constructs an DecisionState from XML that evalutes a boolean expression to determine what transition to execute:

    <flow start-state="shippingRequired">
    
        <decision-state id="shippingRequired">
            <if test="${flowScope.order.needsShipping}" then="enterShippingDetails" else="placeOrder"/>
        </decision-state>
        ...
    </flow>
    			

This state definition reads "if the needsShipping property on the order object in flow scope is true, transition to the enterShippingDetails state, otherwise transition to the placeOrder state."

Caution: flow definitions should not be vehicles for business logic. In this case the decision made was controller logic, reasoning on a pre-calculated value to decide what step of the flow to transition to next. That is the kind of logic that should be in a flow definition. In contrast, having the state itself embed the business rule defining how shipping status is calculated is a misuse. Instead, push such a calculation into application code where it belongs and instruct the flow to invoke that code using an action.

The following example constructs an DecisionState from XML that executes a action that forms the basis for the transition decision:

    <flow start-state="shippingRequired">
    
        <decision-state id="shippingRequired">
            <action bean="shippingService" method="isShippingRequired"/>
            <transition on="yes" to="enterShippingDetails"/>
            <transition on="no" to="placeOrder"/>
        </decision-state>
        ...
    </flow>
    			

This state definition reads "if the isShippingRequired method on the shippingService returns true, transition to the enterShippingDetails state, otherwise transition to the placeOrder state."

Note how the boolean return value of the isShippingRequired method is converted to the event identifiers yes or no.

This conversion process is handled by the action adapter responsible for adapting the method on your application object to the org.springframework.webflow.Action interface. By default, this adapter applies a number of rules for creating a result event from a method return value.

These conversion rules are:

You may customize these default conversion policies by setting a custom EventFactory instance on the bean invoking action performing the adaption.

The following example constructs an DecisionState from XML that executes a action that invokes a method on an application object that returns a java.lang.Enum:

    <flow start-state="shippingRequired">
    
        <decision-state id="shippingRequired">
            <action bean="shippingService" method="calculateShippingMethod(${flowScope.order})"/>
            <transition on="BASIC" to="enterBasicShippingDetails"/>
            <transition on="EXPRESS" to="enterExpressShippingDetails"/>
            <transition on="NONE" to="placeOrder"/>
        </decision-state>
        ...
    </flow>
    			

This state definition reads "if the getShippingMethod method on the shippingService returns BASIC for the current order, transition to the enterBasicShippingDetails state. If the return value is EXPRESS transition to the enterExpressShippingDetails state. If the return value is NONE transition to the placeOrder state."

The following example constructs an SubflowState from XML that spawns a shipping subflow:

    <flow start-state="enterOrderInformation">
    
		...
		        
        <subflow-state id="enterShippingDetails" flow="shipping"<
            <attribute-mapper>
                <input-attribute value="${flowScope.order.shipping}" name="shipping"/>
            </attribute-mapper>
            <transition on="finish" to="placeOrder"/>
        </subflow-state>
        
        ...
        
    </flow>
    			

This subflow state definition reads "spawn the shipping flow and pass it the value of the shipping property on the order object in flow scope as an input attribute with the name shipping. When the shipping flow ends, respond to the finish result event by transitioning to the placeOrder state."

Note how the inner structure and behavior of the shipping flow is fully encapsulated within its own flow definition. A flow calling another flow as a subflow can pass that flow input and capture its output, but it cannot see inside it. Flows are black boxes. Because any flow can be used as a subflow, it can be reused in other contexts without change.

The following illustrates the equivalent example using the FlowBuilder API:

    public class OrderFlowBuilder extends AbstractFlowBuilder {
    	public void buildStates() {
    	    ...
            addSubflowState("enterShippingDetails", flow("shipping"), shippingMapper(),
                transition(on("finish"), to("placeOrder")));
            ...    	          
        }
        
        protected FlowAttributeMapper shippingMapper() {
            ParameterizableFlowAttributeMapper mapper = new ParameterizableFlowAttributeMapper();
    	    mapper.addMapping("${flowScope.order.shipping}", "shipping");
    	    return mapper;
    	}
    }	
    			

When a EndState is entered it terminates a flow and, if used as subflow, returns a result event the parent flow uses to drive a state transition from the calling subflow state. It is the end state's responsibility to create this result event which is the basis for communicating the logical flow outcome to callers.

By default, an EndState creates a result event with an identifier that matches the identifier of the end-state itself. For example, an end state with id finish returns a result event with id finish. Also by default, any attributes in flow scope that have been explicitly marked as output attributes are returned as result event parameters.

Spring Web Flow gives you full control over the ending view selection strategy, as well as what flow attributes should be exposed as output on a per EndState basis. These configurable properties are summarized below:

The following example constructs an EndState from XML that terminates a shipping subflow:

    <flow start-state="enterShippingDetails">
    
		...
		        
        <end-state id="finish">
            <output-attribute name="shipping"/>
        </end-state>
        
    </flow>
    			

This end state definition reads "terminate the shipping flow and expose the shipping property in flow scope as an output attribute."

Since this end-state does not make a view selection it is expected this flow will be always used as a subflow. When this flow ends, the calling parent flow is expected to respond to the finish result, and may map the shipping attribute into its own scope.

The following illustrates the equivalent example using the FlowBuilder API:

    public class ShippingFlowBuilder extends AbstractFlowBuilder {
    	public void buildStates() {
    	    ...
            addEndState("finish", new String[] { "shipping" } );
        }
    }	
    			

The following example constructs an EndState from XML that terminates a shipping subflow and requests a redirect response to an external URL:

    <flow start-state="enterOrderInformation">
    
        ...
		        
        <end-state id="finish" view="redirect:/orders/${flowScope.order.id}"/>
        
    </flow>
    			

This end state definition reads "terminate the order flow and request a redirect to the URL returned by evaluating the /orders/${flowScope.order.id} expression."

This is an example of the familiar redirect after post pattern where after transaction completion a redirect is issued allowing the result of the transaction to be viewed (in this case using REST-style URLs).