org.springframework.batch.support.transaction
Class TransactionAwareProxyFactory<T>

java.lang.Object
  org.springframework.batch.support.transaction.TransactionAwareProxyFactory<T>

public class TransactionAwareProxyFactory<T>
extends Object

Factory for transaction aware objects (like lists, sets, maps). If a transaction is active when a method is called on an instance created by the factory, it makes a copy of the target object and carries out all operations on the copy. Only when the transaction commits is the target re-initialised with the copy.

Works well with collections and maps for testing transactional behaviour without needing a database. The base implementation handles lists, sets and maps. Subclasses can implement begin(Object) and commit(Object, Object) to provide support for other resources.

Generally not intended for multi-threaded use, but the append only version of collections gives isolation between threads operating on different keys in a map, provided they only append to the map. (Threads are limited to removing entries that were created in the same transaction.)

Author:

Dave Syer

Method Summary

protected T	begin(T target) Make a copy of the target that can be used inside a transaction to isolate changes from the original.
protected void	commit(T copy, T target) Take the working copy state and commit it back to the original target.
static <T> List<T>	createAppendOnlyTransactionalList()
static <K,V> ConcurrentMap<K,V>	createAppendOnlyTransactionalMap()
static <T> Set<T>	createAppendOnlyTransactionalSet()
static <T> List<T>	createTransactionalList()
static <T> List<T>	createTransactionalList(List<T> list)
static <K,V> Map<K,V>	createTransactionalMap()
static <K,V> Map<K,V>	createTransactionalMap(Map<K,V> map)
static <T> Set<T>	createTransactionalSet()
static <T> Set<T>	createTransactionalSet(Set<T> set)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

begin

protected final T begin(T target)

Make a copy of the target that can be used inside a transaction to isolate changes from the original. Also called from the factory constructor to isolate the target from the original value passed in.

Parameters:

target - the target object (List, Set or Map)

Returns:

an independent copy

commit

protected void commit(T copy,
                      T target)

Take the working copy state and commit it back to the original target. The target then reflects all the changes applied to the copy during a transaction.

Parameters:

copy - the working copy.

target - the original target of the factory.

createTransactionalMap

public static <K,V> Map<K,V> createTransactionalMap()

createTransactionalMap

public static <K,V> Map<K,V> createTransactionalMap(Map<K,V> map)

createAppendOnlyTransactionalMap

public static <K,V> ConcurrentMap<K,V> createAppendOnlyTransactionalMap()

createAppendOnlyTransactionalSet

public static <T> Set<T> createAppendOnlyTransactionalSet()

createTransactionalSet

public static <T> Set<T> createTransactionalSet()

createTransactionalSet

public static <T> Set<T> createTransactionalSet(Set<T> set)

createAppendOnlyTransactionalList

public static <T> List<T> createAppendOnlyTransactionalList()

createTransactionalList

public static <T> List<T> createTransactionalList()

createTransactionalList

public static <T> List<T> createTransactionalList(List<T> list)