Java TransactionDefinition.PROPAGATION_REQUIRED屬性代碼示例

@Override
public EasyTransResult invoke(EasyTransFilterChain filterChain, Map<String, Object> header,
		EasyTransRequest<?, ?> request) {

	Integer pTrxStatus = MetaDataFilter.getMetaData(EasytransConstant.CallHeadKeys.PARENT_TRANSACTION_STATUS);
	if(!pTrxStatus.equals(com.yiqiniu.easytrans.datasource.TransStatusLogger.TransactionStatus.UNKNOWN)){
		// start transaction to update 
		PlatformTransactionManager transactionManager = getTransactionManager(filterChain, request);
		TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager,
				new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_REQUIRED));
		TransactionId pTrxId = MetaDataFilter.getMetaData(EasytransConstant.CallHeadKeys.PARENT_TRX_ID_KEY);
		transactionTemplate.execute(new TransactionCallback<Object>() {
			@Override
			public Object doInTransaction(TransactionStatus status) {
				TransactionId trxId = pTrxId;
				transStatusLogger.updateExecuteFlagForSlaveTrx(trxId, request, pTrxStatus);
				return null;
			}
		});
		boolean commited = pTrxStatus.equals(com.yiqiniu.easytrans.datasource.TransStatusLogger.TransactionStatus.COMMITTED);
		//may be concurrent,but it's ok
		easyTransSynchronizer.cascadeExecuteCachedTransaction(pTrxId, commited);
	}
	
	return filterChain.invokeFilterChain(header, request);
}
 

public Object execGroovyRetObjByDbTranNest(String groovyName, String methodName, Integer nestDef,
			Object... paramArray) throws Exception{
/*		MicroMetaDao microDao=MicroMetaDao.getInstance(dbName,dbType);
		DataSource dataSource=microDao.getMicroDataSource();
		PlatformTransactionManager  transactionManager=new DataSourceTransactionManager(dataSource);*/
		PlatformTransactionManager  transactionManager=MicroTranManagerHolder.getTransactionManager(dbName);
	    DefaultTransactionDefinition def =new DefaultTransactionDefinition();
	    def.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
	    if(nestDef==null){
	    	nestDef=TransactionDefinition.PROPAGATION_REQUIRED;
	    }
	    def.setPropagationBehavior(nestDef);
	    TransactionStatus status=transactionManager.getTransaction(def);
	    try
	    {
	    	Object retObj= GroovyExecUtil.execGroovyRetObj(groovyName, methodName, paramArray);
	    	transactionManager.commit(status);
	    	return retObj;
	    }
	    catch(Exception ex)
	    {
	    	transactionManager.rollback(status);
	        throw ex;
	    }
		
	}
 

@Test
public void testToStringMatchesEditor() {
	List<RollbackRuleAttribute> list = new LinkedList<RollbackRuleAttribute>();
	list.add(new NoRollbackRuleAttribute("Throwable"));
	RuleBasedTransactionAttribute rta = new RuleBasedTransactionAttribute(TransactionDefinition.PROPAGATION_REQUIRED, list);

	TransactionAttributeEditor tae = new TransactionAttributeEditor();
	tae.setAsText(rta.toString());
	rta = (RuleBasedTransactionAttribute) tae.getValue();

	assertFalse(rta.rollbackOn(new Throwable()));
	assertFalse(rta.rollbackOn(new RuntimeException()));
	assertFalse(rta.rollbackOn(new MyRuntimeException("")));
	assertFalse(rta.rollbackOn(new Exception()));
	assertFalse(rta.rollbackOn(new IOException()));
}
 

/**
 * @return List of next entities for this connection or none if there are no one left.
 * @throws Exception
 *             Exception.
 * */
public Collection<T> getNextEntities() throws Exception {
    if (externalHighestCommittedUSN <= internalHighestCommittedUSN) {
        return null;
    }
    LdapSearchBaseDefinition searchBase = getSearchBaseDefinitions().get(
            currentSearchBaseIndex);
    Collection<T> entities = null;
    while ((entities = getNextEntities(searchBase)) == null || entities.size() == 0) {
        currentSearchBaseIndex++;
        if (currentSearchBaseIndex >= getSearchBaseDefinitions().size()) {
            return null;
        }
        transactionDefinition = new DefaultTransactionDefinition(
                TransactionDefinition.PROPAGATION_REQUIRED);
        pagedResultsControl = new PagedResultsDirContextProcessor(pagingSize);
        noEntitiesLeft = false;
        searchBase = getSearchBaseDefinitions().get(currentSearchBaseIndex);
    }
    return entities;
}
 

private UserTransaction getTxn()
{
    return new SpringAwareUserTransaction(
            transactionManager,
            false,
            TransactionDefinition.ISOLATION_DEFAULT,
            TransactionDefinition.PROPAGATION_REQUIRED,
            TransactionDefinition.TIMEOUT_DEFAULT);
}
 

private UserTransaction getFailingTxn()
{
    return new SpringAwareUserTransaction(
            failingTransactionManager,
            false,
            TransactionDefinition.ISOLATION_DEFAULT,
            TransactionDefinition.PROPAGATION_REQUIRED,
            TransactionDefinition.TIMEOUT_DEFAULT);
}
 

/**
 * Test one checked exception that should roll back.
 */
@Test
public void testRuleForRollbackOnChecked() {
	List<RollbackRuleAttribute> list = new LinkedList<RollbackRuleAttribute>();
	list.add(new RollbackRuleAttribute(IOException.class.getName()));
	RuleBasedTransactionAttribute rta = new RuleBasedTransactionAttribute(TransactionDefinition.PROPAGATION_REQUIRED, list);

	assertTrue(rta.rollbackOn(new RuntimeException()));
	assertTrue(rta.rollbackOn(new MyRuntimeException("")));
	assertFalse(rta.rollbackOn(new Exception()));
	// Check that default behaviour is overridden
	assertTrue(rta.rollbackOn(new IOException()));
}
 

@Test
public void testRuleForCommitOnUnchecked() {
	List<RollbackRuleAttribute> list = new LinkedList<RollbackRuleAttribute>();
	list.add(new NoRollbackRuleAttribute(MyRuntimeException.class.getName()));
	list.add(new RollbackRuleAttribute(IOException.class.getName()));
	RuleBasedTransactionAttribute rta = new RuleBasedTransactionAttribute(TransactionDefinition.PROPAGATION_REQUIRED, list);

	assertTrue(rta.rollbackOn(new RuntimeException()));
	// Check default behaviour is overridden
	assertFalse(rta.rollbackOn(new MyRuntimeException("")));
	assertFalse(rta.rollbackOn(new Exception()));
	// Check that default behaviour is overridden
	assertTrue(rta.rollbackOn(new IOException()));
}
 

@Test
public void testRuleForSelectiveRollbackOnCheckedWithString() {
	List<RollbackRuleAttribute> l = new LinkedList<RollbackRuleAttribute>();
	l.add(new RollbackRuleAttribute(java.rmi.RemoteException.class.getName()));
	RuleBasedTransactionAttribute rta = new RuleBasedTransactionAttribute(TransactionDefinition.PROPAGATION_REQUIRED, l);
	doTestRuleForSelectiveRollbackOnChecked(rta);
}
 

/**
 * Check that a rule can cause commit on a IOException
 * when Exception prompts a rollback.
 */
@Test
public void testRuleForCommitOnSubclassOfChecked() {
	List<RollbackRuleAttribute> list = new LinkedList<RollbackRuleAttribute>();
	// Note that it's important to ensure that we have this as
	// a FQN: otherwise it will match everything!
	list.add(new RollbackRuleAttribute("java.lang.Exception"));
	list.add(new NoRollbackRuleAttribute("IOException"));
	RuleBasedTransactionAttribute rta = new RuleBasedTransactionAttribute(TransactionDefinition.PROPAGATION_REQUIRED, list);

	assertTrue(rta.rollbackOn(new RuntimeException()));
	assertTrue(rta.rollbackOn(new Exception()));
	// Check that default behaviour is overridden
	assertFalse(rta.rollbackOn(new IOException()));
}
 

@Test
public void testRollbackNever() {
	List<RollbackRuleAttribute> list = new LinkedList<RollbackRuleAttribute>();
	list.add(new NoRollbackRuleAttribute("Throwable"));
	RuleBasedTransactionAttribute rta = new RuleBasedTransactionAttribute(TransactionDefinition.PROPAGATION_REQUIRED, list);

	assertFalse(rta.rollbackOn(new Throwable()));
	assertFalse(rta.rollbackOn(new RuntimeException()));
	assertFalse(rta.rollbackOn(new MyRuntimeException("")));
	assertFalse(rta.rollbackOn(new Exception()));
	assertFalse(rta.rollbackOn(new IOException()));
}
 

/**
 * See <a href="http://forum.springframework.org/showthread.php?t=41350">this forum post</a>.
 */
@Test
public void testConflictingRulesToDetermineExactContract() {
	List<RollbackRuleAttribute> list = new LinkedList<RollbackRuleAttribute>();
	list.add(new NoRollbackRuleAttribute(MyBusinessWarningException.class));
	list.add(new RollbackRuleAttribute(MyBusinessException.class));
	RuleBasedTransactionAttribute rta = new RuleBasedTransactionAttribute(TransactionDefinition.PROPAGATION_REQUIRED, list);

	assertTrue(rta.rollbackOn(new MyBusinessException()));
	assertFalse(rta.rollbackOn(new MyBusinessWarningException()));
}
 

private static String propagationBehaviorToString(int propagationBehavior) {
    String rc;
    switch (propagationBehavior) {
    case TransactionDefinition.PROPAGATION_MANDATORY:
        rc = "PROPAGATION_MANDATORY";
        break;
    case TransactionDefinition.PROPAGATION_NESTED:
        rc = "PROPAGATION_NESTED";
        break;
    case TransactionDefinition.PROPAGATION_NEVER:
        rc = "PROPAGATION_NEVER";
        break;
    case TransactionDefinition.PROPAGATION_NOT_SUPPORTED:
        rc = "PROPAGATION_NOT_SUPPORTED";
        break;
    case TransactionDefinition.PROPAGATION_REQUIRED:
        rc = "PROPAGATION_REQUIRED";
        break;
    case TransactionDefinition.PROPAGATION_REQUIRES_NEW:
        rc = "PROPAGATION_REQUIRES_NEW";
        break;
    case TransactionDefinition.PROPAGATION_SUPPORTS:
        rc = "PROPAGATION_SUPPORTS";
        break;
    default:
        rc = "UNKNOWN";
    }
    return rc;
}
 

@Test
public void testRuleForSelectiveRollbackOnCheckedWithClass() {
	List<RollbackRuleAttribute> l = Collections.singletonList(new RollbackRuleAttribute(RemoteException.class));
	RuleBasedTransactionAttribute rta = new RuleBasedTransactionAttribute(TransactionDefinition.PROPAGATION_REQUIRED, l);
	doTestRuleForSelectiveRollbackOnChecked(rta);
}
 

/**
 * Returns a <code>TransactionDefinition</code> object containing the
 * necessary transaction parameters. Simply returns a default
 * <code>DefaultTransactionDefinition</code> object with the 'propagation
 * required' attribute
 *
 * @param testObject The test object, not null
 * @return The default TransactionDefinition
 */
protected TransactionDefinition createTransactionDefinition(Object testObject) {
    return new DefaultTransactionDefinition(TransactionDefinition.PROPAGATION_REQUIRED);
}