récupérer les attributs d'un objet pour un insert DB

Bonjour, j'ai des opération CRUD à faire sur une DB. j'utilise le modèle MVC et une facade entre mes opération DB et ma gestion entités.
Je test mes méthodes avec des tests unitaires.

Ma méthode create de ma gestion entité fonctionne lorsque je rempli les attributs d'un article manuellement.
J'aimerai récupérer les attributs de mon test unitaire, afin de les passer en paramètre à ma méthode create, problème, je ne vois plus comment faire.
Dans un premier temps, c'est surtout pour l'opération Create.

J'ai ma classe ConnectDAO

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
package be.poo.projet1.Persistence;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import javax.swing.JOptionPane;
 
/**
 * Class ConnectDAO pour me connecter à ma DB.
 * 
 * 
 */
public class ConnectDAO {
 
    private final String urlDB;
    private final String passwordDB;
    private final String userDB;
    private static Object instance;
 
    public ConnectDAO() {
        this.userDB = "root";
        this.passwordDB = "";
        this.urlDB = "localhost:3306/vente_articles?useLegacyDatetimeCode=false&serverTimezone=Europe/Brussels";
 
    }
 
    public static ConnectDAO getInstance() {
        if (ConnectDAO.instance == null) {
            instance = new ConnectDAO();
    }
        return (ConnectDAO) instance;
    }
 
    public Connection connection() {
        Connection con;
        try{
            Class.forName("com.mysql.cj.jdbc.Driver");
        con = DriverManager.getConnection(("jdbc:mysql://") + this.urlDB, this.userDB, this.passwordDB);
        return con;
        }catch(ClassNotFoundException ex) {
            JOptionPane.showMessageDialog(null, "Erreur driver mysql: " + ex);
        return null;
        }catch(SQLException ex) {
            JOptionPane.showMessageDialog(null, "Echec à la connexion" + ex);
            System.out.println(ex);
        return null;
        }       
 
    }
 
}

J'ai créé un Factory pour mes opérations CRUD, avec une interface DOA

mon interface

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
package be.poo.projet1.Persistence;
 
/**
 *
 * 
 */
public interface IntDAO {
 
    public void execute(Object obj);
 
}

mon factory

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
 
package be.poo.projet1.Persistence;
 
/**
 *
 * 
 */
public class DAOFactory {
 
    public static IntDAO getCRUD(String DAOType){
        if (DAOType == null){
            return null;
        }
        if (DAOType.equalsIgnoreCase("CREATE")){
            return new Create();
        }else if (DAOType.equalsIgnoreCase("READ")){
            return new Read();
        }else if (DAOType.equalsIgnoreCase("UPDATE")){
            return new Update();
        }else if (DAOType.equalsIgnoreCase("DELETE")){
            return new Delete();
        }
        return null;
 
    }
 
}

Mon opération Create (C) de mon CRUD qui hérite de mon interface

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
35
36
 
package be.poo.projet1.Persistence;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
 
/**
 *
 *
 */
public class Create implements IntDAO{
 
    public Create() {
    }
 
    @Override
    public void execute(Object obj) {
        Connection con = ConnectDAO.getInstance().connection();
        String query = " insert into articles (articles_id,articles_nom,articles_description,articles_prixUnitaire)"+" values (?,?,?,?)";
        PreparedStatement preparedStmt;
 
        try {
            preparedStmt = con.prepareStatement(query);
            preparedStmt.setString(1, "A460");
            preparedStmt.setString(2, "Crayon");
            preparedStmt.setString(3, "HB ordinaire");
            preparedStmt.setDouble(4, 1);
            preparedStmt.executeUpdate();
            preparedStmt.close();
        } catch (SQLException ex) {
            System.out.println("error: " + ex);
        }
    }
 
}

Ma facade

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
35
36
 
package be.poo.projet1.Persistence;
 
/**
 *
 * 
 */
public class FacadeDB {
 
    public FacadeDB(){
 
    }
 
    public void ajoutObj(Object obj){
        IntDAO create = DAOFactory.getCRUD("create");
        create.execute(obj);
    }
 
    public void selectObj(Object obj){
        IntDAO read = DAOFactory.getCRUD("read");
        read.execute(obj);
    }
 
    public void deleteObject(Object obj){
        IntDAO delete = DAOFactory.getCRUD("delete");
        delete.execute(obj);
 
    }
 
    public void updateObject(Object obj){
        IntDAO update = DAOFactory.getCRUD("update");
        update.execute(obj);
 
    }
 
}

ma gestion entité

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
 
package be.poo.projet1.controleur;
 
import be.iepscfjemelle.poo.projet1.Persistence.Persistence;
import static be.iepscfjemelle.poo.projet1.Persistence.Persistence.serialise;
import be.iepscfjemelle.poo.projet1.businessmodel.Article;
import be.iepscfjemelle.poo.projet1.businessmodel.Client;
import be.iepscfjemelle.poo.projet1.businessmodel.Facture;
import be.iepscfjemelle.poo.projet1.businessmodel.Personne;
import be.iepscfjemelle.poo.projet1.businessmodel.PersonneFactory;
import be.iepscfjemelle.poo.projet1.businessmodel.Vendeur;
import be.iepscfjemelle.poo.projet1.Persistence.FacadeDB;
import java.io.IOException;
import java.util.HashSet;
import java.util.Iterator;
import java.util.logging.Level;
import java.util.logging.Logger;
 
/**
 * Class Gestion des entités, contenant plusieurs méthodes,permettant d'ajouter,
 * supprimer, charger un objet à partir d'un fichier.
 *
 * 
 */
public class GestionEntités {
 
    //création de mes hashset pour chaque objets
    public final HashSet<Personne> listeVendeurs;
    public final HashSet<Personne> listeClients;
    public final HashSet<Article> listeArticles;
    public final HashSet<Facture> listeFactures;
    public static final GestionEntités INSTANCE = new GestionEntités();
 
    GestionEntités() {//n'instancier qu'une seul fois la classe
        this.listeVendeurs = new HashSet<>();
        this.listeClients = new HashSet<>();
        this.listeArticles = new HashSet<>();
        this.listeFactures = new HashSet<>();
    }
 
    //*******************************Getteurs et Setters********************************************************
    /**
     * getteur d'une liste Vendeur, retourne une liste de vendeur.
     *
     * @return HashSet listeVendeurs
     */
    public HashSet getListeVendeurs() {
        return listeVendeurs;
    }
 
    /**
     * setteur d'une liste Vendeur.
     *
     * @param emptySet
     */
    public void setListeVendeurs(HashSet emptySet) {
    }
 
    /**
     * getteur d'une liste client, retourne une liste de client.
     *
     *
     * @return HashSet listeClients
     */
    public HashSet getListeClients() {
        return listeClients;
    }
 
    /**
     * setteur d'une liste client.
     *
     * @param emptySet
     */
    public void setListeClients(HashSet emptySet) {
    }
 
    /**
     * getteur d'une liste d'articles, retourne une liste d'article(s).
     *
     * @return HashSet listeArticles
     */
    public HashSet getListeArticles() {
        return listeArticles;
    }
 
    /**
     * setteur d'une liste d'article(s).
     *
     * @param emptySet
     */
    public void setListeArticles(HashSet emptySet) {
 
    }
 
    /**
     * getteur d'une liste de facture, retourne une liste de facture(s).
     *
     * @return HashSet listeFactures
     */
    public HashSet getListeFactures() {
        return listeFactures;
    }
 
    /**
     * setteur d'une liste de facture(s).
     *
     * @param emptySet
     */
    public void setListeFactures(HashSet emptySet) {
 
    }
 
    /**
     * Méthode getFacture, si une facture avec ce numéro existe, alors je renvoi
     * cet facture.
     *
     * @param numéroFacture
     * @return null
     */
    public Facture getFacture(String numéroFacture) {
        Iterator<Facture> iter = this.listeFactures.iterator();
        while (iter.hasNext()) {
            Facture cetFacture = iter.next();
            if (cetFacture.getNuméroFacture().equals(numéroFacture)) {
                return cetFacture;
            }
        }
        return null;
    }
 
    //****************************************Méthodes********************************************************$$
    /**
     * Méthode qui retourne une instance de l'objet unique GestionEntités
     *
     * @return INSTANCE
     */
    public static GestionEntités getInstance() {
        return INSTANCE;
    }
 
    /**
     * Méthode addPersonne, qui crée une personne en fonction de sa fonction,
     * rempli ses attributs, l'ajoute dans une HashSet et regarde si ce n'est
     * pas un doublon. Ensuite sauvegarde de la hashSet et de son contenu dans
     * un fichier binaire grace à la méthode serialise.
     *
     * @param fonction
     * @param numNat
     * @param nom
     * @param prenom
     * @param telephone
     * @param idMagasin
     * @throws be.iepscfjemelle.poo.projet1.controleur.ErrDoublon
     */
    public void addPersonne(String fonction, String numNat, String nom, String prenom, String telephone, String idMagasin) throws ErrDoublon {
        if (fonction.equalsIgnoreCase("vendeur")) {
            Vendeur vendeur = (Vendeur) PersonneFactory.getPersonne(fonction, numNat, nom, prenom, telephone, idMagasin);
            if (!listeVendeurs.add(vendeur)) {//si pas d'ajout du vendeur dans la HashSet gestion d'erreur doublon
                throw new ErrDoublon("Vendeur existant");
            }
            serialise(fonction, listeVendeurs);//Appel de la méthode serialise            
        } else if (fonction.equalsIgnoreCase("Client")) {
            Client client = (Client) PersonneFactory.getPersonne(fonction, numNat, nom, prenom, telephone, idMagasin);
            if (!listeClients.add(client)) {//si pas d'ajout du client dans la HashSet gestion d'erreur doublon
                throw new ErrDoublon("Client existant");
            }
        }
        serialise(fonction, listeClients);//Appel de la méthode serialise
 
    }
 
    /**
     * Class load, récupère une Hashset gràce à le méthode deserialise
     *
     * @param type
     */
    public void load(String type) {
        if (type.equalsIgnoreCase("vendeur")) {
            try {
                this.setListeVendeurs((HashSet<Personne>) Persistence.deserialise(type));
            } catch (IOException | ClassNotFoundException ex) {
                Logger.getLogger(GestionEntités.class.getName()).log(Level.SEVERE, null, ex);
            }
        } else if (type.equalsIgnoreCase("client")) {
            try {
                this.setListeClients((HashSet<Personne>) Persistence.deserialise(type));
            } catch (IOException | ClassNotFoundException ex) {
                Logger.getLogger(GestionEntités.class.getName()).log(Level.SEVERE, null, ex);
            }
        } else if (type.equalsIgnoreCase("article")) {
            try {
                this.setListeArticles((HashSet<Article>) Persistence.deserialise(type));
            } catch (IOException | ClassNotFoundException ex) {
                System.out.println("Erreur : " + ex);
            }
        } else if (type.equalsIgnoreCase("client")) {
            try {
                this.setListeClients((HashSet<Personne>) Persistence.deserialise(type));
            } catch (IOException | ClassNotFoundException ex) {
                Logger.getLogger(GestionEntités.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
 
    /**
     * méthode delPersonne, parcour la hashset avec un iterateur, une fois la
     * bonne personne trouvée, supprime cette personne de la Hashset, et à la
     * fin fait un update de la hahset à l'aide de la méthode update
     * 'resérialise après modifications).
     *
     * @param fonction
     * @param id
     */
    public void delPersonne(String fonction, String id) {
        if (fonction.equalsIgnoreCase("vendeur")) {
            Iterator<Personne> iter = this.listeVendeurs.iterator();
            while (iter.hasNext()) {
                if (iter.next().getNumNat().equalsIgnoreCase(id)) {
                    iter.remove();
                }
            }
        } else if (fonction.equalsIgnoreCase("client")) {
            Iterator<Personne> iter = this.listeClients.iterator();
            while (iter.hasNext()) {
                if (iter.next().getNumNat().equalsIgnoreCase(id)) {
                    iter.remove();
                }
            }
        }
        update(fonction);
    }
 
    /**
     * méthode update sérialise la hashset après une éventuel modification dans
     * celle-ci. grâce à la méthode sérialise
     *
     * @param type
     */
    public void update(String type) {
        if (type.equalsIgnoreCase("vendeur")) {
            serialise(type, listeVendeurs);
        } else if (type.equalsIgnoreCase("client")) {
            serialise(type, listeClients);
        } else if (type.equalsIgnoreCase("article")) {
            serialise(type, listeArticles);
        } else if (type.equalsIgnoreCase("facture")) {
            serialise(type, listeFactures);
        }
    }
 
    /**
     * Méthode addArticle, qui crée un article,rempli ses attributs, l'ajoute
     * dans une HashSet et regarde si ce n'est pas un doublon. Ensuite
     * sauvegarde de la hashSet et de son contenu dans un fichier binaire grace
     * à la méthode serialise.
     *
     * @param id
     * @param nom
     * @param description
     * @param prixUnitaire
     * @throws ErrDoublon
     */
    public void addArticle(String id, String nom, String description, double prixUnitaire) throws ErrDoublon {
        Article article = new Article(id, nom, description, prixUnitaire);
        FacadeDB facade = new FacadeDB();
        facade.ajoutObj(article);
        if(!this.listeArticles.add(article)){
            throw new ErrDoublon("Article déjà existant");
        }
        this .update("article");
 
    }
 
    /**
     * méthode delArticle, parcour la hashset avec un iterateur, une fois la bon
     * article trouvé, supprime cette article de la Hashset, et à la fin fait un
     * update de la hahset à l'aide de la méthode update resérialise après
     * modifications).
     *
     * @param id
     */
    public void delArticle(String id) {
        FacadeDB facade = new FacadeDB();
        facade.deleteObject(id);
        //update("articles");
    }
 
    /**
     * Méthode addFacture, qui crée une facture,rempli ses attributs, l'ajoute
     * dans une HashSet et regarde si ce n'est pas un doublon. Ensuite
     * sauvegarde de la hashSet et de son contenu dans un fichier binaire grace
     * à la méthode serialise.
     *
     * @param numéroFacture
     * @param date
     * @throws ErrDoublon
     */
    public void addFacture(String numéroFacture, String date) throws ErrDoublon {
        Facture facture = new Facture(numéroFacture, date);
        if (!listeFactures.add(facture)) {
            throw new ErrDoublon("Facture existante");
        }
        serialise("facture", listeFactures);
    }
 
}

mon test unitaire

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
package be.poo.projet1.testsunitaires;
 
import be.iepscfjemelle.poo.projet1.businessmodel.Article;
import be.iepscfjemelle.poo.projet1.controleur.ErrDoublon;
import be.iepscfjemelle.poo.projet1.controleur.GestionEntités;
import java.util.HashSet;
import java.util.Iterator;
import static org.hamcrest.CoreMatchers.containsString;
import org.junit.Test;
import static org.junit.Assert.*;
import org.junit.FixMethodOrder;
import org.junit.runners.MethodSorters;
 
/**
 *
 * 
 */
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class Test3_GestionArticle {
 
    private GestionEntités objGest = GestionEntités.getInstance();
 
    public Test3_GestionArticle() {
    }
 
    @Test
    public void test1_ajoutArticle() throws ErrDoublon {
        objGest = GestionEntités.getInstance();
        objGest.addArticle("A457", "Bic rouge", "Bic encre rouge 0.5mm", 2.75);
        HashSet set = objGest.getListeArticles();
        assertEquals(set.size(), 1);
        System.out.println("TEST1 - Article ajouté dans la HashSet et sérialisé.");
    }
 
    @Test
    public void test2_loadingArticle() {
        HashSet emptySet = new HashSet();
        objGest.setListeArticles(emptySet);
        objGest.load("article");
        HashSet set = objGest.getListeArticles();
        assertEquals(set.size(), 1);
        System.out.println("TEST2 - Article désérialisé et ajouté dans la HashSet.");
        Iterator<Article> iter = set.iterator();
        while (iter.hasNext()) {
            Article obj = iter.next();
            assertEquals(obj.getId(), "A458");
            assertEquals(obj.getNom(), "Bic rouge");
            assertEquals(obj.getDescription(), "Bic encre rouge 0.5mm");
            assertEquals(obj.getPrixUnitaire().toString(), "2.75");
        }
        System.out.println("TEST2 - Attributs du vendeur désérialisé corrects.");
    }
 
    @Test
    public void test3_doublonArticle() throws ErrDoublon {
        try {
            objGest.addArticle("A458", "Bic rouge", "Bic encre rouge 0.5mm", 2.75);
            HashSet set = objGest.getListeArticles();
            assertEquals(set.size(), 1);
        } catch (ErrDoublon ex) {
            assertThat(ex.getMessage(), containsString("Article existant"));
            System.out.println("TEST3 - Doublon article refusé");
        }
    }
 
    @Test
    public void test4_suppressionArticle() {
        objGest.delArticle("A457");
        HashSet set = objGest.getListeArticles();
        assertEquals(set.size(), 0);
        System.out.println("TEST4 - Article supprimé dans la HashSet.");
        objGest.load("article");
        HashSet newSet = objGest.getListeArticles();
        assertEquals(newSet.size(), 0);
        System.out.println("TEST4 - Article supprimé de la persistance.");
    }
}