Discussion :

[kZn.13]

Bonjour je fais ce post car je bloque sur quelque chose qui va vous sembler élémentaire...



Voici mon cas :
J'ai une collection X, qui contient des objets Y, qui contiennent une collection d'objets "Personne". (Ces collections sont de type HashMap et se créent à partir d'une base de données).

J'implémente un JTree au lancement de mon application, qui forme son modèle à partir de la collection X.

Il y aura donc des "Personnes" qui ne seront pas instanciées (restantes dans la base de données) car une "Personne" peut ne pas être encore affectées à un objet Y...
Si maintenant je veux lister toutes les "Personnes" dans une JList, dans une nouvelle fenêtre, je ne peux pas me resservir de mes anciennes collections car elles sont incomplètes...

Alors je pense que je dois refaire une collection à partir dans la base de données?! Sauf que lors de la création de cette collection, cela va créer des doublons des objets "Personnes" qui sont déjà instanciés dans les collections d'objets Y (les personnes qui sont déja affichées dans le JTree en gros).

Voilà je bloque là, je voudrais juste faire une référence vers les objets "Personne" qui existent dans la collection Y, et instancier les personnes qui ne le sont pas... Et créer le JList. Que lors d'une modification dans la nouvelle fenêtre, cela mette à jour le JTree sans le recharger à partir de la base de données. -> le principe de l'objet quoi.

J'espère avoir été clair et qu'il existe une solution rapide car c'est pour mon examen dans quelques jours... Cela fait quelques temps déjà que je me casse la tête pour trouver une solution optimisée, donc même si vous aviez quelque chose à me proposer ça pourrait m'intéresser!



Merci par avance.

[dinobogan]

Tout va se passer dans le modèle de ta JList. Tu peux par exemple utiliser une HashTable, avec en clé une Personne et en valeur un booléen (ou autre chose, peu importe, c'est juste pour ne pas insérer un objet null). Tu vas commencer par remplir la hashtable avec les Personne de ta collection, puis ensuite, pour toutes les Personne de ta base de données, tu vas vérifier si une Personne est présente dans ta Hashtable. Si ce n'est pas le cas, alors tu ajoutes cette Personne dans ton Hashtable.
Par contre, si ta collection peut être modifier au runtime, il faudra prendre l'instance de Personne de la Hashtable du modèle de la JList.

[kZn.13]

Merci dinobogan pour ta réponse.

Je viens de voir à l'instant ton message et j'ai fait une méthode similaire entre temps pour remplir le modèle de la JList.

Je dois préciser que dans mes HashMap les clés sont l'id des objets.

Enfet dans ma classe collection de personnes, je fais un "SELECT * FROM personne", et je compare les ID en parcourant tous les objets de la collections X, puis pour chaque objet X je parcours la collection Y, et pour chaque objet Y la collection de personne... et je compare les id des personnes récupéré avec la clé trouvé avec les personnes déja instanciées.

J'ai pas encore fait le test pour voir si ça marche car j'ai modifié d'autres choses entre temps. Mais est-ce que le raisonnement est bon? C'est un dérivé de la solution que tu m'as proposé ou je me suis enflammé? :p

En tout cas merci pour ton courage, t'es le seul à avoir répondu sur 75 lectures. :/

[kZn.13]

Ma méthode si je comprends bien c'est celle que tu m'as proposé

Et elle fonctionne pour afficher les personnes, et sans créer de doublons.

Merci pour ton aide.


kZ.

[kZn.13]

Tout va se passer dans le modèle de ta JList. Tu peux par exemple utiliser une HashTable, avec en clé une Personne et en valeur un booléen (ou autre chose, peu importe, c'est juste pour ne pas insérer un objet null). Tu vas commencer par remplir la hashtable avec les Personne de ta collection, puis ensuite, pour toutes les Personne de ta base de données, tu vas vérifier si une Personne est présente dans ta Hashtable. Si ce n'est pas le cas, alors tu ajoutes cette Personne dans ton Hashtable.
Par contre, si ta collection peut être modifier au runtime, il faudra prendre l'instance de Personne de la Hashtable du modèle de la JList.

Le problème que je rencontre maintenant c'est celui que tu as évoqué...
Je ne comprends pas pourquoi il faut utiliser la nouvelle instance de Personnes...
D'après moi, si l'on le modifie un objet qui apparait à plusieurs endroits du programme, cela devrait le modifier dans sa globalité, et partout?



Voilà un bout de code pour récupérer les Personnes déja dans la mémoire, sinon instancie les autres :

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
/*
                 * "Clients"
                 */
                //Parcours de la collection de Personne de l'objet Y et instancie toutes les Personnes qui sont dans des objets Y
                for (Entry<Integer, Client> currentClient : Y.getCollectionClientsY().entrySet()) {
                    //Cle pour chaque Client de Y
                    int cleClient = currentClient.getKey();
                    //Récupération du Client
                    unClient = Y.getCollectionClientsY().get(cleClient); 
                    //Rajoute le Client à la Collection de Clients
                    _collectionClients.put(unClient.getId(), unClient);
                }
            }
        }
        //Ici on va se connecter à la BDD et ajouter les clients qui sont dans aucun objet Y (donc qui n'ont pas encore été ajouté à la collection de clients)
        try {
            //Créé la connection
            Connection bdd = Bdd.makeConnection();
            
            String sql = "SELECT * FROM client;   

            //Exécute la requête
            PreparedStatement ps = bdd.prepareStatement(sql);
            ResultSet rs = ps.executeQuery();
            
            //Parcours chaque tuple
            while (rs.next()) {
                int idClient = rs.getInt("id_c");
                
                if (_collectionClients.containsKey(idClient) == false) {
                    //Créé l'objet Client
                    unClient = new Client(rs.getInt("id_c"), rs.getString("nom_c"), rs.getString("prenom_c"), rs.getDate("date_naissance_c"), rs.getString("rue_c"), rs.getString("code_postal_c"), rs.getString("ville_c"), rs.getString("num_tel_c"), rs.getString("email_c"), rs.getDate("date_inscription_c"));
                    //Rajoute le Client à la Collection de Clients
                    _collectionClients.put(unClient.getId(), unClient);
                }
            }

La JList va se baser sur cette collection pour afficher toutes les Personnes...
Après avoir vérifier que pour un client, la référence dans le JTree et dans le JList est la même en mémoire, si je le modifie dans le JList (unClient.setNom("blabla")) par ex. Si je vais dans le JTree et que je le sélectionne, que j'ouvre une fenêtre qui montre ses propriétés, elles apparaissent comme si elles n'avaient pas été modifiées... Moi pas comprendre là!

Je me suis fait une fausse idée de l'objet ou je m'y prends mal tout simplement?



Merci de m'éclairer

[dinobogan]

Tu t'y prends mal
Assure-toi que l'ajout et la récupération des éléments dans les différentes collections se fait par pointeur, et non par copie.
Pourquoi dupliquer les valeurs de "Y.getCollectionClientsY()" dans "_collectionClients" ? Ne peux-tu pas travailler directement avec "Y.getCollectionClientsY()" ? Ca éviterait pas mal de risque de désynchronisation des données.

[divxdede]

Pourquoi ne pas passer par un objet "Proxy" pour récuperer un objet Personne ?
Ce proxy aurait la charge de créer un objet si la personne n'a encore jamais été réferencé sinon il aurait la charge de rendre l'instance unique.

Ensuite par exemple si tu es amené a serialiser une personne.
Tu peu écrire un writeReplace et un readResolve pour repasser par le proxy pour gérer l'unicité. (je sais c'est une problèmatique que tu n'as peut etre pas)

[kZn.13]

Tu t'y prends mal
Assure-toi que l'ajout et la récupération des éléments dans les différentes collections se fait par pointeur, et non par copie.
Pourquoi dupliquer les valeurs de "Y.getCollectionClientsY()" dans "_collectionClients" ? Ne peux-tu pas travailler directement avec "Y.getCollectionClientsY()" ? Ca éviterait pas mal de risque de désynchronisation des données.

Enfet je ne vois pas où ils sont dupliqués... C'est un même objet qui est mi dans une autre collection. Si l'on le modifie à partir de la 2ème collection, cela ne va pas modifier la 1ère version de l'objet? ...

Pourquoi ne pas passer par un objet "Proxy" pour récuperer un objet Personne ?
Ce proxy aurait la charge de créer un objet si la personne n'a encore jamais été réferencé sinon il aurait la charge de rendre l'instance unique.

Ensuite par exemple si tu es amené a serialiser une personne.
Tu peu écrire un writeReplace et un readResolve pour repasser par le proxy pour gérer l'unicité. (je sais c'est une problèmatique que tu n'as peut etre pas)

Alors là parcontre ça m'intéresse beaucoup aussi cette façon, mais je n'en ai encore jamais entendu parlé... Je vais de ce pas me documenter.

Edit : J'ai trouvé un tuto ici même, et c'est pas si simple...



Merci à vous 2 en tout cas, si j'y arrive je vais combiner vos 2 méthodes et ça sera très beau! :p


RE-EDIT :
Nouvelle technique :

1. Mes collections sont des singletons.

1. Je remplie d'abord ma collection de Personnes, et je vais me servir dedans pour remplir mon JTree, tout bêtement... :]