est-il un moyen de forcer les opérations de restauration sans rencontrer une exception?

J'ai une méthode qui fait un tas de choses; parmi eux, de faire un certain nombre d'insertions et mises à jour. Elle est déclarée à l'thusly...

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

Il fonctionne exactement comme il est censé faire, et je n'ai pas de problèmes avec elle. Il y a des cas, cependant quand je veux de la force de la restauration, en dépit de ne pas être une exception... pour le moment, je suis en forçant une exception lorsque je rencontre les bonnes conditions, mais c'est moche et je n'aime pas ça.

Peut je contribue activement à l'appel de la restauration en quelque sorte? L'exception appelle... je pense peut-être que je peut trop.

InformationsquelleAutor Genia S. | 2009-05-07
  1. 22

    Au Printemps Transactions, vous utilisez TransactionStatus.setRollbackOnly().

    Le problème que vous avez ici est que vous utilisez @Transactional pour délimiter vos transactions. Cela a l'avantage d'être non invasive, mais cela signifie également que si vous souhaitez manuellement interagir avec le contexte de transaction, vous ne pouvez pas.

    Si vous voulez un contrôle serré de votre statut de la transaction, vous devez utiliser programmatique transactions plutôt que déclarative des annotations. Cela signifie en utilisant le Printemps TransactionTemplate, ou d'utiliser ses PlatformTransactionManager directement. Voir la section 9.6 du Printemps manuel de référence.

    Avec TransactionTemplate, vous fournir un rappel de l'objet qui implémente TransactionCallback, et le code de cette fonction de rappel a accès à la TransactionStatus objets.

    C'est pas aussi beau que @Transactional, mais vous vous rapprochez de contrôle de votre tx état.

    • En utilisant TransactionInterceptor.currentTransactionStatus().setRollbackOnly() être un moyen de le faire manuellement en interaction avec la transaction au moyen d'une méthode qui utilise @Transactional ? Principalement pour le remplacement de la setRollbackOnly les méthodes d'EJB. Serais intéressé si vous avez un commentaire à faire sur ce. Merci!
    InformationsquelleAutor skaffman
  2. 16

    Nous n'utilisons pas d'EJB, mais de simples Printemps et nous avons choisi la démarche AOP.
    Nous avons mis en œuvre la nouvelle annotation @TransactionalWithRollback et AOP utilisé pour envelopper ces méthodes annotées avec "autour de" conseils. Pour mettre en œuvre les conseils que nous leur utilisation, comme mentionné TransactionTemplate. Cela signifie un peu de travail au début, mais comme un résultat, nous pouvons seulement d'annoter une méthode avec @TransactionalWithRollback comme nous utilisons @Transactional dans les autres cas. Le code principal aspect propre et 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>
    • +1 pour avoir pris le temps de répondre à une question que j'ai demandé il y a 4 ans et qui a déjà plusieurs upvoted accepté de répondre! 🙂
    • J'aime les choses pour être complet 🙂
    InformationsquelleAutor Jakub
  3. 15

    Appel setRollbackOnly() sur le SessionContext si vous êtes dans un EJB.

    Vous pouvez injecter SessionContext comme suit:

    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() est un membre de EJBContext. SessionContext s'étend EJBContext:
    http://java.sun.com/j2ee/1.4/docs/api/javax/ejb/SessionContext.html Remarque il est uniquement disponible dans la session Ejb.

    @Resource est un standard Java EE annotation, de sorte que vous devriez vérifier votre configuration dans Eclipse. Voici un exemple de comment injecter le SessionContext à l'aide de @Resource.

    Je soupçonne que ce n'est probablement pas votre solution, car il semble que vous ne pouvez pas travailler avec les Ejb -- expliquer pourquoi Eclipse n'est pas de trouver @Resource.

    Si c'est le cas, alors vous aurez besoin d'interagir avec la transaction directement-voir le modèle de transaction.

    • Eclipse ne reconnaît pas @Ressource comme une annotation, et setRollbackOnly() n'est pas un membre de SessionContext (lors de l'importation à partir de org.springframework.orm.hibernate3.SpringSessionContext). Donc... je suis de plus près, mais pas assez près 🙂
    • Merci pour la réponse...
    InformationsquelleAutor Edward Q. Bridges
  4. 14

    Cela fonctionne pour moi:

    TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
    InformationsquelleAutor Melquiades Fagundez
  5. 3

    Vous devriez avoir le printemps injecter le gestionnaire transactionnel. Ensuite, vous pouvez simplement appeler la méthode de retour en arrière sur elle.

    • cela semble comme la bonne façon de faire... je recherche SavepointManager maintenant.
    • ceci est à l'origine de la levée d'une exception à la fin de "Transaction annulée parce qu'il a été marqué que la restauration seule"
    InformationsquelleAutor Ruggs
  6. 2

    J'ai de service méthodes annotées avec @Transactional. Si la validation échoue, et j'ai déjà une entité attachée à l'unité de travail, j'utilise sessionFactory.getCurrentSession().evict(entity) à assurez-vous que rien n'est écrit dans la base de données. De cette façon, je n'ai pas besoin de lever une exception.

    • Cela pourrait être une solution de compromis dans une longue session.
    InformationsquelleAutor Urs
  7. 0

    Oui nous pouvons forcer la restauration tout en utilisant @Transactionnelle (niveau de classe) sans rencontrer une exception. Nous pouvons simplement lever une exception (tout en un). Comme

    if(some condition matches){
 throw new DataIntegrityViolationException("Rollback Tnx.. Since ..." );
}
    InformationsquelleAutor myounism
  8. -3

    Lever une exception et d'utiliser le cadre comme prévu, autrement, ne pas utiliser déclarative des transactions de gestion et de suivi skaffman conseiller ci-dessus. Garder les choses simples.

    InformationsquelleAutor JARC