(EntityManagerHolder) TransactionSynchronizationManager.getResource(emf); if (emHolder != null) { if (synchronizedWithTransaction) { if (!emHolder.isSynchronizedWithTransaction()) { if (TransactionSynchronizationManager.isActualTransactionActive()) { emHolder.getEntityManager().joinTransaction(); if (TransactionSynchronizationManager.isSynchronizationActive()) { Object transactionData = prepareTransaction(emHolder.getEntityManager(), emf); TransactionSynchronizationManager.registerSynchronization( new TransactionalEntityManagerSynchronization(emHolder, emf, transactionData, false)); emHolder.setSynchronizedWithTransaction(true); emHolder.requested(); return emHolder.getEntityManager(); if (emHolder.isTransactionActive() && !emHolder.isOpen()) { if (!TransactionSynchronizationManager.isSynchronizationActive()) { return null; return emHolder.getEntityManager(); emHolder = new EntityManagerHolder(em); if (synchronizedWithTransaction) { Object transactionData = prepareTransaction(em, emf); TransactionSynchronizationManager.registerSynchronization( new TransactionalEntityManagerSynchronization(emHolder, emf, transactionData, true)); emHolder.setSynchronizedWithTransaction(true);
/** * Apply the current transaction timeout, if any, to the given JPA Query object. * <p>This method sets the JPA 2.0 query hint "javax.persistence.query.timeout" accordingly. * @param query the JPA Query object * @param emf the JPA EntityManagerFactory that the Query was created for */ public static void applyTransactionTimeout(Query query, EntityManagerFactory emf) { EntityManagerHolder emHolder = (EntityManagerHolder) TransactionSynchronizationManager.getResource(emf); if (emHolder != null && emHolder.hasTimeout()) { int timeoutValue = (int) emHolder.getTimeToLiveInMillis(); try { query.setHint("javax.persistence.query.timeout", timeoutValue); } catch (IllegalArgumentException ex) { // oh well, at least we tried... } } }
protected TransactionInfo getCurrentTransactionInfo() { TransactionInfo response = null; if (transactionManagers != null) { for (LifecycleAwareJpaTransactionManager transactionManager : transactionManagers) { if (transactionManager.isEnabled()) { EntityManagerHolder emHolder = (EntityManagerHolder) TransactionSynchronizationManager.getResource(transactionManager.getEntityManagerFactory()); if (emHolder != null && emHolder.isOpen() && emHolder.isSynchronizedWithTransaction()) { response = infos.get(emHolder.getEntityManager().hashCode()); if (response != null) { break; } } } } } return response; }
tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); given(manager.getTransaction()).willReturn(tx); assertTrue(!TransactionSynchronizationManager.hasResource(factory)); assertTrue(!TransactionSynchronizationManager.isSynchronizationActive()); TransactionSynchronizationManager.bindResource(factory, new EntityManagerHolder(manager)); verify(manager).flush(); verify(manager).close();
public EntityManager getCommandScopedEntityManager() { EntityManager cmdScopedEntityManager = (EntityManager) env.get(EnvironmentName.CMD_SCOPED_ENTITY_MANAGER); if (cmdScopedEntityManager == null || !cmdScopedEntityManager.isOpen()) { EntityManagerHolder emHolder = (EntityManagerHolder) TransactionSynchronizationManager.getResource("cmdEM"); EntityManager em = null; if (emHolder == null) { em = this.emf.createEntityManager(); emHolder = new EntityManagerHolder(em); TransactionSynchronizationManager.bindResource("cmdEM", emHolder); } else { em = emHolder.getEntityManager(); } cmdScopedEntityManager = em; this.env.set(EnvironmentName.CMD_SCOPED_ENTITY_MANAGER, Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class[]{EntityManager.class}, new EmHolderDelegateInvocationHandler())); } return cmdScopedEntityManager; }
@Test public void testWriteAndFlushSunnyDay() throws Exception { EntityManager em = mock(EntityManager.class,"em"); em.contains("foo"); em.contains("bar"); em.merge("bar"); em.flush(); TransactionSynchronizationManager.bindResource(emf, new EntityManagerHolder(em)); List<String> items = Arrays.asList(new String[] { "foo", "bar" }); writer.write(items); TransactionSynchronizationManager.unbindResource(emf); }
@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 testPropertiesForSharedEntityManager2() { Properties props = new Properties(); props.put("foo", "bar"); EntityManager em = mock(EntityManager.class); // only one call made - the first EM definition wins (in this case the one w/o the properties) given(mockEmf.createEntityManager()).willReturn(em); given(em.getDelegate()).willReturn(new Object(), 2); given(em.isOpen()).willReturn(true); PersistenceAnnotationBeanPostProcessor pabpp = new MockPersistenceAnnotationBeanPostProcessor(); DefaultPrivatePersistenceContextFieldWithProperties transactionalFieldWithProperties = new DefaultPrivatePersistenceContextFieldWithProperties(); DefaultPrivatePersistenceContextField transactionalField = new DefaultPrivatePersistenceContextField(); pabpp.postProcessProperties(null, transactionalFieldWithProperties, "bean1"); pabpp.postProcessProperties(null, transactionalField, "bean2"); assertNotNull(transactionalFieldWithProperties.em); assertNotNull(transactionalField.em); // the EM w/o properties will be created assertNotNull(transactionalField.em.getDelegate()); // bind em to the thread now since it's created try { TransactionSynchronizationManager.bindResource(mockEmf, new EntityManagerHolder(em)); assertNotNull(transactionalFieldWithProperties.em.getDelegate()); verify(em).close(); } finally { TransactionSynchronizationManager.unbindResource(mockEmf); } }
@Test public void testTransactionCommitWithPreboundAndPropagationSupports() { final List<String> l = new ArrayList<>(); l.add("test"); tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_SUPPORTS); 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()); assertTrue(!status.isNewTransaction()); EntityManagerFactoryUtils.getTransactionalEntityManager(factory).flush(); return l; } }); assertSame(l, result); assertTrue(TransactionSynchronizationManager.hasResource(factory)); assertTrue(!TransactionSynchronizationManager.isSynchronizationActive()); } finally { TransactionSynchronizationManager.unbindResource(factory); } verify(manager).flush(); }
given(mockEm.isOpen()).willReturn(true); assertFalse(proxy.contains(o)); TransactionSynchronizationManager.bindResource(mockEmf, new EntityManagerHolder(mockEm)); try { assertSame(mockEm, emProxy.getTargetEntityManager()); TransactionSynchronizationManager.unbindResource(mockEmf); assertTrue(TransactionSynchronizationManager.getResourceMap().isEmpty()); verify(mockEm).contains(o); verify(mockEm).close();
@Override public boolean isRollbackOnly() { EntityTransaction tx = getEntityManagerHolder().getEntityManager().getTransaction(); return tx.getRollbackOnly(); }
@SuppressWarnings("deprecation") public Session currentSession() throws HibernateException { Object value = TransactionSynchronizationManager.getResource(this.sessionFactory); if (value instanceof Session) { return (Session) value; Session session = sessionHolder.getSession(); if (!sessionHolder.isSynchronizedWithTransaction() && TransactionSynchronizationManager.isSynchronizationActive()) { TransactionSynchronizationManager.registerSynchronization( new SpringSessionSynchronization(sessionHolder, this.sessionFactory, false)); sessionHolder.setSynchronizedWithTransaction(true); return ((EntityManagerHolder) value).getEntityManager().unwrap(Session.class);
@Override protected void doRollback(DefaultTransactionStatus status) { JpaTransactionObject txObject = (JpaTransactionObject) status.getTransaction(); if (status.isDebug()) { logger.debug("Rolling back JPA transaction on EntityManager [" + txObject.getEntityManagerHolder().getEntityManager() + "]"); } try { EntityTransaction tx = txObject.getEntityManagerHolder().getEntityManager().getTransaction(); if (tx.isActive()) { tx.rollback(); } } catch (PersistenceException ex) { throw new TransactionSystemException("Could not roll back JPA transaction", ex); } finally { if (!txObject.isNewEntityManagerHolder()) { // Clear all pending inserts/updates/deletes in the EntityManager. // Necessary for pre-bound EntityManagers, to avoid inconsistent state. txObject.getEntityManagerHolder().getEntityManager().clear(); } } }
@Override public void runOptionalEntityManagerInViewOperation(Runnable runnable) { EntityManagerFactory emf = ((JpaTransactionManager) getTransactionManager()).getEntityManagerFactory(); boolean isEntityManagerInView = TransactionSynchronizationManager.hasResource(emf); try { if (!isEntityManagerInView) { EntityManager em = emf.createEntityManager(); EntityManagerHolder emHolder = new EntityManagerHolder(em); TransactionSynchronizationManager.bindResource(emf, emHolder); } runnable.run(); } finally { if (!isEntityManagerInView) { EntityManagerHolder emHolder = (EntityManagerHolder) TransactionSynchronizationManager.unbindResource(emf); EntityManagerFactoryUtils.closeEntityManager(emHolder.getEntityManager()); } } }
if (em instanceof EntityManagerProxy) { EntityManager target = ((EntityManagerProxy) em).getTargetEntityManager(); if (TransactionSynchronizationManager.hasResource(target)) { em.flush(); resourceHolder.getEntityManager().clear();
@Override protected void flushResource(EntityManagerHolder resourceHolder) { EntityManager em = resourceHolder.getEntityManager(); if (em instanceof EntityManagerProxy) { EntityManager target = ((EntityManagerProxy) em).getTargetEntityManager(); if (TransactionSynchronizationManager.hasResource(target)) { // ExtendedEntityManagerSynchronization active after joinTransaction() call: // flush synchronization already registered. return; } } try { em.flush(); } catch (RuntimeException ex) { DataAccessException dae; if (this.jpaDialect != null) { dae = this.jpaDialect.translateExceptionIfPossible(ex); } else { dae = convertJpaAccessExceptionIfPossible(ex); } throw (dae != null ? dae : ex); } }
@Override protected EntityManager getEntityManager(Command<?> command) { if (sharedEntityManager != null) { return sharedEntityManager; } EntityManagerHolder emHolder = ((EntityManagerHolder) TransactionSynchronizationManager.getResource("cmdEM")); if (emHolder != null) { EntityManager em = emHolder.getEntityManager(); EntityManagerFactory nativeEmf = ((EntityManagerFactoryInfo) emf).getNativeEntityManagerFactory(); if (em != null && em.isOpen() && em.getEntityManagerFactory().equals(nativeEmf)) { return em; } } return super.getEntityManager(command); } }
boolean isEntityManagerInView = TransactionSynchronizationManager.hasResource(emf); if (!isEntityManagerInView) { EntityManager em = emf.createEntityManager(); em.clear(); EntityManagerHolder emHolder = new EntityManagerHolder(em); TransactionSynchronizationManager.bindResource(emf, emHolder); Stack<String> stack = new Stack<>(); TransactionSynchronizationManager.bindResource("emStack", stack); if (siteId != null) { Site site = siteService.retrievePersistentSiteById(siteId);
if (emHolder != null) { if (synchronizedWithTransaction) { if (!emHolder.isSynchronizedWithTransaction()) { if (TransactionSynchronizationManager.isActualTransactionActive()) { emHolder.getEntityManager().joinTransaction(); emHolder.requested(); return emHolder.getEntityManager(); if (emHolder.isTransactionActive() && !emHolder.isOpen()) { if (!TransactionSynchronizationManager.isSynchronizationActive()) { return null; TransactionSynchronizationManager.unbindResource(emf); return emHolder.getEntityManager(); emHolder = new EntityManagerHolder(em); if (synchronizedWithTransaction) { Object transactionData = prepareTransaction(em, emf);
@Override public void flush() { try { getEntityManagerHolder().getEntityManager().flush(); } catch (RuntimeException ex) { throw DataAccessUtils.translateIfNecessary(ex, getJpaDialect()); } }