Catcher une exception

Version imprimable

Bonjour !

J'ai un objet que je persiste en base de données.
Lorsque je mets à jour un objet déjà enregistré, je fais des contrôles de cohérence dans mon entité et je lève une exception si besoin est :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
@Entity
@Table(name = "mreglement")
public class ModeReglement implements Serializable {
 
    (...)
 
    @PrePersist
    @PreUpdate
    private void control() {
 
        if (code == null || "".equals(code))
            throw new ValidationException("Code invalide !");
 
        if (libelle == null || "".equals(libelle))
            throw new ValidationException("Libellé invalide !");
 
        if ( type==null || "".equals(type))
            throw new ValidationException("Type de règlement invalide !");
 
    }
 
    (...)
 
 
}

Ainsi, tout est déclenché dans mon bean de session comme ceci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
@Stateless
public class ModeReglementFacade ModeReglementFacadeLocal {
 
    @PersistenceContext(unitName = "TestPU")
    private EntityManager em;
 
 
    @Override
    public void update(ModeReglement mode) {
        em.merge(mode);
    }
 
}

Donc ça marche nickel !

Seulement, j'aurais voulu intercepter mon erreur pour pouvoir faire une autre action sur mon entité. J'ai donc penser que cela pouvait marcher dans mon bean de session :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    @Override
    public void update(ModeReglement mode) {
        try {
            em.merge(mode);

//            ACTION A FAIRE SI OK

        } catch (ValidationException ex) {

//            ACTION A FAIRE SI PAS OK

        }
    }

Et bien l'exception n'est jamais interceptée !!!
Et quel que soit le résultat de la mise à jour (ou pas) de mon entité, l'action A FAIRE SI OK est toujours déclenchée !!!

:cry:

Comment faire ?

En fait, je voudrais éviter de gérer dans le Managed-Bean :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
@ManagedBean
@ViewScoped
public class ModeReglementController implements Serializable {

    @EJB
    private ModeReglementFacadeLocal ejb;
    private ModeReglement modeReglement = new ModeReglement();

    public void doUpdate() {

        try {
            ejb.update(modeReglement);

//            ACTION A FAIRE SI OK
            ejb.faireSiOk();

        } catch (Exception ex) {
            getFacesContext().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, ex.getMessage(), null));

//            ACTION A FAIRE SI PAS OK
            ejb.faireSiPasOk();

        }
    }

}

Merci de vos suggestions !

28/11/2010, 11h47
OButterlin

Ce qu'il y a avec les callback c'est qu'ils ne sont appelés que lors de la validation réelle de l'entity (en d'autres termes, lors du commit de la connexion).
Je suppose que tu utilises un contexte JTA, non ?

Dans ce cas de figure, il est normal que tu ne passes pas par le catch, le commit étant fait à la sortie de ta méthode. Ce sera donc à l'appelant de l'intercepter.
Pour ce qui est des solutions de contournement, regarde ceci.

Merci ça peut être une solution...

Néanmoins, j'avais pensé utilliser les fonctions liées à l'objet transactions de Entity Manager :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
    @Override
    public void update(ModeReglement mode) {
 
        em.getTransaction().begin();
 
        try {
            em.merge(mode);
            em.getTransaction().commit();
 
//            ACTION A FAIRE SI OK
 
        } catch (ValidationException ex) {
 
             em.getTransaction().rollback();
 
//            ACTION A FAIRE SI PAS OK
 
        }
    }

Mais là ça ne veut pas !
:?

28/11/2010, 15h02
OButterlin

Encore une fois, c'est normal.
Dans un contexte JTA normal, on n'a pas accès à la transaction, c'est la conteneur qui se charge de cet aspect.
Dans l'exemple en lien, la transaction est déclarée comme une ressource et que la gestion des transactions est @TransactionManagement(TransactionManagementType.BEAN) (par défaut c'est TransactionManagementType.CONTAINER).
As-tu essayé ?

Ok ! Je vais essayer...

Sinon, j'ai réussi qd même à intercepter mon exception dans mon bean de session grâce à flush() :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 @Override public void update(ModeReglement mode) { try { em.merge(mode); em.flush(); // ACTION A FAIRE SI OK } catch (ValidationException ex) { // ACTION A FAIRE SI PAS OK try { throw ex; } catch (Exception e) { System.out.println(e.getMessage()); } } }
Et donc ça passe dans mon catch !
Cependant, impossible de faire suivre l'exception levée (ça génère une exception - la même !) et donc plus interceptée dans le Managed-bean !

:roll:

J'y étais presque...

Bon je viens de tester avec UserTransaction :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
    @Override
    public void update(ModeReglement mode) {
 
        System.out.println("USER TRANSACTION");
        UserTransaction utx = ctx.getUserTransaction();
        try {
 
            System.out.println("BEGIN");
 
            utx.begin();
 
            System.out.println("MERGE");
            em.merge(mode);
 
            System.out.println("COMMIT");
            utx.commit();
 
        } catch (Exception ex) {
 
            System.out.println("ERREUR : " + ex.getMessage());
 
            try {
                utx.rollback();
                throw ex;
            } catch (Exception ex1) {
                System.out.println("ERR ROLLBACK : " + ex1.getMessage());
            }
 
        }
 
        System.out.println("FIN");
 
    }

Et résultat, je capte bien la transaction mais au rollback il y a une erreur...

Citation:

USER TRANSACTION
BEGIN
MERGE
COMMIT
ERREUR : Transaction marked for rollback.
ERR ROLLBACK : Transaction is not active in the current thread.
FIN

Alors j'ai qd même essayé de faire suivre mon erreur (en enlevant utx.rollback();), et là non plus je n'arrive pas à faire suivre mon exception !

:(

Dur dur...

01/12/2010, 12h33
kimausoleil
Finalement j'ai "persisté" dans ma 1ere solution avec flush ! :mrgreen:

Et en fait il fallait juste rajouter les clauses throws dans les fonctions :
- de contrôle de mon entité,
- de mise à jour de mon session bean
- et celles de l'interface @Local et @Remote
Et j'intercepte, je fais mes traitements, et fait suivre mon exception...

:ccool: