/** * This implementation invokes the standard JPA {@code Transaction.begin} * method. Throws an InvalidIsolationLevelException if a non-default isolation * level is set. * <p>This implementation does not return any transaction data Object, since there * is no state to be kept for a standard JPA transaction. Hence, subclasses do not * have to care about the return value ({@code null}) of this implementation * and are free to return their own transaction data Object. * @see javax.persistence.EntityTransaction#begin * @see org.springframework.transaction.InvalidIsolationLevelException * @see #cleanupTransaction */ @Override @Nullable public Object beginTransaction(EntityManager entityManager, TransactionDefinition definition) throws PersistenceException, SQLException, TransactionException { if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) { throw new InvalidIsolationLevelException(getClass().getSimpleName() + " does not support custom isolation levels due to limitations in standard JPA. " + "Specific arrangements may be implemented in custom JpaDialect variants."); } entityManager.getTransaction().begin(); return null; }
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 // ... } // ... } }
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(); }
public EntityManager getEntityManager() { if (entityManager == null) { entityManager = getEntityManagerFactory().createEntityManager(); if (handleTransactions) { // Add transaction listeners, if transactions should be handled TransactionListener jpaTransactionCommitListener = new TransactionListener() { public void execute(CommandContext commandContext) { if (isTransactionActive()) { entityManager.getTransaction().commit(); } } }; TransactionListener jpaTransactionRollbackListener = new TransactionListener() { public void execute(CommandContext commandContext) { if (isTransactionActive()) { entityManager.getTransaction().rollback(); } } }; TransactionContext transactionContext = Context.getTransactionContext(); transactionContext.addTransactionListener(TransactionState.COMMITTED, jpaTransactionCommitListener); transactionContext.addTransactionListener(TransactionState.ROLLED_BACK, jpaTransactionRollbackListener); // Also, start a transaction, if one isn't started already if (!isTransactionActive()) { entityManager.getTransaction().begin(); } } } return entityManager; }
@Test @TestForIssue(jiraKey = "HHH-12138") public void testStoredProcedureReturnValue() { EntityManager entityManager = createEntityManager(); entityManager.getTransaction().begin(); try { Integer phoneCount = (Integer) entityManager .createNativeQuery( "SELECT fn_count_phones(:personId) FROM SYS.DUMMY" ) .setParameter( "personId", 1 ) .getSingleResult(); assertEquals( Integer.valueOf( 2 ), phoneCount ); } finally { entityManager.getTransaction().rollback(); entityManager.close(); } }
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();
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(); }
public EntityManager getEntityManager() { if (entityManager == null) { entityManager = getEntityManagerFactory().createEntityManager(); entityManager.getTransaction().begin();
@Test @TestForIssue(jiraKey = "HHH-12138") public void testHibernateProcedureCallRefCursor() { EntityManager entityManager = createEntityManager(); entityManager.getTransaction().begin(); try { Session session = entityManager.unwrap( Session.class ); ProcedureCall call = session.createStoredProcedureCall( "sp_person_phones" ); call.registerParameter( 1, Long.class, ParameterMode.IN ).bindValue( 1L ); call.registerParameter( 2, Class.class, ParameterMode.REF_CURSOR ); Output output = call.getOutputs().getCurrent(); List<Object[]> postComments = ( (ResultSetOutput) output ).getResultList(); assertEquals( 2, postComments.size() ); } finally { entityManager.getTransaction().rollback(); entityManager.close(); } }
/** * Enlist this application-managed EntityManager in the current transaction. */ private void enlistInCurrentTransaction() { // Resource local transaction, need to acquire the EntityTransaction, // start a transaction now and enlist a synchronization for commit or rollback later. EntityTransaction et = this.target.getTransaction(); et.begin(); if (logger.isDebugEnabled()) { logger.debug("Starting resource-local transaction on application-managed " + "EntityManager [" + this.target + "]"); } ExtendedEntityManagerSynchronization extendedEntityManagerSynchronization = new ExtendedEntityManagerSynchronization(this.target, this.exceptionTranslator); TransactionSynchronizationManager.bindResource(this.target, extendedEntityManagerSynchronization); TransactionSynchronizationManager.registerSynchronization(extendedEntityManagerSynchronization); } }
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();
private void modifyEntity(Integer id, String str1, String str2) { EntityManager em = getEntityManager(); em.getTransaction().begin(); BasicTestEntity2 bte2 = em.find( BasicTestEntity2.class, id ); bte2.setStr1( str1 ); bte2.setStr2( str2 ); em.getTransaction().commit(); }
public EntityManager getEntityManager() { if (entityManager == null) { entityManager = getEntityManagerFactory().createEntityManager(); entityManager.getTransaction().begin();
@Override @Nullable public Object beginTransaction(EntityManager entityManager, TransactionDefinition definition) throws PersistenceException, SQLException, TransactionException { if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) { // Pass custom isolation level on to EclipseLink's DatabaseLogin configuration // (since Spring 4.1.2) UnitOfWork uow = entityManager.unwrap(UnitOfWork.class); uow.getLogin().setTransactionIsolation(definition.getIsolationLevel()); } entityManager.getTransaction().begin(); if (!definition.isReadOnly() && !this.lazyDatabaseTransaction) { // Begin an early transaction to force EclipseLink to get a JDBC Connection // so that Spring can manage transactions with JDBC as well as EclipseLink. entityManager.unwrap(UnitOfWork.class).beginEarlyTransaction(); } return null; }
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 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(); }
@Test public void testTransactionRollbackWithPrebound() { given(manager.getTransaction()).willReturn(tx); given(tx.isActive()).willReturn(true); assertTrue(!TransactionSynchronizationManager.hasResource(factory)); assertTrue(!TransactionSynchronizationManager.isSynchronizationActive()); TransactionSynchronizationManager.bindResource(factory, new EntityManagerHolder(manager)); try { tt.execute(new TransactionCallback() { @Override public Object doInTransaction(TransactionStatus status) { assertTrue(TransactionSynchronizationManager.hasResource(factory)); assertTrue(TransactionSynchronizationManager.isSynchronizationActive()); EntityManagerFactoryUtils.getTransactionalEntityManager(factory); status.setRollbackOnly(); return null; } }); assertTrue(TransactionSynchronizationManager.hasResource(factory)); assertTrue(!TransactionSynchronizationManager.isSynchronizationActive()); } finally { TransactionSynchronizationManager.unbindResource(factory); } verify(tx).begin(); verify(tx).rollback(); verify(manager).clear(); }
@Test @Priority(10) public void initData() { // Revision 1 EntityManager em = getEntityManager(); em.getTransaction().begin(); em.persist( testEntity ); em.getTransaction().commit(); em.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(); }
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(); }