org.springframework.batch.support.transaction

## Class TransactionAwareProxyFactory<T>

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

-     public class TransactionAwareProxyFactory<T>
      extends java.lang.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

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `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> java.util.List<T>` | `createAppendOnlyTransactionalList()`
    `static <K,V> java.util.concurrent.ConcurrentMap<K,V>` | `createAppendOnlyTransactionalMap()`
    `static <T> java.util.Set<T>` | `createAppendOnlyTransactionalSet()`
    `static <T> java.util.List<T>` | `createTransactionalList()`
    `static <T> java.util.List<T>` | `createTransactionalList(java.util.List<T> list)`
    `static <K,V> java.util.Map<K,V>` | `createTransactionalMap()`
    `static <K,V> java.util.Map<K,V>` | `createTransactionalMap(java.util.Map<K,V> map)`
    `static <T> java.util.Set<T>` | `createTransactionalSet()`
    `static <T> java.util.Set<T>` | `createTransactionalSet(java.util.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> java.util.Map<K,V> createTransactionalMap()

    - #### createTransactionalMap

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

    - #### createAppendOnlyTransactionalMap

          public static <K,V> java.util.concurrent.ConcurrentMap<K,V> createAppendOnlyTransactionalMap()

    - #### createAppendOnlyTransactionalSet

          public static <T> java.util.Set<T> createAppendOnlyTransactionalSet()

    - #### createTransactionalSet

          public static <T> java.util.Set<T> createTransactionalSet()

    - #### createTransactionalSet

          public static <T> java.util.Set<T> createTransactionalSet(java.util.Set<T> set)

    - #### createAppendOnlyTransactionalList

          public static <T> java.util.List<T> createAppendOnlyTransactionalList()

    - #### createTransactionalList

          public static <T> java.util.List<T> createTransactionalList()

    - #### createTransactionalList

          public static <T> java.util.List<T> createTransactionalList(java.util.List<T> list)