public static TransactionStatus createTransaction(int propagationBehavior, int isolationLevel, PlatformTransactionManager transactionManager, boolean isReadOnly) { DefaultTransactionDefinition def = new DefaultTransactionDefinition(); def.setReadOnly(isReadOnly); def.setPropagationBehavior(propagationBehavior); def.setIsolationLevel(isolationLevel); return transactionManager.getTransaction(def); }
public static TransactionStatus createTransaction(String name, int propagationBehavior, int isolationLevel, PlatformTransactionManager transactionManager, boolean isReadOnly) { DefaultTransactionDefinition def = new DefaultTransactionDefinition(); def.setName(name); def.setReadOnly(isReadOnly); def.setPropagationBehavior(propagationBehavior); def.setIsolationLevel(isolationLevel); return transactionManager.getTransaction(def); }
@Test // SPR-16956 public void testReadOnly() { assertSame(FlushMode.AUTO, sessionFactory.getCurrentSession().getHibernateFlushMode()); assertFalse(sessionFactory.getCurrentSession().isDefaultReadOnly()); endTransaction(); this.transactionDefinition.setReadOnly(true); startNewTransaction(); assertSame(FlushMode.MANUAL, sessionFactory.getCurrentSession().getHibernateFlushMode()); assertTrue(sessionFactory.getCurrentSession().isDefaultReadOnly()); }
@Test // SPR-16956 public void testReadOnly() { assertSame(FlushMode.AUTO, sharedEntityManager.unwrap(Session.class).getHibernateFlushMode()); assertFalse(sharedEntityManager.unwrap(Session.class).isDefaultReadOnly()); endTransaction(); this.transactionDefinition.setReadOnly(true); startNewTransaction(); assertSame(FlushMode.MANUAL, sharedEntityManager.unwrap(Session.class).getHibernateFlushMode()); assertTrue(sharedEntityManager.unwrap(Session.class).isDefaultReadOnly()); }
@Test public void newTransactionWithCommitAndTimeout() { MockUOWManager manager = new MockUOWManager(); WebSphereUowTransactionManager ptm = new WebSphereUowTransactionManager(manager); DefaultTransactionDefinition definition = new DefaultTransactionDefinition(); definition.setTimeout(10); definition.setReadOnly(true); assertFalse(TransactionSynchronizationManager.isSynchronizationActive()); assertFalse(TransactionSynchronizationManager.isActualTransactionActive()); assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly()); assertEquals("result", ptm.execute(definition, new TransactionCallback<String>() { @Override public String doInTransaction(TransactionStatus status) { assertTrue(TransactionSynchronizationManager.isSynchronizationActive()); assertTrue(TransactionSynchronizationManager.isActualTransactionActive()); assertTrue(TransactionSynchronizationManager.isCurrentTransactionReadOnly()); return "result"; } })); assertFalse(TransactionSynchronizationManager.isSynchronizationActive()); assertFalse(TransactionSynchronizationManager.isActualTransactionActive()); assertFalse(TransactionSynchronizationManager.isCurrentTransactionReadOnly()); assertEquals(10, manager.getUOWTimeout()); assertEquals(UOWManager.UOW_TYPE_GLOBAL_TRANSACTION, manager.getUOWType()); assertFalse(manager.getJoined()); assertFalse(manager.getRollbackOnly()); }
DefaultTransactionDefinition definition = new DefaultTransactionDefinition(); definition.setPropagationBehavior(propagationBehavior); definition.setReadOnly(true);
final DefaultTransactionDefinition definition2 = new DefaultTransactionDefinition(); definition2.setPropagationBehavior(propagationBehavior); definition2.setReadOnly(true);
final DefaultTransactionDefinition definition2 = new DefaultTransactionDefinition(); definition2.setPropagationBehavior(TransactionDefinition.PROPAGATION_NOT_SUPPORTED); definition2.setReadOnly(true);
DefaultTransactionDefinition definition = new DefaultTransactionDefinition(); definition.setPropagationBehavior(propagationBehavior); definition.setReadOnly(true);
final DefaultTransactionDefinition definition2 = new DefaultTransactionDefinition(); definition2.setPropagationBehavior(propagationBehavior); definition2.setReadOnly(true);
/** * Parse a "transactional" element and configure the "transactionManager" and "transactionDefinition" * properties for the target builder. */ private void configureTransactionAttributes(Element txElement, BeanDefinitionBuilder targetBuilder) { targetBuilder.addPropertyReference("transactionManager", txElement.getAttribute("transaction-manager")); DefaultTransactionDefinition txDefinition = new DefaultTransactionDefinition(); txDefinition.setPropagationBehaviorName( DefaultTransactionDefinition.PREFIX_PROPAGATION + txElement.getAttribute("propagation")); txDefinition.setIsolationLevelName( DefaultTransactionDefinition.PREFIX_ISOLATION + txElement.getAttribute("isolation")); txDefinition.setTimeout(Integer.valueOf(txElement.getAttribute("timeout"))); txDefinition.setReadOnly(txElement.getAttribute("read-only").equalsIgnoreCase("true")); targetBuilder.addPropertyValue("transactionDefinition", txDefinition); }
/** * Start transaction manually. * <p> * <b>Use it with caution!</b><br> * <b>Do not mix annotation based transaction handling and programmatically one!</b><br> * <b>Do not call any repository method before starting a transaction.</b> (It seems an implicit transaction is created.)<br> * * @param readonly * For readonly transactions. */ protected TransactionStatus startTransaction(boolean readonly) { LOG.trace("Starting new transaction"); DefaultTransactionDefinition transactionDefinition = new DefaultTransactionDefinition(); transactionDefinition.setReadOnly(readonly); return transactionManager.getTransaction(transactionDefinition); }
@Override public void doInitialize(TransactionMetadata transactionMetadata) { try { transactionManager = injector.getInstance(Key.get(AbstractPlatformTransactionManager.class, Names.named(springTransactionManagerBeanId))); DefaultTransactionDefinition defaultTransactionDefinition = new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_REQUIRES_NEW); defaultTransactionDefinition.setReadOnly(transactionMetadata.isReadOnly()); transactionLink.push(transactionManager.getTransaction(defaultTransactionDefinition)); } catch (TransactionException e) { throw new IllegalStateException(e); } }
@Override public void doInitialize(TransactionMetadata transactionMetadata) { try { transactionManager = injector.getInstance(Key.get(AbstractPlatformTransactionManager.class, Names.named(springTransactionManagerBeanId))); DefaultTransactionDefinition defaultTransactionDefinition = new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_REQUIRES_NEW); defaultTransactionDefinition.setReadOnly(transactionMetadata.isReadOnly()); transactionLink.push(transactionManager.getTransaction(defaultTransactionDefinition)); } catch (TransactionException e) { throw new IllegalStateException(e); } }
private <T> T runInNewTransaction(final String transactionName, final TransactionCallback<T> action) { final DefaultTransactionDefinition def = new DefaultTransactionDefinition(); def.setName(transactionName); def.setReadOnly(false); def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); return new TransactionTemplate(txManager, def).execute(action); }
/** * Executes the modifying action in new transaction * * @param txManager * transaction manager interface * @param transactionName * the name of the new transaction * @param action * the callback to execute in new tranaction * * @return the result of the action */ public static <T> T runInNewTransaction(@NotNull final PlatformTransactionManager txManager, final String transactionName, @NotNull final TransactionCallback<T> action) { final DefaultTransactionDefinition def = new DefaultTransactionDefinition(); def.setName(transactionName); def.setReadOnly(false); def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); return new TransactionTemplate(txManager, def).execute(action); } }
/** * Creating the initial tenant meta-data in a new transaction. Due the * {@link MultiTenantJpaTransactionManager} is using the current tenant to * set the necessary tenant discriminator to the query. This is not working * if we don't have a current tenant set. Due the * {@link #getTenantMetadata(String)} is maybe called without having a * current tenant we need to re-open a new transaction so the * {@link MultiTenantJpaTransactionManager} is called again and set the * tenant for this transaction. * * @param tenant * the tenant to be created * @return the initial created {@link TenantMetaData} */ private TenantMetaData createInitialTenantMetaData(final String tenant) { final DefaultTransactionDefinition def = new DefaultTransactionDefinition(); def.setName("initial-tenant-creation"); def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); def.setReadOnly(false); return systemSecurityContext .runAsSystemAsTenant(() -> new TransactionTemplate(txManager, def).execute(status -> { final DistributionSetType defaultDsType = createStandardSoftwareDataSetup(); return tenantMetaDataRepository.save(new JpaTenantMetaData(defaultDsType, tenant)); }), tenant); }
@Override public <T> T execute(final Function<Session, T> callback) { try { DefaultTransactionDefinition definition = new DefaultTransactionDefinition(); definition.setIsolationLevel(getTransactionIsolation().getTransactionIsolation()); int timeout = getTimeout(); if (timeout >= 0) { definition.setTimeout(timeout); } definition.setReadOnly(isReadOnly()); return connectionProvider.connection(false, connection -> { Session session = newSession(connection); TransactionTemplate tt = new TransactionTemplate(platformTransactionManager, definition); return tt.execute(transactionStatus -> callback.apply(session)); }); } catch (final Exception e) { throw JdbcTemplateExceptionTranslator.doTranslate(e); } }
@Override public <T> T doInTransaction(final Session session, final TransactionDefinition transactionDefinition, final TransactionCallback<T> transactionCallback) { try { DefaultTransactionDefinition definition = new DefaultTransactionDefinition(); setIsolationLevel(definition , transactionDefinition.getIsolationLevel()); setPropagation( definition , transactionDefinition.getPropagation() ); setTimeout( definition , transactionDefinition.getTimeout() ); definition.setReadOnly( transactionDefinition.isReadOnly() ); TransactionTemplate tt = new TransactionTemplate(platformTransactionManager, definition); return tt.execute(transactionStatus -> transactionCallback.doInTransaction(session)); } catch (final Exception e) { throw JdbcTemplateExceptionTranslator.doTranslate(e); } }
public TransactionImpl(PlatformTransactionManager transactionManager, PersistenceImpl persistence, boolean join, @Nullable TransactionParams params, String storeName) { this.tm = transactionManager; this.persistence = persistence; this.storeName = storeName; log.trace("Creating transaction: store='{}' join={} params={}", storeName, join, params); td = new DefaultTransactionDefinition(); if (join) td.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED); else td.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW); if (params != null) { if (params.getTimeout() != 0) td.setTimeout(params.getTimeout()); if (params.isReadOnly()) td.setReadOnly(true); } ts = tm.getTransaction(td); persistence.registerSynchronizations(storeName); }