Transação marcada como reversão apenas: como encontro a causa

Estou tendo problemas para confirmar uma transação no meu método @Transactional:

methodA() {
    methodB()
}

@Transactional
methodB() {
    ...
    em.persist();
    ...
    em.flush();
    log("OK");
}

Quando chamo methodB () de methodA (), o método foi aprovado com sucesso e posso ver "OK" em meus logs. Mas então eu consigo

Could not commit JPA transaction; nested exception is javax.persistence.RollbackException: Transaction marked as rollbackOnly org.springframework.transaction.TransactionSystemException: Could not commit JPA transaction; nested exception is javax.persistence.RollbackException: Transaction marked as rollbackOnly
    at org.springframework.orm.jpa.JpaTransactionManager.doCommit(JpaTransactionManager.java:521)
    at org.springframework.transaction.support.AbstractPlatformTransactionManager.processCommit(AbstractPlatformTransactionManager.java:754)
    at org.springframework.transaction.support.AbstractPlatformTransactionManager.commit(AbstractPlatformTransactionManager.java:723)
    at org.springframework.transaction.interceptor.TransactionAspectSupport.commitTransactionAfterReturning(TransactionAspectSupport.java:393)
    at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:120)
    at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
    at org.springframework.aop.framework.Cglib2AopProxy$DynamicAdvisedInterceptor.intercept(Cglib2AopProxy.java:622)
    at methodA()...

1. O contexto do método B está completamente ausente na exceção - o que está certo, suponho?
2. Algo dentro do methodB () marcou a transação apenas como rollback? Como posso descobrir? Existe, por exemplo, uma maneira de verificar algo como getCurrentTransaction().isRollbackOnly()?- eu poderia percorrer o método e encontrar a causa.

Quando você marca seu método como @Transactional, a ocorrência de qualquer exceção dentro de seu método marcará o TX circundante apenas como reversão (mesmo se você capturá-los). Você pode usar outros atributos de @Transactionalanotação para evitar que ela volte, como:

@Transactional(rollbackFor=MyException.class, noRollbackFor=MyException2.class)

Eu finalmente entendi o problema:

methodA() {
    methodB()
}

@Transactional(noRollbackFor = Exception.class)
methodB() {
    ...
    try {
        methodC()
    } catch (...) {...}
    log("OK");
}

@Transactional
methodC() {
    throw new ...();
}

O que acontece é que, embora methodBtenha a anotação correta, methodCnão tem. Quando a exceção é lançada, o segundo @Transactionalmarca a primeira transação apenas como Rollback.

Para buscar rapidamente a exceção causadora sem a necessidade de recodificar ou reconstruir , defina um ponto de interrupção em

org.hibernate.ejb.TransactionImpl.setRollbackOnly() // Hibernate < 4.3, or
org.hibernate.jpa.internal.TransactionImpl() // as of Hibernate 4.3

e sobe na pilha, geralmente para algum Interceptor. Lá você pode ler a exceção causadora de algum bloco catch.

Lutei com essa exceção ao executar meu aplicativo.

Finalmente o problema estava na consulta sql . quero dizer que a consulta está errada.

por favor, verifique sua consulta. Esta é minha sugestão

Procure exceções sendo lançadas e capturadas no ... seções de seu código. As exceções de tempo de execução e de aplicativo de reversão causam reversão quando descartadas de um método de negócios, mesmo se capturadas em algum outro lugar.

Você pode usar o contexto para descobrir se a transação está marcada para reversão.

@Resource
private SessionContext context;

context.getRollbackOnly();

Encontrou uma boa explicação com as soluções: https://vcfvct.wordpress.com/2016/12/15/spring-nested-transactional-rollback-only/

1) remova o @Transacional do método aninhado se ele realmente não exigir o controle da transação. Portanto, mesmo com exceção, ele simplesmente surge e não afeta as transações.

OU:

2) se o método aninhado precisar de controle de transação, torne-o REQUIRE_NEW para a política de propagação dessa forma, mesmo que lance uma exceção e seja marcado apenas como rollback, o chamador não será afetado.

desative o gerenciador de transações em seu Bean.xml

<tx:annotation-driven proxy-target-class="true" transaction-manager="transactionManager"/>
    <bean id="transactionManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

comente essas linhas e você verá a exceção que causa a reversão;)

aplique o código abaixo em productRepository

@Query("update Product set prodName=:name where prodId=:id ") @Transactional @Modifying int updateMyData(@Param("name")String name, @Param("id") Integer id);

enquanto no teste junit, aplique o código abaixo

@Test
public void updateData()
{
  int i=productRepository.updateMyData("Iphone",102);

  System.out.println("successfully updated ... ");
  assertTrue(i!=0);

}

está funcionando bem para o meu código