¿hay alguna manera de forzar una reversión transaccional sin encontrar una excepción?

Question

Tengo un método que hace un montón de cosas; entre ellos haciendo una serie de inserciones y actualizaciones. Se declara así ...

@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT, readOnly = false) 
public int saveAll(){ 
//do stuff; 
} 

Funciona exactamente como se supone que debe y no tengo problemas con él. Sin embargo, hay situaciones en las que quiero forzar la reversión a pesar de que no haya una excepción ... en este momento, forzo una excepción cuando encuentro las condiciones adecuadas, pero es feo y no me gusta.

¿Puedo invocar activamente la reversión de alguna manera? La excepción lo llama ... Estoy pensando que quizás yo también pueda.

Answer 1

Llame al setRollbackOnly() en el SessionContext si se encuentra en un EJB.

Puede inyectarse SessionContext así:

public MyClass { 
    @Resource 
    private SessionContext sessionContext; 

    @Transactional(propagation = Propagation.REQUIRED, 
        isolation = Isolation.DEFAULT, 
        readOnly = false) 
    public int saveAll(){ 
     //do stuff; 
     if(oops == true) { 
      sessionContext.setRollbackOnly(); 
      return; 
     } 
    } 

setRollbackOnly() es miembro de EJBContext. SessionContext extiende EJBContext: http://java.sun.com/j2ee/1.4/docs/api/javax/ejb/SessionContext.html Nota que solo está disponible en los EJB de sesión.

@Resource es una anotación Java EE estándar, por lo que probablemente debería verificar su configuración en Eclipse. Aquí hay un example de cómo inyectar el SessionContext usando @Resource.

Sospecho que probablemente esta no sea su solución, ya que parece que no está trabajando con EJB, explicando por qué Eclipse no encuentra @Resource.

Si ese es el caso, entonces deberá interactuar directamente con la transacción - vea la plantilla de transacción.

Answer 2

Debe tener la primavera de inyectar el administrador de transacciones. Luego puede llamar al método de reversión.

Answer 3

En Spring Transactions, usa TransactionStatus.setRollbackOnly().

El problema que tiene aquí es que está usando @Transactional para demarcar sus transacciones. Esto tiene el beneficio de ser no invasivo, pero también significa que si desea interactuar manualmente con el contexto de la transacción, no puede hacerlo.

Si desea un control estricto del estado de su transacción, debe usar transacciones programáticas en lugar de anotaciones declarativas. Esto significa usar Spring's TransactionTemplate, o usar PlatformTransactionManager directamente. Ver la sección 9.6 del manual de referencia de Spring.

Con TransactionTemplate, proporciona un objeto de devolución de llamada que implementa TransactionCallback, y el código en esta devolución de llamada tiene acceso a los objetos TransactionStatus.

No es tan bueno como @Transactional, pero se obtiene un control más estricto de su estado de tx.

Answer 4

Lanza una excepción y usa el framework como está diseñado; de lo contrario, no uses gestión de transacciones declarativa y sigue los consejos de skaffman anteriores. Mantenlo simple.

Answer 5

Tengo métodos de servicio anotados con @Transactional.Cuando la validación falla, y ya tengo una entidad adjunta a la unidad de trabajo actual, utilizo sessionFactory.getCurrentSession().evict(entity) para asegurarme de que no se escribe nada en la base de datos. De esa forma no necesito lanzar una excepción.

Answer 6

No usamos EJB, sino simplemente Spring y hemos elegido el enfoque AOP. Hemos implementado la nueva anotación @TransactionalWithRollback y usamos AOP para envolver esos métodos anotados con consejos "cercanos". Para implementar el consejo que utilizamos mencionado TransactionTemplate. Esto significa un poco de trabajo al principio, pero como resultado podemos simplemente anotar un método con @TransactionalWithRollback como usamos @Transactional en otros casos. El código principal se ve limpio y simple.

// 
// Service class - looks nice 
// 
class MyServiceImpl implements MyService { 
    @TransactionalWithRollback 
    public int serviceMethod { 
     // DO "read only" WORK 
    } 
} 

---

// 
// Annotation definition 
// 
@Retention(RetentionPolicy.RUNTIME) 
@Target({ElementType.METHOD}) 
public @interface TransactionalWithRollback { 
} 

---

// 
// the around advice implementation 
// 
public class TransactionalWithRollbackInterceptor { 
    private TransactionTemplate txTemplate; 
    @Autowired private void setTransactionManager(PlatformTransactionManager txMan) { 
     txTemplate = new TransactionTemplate(txMan); 
    } 

    public Object doInTransactionWithRollback(final ProceedingJoinPoint pjp) throws Throwable { 
     return txTemplate.execute(new TransactionCallback<Object>() { 
      @Override public Object doInTransaction(TransactionStatus status) { 
       status.setRollbackOnly(); 
       try { 
        return pjp.proceed(); 
       } catch(RuntimeException e) { 
        throw e; 
       } catch (Throwable e) { 
        throw new RuntimeException(e); 
       } 
      } 
     }); 
    } 
} 

---

// 
// snippet from applicationContext.xml: 
// 
<bean id="txWithRollbackInterceptor" class="net.gmc.planner.aop.TransactionalWithRollbackInterceptor" /> 

<aop:config> 
    <aop:aspect id="txWithRollbackAspect" ref="txWithRollbackInterceptor"> 
     <aop:pointcut 
      id="servicesWithTxWithRollbackAnnotation" 
      expression="execution(* org.projectx..*.*(..)) and @annotation(org.projectx.aop.TransactionalWithRollback)"/> 
     <aop:around method="doInTransactionWithRollback" pointcut-ref="servicesWithTxWithRollbackAnnotation"/> 
    </aop:aspect> 
</aop:config> 

Answer 7

Esto funciona para mí:

TransactionInterceptor.currentTransactionStatus().setRollbackOnly();