Package 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

  Modifier and Type
  Method
  Description
  `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.
  `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 Details

  - ### 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)