javax.transaction

---

1. Committing a Transaction:

@Transactional
public void save(Entity entity) {
    // ...
    entityManager.persist(entity);
    entityManager.getTransaction().commit();
}

2. Rolling Back a Transaction:

@Transactional
public void delete(Entity entity) {
    try {
        // ...
        entityManager.remove(entity);
        entityManager.getTransaction().commit();
    } catch (Exception e) {
        entityManager.getTransaction().rollback();
        throw e;
    }
}

3. Creating a Transaction Manager:

TransactionManager transactionManager = JTA.getTransactionManager();

4. Beginning a Transaction:

Transaction transaction = transactionManager.beginTransaction();

5. Committing a Transaction Using JTA:

transaction.commit();

6. Rolling Back a Transaction Using JTA:

transaction.rollback();

7. Custom Propagation with @Transactional:

@Transactional(propagation = Propagation.REQUIRED)
public void method() {
    // ...
}

8. Custom Isolation with @Transactional:

@Transactional(isolation = Isolation.READ_COMMITTED)
public void method() {
    // ...
}

9. Custom Timeout with @Transactional:

@Transactional(timeout = 10)
public void method() {
    // ...
}

10. Using Transaction Templates:

TransactionTemplate transactionTemplate = new TransactionTemplate();
transactionTemplate.execute(new TransactionCallbackWithoutResult() {
    @Override
    protected void doInTransactionWithoutResult(TransactionStatus status) {
        // ...
    }
});

11. Using Interface-Based Transactions:

public interface TransactionalService {
    @Transactional
    void method();
}

12. Custom Transaction Interceptors:

public class MyTransactionInterceptor implements TransactionInterceptor {
    // ...
}

13. Creating a UserTransaction:

UserTransaction userTransaction = (UserTransaction) initialContext.lookup("java:comp/UserTransaction");

14. Beginning a Transaction with a UserTransaction:

userTransaction.begin();

15. Committing a Transaction with a UserTransaction:

userTransaction.commit();

16. Rolling Back a Transaction with a UserTransaction:

userTransaction.rollback();

17. Marking a Resource for Rollback:

transaction.setRollbackOnly();

18. Checking if a Transaction is Active:

if (transactionManager.getTransaction() != null) {
    // ...
}

19. Suspending a Transaction:

Transaction tx = transactionManager.suspend();

20. Resuming a Transaction:

transactionManager.resume(tx);

21. Using a Synchronization Hook:

transaction.registerSynchronization(new Synchronization() {
    // ...
});

22. Using a Resource Manager:

ResourceManager rm = (ResourceManager) initialContext.lookup("java:comp/env/myRM");

23. Registering a Resource Manager:

transactionManager.registerResource(rm, null);

24. Creating a Transaction Synchronization Registry:

TransactionSynchronizationRegistry registry = (TransactionSynchronizationRegistry) transactionManager.getTransaction();

25. Registering a Synchronization with the Registry:

registry.registerSynchronization(new Synchronization() {
    // ...
});

26. Getting the Transaction Status:

TransactionStatus status = (TransactionStatus) transactionManager.getTransaction();

27. Using a JTA Transaction Context:

TransactionContext tc = (TransactionContext) initialContext.lookup("java:comp/TransactionContext");

28. Managing Transactions Programmatically:

tc.begin();
try {
    // ...
    tc.commit();
} catch (Exception e) {
    tc.rollback();
}

29. Using Transaction Annotations in CDI:

@Transactional(qualifier = "MyQualifier")
public void method() {
    // ...
}

30. Customizing Transaction Annotations:

@Target({METHOD, TYPE})
@Retention(RUNTIME)
@Inherited
@ transactional
public @interface MyTransactional {
    String value() default "";
    Class<? extends Throwable>[] dontRollbackOn() default {};
    Class<? extends Throwable>[] rollbackOn() default {};
}

31. Using JTA API in a Servlet:

@WebServlet("/myServlet")
public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        try {
            UserTransaction userTransaction = (UserTransaction) initialContext.lookup("java:comp/UserTransaction");
            userTransaction.begin();
            // ...
            userTransaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            resp.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
        }
    }
}

32. Using JTA API in an EJB:

@Stateless
@TransactionManagement(TransactionManagementType.BEAN)
public class MyEJB {
    @Resource
    private UserTransaction userTransaction;
    // ...
}

33. Using JTA API in a Message Driven Bean:

@MessageDriven(activationConfig = {
    @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Topic"),
    @ActivationConfigProperty(propertyName = "destination", propertyValue = "topic/myTopic"),
    @ActivationConfigProperty(propertyName = "transactionType", propertyValue = "JTA")
})
public class MyMDB implements MessageListener {
    @Resource
    private UserTransaction userTransaction;
    // ...
}

34. Using JTA API in a RESTful Service:

@Path("/myResource")
public class MyResource {
    @Context
    private UserTransaction userTransaction;
    // ...
}

35. Using JTA API in a WebSocket:

@ServerEndpoint("/myWebSocket")
public class MyWebSocket {
    @OnOpen
    public void onOpen(Session session) {
        try {
            UserTransaction userTransaction = (UserTransaction) initialContext.lookup("java:comp/UserTransaction");
            userTransaction.begin();
            // ...
            userTransaction.commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.close();
        }
    }
}

36. Using JTA API in a JavaFX Application:

public class MyJavaFXApp extends Application {
    @Override
    public void start(Stage stage) throws Exception {
        UserTransaction userTransaction = (UserTransaction) initialContext.lookup("java:comp/UserTransaction");
        // ...
    }
}

37. Using JTA API with Spring Framework:

<bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager">
    <property name="userTransaction" ref="userTransaction"/>
</bean>

<bean id="userTransaction" class="org.springframework.transaction.jta.JtaTransactionManager"
        factory-method="getUserTransaction" factory-bean="transactionManager"/>

38. Using JTA API with Hibernate:

<property name="transactionManagerLookupClass" value="org.hibernate.transaction.JOTMTransactionManagerLookup"/>

39. Using JTA API with EJB 3.1:

public class MySessionBean implements javax.ejb.SessionBean {
    @Resource
    private UserTransaction userTransaction;
    // ...
}

40. Using JTA API with JPA 2.0:

public class MyEntityManagerFactory extends javax.persistence.spi.PersistenceProvider {
    @Override
    public EntityManagerFactory createEntityManagerFactory(String persistenceUnitName, Map properties) throws PersistenceException {
        // ...
        properties.put("javax.persistence.transactionType", "JTA");
        // ...
    }
}

41. Using JTA API with JBoss:

<subsystem xmlns="urn:jboss:domain:transactions:6.0">
    <core-configuration>
        <transaction manager-lookup-name="java:comp/TransactionManager"/>
        <default-timeout>300</default-timeout>
    </core-configuration>
</subsystem>

42. Using JTA API with WildFly:

<subsystem xmlns="urn:jboss:domain:transactions:6.0">
    <core-configuration>
        <transaction manager-lookup-name="java:jboss/TransactionManager"/>
        <default-timeout>300</default-timeout>
    </core-configuration>
</subsystem>

43. Using JTA API with GlassFish:

<transaction concurrency-definition-factory="com.sun.enterprise.transaction.jta.DefaultConcurrencyDefinitionFactory"
        jta-data-source="jdbc/myDataSource"/>

44. Using JTA API with WebSphere:

<transaction jta="true">
    <name>myTransaction</name>
</transaction>

45. Using JTA API with Oracle WebLogic Server:

<transaction-descriptor>
    <jta-transaction>
        <name>myTransaction</name>
    </jta-transaction>
</transaction-descriptor>

46. Using JTA API with IBM WebSphere Liberty:

<jta-resource jndi-name="java:comp/env/jdbc/myDataSource"/>

47. Using JTA API with Apache TomEE:

<Resource name="jdbc/myDataSource" type="DataSource" jta-transaction="true"/>

48. Using JTA API with JBoss EAP:

<subsystem xmlns="urn:jboss:domain:transactions:6.0">
    <transaction manager-lookup-name="java:jboss/TransactionManager"/>
    <default-timeout>300</default-timeout>
</subsystem>

49. Using JTA API with Payara Platform:

<transaction jta="true" jta-data-source="jdbc/myDataSource"/>

50. Using JTA API with WebLogic Server:

<transaction jta="true" jta-data-source="jdbc/myDataSource"/>