javax.activity

---

1. Creating and Using a Transaction Manager

import javax.activity.TransactionManager;

try {
    TransactionManager tm = TransactionManagerFactory.getTransactionManager();
    tm.begin();
    // Perform transactional operations
    tm.commit();
} catch (Exception e) {
    tm.rollback();
}

2. Implementing the javax.transaction.Synchronization Interface

import javax.activity.Synchronization;

public class MySynchronization implements Synchronization {

    @Override
    public void beforeCompletion() {
        // Perform any necessary actions before transaction completes
    }

    @Override
    public void afterCompletion(int status) {
        // Perform any necessary actions after transaction completes, status indicates success/failure
    }
}

3. Registering a Resource Manager

import javax.activity.ResourceAdapter;
import javax.activity.ResourceAdapterWrapper;
import javax.activity.XAResource;

public class MyResourceManager implements ResourceAdapterWrapper {

    @Override
    public ResourceAdapter getDelegate() {
        return null;
    }

    @Override
    public XAResource getXAResource(String name) {
        return new MyXAResource();
    }
}

4. Registering a Transactional Callback

import javax.activity.TransactionSynchronizationRegistry;

public class MyCallback implements TransactionSynchronizationRegistry {

    @Override
    public void registerInterposedSynchronization(Synchronization sync) {
        // Register a synchronization object for transaction
    }
    
    @Override
    public void registerSynchronization(Synchronization sync) {
        // Register a synchronization object for transaction
    }
}

5. Using a Transaction Synchronization Context

import javax.activity.TransactionSynchronizationContext;

public class MySynchronizationContext implements TransactionSynchronizationContext {

    @Override
    public void beforeCompletion() {
        // Perform any necessary actions before transaction completes
    }

    @Override
    public void afterCompletion(int status) {
        // Perform any necessary actions after transaction completes, status indicates success/failure
    }
}

6. Suspending and Resuming a Transaction

import javax.activity.Transaction;

try {
    Transaction tx = TransactionManagerFactory.getTransactionManager().getTransaction();
    tx.suspend();
    // Perform non-transactional operations
    tx.resume();
    // Continue transactional operations
} catch (Exception e) {
    tx.rollback();
}

7. Committing, Rolling Back, and Marking Transactions Rolled Back

import javax.activity.Transaction;

Transaction tx = TransactionManagerFactory.getTransactionManager().getTransaction();
try {
    tx.commit();
} catch (Exception e) {
    tx.rollback();
} finally {
    if (tx.getStatus() == Status.ROLLEDBACK) {
        tx.markRollbackOnly();
    }
}

8. Using the TransactionFactory

import javax.activity.TransactionFactory;

TransactionFactory tf = TransactionFactoryFactory.getTransactionFactory();
Transaction tx = tf.newTransaction();
// Use transaction as needed

9. Creating a Transaction Descriptor

import javax.transaction.xa.XAException;
import javax.transaction.xa.XAResource;
import javax.transaction.xa.Xid;
import javax.transaction.xa.XADescriptor;

public class MyXADescriptor implements XADescriptor {

    @Override
    public byte[] toByteArray() throws XAException {
        return new byte[0];
    }

    @Override
    public void fromByteArray(byte[] data) throws XAException {
        // Do nothing
    }

    @Override
    public String getXAResourceName() {
        return null;
    }
}

10. Creating a JTS Connector Architecture (JCA) Resource Adapter

import javax.resource.ResourceAdapter;

public class MyResourceAdapter implements ResourceAdapter {

    @Override
    public XAResource[] getXAResources(Xid[] xids) {
        return new XAResource[0];
    }
}

11. Using the TransactionManagerFactory

import javax.activity.TransactionManagerFactory;

TransactionManagerFactory tmFactory = TransactionManagerFactory.getTransactionManagerFactory();
TransactionManager tm = tmFactory.getTransactionManager();

12. Using the TransactionSynchronizationManager

import javax.transaction.TransactionSynchronizationManager;

TransactionSynchronizationManager.registerSynchronization(new MySynchronization());

13. Using the TransactionSynchronization Registry

import javax.activity.TransactionSynchronizationRegistry;

TransactionSynchronizationRegistry registry = TransactionSynchronizationManager.getTransactionSynchronizationRegistry();
registry.registerInterposedSynchronization(new MySynchronization());

14. Using the TransactionTimeoutManager

import javax.transaction.TransactionTimeoutManager;

TransactionTimeoutManager timeoutManager = TransactionTimeoutManagerFactory.getTransactionTimeoutManager();
timeoutManager.setTransactionTimeout(30);

15. Using the TransactionId

import javax.transaction.TransactionId;

TransactionId id = TransactionManagerFactory.getTransactionManager().getTransaction().getTransactionId();

16. Using the TransactionState

import javax.transaction.TransactionState;

TransactionState state = TransactionManagerFactory.getTransactionManager().getTransaction().getStatus();

17. Using the TransactionType

import javax.transaction.TransactionType;

TransactionType type = TransactionManagerFactory.getTransactionManager().getTransaction().getTransactionType();

18. Using the Xid

import javax.transaction.xa.Xid;

Xid id = new MyXid("id");

19. Using the XAResource

import javax.transaction.xa.XAResource;

XAResource resource = TransactionManagerFactory.getTransactionManager().getTransaction().getResourceManager();

20. Using the XADescriptor

import javax.transaction.xa.XADescriptor;

XADescriptor descriptor = TransactionManagerFactory.getTransactionManager().getTransaction().getResourceDescriptor();

21. Using the XAResourceManager

import javax.transaction.xa.XAResourceManager;

XAResourceManager rm = TransactionManagerFactory.getTransactionManager().getTransaction().getResourceManager().getXAResourceManager();

22. Using the TransactionManager

import javax.activity.TransactionManager;

TransactionManager tm = TransactionManagerFactory.getTransactionManager();

23. Using the TransactionFactory

import javax.transaction.TransactionFactory;

TransactionFactory tf = TransactionFactoryFactory.getTransactionFactory();

24. Using the XAResourceFactory

import javax.transaction.xa.XAResourceFactory;

XAResourceFactory rf = XAResourceFactoryFactory.getXAResourceFactory();

25. Using the XAClass

import javax.transaction.xa.XAClass;

XAClass xaClass = new XAClass(XAClass.XAResource);

26. Using the XAException

import javax.transaction.xa.XAException;

try {
    // Do something that could throw an XAException
} catch (XAException e) {
    // Handle the exception
}

27. Using the XAResource

import javax.transaction.xa.XAResource;

XAResource resource = TransactionManagerFactory.getTransactionManager().getTransaction().getResourceManager();

28. Using the XAException

import javax.transaction.xa.XAException;

try {
    // Do something that could throw an XAException
} catch (XAException e) {
    // Handle the exception
}

29. Using the Xid

import javax.transaction.xa.Xid;

Xid id = TransactionManagerFactory.getTransactionManager().getTransaction().getTransactionId();

30. Using the XAState

import javax.transaction.xa.XAState;

XAState state = TransactionManagerFactory.getTransactionManager().getTransaction().getResourceManager().getXAResource().getState();

31. Using the Transaction

import javax.transaction.Transaction;

Transaction tx = TransactionManagerFactory.getTransactionManager().getTransaction();

32. Using the TransactionType

import javax.transaction.TransactionType;

TransactionType type = TransactionManagerFactory.getTransactionManager().getTransaction().getTransactionType();

33. Using the TransactionIsolation

import javax.transaction.TransactionIsolation;

TransactionIsolation isolationLevel = TransactionManagerFactory.getTransactionManager().getTransaction().getTransactionIsolationLevel();

34. Using the TransactionTimeout

import javax.transaction.TransactionTimeout;

TransactionTimeout timeout = TransactionManagerFactory.getTransactionManager().getTransaction().getTimeout();

35. Using the TransactionTimeoutManager

import javax.transaction.TransactionTimeoutManager;

TransactionTimeoutManager timeoutManager = TransactionFactoryFactory.getTransactionTimeoutManager();

36. Using the TransactionSynchronization

import javax.transaction.Synchronization;

TransactionSynchronization synchronization = TransactionManagerFactory.getTransactionManager().getTransaction().getSynchronization();

37. Using the TransactionSynchronizationRegistry

import javax.transaction.TransactionSynchronizationRegistry;

TransactionSynchronizationRegistry registry = TransactionManagerFactory.getTransactionManager().getTransaction().getSynchronizationRegistry();

38. Using the TransactionFactory

import javax.transaction.TransactionFactory;

TransactionFactory factory = TransactionFactoryFactory.getTransactionFactory();

39. Using the XAResourceFactory

import javax.transaction.xa.XAResourceFactory;

XAResourceFactory resourceFactory = XAResourceFactoryFactory.getXAResourceFactory();

40. Using the Transaction

import javax.transaction.Transaction;

Transaction transaction = TransactionManagerFactory.getTransactionManager().getTransaction();

41. Using the TransactionManager

import javax.activity.TransactionManager;

TransactionManager manager = TransactionManagerFactory.getTransactionManager();

42. Using the TransactionFactory

import javax.transaction.TransactionFactory;

TransactionFactory factory = TransactionFactoryFactory.getTransactionFactory();

43. Using the XAException

import javax.transaction.xa.XAException;

try {
    // Do something that could throw an XAException
} catch (XAException e) {
    // Handle the exception
}

44. Using the XAResource

import javax.transaction.xa.XAResource;

XAResource resource = null;
try {
    // Do something to retrieve the XAResource
} catch (XAException e) {
    // Handle the exception
}

45. Using the XADescriptor

import javax.transaction.xa.XADescriptor;

XADescriptor descriptor = null;
try {
    // Do something to retrieve the XADescriptor
} catch (XAException e) {
    // Handle the exception
}

46. Using the XAResourceManager

import javax.transaction.xa.XAResourceManager;

XAResourceManager resourceManager = null;
try {
    // Do something to retrieve the XAResourceManager
} catch (XAException e) {
    // Handle the exception
}

47. Using the Transaction

import javax.transaction.Transaction;

Transaction transaction = null;
try {
    // Do something to retrieve the Transaction
} catch (Exception e) {
    // Handle the exception
}

48. Using the TransactionManager

import javax.activity.TransactionManager;

TransactionManager transactionManager = null;
try {
    // Do something to retrieve the TransactionManager
} catch (Exception e) {
    // Handle the exception
}

49. Using the TransactionFactory

import javax.transaction.TransactionFactory;

TransactionFactory transactionFactory = null;
try {
    // Do something to retrieve the TransactionFactory
} catch (Exception e) {
    // Handle the exception
}

50. Using the XAException

import javax.transaction.xa.XAException;

try {
    // Do something that could throw an XAException
} catch (XAException e) {
    // Handle the exception
}