Discussion :

[chat_roux]

Bonjour,

voici la description de mon problème :
(semblable à celui de l'intervenant précédent)

Mon entité 'Utilisateur':

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
...
@Entity
public class Utilisateur implements Serializable {
 
    @Id
    private Long id;
 
    private String identifiant;
    private String motDePasse;
    ...
}

Mon service 'UtilisateurService':

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
...
@Stateless
public class UtilisateurService implements UtilisateurServiceLocal {
    @EJB
    private UtilisateurFacadeLocal utilisateurFacade;
    ...
    @Override
    public Utilisateur identifierRecuperer (Utilisateur utilisateur) {
        if (!this.identifier(utilisateur)) {
            return null;
        }
        Utilisateur utilisateurRecupere = this.recuperer(utilisateur);
        return utilisateurRecupere ;
    }
    ...
    @Override
    private Utilisateur recuperer (Utilisateur utilisateur) {
        Utilisateur utilisateurTrouve = utilisateurFacade.findByIdentifiant (utilisateur.getIdentifiant());
        if (utilisateurTrouve==null) {
            return null;
        }
        utilisateurTrouve.setMotDePasse(null); // Le mot de passe ne doit pas être renvoyé vers les sous-contrôleurs --> On le met à null...
        return utilisateurTrouve;
    }
    ....
}

Comportement à l'exécution :

Dans la table 'UTILISATEUR', le mot de passe de cet utilisateur a été modifié (à null).
Le code responsable de ce comportement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

utilisateurTrouve.setMotDePasse(null);

Conséquence : le mot de passe est perdu.

Mon objectif :
Je ne souhaitais pas modifier la table de cette entité. Je souhaitais uniquement ne pas renvoyer le mot de passe vers les sous-contrôleurs.
(Pour des raisons de confidentialité : je ne souhaite pas que les sous-contrôleurs aient accès aux mots de passe des utilisateurs)...

Ma Question:
Je voudrais empêcher les setters de mon entité JPA de modifier la table associée à cette entité ?
Existe-t-il un moyen ?

Merci à tous ceux qui pourraient m'aider, et bon courage...

[tchize_]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
...
@Entity
public class Utilisateur implements Serializable {
 
    @Id
    private Long id;
 
    private String identifiant;
    @Column(name = "password", insertable = false, updatable = false)
    private String motDePasse;
    ...
}

Ainsi password ne pourra jamais être écrit.

Si toute l'entité doit être readonly, la question deviens plutot: pourquoi tu retourne l'entité et pas une autre classe genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
@Override
    public UtilisateurPrincipal identifierRecuperer (String login, String password) {
        if (!this.identifier(login,password)) {
            return null;
        }
        Utilisateur utilisateurRecupere = this.recuperer(login);   
        return new UtilisateurPrincipal(utilisateurRecupere.getLogin()) ;
    }

[chat_roux]

Bonjour,

bien enregistré la solution que tu décris ci-dessus.

Entretemps, j'avais trouvé la solution suivante :
J'avais "détaché" mon entité "Utilisateur" du contexte de persistance.
(qui fonctionne, mais n'est pas très fiable)

DESCRIPTION :
-----------------------------------------------------------------
-->Considérons mon objet d'accès aux données ("UtilisateurFacade").
-->Celui-ci possède un attribut de type "EntityManager".
-->La classe "EntityManager" possède une méthode "detach()".
-->Cette méthode prend pour argument : l'entité que l'on veut détacher du contexte de persistance.

REALISATION DANS LE CODE :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
Class UtilisateurFacade {
 
    @PersistenceContext(unitName="XXX-ejbPU") // "XXX-ejbPU" est l'unité de persistance.
    private EntityManager em;
 
    @Override
    private void detach (Utilisateur utilisateur) {
        em.detach(utilisateur);
    }
}

Et, dans mon objet "UtilisateurService", j'appelle cette méthode 'detach()'.

COMPORTEMENT A L'EXECUTION :
-----------------------------------------------------------------
-->L'entité "utilisateur" se trouve "détachée" du contexte de persistance.
-->Ses getters et setters n'ont plus d'accès à la base de données.
-->Après avoir été détachée, l'entité fonctionne comme un objet java ordinaire

CONCLUSION :
-----------------------------------------------------------------
J'ai opté pour la solution proposé par tchize (voir message précédent).
(=récupérer le contenu de l'entité "Utilisateur" dans un objet java ordinaire "UtilisateurPrincipal", qui possède les mêmes attributs).

Ca marche parfaitement. Merci à tchize pour la solution fournie.
Et bon courage à tous !...

chat_roux