Java DefaultTransactionAttribute类代码示例

import org.springframework.transaction.interceptor.DefaultTransactionAttribute; //导入依赖的package包/类
@Test
public void evictTransactional() {
	Cache target = new ConcurrentMapCache("testCache");
	Cache cache = new TransactionAwareCacheDecorator(target);
	Object key = new Object();
	cache.put(key, "123");


	TransactionStatus status = txManager.getTransaction(new DefaultTransactionAttribute(
			TransactionDefinition.PROPAGATION_REQUIRED));
	cache.evict(key);
	assertEquals("123", target.get(key, String.class));
	txManager.commit(status);

	assertNull(target.get(key));
}
 

import org.springframework.transaction.interceptor.DefaultTransactionAttribute; //导入依赖的package包/类
@Test
public void clearTransactional() {
	Cache target = new ConcurrentMapCache("testCache");
	Cache cache = new TransactionAwareCacheDecorator(target);
	Object key = new Object();
	cache.put(key, "123");


	TransactionStatus status = txManager.getTransaction(new DefaultTransactionAttribute(
			TransactionDefinition.PROPAGATION_REQUIRED));
	cache.clear();
	assertEquals("123", target.get(key, String.class));
	txManager.commit(status);

	assertNull(target.get(key));
}
 

import org.springframework.transaction.interceptor.DefaultTransactionAttribute; //导入依赖的package包/类
/**
 * Permet d'initialiser le TransactionManager utilisé pour l'exécution de la tâche.
 * Dans la mesure du possible, surcharger plutôt {@link #getTaskExecutionTransactionTemplateConfig()}.
 */
protected TransactionTemplate newTaskExecutionTransactionTemplate(EntityManagerUtils entityManagerUtils,
		PlatformTransactionManager transactionManager) {
	TaskExecutionTransactionTemplateConfig config = getTaskExecutionTransactionTemplateConfig();
	TransactionTemplate taskExecutionTransactionTemplate;
	if (config.isTransactional()) {
		DefaultTransactionAttribute defaultTransactionAttributes = new DefaultTransactionAttribute(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
		defaultTransactionAttributes.setReadOnly(config.isReadOnly());
		
		taskExecutionTransactionTemplate = new TransactionTemplate(transactionManager, defaultTransactionAttributes);
	} else {
		taskExecutionTransactionTemplate = new OpenEntityManagerWithNoTransactionTransactionTemplate(
				entityManagerUtils, transactionManager, config.isReadOnly());
	}
	return taskExecutionTransactionTemplate;
}
 

import org.springframework.transaction.interceptor.DefaultTransactionAttribute; //导入依赖的package包/类
@Autowired
private void setTransactionTemplate(PlatformTransactionManager transactionManager) {
	DefaultTransactionAttribute writeTransactionAttribute =
			new DefaultTransactionAttribute(TransactionAttribute.PROPAGATION_REQUIRED);
	writeTransactionAttribute.setReadOnly(false);
	writeTransactionTemplate = new TransactionTemplate(transactionManager, writeTransactionAttribute);
	
	DefaultTransactionAttribute writeRequiresNewTransactionAttribute =
			new DefaultTransactionAttribute(TransactionAttribute.PROPAGATION_REQUIRES_NEW);
	writeRequiresNewTransactionAttribute.setReadOnly(false);
	writeRequiresNewTransactionTemplate = new TransactionTemplate(transactionManager, writeRequiresNewTransactionAttribute);
	
	DefaultTransactionAttribute readOnlyTransactionAttribute =
			new DefaultTransactionAttribute(TransactionAttribute.PROPAGATION_REQUIRED);
	readOnlyTransactionAttribute.setReadOnly(true);
	readOnlyTransactionTemplate = new TransactionTemplate(transactionManager, readOnlyTransactionAttribute);
}
 

import org.springframework.transaction.interceptor.DefaultTransactionAttribute; //导入依赖的package包/类
@Override
public TransactionAttributeSource getTransactionAttributeSource() {
    final TransactionAttributeSource origTxAttrSource = super.getTransactionAttributeSource();

    return new TransactionAttributeSource() {

        @Override
        public TransactionAttribute getTransactionAttribute(final Method method, final Class<?> targetClass) {
            TransactionAttribute txAttr = origTxAttrSource.getTransactionAttribute(method, targetClass);

            if (txAttr instanceof DefaultTransactionAttribute) {
                ((DefaultTransactionAttribute) txAttr).setQualifier(AuthContextUtils.getDomain());
            }

            return txAttr;
        }
    };
}
 

import org.springframework.transaction.interceptor.DefaultTransactionAttribute; //导入依赖的package包/类
/**
 * If the test method of the supplied {@link TestContext test context} is
 * configured to run within a transaction, this method will run
 * {@link BeforeTransaction @BeforeTransaction methods} and start a new
 * transaction.
 * <p>
 * Note that if a {@link BeforeTransaction &#064;BeforeTransaction method}
 * fails, remaining {@link BeforeTransaction &#064;BeforeTransaction
 * methods} will not be invoked, and a transaction will not be started.
 * 
 * @see org.springframework.transaction.annotation.Transactional
 */
@SuppressWarnings("serial")
@Override
public void beforeTestClass(TestContext testContext) throws Exception {

	TransactionDefinition transactionDefinition = new DefaultTransactionAttribute();

	if (transactionDefinition != null) {
		PlatformTransactionManager tm = testContext.getApplicationContext()
				.getBean(PlatformTransactionManager.class);
		TransactionContext txContext = new TransactionContext(tm,
				transactionDefinition);
		startNewTransaction(testContext, txContext);
		this.transactionContextCache.put(testContext.getTestClass(),
				txContext);
	}

}
 

import org.springframework.transaction.interceptor.DefaultTransactionAttribute; //导入依赖的package包/类
private void addUserToGroup(final User crowdUser, final Group group) {
    if (crowdUser == null) {
        log.warn("Cannot add null user to group!");
    } else if (group == null) {
        log.warn("Cannot add user to null group!");
    } else {
        new TransactionTemplate(getTransactionManager(), new DefaultTransactionAttribute(TransactionDefinition.PROPAGATION_REQUIRED)).execute(new TransactionCallback() {
            public Object doInTransaction(TransactionStatus status) {
                try {
                    getCrowdService().addUserToGroup(crowdUser, group);
                } catch (Throwable t) {
                    log.error("Failed to add user " + crowdUser.getName() + " to group '" + group.getName() + "'!", t);
                }
                return null;
            }
        });
    }
}
 

import org.springframework.transaction.interceptor.DefaultTransactionAttribute; //导入依赖的package包/类
private void removeUserFromGroup(final CrowdService crowdService, final User crowdUser, final Group group) {
    if (crowdUser == null) {
        log.warn("Cannot remove null user from group!");
    } else if (group == null) {
        log.warn("Cannot remove user from null group!");
    } else {
        new TransactionTemplate(getTransactionManager(), new DefaultTransactionAttribute(TransactionDefinition.PROPAGATION_REQUIRED)).execute(new TransactionCallback() {
            public Object doInTransaction(TransactionStatus status) {
                try {
                    crowdService.removeUserFromGroup(crowdUser, group);
                } catch (Throwable t) {
                    log.error("Failed to remove user " + crowdUser.getName() + " from group '" + group.getName() + "'!", t);
                }
                return null;
            }
        });
    }
}
 

import org.springframework.transaction.interceptor.DefaultTransactionAttribute; //导入依赖的package包/类
private void createUser(final UserAccessor userAccessor, final String username, final String fullName, final String emailAddress) {
    if (username != null) {
        new TransactionTemplate(getTransactionManager(), new DefaultTransactionAttribute(TransactionDefinition.PROPAGATION_REQUIRED)).execute(new TransactionCallback() {
            public Object doInTransaction(TransactionStatus status) {
                try {
                    userAccessor.createUser(new DefaultUser(username, null, null), Credential.NONE);
                } catch (LicensingException le) {
                    log.error("Cannot create user '" + username + "'!", le);
                    // if you're having licensing issues, this needs to bubble up.
                    // see: https://github.com/chauth/confluence_http_authenticator/issues/33
                    throw le;
                } catch (Throwable t) {
                    log.error("Failed to create user '" + username + "'!", t);
                }
                return null;
            }
        });
    } else {
        log.warn("Cannot add user with null username!");
    }
}
 

import org.springframework.transaction.interceptor.DefaultTransactionAttribute; //导入依赖的package包/类
private void updateUser(final CrowdService crowdService, final User crowdUser) {
    if (crowdUser != null) {
        new TransactionTemplate(getTransactionManager(), new DefaultTransactionAttribute(TransactionDefinition.PROPAGATION_REQUIRED)).execute(new TransactionCallback() {
            public Object doInTransaction(TransactionStatus status) {
                try {
                    crowdService.updateUser(crowdUser);
                } catch (Throwable t) {
                    log.error("Failed to update user '" + crowdUser.getName() + "'!", t);
                }
                return null;
            }
        });
    } else {
        log.warn("Cannot update null user!");
    }
}
 

import org.springframework.transaction.interceptor.DefaultTransactionAttribute; //导入依赖的package包/类
@Test
public void testApplicationManagedEntityManagerWithTransaction() throws Exception {
	Object testEntity = new Object();

	EntityTransaction mockTx = mock(EntityTransaction.class);

	// This one's for the tx (shared)
	EntityManager sharedEm = mock(EntityManager.class);
	given(sharedEm.getTransaction()).willReturn(new NoOpEntityTransaction());

	// This is the application-specific one
	EntityManager mockEm = mock(EntityManager.class);
	given(mockEm.getTransaction()).willReturn(mockTx);

	given(mockEmf.createEntityManager()).willReturn(sharedEm, mockEm);

	LocalContainerEntityManagerFactoryBean cefb = parseValidPersistenceUnit();

	JpaTransactionManager jpatm = new JpaTransactionManager();
	jpatm.setEntityManagerFactory(cefb.getObject());

	TransactionStatus txStatus = jpatm.getTransaction(new DefaultTransactionAttribute());

	EntityManagerFactory emf = cefb.getObject();
	assertSame("EntityManagerFactory reference must be cached after init", emf, cefb.getObject());

	assertNotSame("EMF must be proxied", mockEmf, emf);
	EntityManager em = emf.createEntityManager();
	em.joinTransaction();
	assertFalse(em.contains(testEntity));

	jpatm.commit(txStatus);

	cefb.destroy();

	verify(mockTx).begin();
	verify(mockTx).commit();
	verify(mockEm).contains(testEntity);
	verify(mockEmf).close();
}
 

import org.springframework.transaction.interceptor.DefaultTransactionAttribute; //导入依赖的package包/类
@Test
public void testApplicationManagedEntityManagerWithJtaTransaction() throws Exception {
	Object testEntity = new Object();

	// This one's for the tx (shared)
	EntityManager sharedEm = mock(EntityManager.class);
	given(sharedEm.getTransaction()).willReturn(new NoOpEntityTransaction());

	// This is the application-specific one
	EntityManager mockEm = mock(EntityManager.class);

	given(mockEmf.createEntityManager()).willReturn(sharedEm, mockEm);

	LocalContainerEntityManagerFactoryBean cefb = parseValidPersistenceUnit();
	MutablePersistenceUnitInfo pui = ((MutablePersistenceUnitInfo) cefb.getPersistenceUnitInfo());
	pui.setTransactionType(PersistenceUnitTransactionType.JTA);

	JpaTransactionManager jpatm = new JpaTransactionManager();
	jpatm.setEntityManagerFactory(cefb.getObject());

	TransactionStatus txStatus = jpatm.getTransaction(new DefaultTransactionAttribute());

	EntityManagerFactory emf = cefb.getObject();
	assertSame("EntityManagerFactory reference must be cached after init", emf, cefb.getObject());

	assertNotSame("EMF must be proxied", mockEmf, emf);
	EntityManager em = emf.createEntityManager();
	em.joinTransaction();
	assertFalse(em.contains(testEntity));

	jpatm.commit(txStatus);

	cefb.destroy();

	verify(mockEm).joinTransaction();
	verify(mockEm).contains(testEntity);
	verify(mockEmf).close();
}
 

import org.springframework.transaction.interceptor.DefaultTransactionAttribute; //导入依赖的package包/类
@Test
public void putTransactional() {
	Cache target = new ConcurrentMapCache("testCache");
	Cache cache = new TransactionAwareCacheDecorator(target);

	TransactionStatus status = txManager.getTransaction(new DefaultTransactionAttribute(
			TransactionDefinition.PROPAGATION_REQUIRED));

	Object key = new Object();
	cache.put(key, "123");
	assertNull(target.get(key));
	txManager.commit(status);

	assertEquals("123", target.get(key, String.class));
}
 

import org.springframework.transaction.interceptor.DefaultTransactionAttribute; //导入依赖的package包/类
@Autowired
@Lazy // Mutable properties may require a more complex infrastructure, whose setup may require access to immutable properties
public void setPlatformTransactionManager(PlatformTransactionManager transactionManager) {
	DefaultTransactionAttribute writeTransactionAttribute =
			new DefaultTransactionAttribute(TransactionAttribute.PROPAGATION_REQUIRED);
	writeTransactionAttribute.setReadOnly(false);
	writeTransactionTemplate = new TransactionTemplate(transactionManager, writeTransactionAttribute);
}
 

import org.springframework.transaction.interceptor.DefaultTransactionAttribute; //导入依赖的package包/类
@Autowired
public void setPlatformTransactionManager(PlatformTransactionManager transactionManager) {
	DefaultTransactionAttribute readOnlyTransactionAttribute = new DefaultTransactionAttribute(TransactionAttribute.PROPAGATION_REQUIRES_NEW);
	readOnlyTransactionAttribute.setReadOnly(true);
	readOnlyTransactionTemplate = new TransactionTemplate(transactionManager, readOnlyTransactionAttribute);
	
	DefaultTransactionAttribute writeTransactionAttribute = new DefaultTransactionAttribute(TransactionAttribute.PROPAGATION_REQUIRES_NEW);
	writeTransactionAttribute.setReadOnly(false);
	writeTransactionTemplate = new TransactionTemplate(transactionManager, writeTransactionAttribute);
}