Anotação @Transactional. Como reverter?

Usei essa anotação com sucesso para uma classe Dao. E a reversão funciona para testes.

Mas agora preciso reverter o código real, não apenas os testes. Existem anotações especiais para uso em testes. Mas quais anotações são para código que não é de teste? É uma grande questão para mim. Já passei um dia por isso. A documentação oficial não atendeu às minhas necessidades.

class MyClass { // this does not make rollback! And record appears in DB.
        EmployeeDaoInterface employeeDao;

        public MyClass() {
            ApplicationContext context = new ClassPathXmlApplicationContext(
                    new String[] { "HibernateDaoBeans.xml" });
            employeeDao = (IEmployeeDao) context.getBean("employeeDao");
         }

        @Transactional(rollbackFor={Exception.class})
    public void doInsert( Employee newEmp ) throws Exception {
        employeeDao.insertEmployee(newEmp);
        throw new RuntimeException();
    }
}

empregadoDao é

@Transactional
public class EmployeeDao implements IEmployeeDao {
    private SessionFactory sessionFactory;

    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    public void insertEmployee(Employee emp) {
        sessionFactory.getCurrentSession().save(emp);
    }
}

E aqui está um teste para o qual as anotações funcionam bem:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "/HibernateDaoBeans.xml" })
@TransactionConfiguration(transactionManager = "txManager", defaultRollback = true)
@Transactional
public class EmployeeDaoTest {

    @Autowired
    EmployeeDaoInterface empDao;

    @Test
    public void insert_record() {
       ...
       assertTrue(empDao.insertEmployee(newEmp));
    }

HibernateDaoBeans.xml

   ...
<bean id="employeeDao" class="Hibernate.EmployeeDao">
    <property name="sessionFactory" ref="sessionFactory" />
</bean>
    <tx:annotation-driven transaction-manager="txManager"/>

<bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory" />
</bean>
   ...

** SIM, eu reverti a transação. Acabei de adicionar BEAN para o serviço ... e então a anotação @Transactional begin to work :-) **

<bean id="service" class="main.MyClass">
    <property name="employeeDao" ref="employeeDao" />
</bean>

Obrigado a todos, a Rússia não vai esquecer de vocês!

Basta jogar qualquer RuntimeExceptionum de um método marcado como @Transactional.

Por padrão, todas RuntimeExceptionas transações de rollback, enquanto as exceções verificadas não. Este é um legado EJB. Você pode configurar isso usando os parâmetros de anotação rollbackFor()e noRollbackFor():

@Transactional(rollbackFor=Exception.class)

Isso irá reverter a transação após lançar qualquer exceção.

ou programaticamente

TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();

Você pode lançar uma exceção não verificada do método que deseja reverter. Isso será detectado na primavera e sua transação será marcada apenas como reversão.

Presumo que você esteja usando Spring aqui. E suponho que as anotações às quais você se refere em seus testes são as anotações baseadas no teste de mola.

A maneira recomendada de indicar à infraestrutura de transação do Spring Framework que o trabalho de uma transação deve ser revertido é lançar uma Exceção do código que está em execução no contexto de uma transação.

e observe que:

observe que o código de infraestrutura de transação do Spring Framework irá, por padrão, apenas marcar uma transação para reversão no caso de tempo de execução, exceções não verificadas; ou seja, quando a exceção lançada é uma instância ou subclasse de RuntimeException.

Para mim o rollbackFor não foi suficiente, então tive que colocar isso e funcionou conforme o esperado:

@Transactional(propagation = Propagation.REQUIRED, readOnly = false, rollbackFor = Exception.class)

Espero que ajude :-)