# javax.transaction

***

**1. Committing a Transaction:**

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

**2. Rolling Back a Transaction:**

```java
@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:**

```java
TransactionManager transactionManager = JTA.getTransactionManager();
```

**4. Beginning a Transaction:**

```java
Transaction transaction = transactionManager.beginTransaction();
```

**5. Committing a Transaction Using JTA:**

```java
transaction.commit();
```

**6. Rolling Back a Transaction Using JTA:**

```java
transaction.rollback();
```

**7. Custom Propagation with @Transactional:**

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

**8. Custom Isolation with @Transactional:**

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

**9. Custom Timeout with @Transactional:**

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

**10. Using Transaction Templates:**

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

**11. Using Interface-Based Transactions:**

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

**12. Custom Transaction Interceptors:**

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

**13. Creating a UserTransaction:**

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

**14. Beginning a Transaction with a UserTransaction:**

```java
userTransaction.begin();
```

**15. Committing a Transaction with a UserTransaction:**

```java
userTransaction.commit();
```

**16. Rolling Back a Transaction with a UserTransaction:**

```java
userTransaction.rollback();
```

**17. Marking a Resource for Rollback:**

```java
transaction.setRollbackOnly();
```

**18. Checking if a Transaction is Active:**

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

**19. Suspending a Transaction:**

```java
Transaction tx = transactionManager.suspend();
```

**20. Resuming a Transaction:**

```java
transactionManager.resume(tx);
```

**21. Using a Synchronization Hook:**

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

**22. Using a Resource Manager:**

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

**23. Registering a Resource Manager:**

```java
transactionManager.registerResource(rm, null);
```

**24. Creating a Transaction Synchronization Registry:**

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

**25. Registering a Synchronization with the Registry:**

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

**26. Getting the Transaction Status:**

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

**27. Using a JTA Transaction Context:**

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

**28. Managing Transactions Programmatically:**

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

**29. Using Transaction Annotations in CDI:**

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

**30. Customizing Transaction Annotations:**

```java
@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:**

```java
@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:**

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

**33. Using JTA API in a Message Driven Bean:**

```java
@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:**

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

**35. Using JTA API in a WebSocket:**

```java
@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:**

```java
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:**

```xml
<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:**

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

**39. Using JTA API with EJB 3.1:**

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

**40. Using JTA API with JPA 2.0:**

```java
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:**

```xml
<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:**

```xml
<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:**

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

**44. Using JTA API with WebSphere:**

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

**45. Using JTA API with Oracle WebLogic Server:**

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

**46. Using JTA API with IBM WebSphere Liberty:**

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

**47. Using JTA API with Apache TomEE:**

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

**48. Using JTA API with JBoss EAP:**

```xml
<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:**

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

**50. Using JTA API with WebLogic Server:**

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