Discussion :

[kokumbo]

Bonjour à tous,

Le débat a sûrement déjà eu lieu ailleurs, ma question est la suivante, doit-on initialiser les propriétés d'une entité au moment de sa création ou le faire au moment de l'accès au niveau de l'entité?

Code :

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

1
2
3
4
5
6
7
8
public class person implements serializable{
...
private String nom;
private Date date = new Date()
private Departement dept = new Departement();
..
 
}

[Mishulyna]

Bonjour,

Je n'ai jamais vu une entité qui implémente Serializable.
Si tu parles d'un entityController: le plus propre (à mon avis) serait d'initialiser certaines valeurs dans une méthode @PostConstruct. Pour initialiser une variable String ou Date c'est possible même dans le constructeur du Controller (on peut supposer que new String() et new Date() seront crées sans problème) mais une variable Departement devrait absolument être initialisée dans une méthode @PostConstruct.

[kokumbo]

Merci pour ta réaction mais le code exemple est mauvais effectivement, il s'agit d'une entité POJO et elle n'implémente pas l'interface serializable. Donc je reformule ma question et j'aimerai avoir un avis sur la question. Ces entités sont lues via ma page Jsf via les méthodes get et si elle ne sont pas initialisées renvoient null.

[chewing-gum]

Plusieurs réponses sont possibles. Pour ma part, je préfère initialiser les champs lors de la création d'une entité, notamment en utilisant les setters.

Code :

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

1
2
3
4
 
Person p = new Person();
p.setDate(new Date());
p.setDepartment(new Department());

Autre solution : tu peux créer différents constructeurs qui initialiseront tes champs plutôt que d'utiliser les setters.

[Mishulyna]

Plusieurs réponses sont possibles.

Effectivement...

Habituée des applications JavaEE et du modèle MVC, pour moi:
- une entité c'est une classe Java qui "reflète" un enregistrement d'une table de la base de données
- un Contrôleur (JSF, ManagedBean) c'est une classe Java qui implémente l'interface Serializable et gère les différentes instances d'un même objet
- une "vue" (page .xhtml dans mon cas) est censée à regrouper certains éléments d'un ou plusieurs objets pour les afficher à l'utilisateur à l'aide des
- Façades (EJB), des classes Java qui se chargent d'effectuer des requêtes dans la base de données pour obtenir les objets à afficher (selon des critères spécifiques) à l'utilisateur.

Alors j'aimerais bien comprendre comment peut-on initialiser les champs d'une entité lors de sa déclaration, quand de mon point de vue: une entité n'est qu'un modèle, une "réservation d'espace" dans la mémoire du programme Java et qu'on peut gérer plusieurs instances d'un objet sans en avoir à faire des "constantes", c'est à dire: des instances d'un seul et toujours le même objet.

Je comprends que Java est vaste comme domaine et que je ne suis pas au bout de mes découvertes (comme dirait Belgique Loisirs) mais j'aimerais bien comprendre au moins l'objet de cette discussion. Merci par avance à ceux qui pourraient m'éclairer!

[kokumbo]

Merci pour ta réaction, je vois qu'il ya plusieurs possibilités adapter à chaque usage et qu'il nya pas de best practice à la matière.

[Mishulyna]

je vois qu'il ya plusieurs possibilités adapter à chaque usage et qu'il nya pas de best practice à la matière.

Ben, peut-être qu'il y en a et nous ne sommes pas au courant...

[kokumbo]

Je comprends ta réaction mais ma question par rapport au "best practice" en la matière était de savoir, si au niveau de mon entité j'ai des références vers des objets qui ne sont pas initialisées, au moment ou JSF accède à ces objet via le EL expression une exception NPE est levée vu que ces objets ne sont pas initialisés. Alors faudrait-il pour chaque méthode ascesseur de l'entité re-écrire une méthode au niveau du controlleur qui les initialise à la demande. Voilà en quelques lignes mon interrogation.

[Mishulyna]

Bonjour,

Ce serait peut-être plus clair avec un peu de code:

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
@ManagedBean(name = "distributeurController")
@SessionScoped
public class DistributeurController implements Serializable {
 
    private Distributeur current;
    private Distributeur newInstanceDistributeur;
    private List<Distributeur> distributeurs;
    @EJB
    private be.isl.tfe.negoce.ejb.DistributeurFacade ejbFacade;
    @ManagedProperty(value = "#{articleController}")
    private ArticleController articleController;
    private int selectedItemIndex;
 
    public DistributeurController() {
    }
 
    // un objet Distributeur est crée dans cette méthode, comme ça si un autre classe Controller appelle DistributeurController, via
    // @ManagedProperty(value = "#{distributeurController}"), il y aura toujours dedans un objet Distributeur initialisé et prêt à être utilisé.
    @PostConstruct
    public void init() { 
        newInstanceDistributeur = new Distributeur(new String()); // dans la classe Distributeur.java il y a un constructeur avec un paramètre String
        newInstanceDistributeur.setArticleCollection(new ArrayList<Article>());
        newInstanceDistributeur.getArticleCollection().add(new Article());
        // initialiser l'attribut ZoneGeographique de l'objet Distributeur, un peu comme le Departement de Person
        newInstanceDistributeur.setFkzoneGeographique(new ZoneGeographique());
        distributeurs = ejbFacade.findAll();
        // ajouter ce Distributeur à la Collection gérée par l'application
        distributeurs.add(newInstanceDistributeur);
    }
 
    // cette méthode à été modifiée, pour bien initialiser tous les attributs d'un objet Distributeur et sera appelée
    // à chaque fois où il arrive que le Distributeur "current" soit null
    public Distributeur getSelected() {
        if (current == null) {
            current = new Distributeur(new String());
            current.setArticleCollection(new ArrayList<Article>());
            current.getArticleCollection().add(new Article());
            current.setFkzoneGeographique(new ZoneGeographique());
            selectedItemIndex = -1;
        }
        return current;
 
     // getters, setters, Converter, méthodes de navigation, etc.
    }

Votre méthode de travail pourrait être différente mais le principe reste le même et il y a probablement moyen d'en faire mieux, c'est pour cela que les "best practice" m'intéressent aussi.
Il est peut-être plus clair pourquoi c'est parfois difficile de créer un objet dans le constructeur du bean: s'il y en a des références vers d'autres beans on risque de se retrouver avec ces beans pas encore créés ou avec des objets non initialisés à l'intérieur et ça va gêner l'exécution du constructeur du bean "appelant".

Alors voilà...