import javax.transaction.UserTransaction;
import org.wamblee.general.ThreadSpecificProxyFactory;
+import org.wamblee.general.ThreadSpecificProxyFactory.CreationCallback;
+import org.wamblee.test.persistence.JpaBuilder;
/**
- * Simple transaction manager provides a simple mechanism to manage transaction
- * in test code through the {@link UserTransaction} object.
+ *
+ * <p>
+ * Simple transaction manager provides a simple mechanism to manage transactions
+ * in test code through the {@link UserTransaction} object. To construct the
+ * transaction manager use:
+ * </p>
+ *
+ * <pre>
+ * SimpleTransactionManager manager = new SimpleTransactionManager(
+ * new DefaultUserTransactionFactory());
+ * </pre>
+ *
+ * <p>
+ * Next, add resources to manage using {@link #addResource(TransactionResource)}:
+ *
+ * <pre>
+ * manager.addResource(jpaTester.getJpaBuilder());
+ * </pre>
+ * <p>
+ * As you can see from the above, {@link JpaBuilder} is a resource that can be
+ * used so this mechanism can be used with JPA testing.
+ * </p>
+ *
+ * <p>
+ * The next step is to manage transactions using the standard
+ * <code>UserTransaction</code> APIs:
+ * </p>
+ *
+ * <pre>
+ * UserTransaction transaction = manager.getTransaction();
+ * transaction.begin();
+ *
+ * ... do work...
+ *
+ * transaction.commit();
+ * </pre>
*
* @author Erik Brakkee
*
public class SimpleTransactionManager {
private UserTransactionFactory factory;
- private ThreadSpecificProxyFactory<UserTransaction> transaction;
- private UserTransactionCallback callback;
private List<TransactionResource> resources;
+ private UserTransactionCallback transactionFInishedCallback;
+ private ThreadSpecificProxyFactory<UserTransaction> transaction;
/**
* Constructs the transaction manager.
*/
public SimpleTransactionManager(UserTransactionFactory aFactory) {
factory = aFactory;
- transaction = new ThreadSpecificProxyFactory<UserTransaction>(UserTransaction.class);
- callback = new UserTransactionCallback() {
+ resources = new ArrayList<TransactionResource>();
+
+ transactionFInishedCallback = new UserTransactionCallback() {
@Override
public void transactionFinished() {
- transaction.set(null);
+ transaction.set(factory.create(this, resources));
}
};
- resources = new ArrayList<TransactionResource>();
+ transaction = new ThreadSpecificProxyFactory<UserTransaction>(
+ UserTransaction.class, new CreationCallback<UserTransaction>() {
+ @Override
+ public UserTransaction create() {
+ return factory.create(transactionFInishedCallback,
+ resources);
+ }
+ });
}
/**
/**
* Gets the user transaction. This is a contextual reference, meaning that
- * it will delegate to the appropriate thread-specific user transaction.
- * It is also safe to store in a JNDI tree and for caching by applications.
+ * it will delegate to the appropriate thread-specific user transaction. It
+ * is also safe to store in a JNDI tree and for caching by applications.
*
* @return User transaction.
*/
public UserTransaction getTransaction() {
- UserTransaction tx = transaction.get();
- if (tx == null) {
- tx = factory.create(callback, resources);
- transaction.set(tx);
- }
return transaction.getProxy();
}
/**
- * Gets the thread-specific transaction object.
- * @return Transaction object.
+ * Gets the thread-specific transaction object.
+ *
+ * @return Transaction object.
*/
- UserTransaction getThreadSpecificTransaction() {
- getTransaction(); // create tx if needed
- return transaction.get();
+ UserTransaction getThreadSpecificTransaction() {
+ getTransaction(); // create tx if needed
+ return transaction.get();
}
}