Annotation @Transactional. Comment revenir en arrière?

J'ai utilisé cette annotation avec succès pour une classe Dao. Et la restauration fonctionne pour les tests.

Mais maintenant, j'ai besoin de restaurer du vrai code, pas seulement des tests. Il existe des annotations spéciales à utiliser dans les tests. Mais quelles annotations sont pour le code non test? C'est une grande question pour moi. J'ai déjà passé une journée pour ça. La documentation officielle ne répondait pas à mes besoins.

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();
    }
}

employéDao est

@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);
    }
}

Et voici un test pour lequel les annotations fonctionnent bien:

@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>
   ...

** OUI, j'ai annulé la transaction. Je viens d'ajouter BEAN pour le service ... puis l'annotation @Transactional commence à fonctionner :-) **

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

Merci à tous, la Russie ne vous oubliera pas!

Jetez-en simplement une à RuntimeExceptionpartir d'une méthode marquée comme @Transactional.

Par défaut, toutes RuntimeExceptionles transactions d'annulation, contrairement aux exceptions cochées. C'est un héritage EJB. Vous pouvez configurer cela à l'aide des paramètres d'annotation rollbackFor()et noRollbackFor():

@Transactional(rollbackFor=Exception.class)

Cela annulera la transaction après avoir levé une exception.

ou par programme

TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();

Vous pouvez lever une exception non vérifiée à partir de la méthode que vous souhaitez restaurer. Cela sera détecté au printemps et votre transaction sera marquée comme annulation uniquement.

Je suppose que vous utilisez Spring ici. Et je suppose que les annotations auxquelles vous faites référence dans vos tests sont les annotations basées sur les tests de ressorts.

La méthode recommandée pour indiquer à l'infrastructure de transaction de Spring Framework que le travail d'une transaction doit être annulé consiste à lever une exception à partir du code en cours d'exécution dans le contexte d'une transaction.

et notez que:

veuillez noter que le code d'infrastructure de transaction de Spring Framework marquera, par défaut, une transaction pour une annulation uniquement dans le cas d'exceptions non vérifiées à l'exécution; autrement dit, lorsque l'exception levée est une instance ou une sous-classe de RuntimeException.

Pour moi, rollbackFor n'était pas suffisant, j'ai donc dû mettre ceci et cela fonctionne comme prévu:

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

J'espère que cela aide :-)