Projet d'application en Java : Interaction Java / BDD en JDBC

Version imprimable

1 pièce(s) jointe(s)

Bonjour,

Pour un projet d'école je souhaiterais créer une appli de gestion de salon. Je la veut très très simple . Voici le MCD que j'ai crée :

Pièce jointe 310833

L'idée est d'avoir une interface où le coiffeur pourra selectionner :
Son client qu'il à coiffer ( Client ), lui même ( Coiffeur ), la prestation effectué etc coupe .. ( Prestation + typePrestation ) . A la fin de la selection : une validation qui met toutes ses informations dans la table prestationsEffectuees.
De sorte à pouvoir afficher toutes les informations de la table prestationsEffectuees comme : Le nombre de prestations enregistrés, le nb de prestation par coiffeur, ....

J'ai ensuite commencé à créer mes classes sous eclipse, mais c'est là où j'ai du mal . Je sais qu'avec la programmation orientée objet il faut une classe par table.. Cependant comment faire ma classe typePrestation ? Comment relier les classes entre elles ?

J'ai essayé avec un hashmap, voici ma classe Prestations :
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 import java.util.HashMap; public class Prestations { private int dateHeure; private HashMap<String,Float> listePresta = new HashMap<String,Float>(); public Prestations(int dateHeure) { super(); this.dateHeure = dateHeure; } public Prestations(){} public HashMap<String, Float> getListePresta() { return listePresta; } public void setListePresta(HashMap<String, Float> listePresta) { this.listePresta = listePresta; } public int getDateHeure() { return dateHeure; } public void setDateHeure(int dateHeure) { this.dateHeure = dateHeure; } // Ajoute une prestation public void addPrestation(Prestations prestations){ this.listePresta.add(prestations); } //Supprime une prestation public void removePrestation(Prestations prestations){ this.listePresta.remove(prestations); }
Mais j'ai du mal à l'utiliser ..

Pour les classes coiffeur et client j'ai mis tous les attributs avec le constructeur, les setters et getters.

Puis je ne vois pas comment faire non plus la classe prestationsEffectuees. ( Dois-je utiliser l'héritage ou autre ? )

J'aimerais avoir une orientation sur comment coder tout ça ( ne me donnez pas de code tout fait, j'aimerais comprendre seulement et pratiquer moi même ).

En vous remerciant .

Bonjour fa_dev,

comme tu l'as dit toi même, tu programmes dans un langage orienté objet.

De ce fait, tu dois envisager ta classe TypePrestation comme un objet, composé d'un libellé et d'un prix. Cet objet sera alors déclaré comme un attribut de ta classe Prestation.
Pour accéder au libellé de ta Prestation, tu dois d'abord récupérer l'objet TypePrestation de ta Prestation, et ensuite accéder au libellé de cet objet.
Je te donne un exemple:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 public class Voiture { private String marque; private String modele; private Moteur moteur; ... } public class Moteur { private String marque; private int puissanceFiscale; private float prix; ... }
Pour ce qui est de l'utilisation de la HashMap, je ne crois pas que ce soit approprié. Lorsque tu déclares HashMap<String, Float>, il faut bien comprendre que la String est une clé et le Float une valeur. Cela veut dire que ta map aura comme liste de clés les libellés de tes prestations et comme valeurs associées à ces clés les prix de tes prestations. Cela est trop complexe pour l'utilisation que tu décris.

Pour finir sur la classe PrestationsEffectuées, cette classe sera composée de trois objets. Un objet Client, un objet Coiffeur et un objet Prestation. Ce modèle fonctionne uniquement à cause des cardinalités que tu indiques dans ton diagramme.

En espérant t'avoir aidé, ne serait-ce qu'un peu.

Cordialement,
JuPer71

Merci beaucoup pour ta réponse très claire ! Ca m'a vraiment aidé à comprendre.
Du coup je n'ai besoin d'aucun objet de Collection ?

Un résumé de ce que j'ai fait :
Code:

1 2 3 public class Prestations { private int dateHeure; private TypePrestation typePrestation; }
Code:

1 2 3 public class TypePrestation { private String nomPrestation; private int prix; }
Code:

1 2 3 4 5 6 public class prestationEffectuee { private Client client; private Coiffeur coiffeur; private Prestations prestations; + constructeur / Getters / setters pour tous.

14/09/2017, 14h50
JuPer71

C'est exactement ça.

Le problème de la HashMap, c'est que chacun de tes objets Prestation aurait contenu une map contenant tous les types de prestations. Or toi, tu veux uniquement le type de ta prestation.

Ton code répond donc à ton besoin et est bien écrit.

Voilà.
Bon courage pour la suite. ;)
A plus.

Je continue dans mon projet..
J'ai adapté mon DAO pour le projet :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package DAO;
 
import java.sql.Connection;
import java.sql.SQLException;
 
public abstract class DAO<T> {
 
		public static Connection getConnexion() throws ClassNotFoundException, SQLException 
        {
	     Connection cnx = Connect.getInstance().getConnection();
	        return cnx;
	    }
 
	  public abstract int create(T obj) throws ClassNotFoundException, SQLException;
 
	  public abstract int delete(int id) throws ClassNotFoundException, SQLException ;
 
	  public abstract boolean update(T obj);
 
	  public abstract T find(int id);
 
 
}

Un exemple de ma classe coiffeurDAO :

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
package DAO;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
 
import bean.Coiffeur;
 
public class CoiffeurDAO extends DAO<Coiffeur> {
 
 
	public int create(Coiffeur coiffeur) throws ClassNotFoundException, SQLException {
		Connection cnx = getConnexion();
 
        PreparedStatement pst = null;
        int nblignes = 0;
 
        String requeteSQL = "INSERT INTO coiffeur (nom, prenom) values(?, ?)";
 
        System.out.println("beforexecute");
        pst = cnx.prepareStatement(requeteSQL);
 
        pst.setString(1, coiffeur.getNomCoiffeur());
        pst.setString(2, coiffeur.getPrenomCoiffeur());
 
 
        try {
            nblignes = pst.executeUpdate();
        } catch (SQLException ex) {
            System.out.println(ex.getMessage());
        }
        pst.close();
        cnx.close();
        return nblignes;
	}
 
	@Override
	public int delete(int  id) throws ClassNotFoundException, SQLException {   
        Connection cnx = getConnexion();
 
        PreparedStatement pst = null;
        int nblignes = 0;
 
        String requeteSQL = "DELETE from coiffeur where id ="+id;
 
        System.out.println("beforexecute");
        pst = cnx.prepareStatement(requeteSQL);
 
        try {
            nblignes = pst.executeUpdate();
        } catch (SQLException ex) {
            System.out.println(ex.getMessage());
        }
        pst.close();
        cnx.close();
        return nblignes;
 
    }

J'ai juste du mal avec la classe prestationsDAO :

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
public class PrestationsDAO extends DAO<Prestations> {
 
 
	public int create(Prestations prestations) throws ClassNotFoundException, SQLException {
		Connection cnx = getConnexion();
 
        PreparedStatement pst = null;
        int nblignes = 0;
 
        String requeteSQL = "INSERT INTO prestations (dateheureprestation, ) values(?, ?)";   // + L'id typePrestation ??
 
        System.out.println("beforexecute");
        pst = cnx.prepareStatement(requeteSQL);
 
        pst.setInt(1, prestations.getDateHeurePrestation());
        pst.setTypePrestation(2, prestations.getTypePrestation());  // Comment déclarer l'objet TypePrestation ?
 
        try {
            nblignes = pst.executeUpdate();
        } catch (SQLException ex) {
            System.out.println(ex.getMessage());
        }
        pst.close();
        cnx.close();
        return nblignes;
	}

Question : Comment est ce que je déclare mon objet TypePrestation ? Car je suis sencé envoyé à ma bdd l'id du typePrestation choisi.. Je bloque .
Puis le même problème dans la classe PrestationsEffectueesDAO :

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
public int create(prestationEffectuee prestationEffectuee) {  // A REVOIR. COMMENT RELIER LES ID ?
		Connection cnx = getConnexion();
 
        PreparedStatement pst = null;
        int nblignes = 0;
 
        String requeteSQL = "INSERT INTO prestationeffectuee (, ) values(?, ?, ?)";
 
        System.out.println("beforexecute");
        pst = cnx.prepareStatement(requeteSQL);
 
        pst.setClient(1, prestationEffectuee.getClient());  // ??
        pst.setString(2, prestationEffectuee.getCoiffeur());  // ??
 
 
        try {
            nblignes = pst.executeUpdate();
        } catch (SQLException ex) {
            System.out.println(ex.getMessage());
        }
        pst.close();
        cnx.close();
        return nblignes;
	}

Je voudrais récupérer les ID comme dit dans le MCD de mon premier post.

Merci à vous !

17/09/2017, 16h08
joel.drigo

Salut,

Tu pêux récupérer l'id de l'enregistrement inséré par la méthode getGeneratedKeys().
19/09/2017, 10h18
fa_dev

Bonjour, merci pour la réponse.
Malgré plusieurs essais j'avoue que j'ai du mal à placer cette méthode ...

Quelque chose comme ça, par exemple :

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
public int create(Prestations prestations) throws SQLException {
    try(Connection cnx = getConnexion()) {
 
        System.out.println("beforexecute");
        String requeteSQL = "INSERT INTO prestations (dateheureprestation, ) values(?, ?)";   // + L'id typePrestation ??
 
        try(PreparedStatement pst = cnx.prepareStatement(requeteSQL)) {
 
            pst.setInt(1, prestations.getDateHeurePrestation());
            pst.setInt(2, prestations.getTypePrestation().getId());  // Comment déclarer l'objet TypePrestation ? : setTypePrestation n'existe pas dans PreparedStatement ! c'est son id qu'il faut affecter ici
 
            if ( pst.executeUpdate()>0 ) {
 
                try (ResultSet generatedKeys = pst.getGeneratedKeys()) {
                    if (generatedKeys.next()) {
                        return generatedKeys.getInt(1);
                    }
                    else {
                        throw new SQLException("Erreur lors de la création de prestations failed, pas d'identifiant obtenu.");
                    }
                }
 
            }
            else {
                throw new SQLException("Erreur lors de la création de prestations failed, pas d'identifiant obtenu.");
            }
       }
 
    }
 
}

19/09/2017, 16h06
fa_dev

Ah super, merci beaucoup !

J'aimerais tester l'ajout dans ma bdd pour voir si tout marche bien.
J'ai du mal par contre à trouver la bonne 'formule'.
Je pensais que celle ci serais bonne, mais non :

Code:

DAO<Coiffeur> Coiffeur = new CoiffeurDAO().create(Coiffeur);

Pouvez vous m'orienter ? merci

Déjà cette forme pose problème : tu déclares une variable qui existe déjà (Coiffeur), ce qui n'est pas possible.

Comme ça, oui :

Code:

DAO<Coiffeur> daoCoiffeur = new CoiffeurDAO().create(Coiffeur);

Si tu choisis cette forme, c'est que create retourne du "DAO<Coiffeur>". C'est intéressant pour pouvoir enchaîner :
Code:

1 2 3 4 new CoiffeurDAO().create(coiffeur1) .create(coiffeur2) .create(machinChose) .create(biduleChoutte);
Cela peut avoir un côté pratique, mais d'un autre côté ça l'est moins, parce que par exemple, si tu as une collection, tu sera de toute manière obligé de faire :
Code:

1 2 3 4 5 DAO<Coiffeur> daoCoiffeur = new CoiffeurDAO(); for(Coiffeur coiffeur : coiffeurCollection) { daoCoiffeur.create(coiffeur); }
si tu veux éviter de créer autant d'instance de daoCoiffeur que de coiffeurs.

Mais on peut régler ça en ajoutant des méthodes qui prennent en paramètre une collection, un tableau (ou un varargs), un itérateur, un stream...

En revanche, cette forme est problématique pour les méthodes qui retournent déjà une donnée (d'un autre type), comme le cas de la méthode qu'on a vu avant, qui retourne l'id de la prestation créée (ou -1) si elle n'existe pas. Mais tu peux orienter la classe pour que les méthodes exposées (publiques) soient toutes de cette forme, et que les méthodes qui retournent quelque chose de spécial soient internes (protected, voire private), et appelées forcément à l'intérieure de méthodes exposées.

Par exemple (de principe, je n'ai pas regardé si ça correspondait à ton modèle) :
Code:

1 2 3 4 5 6 7 8 public CoiffeurDAO create(Coiffeur coiffeur, Prestation prestation) { int idPrestation = create(prestation); if ( idPrestation==-1 ) { throw new SQLException("Impossible de créer le coiffeur : prestation non créé"); } create(coiffeur, idPresation); return this; }
avec create(Prestation prestation) et create(Coiffeur coiffeur, int idPrestation) privées.

Autre solution : intégrer dans tes classes l'id, ce qui te permettra de les utiliser dans tous les contextes du CRUD.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 public class Coiffeur { private int id; private String nom; Coiffeur(String nom) { this(-1, nom); } Coiffeur(int id, String nom) { this.id=id; this.nom=nom; } /**...**/ }
La méthode create(Prestation) deviendra :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 public CoiffeurDAO create(Prestations prestations) throws SQLException { try(Connection cnx = getConnexion()) { /** .... **/ try (ResultSet generatedKeys = pst.getGeneratedKeys()) { if (generatedKeys.next()) { prestations.setId(generatedKeys.getInt(1)); } else { throw new SQLException("Erreur lors de la création de prestations, pas d'identifiant obtenu."); } } return this; }
Ce qui pourra te permettre d'écrire des trucs dans le genre:
Code:

1 2 3 new CoiffeurDAO().create(prestation) // créé un nouvel enregistrement avec les données de prestation, récupère un nouvel id de prestations .createWith(coiffeur, prestation); // créé un nouvel enregistrement de coiffeur, en utilisant l'id de prestation s'il y en a un, ou la créer s'il y en a pas
avec
Code:

1 2 3 4 5 6 7 8 9 10 11 public CoiffeurDAO create(Prestations prestation) { /**....**/ } public CoiffeurDAO create(Coiffeur coiffeur, Prestations prestations) { if( prestations.getId()==-1 ) { create(prestations); } coiffeur.setPrestation(prestations); create(coiffeur); return this; }
etc.

Après rien n'empêche d'avoir des méthodes des deux formes. (des méthodes qui retournent du Dao<Coiffeur> et d'autres qui retournent du Coiffeur, du Prestation, etc...
La forme que tu décris est utilisée en général pour les builders. Des classes qui créer des instances d'autres classes qui ont plein de paramètres optionnels, pour éviter d'avoir 50 méthodes avec toutes les combinaisons, et qui permet d'écrire des trucs du genre :
Code:

1 2 3 4 5 6 7 8 9 10 Style style1 = new StyleBuilder().setFontName("Arial") .setFontSize(25) .setUnderline(true) .setColor(Color.RED) .setWeight(Weight.BOLD) .create(); Style style2 = new StyleBuilder().setFontName("Arial") .setWeight(940) .setOutlined(true) .create();
Un DAO se présente plus comme une façade (un regroupement de services diverses (CRUD) sous une même classe) avec une partie fabrique éventuellement (avec des méthode du genre Coiffeur createCoiffeur(String nom)). J'éviterais cette forme personnellement (bien que j'en sois assez friand habituellement).