JpaFlowExecutionListener (Spring Web Flow 2.4.0.M1 API)

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.persistence
Class JpaFlowExecutionListener

java.lang.Object
  org.springframework.webflow.execution.FlowExecutionListenerAdapter
      org.springframework.webflow.persistence.JpaFlowExecutionListener

All Implemented Interfaces:: FlowExecutionListener

public class JpaFlowExecutionListener
extends FlowExecutionListenerAdapter
extends FlowExecutionListenerAdapter

A FlowExecutionListener that implements the Flow Managed Persistence Context (FMPC) pattern using the standard Java Persistence API (JPA).

This implementation uses standard JPA APIs. The general pattern is as follows:

When a flow execution starts, create a new JPA persistence context and bind it to flow scope under the name PERSISTENCE_CONTEXT_ATTRIBUTE.
Before processing a flow execution request, expose the flow-scoped persistence context as the "current" persistence context for the current thread.
When an existing flow pauses, unbind the persistence context from the current thread.
When an existing flow ends, commit the changes made to the persistence context in a transaction if the ending state is a commit state. Then, unbind the context and close it.

The general data access pattern implemented here is:

Create a new persistence context when a new flow execution with the 'persistenceContext' attribute starts
Load some objects into this persistence context
Perform edits to those objects over a series of requests into the flow
On successful conversation completion, commit and flush those edits to the database, applying a version check if necessary.

Note: All data access except for the final commit will, by default, be non-transactional. However, a flow may call into a transactional service layer to fetch objects during the conversation in the context of a read-only system transaction if the underlying JPA Transaction Manager supports this. Spring's JPA TransactionManager does support this when working with a Hibernate JPA provider, for example. In that case, Spring will handle setting the FlushMode to MANUAL to ensure any in-progress changes to managed persistent entities are not flushed, while reads of new objects occur transactionally.

Care should be taken to prevent premature commits of flow data while the flow is in progress. You would generally not want intermediate flushing to happen, as the nature of a flow implies a transient, isolated resource that can be canceled before it ends. Generally, the only time a read-write transaction should be started is upon successful completion of the flow, triggered by reaching a 'commit' end state.

Author:: Keith Donald, Juergen Hoeller

Field Summary
`static java.lang.String`	`PERSISTENCE_CONTEXT_ATTRIBUTE` The name of the attribute the flow `persistence context` is indexed under.

Constructor Summary
`JpaFlowExecutionListener(javax.persistence.EntityManagerFactory entityManagerFactory, org.springframework.transaction.PlatformTransactionManager transactionManager)` Create a new JPA flow execution listener using given JPA Entity Manager factory.

Method Summary
`void`	`exceptionThrown(RequestContext context, FlowExecutionException exception)` Called when an exception is thrown during a flow execution, before the exception is handled by any registered `handler`.
`void`	`paused(RequestContext context)` Called when a flow execution is paused, for instance when it is waiting for user input (after event processing).
`void`	`resuming(RequestContext context)` Called after a flow execution is successfully reactivated after pause (but before event processing).
`void`	`sessionEnded(RequestContext context, FlowSession session, java.lang.String outcome, AttributeMap<?> output)` Called when a flow execution session ends.
`void`	`sessionEnding(RequestContext context, FlowSession session, java.lang.String outcome, MutableAttributeMap<?> output)` Called when the active flow execution session has been asked to end but before it has ended.
`void`	`sessionStarting(RequestContext context, FlowSession session, MutableAttributeMap<?> input)` Called after a new flow session has been created but before it starts.

Methods inherited from class org.springframework.webflow.execution.FlowExecutionListenerAdapter
`eventSignaled, requestProcessed, requestSubmitted, sessionCreating, sessionStarted, stateEntered, stateEntering, transitionExecuting, viewRendered, viewRendering`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

PERSISTENCE_CONTEXT_ATTRIBUTE

public static final java.lang.String PERSISTENCE_CONTEXT_ATTRIBUTE

The name of the attribute the flow persistence context is indexed under.

See Also:: Constant Field Values

Constructor Detail

JpaFlowExecutionListener

public JpaFlowExecutionListener(javax.persistence.EntityManagerFactory entityManagerFactory,
                                org.springframework.transaction.PlatformTransactionManager transactionManager)

Create a new JPA flow execution listener using given JPA Entity Manager factory.

Parameters:: entityManagerFactory - the entity manager factory to use

Method Detail