@Override public void afterCommit() { super.afterCommit(); // Trigger commit here to let exceptions propagate to the caller. try { this.entityManager.getTransaction().commit(); } catch (RuntimeException ex) { throw convertException(ex); } }
public class ProjectServlet extends HttpServlet { @EJB ProjectService bean; protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { // ... try { EntityManagerFactory emf = Persistence.createEntityManagerFactory("myPU"); EntityManager em = emf.createEntityManager(); EntityTransaction tx = em.getTransaction(); tx.begin(); try { bean.assignEmployeeToProject(projectId, empId); bean.updateProjectStatistics(); } finally { tx.commit(); } } catch (Exception e) { // handle exceptions from EntityTransaction methods // ... } // ... } }
@Test public void testTransactionCommitWithExtendedEntityManagerUnsynchronized() { given(manager.getTransaction()).willReturn(tx); tt.execute(status -> { bean.extendedEntityManagerUnsynchronized.flush(); return null; }); verify(tx).commit(); verify(manager).flush(); verify(manager).close(); }
private void modifyEntity(Integer id, String str, long lng) { EntityManager em = getEntityManager(); em.getTransaction().begin(); BasicTestEntity1 bte1 = em.find( BasicTestEntity1.class, id ); bte1.setLong1( lng ); bte1.setStr1( str ); em.getTransaction().commit(); }
try { entityManager = properties == null ? factorySupplier.get().createEntityManager(): factorySupplier.get().createEntityManager(properties); function.beforeTransactionCompletion(); txn = entityManager.getTransaction(); txn.begin(); result = function.apply( entityManager ); txn.commit(); function.afterTransactionCompletion(); if ( entityManager != null ) { entityManager.close();
@Test public void testTransactionCommitWithSharedEntityManager() { given(manager.getTransaction()).willReturn(tx); tt.execute(status -> { bean.sharedEntityManager.flush(); return null; }); verify(tx).commit(); verify(manager).flush(); verify(manager).close(); }
private void modifyEntity(Integer id, String str, long lng) { EntityManager em = getEntityManager(); em.getTransaction().begin(); BasicTestEntity1 bte1 = em.find( BasicTestEntity1.class, id ); bte1.setLong1( lng ); bte1.setStr1( str ); em.getTransaction().commit(); }
@Override protected void doCommit(DefaultTransactionStatus status) { JpaTransactionObject txObject = (JpaTransactionObject) status.getTransaction(); if (status.isDebug()) { logger.debug("Committing JPA transaction on EntityManager [" + txObject.getEntityManagerHolder().getEntityManager() + "]"); } try { EntityTransaction tx = txObject.getEntityManagerHolder().getEntityManager().getTransaction(); tx.commit(); } catch (RollbackException ex) { if (ex.getCause() instanceof RuntimeException) { DataAccessException dae = getJpaDialect().translateExceptionIfPossible((RuntimeException) ex.getCause()); if (dae != null) { throw dae; } } throw new TransactionSystemException("Could not commit JPA transaction", ex); } catch (RuntimeException ex) { // Assumably failed to flush changes to database. throw DataAccessUtils.translateIfNecessary(ex, getJpaDialect()); } }
try { entityManager = properties == null ? factorySupplier.get().createEntityManager(): factorySupplier.get().createEntityManager(properties); function.beforeTransactionCompletion(); txn = entityManager.getTransaction(); txn.begin(); function.accept( entityManager ); if ( !txn.getRollbackOnly() ) { txn.commit(); function.afterTransactionCompletion(); if ( entityManager != null ) { entityManager.close();
@Test public void testTransactionCommitWithExtendedEntityManager() { given(manager.getTransaction()).willReturn(tx); tt.execute(status -> { bean.extendedEntityManager.flush(); return null; }); verify(tx, times(2)).commit(); verify(manager).flush(); verify(manager).close(); }
@Test public void testTransactionCommitWithPrebound() { given(manager.getTransaction()).willReturn(tx); final List<String> l = new ArrayList<>(); l.add("test"); assertTrue(!TransactionSynchronizationManager.hasResource(factory)); assertTrue(!TransactionSynchronizationManager.isSynchronizationActive()); TransactionSynchronizationManager.bindResource(factory, new EntityManagerHolder(manager)); try { Object result = tt.execute(new TransactionCallback() { @Override public Object doInTransaction(TransactionStatus status) { assertTrue(TransactionSynchronizationManager.hasResource(factory)); assertTrue(TransactionSynchronizationManager.isSynchronizationActive()); EntityManagerFactoryUtils.getTransactionalEntityManager(factory); return l; } }); assertSame(l, result); assertTrue(TransactionSynchronizationManager.hasResource(factory)); assertTrue(!TransactionSynchronizationManager.isSynchronizationActive()); } finally { TransactionSynchronizationManager.unbindResource(factory); } verify(tx).begin(); verify(tx).commit(); }
EntityTransaction tx = null; try { em = emf.createEntityManager(); tx = em.getTransaction(); tx.begin(); em.persist(person); tx.commit(); } finally { if (em != null && em.isOpen()) { em.close();
@Test public void testTransactionCommitWithSharedEntityManagerUnsynchronized() { given(manager.getTransaction()).willReturn(tx); tt.execute(status -> { bean.sharedEntityManagerUnsynchronized.flush(); return null; }); verify(tx).commit(); verify(manager).flush(); verify(manager, times(2)).close(); }
@Test @Priority(10) public void initData() { // Revision 1 EntityManager em = getEntityManager(); em.getTransaction().begin(); em.persist( testEntity ); em.getTransaction().commit(); em.close(); }
@Test public void testTransactionCommitWithSharedEntityManagerUnsynchronizedJoined() { given(manager.getTransaction()).willReturn(tx); tt.execute(status -> { bean.sharedEntityManagerUnsynchronized.joinTransaction(); bean.sharedEntityManagerUnsynchronized.flush(); return null; }); verify(tx).commit(); verify(manager).flush(); verify(manager, times(2)).close(); }
private void setup() { EntityManager entityManager = getEntityManager(); entityManager.getTransaction().begin(); for ( int i = 0; i < NUMBER_ENTITIES; i++ ) { StrTestEntity testEntity = new StrTestEntity( "x" + i ); entityManager.persist( testEntity ); ids.add( testEntity.getId() ); } entityManager.getTransaction().commit(); }
@Test public void testTransactionCommitWithExtendedEntityManagerUnsynchronizedJoined() { given(manager.getTransaction()).willReturn(tx); tt.execute(status -> { bean.extendedEntityManagerUnsynchronized.joinTransaction(); bean.extendedEntityManagerUnsynchronized.flush(); return null; }); verify(tx, times(2)).commit(); verify(manager).flush(); verify(manager).close(); }
private Integer addNewEntity(String str, long lng) { EntityManager em = getEntityManager(); em.getTransaction().begin(); BasicTestEntity1 bte1 = new BasicTestEntity1( str, lng ); em.persist( bte1 ); em.getTransaction().commit(); return bte1.getId(); }
@Test public void testTransactionCommit() { given(manager.getTransaction()).willReturn(tx); final List<String> l = new ArrayList<>(); l.add("test"); assertTrue(!TransactionSynchronizationManager.hasResource(factory)); assertTrue(!TransactionSynchronizationManager.isSynchronizationActive()); Object result = tt.execute(new TransactionCallback() { @Override public Object doInTransaction(TransactionStatus status) { assertTrue(TransactionSynchronizationManager.hasResource(factory)); EntityManagerFactoryUtils.getTransactionalEntityManager(factory).flush(); return l; } }); assertSame(l, result); assertTrue(!TransactionSynchronizationManager.hasResource(factory)); assertTrue(!TransactionSynchronizationManager.isSynchronizationActive()); verify(tx).commit(); verify(manager).flush(); verify(manager).close(); }
private Integer addNewEntity(String str1, String str2) { EntityManager em = getEntityManager(); em.getTransaction().begin(); BasicTestEntity2 bte2 = new BasicTestEntity2( str1, str2 ); em.persist( bte2 ); em.getTransaction().commit(); return bte2.getId(); }