protected boolean needRollback(Transactional ann, Throwable e) throws Exception { assert ann != null; assert e != null; if(transactionManager.getStatus() == Status.STATUS_MARKED_ROLLBACK) { return true; } if(ann.dontRollbackOn() != null) { for(Class<?> dontRollback : ann.dontRollbackOn()) { if(dontRollback.isAssignableFrom(e.getClass())) { return false; } } } if(ann.rollbackOn() != null) { for(Class<?> rollback : ann.rollbackOn()) { if(rollback.isAssignableFrom(e.getClass())) { return true; } } } if(ann.rollbackOn() == null || ann.rollbackOn().length == 0) { return true; } return false; }
protected void handleException(InvocationContext ic, Exception e, Transaction tx) throws Exception { Transactional transactional = getTransactional(ic); for (Class<?> dontRollbackOnClass : transactional.dontRollbackOn()) { if (dontRollbackOnClass.isAssignableFrom(e.getClass())) { throw e; } } for (Class<?> rollbackOnClass : transactional.rollbackOn()) { if (rollbackOnClass.isAssignableFrom(e.getClass())) { tx.setRollbackOnly(); throw e; } } if (e instanceof RuntimeException) { tx.setRollbackOnly(); throw e; } throw e; }
protected void handleException(InvocationContext ic, Exception e, Transaction tx) throws Exception { Transactional transactional = getTransactional(ic); for (Class<?> dontRollbackOnClass : transactional.dontRollbackOn()) { if (dontRollbackOnClass.isAssignableFrom(e.getClass())) { throw e; } } for (Class<?> rollbackOnClass : transactional.rollbackOn()) { if (rollbackOnClass.isAssignableFrom(e.getClass())) { tx.setRollbackOnly(); throw e; } } if (e instanceof RuntimeException) { tx.setRollbackOnly(); throw e; } throw e; }
protected void handleException(InvocationContext ic, Exception e, Transaction tx) throws Exception { Transactional transactional = getTransactional(ic); for (Class<?> dontRollbackOnClass : transactional.dontRollbackOn()) { if (dontRollbackOnClass.isAssignableFrom(e.getClass())) { throw e; } } for (Class<?> rollbackOnClass : transactional.rollbackOn()) { if (rollbackOnClass.isAssignableFrom(e.getClass())) { tx.setRollbackOnly(); throw e; } } if (e instanceof RuntimeException) { tx.setRollbackOnly(); throw e; } throw e; }
protected void handleException(InvocationContext ic, Exception e, Transaction tx) throws Exception { Transactional transactional = getTransactional(ic); for (Class<?> dontRollbackOnClass : transactional.dontRollbackOn()) { if (dontRollbackOnClass.isAssignableFrom(e.getClass())) { throw e; } } for (Class<?> rollbackOnClass : transactional.rollbackOn()) { if (rollbackOnClass.isAssignableFrom(e.getClass())) { tx.setRollbackOnly(); throw e; } } if (e instanceof RuntimeException) { tx.setRollbackOnly(); throw e; } throw e; }
private boolean parseTxData(Class<?> c) { boolean shouldAssignInterceptor = false; Transactional classAnnotation = c.getAnnotation(Transactional.class); TxType defaultType = getType(classAnnotation); if (defaultType != null) { shouldAssignInterceptor = true; } for (Method m : c.getDeclaredMethods()) { try { Transactional methodAnnotation = m.getAnnotation(Transactional.class); TxType t = getType(methodAnnotation); if (t != null) { TransactionalAnnotationAttributes txData = new TransactionalAnnotationAttributes(t, methodAnnotation.dontRollbackOn(), methodAnnotation.rollbackOn()); assertAllowedModifier(m); txMap.put(m, txData); shouldAssignInterceptor = true; } else if (defaultType != null){ txMap.put(m, new TransactionalAnnotationAttributes(defaultType, classAnnotation.dontRollbackOn(), classAnnotation.rollbackOn())); } } catch(IllegalStateException e) { LOG.warn("Invalid transaction annoation found", e); } } return shouldAssignInterceptor; }
Class[] dontRollbackOn = null; if (transactionalAnnotation != null) { //if at method level rollbackOn = transactionalAnnotation.rollbackOn(); dontRollbackOn = transactionalAnnotation.dontRollbackOn(); } else { //if not, at class level transactionalAnnotation = targetClass.getAnnotation(javax.transaction.Transactional.class); if (transactionalAnnotation != null) { rollbackOn = transactionalAnnotation.rollbackOn(); dontRollbackOn = transactionalAnnotation.dontRollbackOn();
private TransactionMetadata readTransactionMetadata(MethodInvocation methodInvocation) { Method method = methodInvocation.getMethod(); TransactionMetadata defaults = defaultTransactionMetadata(); TransactionMetadata target = defaultTransactionMetadata(); for (TransactionMetadataResolver transactionMetadataResolver : transactionMetadataResolvers) { target.mergeFrom(transactionMetadataResolver.resolve(methodInvocation, defaults)); } Optional<Transactional> nativeTransactional = TransactionalResolver.INSTANCE.apply(method); if (nativeTransactional.isPresent()) { target.mergeFrom(nativeTransactional.get()); } else if (TransactionPlugin.JTA_12_OPTIONAL.isPresent()) { Optional<javax.transaction.Transactional> transactionalOptional = JtaTransactionalResolver.INSTANCE .apply(method); if (transactionalOptional.isPresent()) { javax.transaction.Transactional transactional = transactionalOptional.get(); target.setPropagation(Propagation.valueOf(transactional.value().name())); if (transactional.rollbackOn().length > 0) { target.setRollbackOn(asExceptions(transactional.rollbackOn())); } if (transactional.dontRollbackOn().length > 0) { target.setNoRollbackFor(asExceptions(transactional.dontRollbackOn())); } } } return target; }
doRollback = new ExceptionPriotiryRules(tx.rollbackOn(), tx.dontRollbackOn()).accept(error, method.getExceptionTypes()); rollback.putIfAbsent(method, doRollback); if (doRollback && isTransactionActive(state.current)) {
doRollback = new ExceptionPriotiryRules(tx.rollbackOn(), tx.dontRollbackOn()).accept(error, method.getExceptionTypes()); rollback.putIfAbsent(method, doRollback); if (doRollback && policy != null && policy.isTransactionActive()) {