Aller au menu - Aller au contenu

Icône Le pattern DAO (1/2)

Par Avatar cysboy
Mise à jour : 17/06/2009
Difficulté : Difficile Difficile Creative Commons BY-NC-SA
3 526 visites depuis 7 jours, dont 288 sur ce chapitre classé 45/786
Bon, vous voulez pouvoir utiliser vos données dans des objets, et c'est normal ! ^^
Avec le pattern DAO, vous allez voir comment faire ceci mais en plus, comment rendre ça stable !

En fait, je suppose que vous avez dû essayer de faire en sorte que les données de votre base collent à vos objets, avec des méthodes :
  • de récupération ;
  • de création ;
  • de mise à jour ;
  • de suppression.


Nous allons voir tout ceci dans ce chapitre et le suivant ! :)
Retour en haut
Sommaire du chapitre :
Icône du chapitre
Chapitre précédent Sommaire Chapitre suivant
Retour en haut

Avant toute chose

Comme je le disais, vous avez dû essayer de faire en sorte que les données de la base puissent être utilisées via des objets Java.
En tout premier lieu, il faut créer une classe par entité (les tables hors tables de jointures...), ce qui nous donnerait les classes suivantes :
  • Eleve ;
  • Matiere ;
  • Professeur ;
  • Classe.


Et, si nous suivons la logique des relations entre nos tables, nous avons des classes liées suivant le diagramme de classes suivant :

Image utilisateur


Nous voyons les liens entre les objets avec ce diagramme : une classe est composée de plusieurs élèves et de plusieurs professeurs, et un professeur peut exercer plusieurs matières !
Les tables de jointures de la base sont symbolisées par la composition dans nos objets.

Une fois ceci fait, nous devons coder ces objets avec les accesseurs et les mutateurs adéquats :
  • getters et setters pour tous les attributs de toutes les classes ;
  • méthode d'ajout et de suppression pour les objets ayant des listes d'objets.


On appelle ce genre d'objet des POJO, pour Plain Old Java Object !
Ce qui nous donne ces codes sources :

Secret (cliquez pour afficher)


Classe Eleve.java


Code : Java
 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
package com.sdz.bean;


public class Eleve {

        /**
         * ID
         */
        private int id = 0;
        /**
         * Nom de l'élève
         */
        private String nom = "";
        /**
         * Prénom de l'élève
         */
        private String prenom = "";
        
        
        //****************************************************
        // CONSTRUCTEUR DE L'OBJET
        //****************************************************

        /**
         * @param id
         * @param nom
         * @param prenom
         */
        public Eleve(int id, String nom, String prenom) {
                this.id = id;
                this.nom = nom;
                this.prenom = prenom;
        }
        public Eleve(){};
        
        //****************************************************
        // ACCESSEURS ET MUTATEURS
        //****************************************************
                
        /**
         * @return the id
         */
        public int getId() {
                return id;
        }


        /**
         * @param id the id to set
         */
        public void setId(int id) {
                this.id = id;
        }

        /**
         * @return the nom
         */
        public String getNom() {
                return nom;
        }

        /**
         * @param nom the nom to set
         */
        public void setNom(String nom) {
                this.nom = nom;
        }

        /**
         * @return the prenom
         */
        public String getPrenom() {
                return prenom;
        }

        /**
         * @param prenom the prenom to set
         */
        public void setPrenom(String prenom) {
                this.prenom = prenom;
        }        
}


Classe Matiere.java


Code : Java
 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
package com.sdz.bean;

public class Matiere {

        /**
         * ID
         */
        private int id = 0;
        /**
         * Nom du professeur
         */
        private String nom = "";
        
        

        //****************************************************
        // CONSTRUCTEUR DE L'OBJET
        //****************************************************
        /**
         * @param id
         * @param nom
         */
        public Matiere(int id, String nom) {
                this.id = id;
                this.nom = nom;
        }

        public Matiere(){}

        
        //****************************************************
        // ACCESSEURS ET MUTATEURS
        //****************************************************
                
        /**
         * @return the id
         */
        public int getId() {
                return id;
        }
        /**
         * @param id the id to set
         */
        public void setId(int id) {
                this.id = id;
        }
        /**
         * @return the nom
         */
        public String getNom() {
                return nom;
        }
        /**
         * @param nom the nom to set
         */
        public void setNom(String nom) {
                this.nom = nom;
        }
        
}


Classe Professeur.java


Code : Java
  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
package com.sdz.bean;

import java.util.HashSet;
import java.util.Set;

public class Professeur {

        /**
         * ID
         */
        private int id = 0;
        /**
         * Nom du professeur
         */
        private String nom = "";
        /**
         * Prénom du professeur
         */
        private String prenom = "";
        /**
         * Liste des matières dispensées
         */
        private Set<Matiere> listMatiere = new HashSet<Matiere>();
        
        
        //****************************************************
        // CONSTRUCTEUR DE L'OBJET
        //****************************************************

        /**
         * @param id
         * @param nom
         * @param prenom
         */
        public Professeur(int id, String nom, String prenom) {
                this.id = id;
                this.nom = nom;
                this.prenom = prenom;
        }
        
        public Professeur(){}
        
        //****************************************************
        // ACCESSEURS ET MUTATEURS
        //****************************************************
                
        /**
         * @return the id
         */
        public int getId() {
                return id;
        }
        /**
         * @param id the id to set
         */
        public void setId(int id) {
                this.id = id;
        }
        /**
         * @return the nom
         */
        public String getNom() {
                return nom;
        }
        /**
         * @param nom the nom to set
         */
        public void setNom(String nom) {
                this.nom = nom;
        }
        /**
         * @return the prenom
         */
        public String getPrenom() {
                return prenom;
        }
        /**
         * @param prenom the prenom to set
         */
        public void setPrenom(String prenom) {
                this.prenom = prenom;
        }

        /**
         * @return the listMatiere
         */
        public Set<Matiere> getListMatiere() {
                return listMatiere;
        }

        /**
         * @param listMatiere the listMatiere to set
         */
        public void setListMatiere(Set<Matiere> listMatiere) {
                this.listMatiere = listMatiere;
        }

        /**
         * Ajoute une matière à la liste des cours dispensés
         * @param Matiere
         */
        public void addMatiere(Matiere matiere){
                this.listMatiere.add(matiere);
        }
        
        /**
         * Retire une matière de la liste des cours dispensés
         * @param Matiere
         */
        public void removeMatiere(Matiere matiere){
                this.listMatiere.remove(matiere);
        }
        
}


Classe Classe.java


Code : Java
  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
package com.sdz.bean;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class Classe {


	/**
	 * ID
	 */
	private int id = 0;
	/**
	 * Nom du professeur
	 */
	private String nom = "";
	/**
	 * Liste des professeurs
	 */
	private Set<Professeur> listProfesseur = new HashSet<Professeur>();
	
	/**
	 * Liste des élèves
	 */
	private Set<Eleve> listEleve = new HashSet<Eleve>();
	

	//****************************************************
	// CONSTRUCTEUR DE L'OBJET
	//****************************************************
	/**
	 * @param id
	 * @param nom
	 */
	public Classe(int id, String nom) {
		this.id = id;
		this.nom = nom;
	}
	public Classe(){}
	

	
	//****************************************************
	// ACCESSEURS ET MUTATEURS
	//****************************************************
		
	/**
	 * @return the id
	 */
	public int getId() {
		return id;
	}
	/**
	 * @param id the id to set
	 */
	public void setId(int id) {
		this.id = id;
	}
	/**
	 * @return the nom
	 */
	public String getNom() {
		return nom;
	}
	/**
	 * @param nom the nom to set
	 */
	public void setNom(String nom) {
		this.nom = nom;
	}
	
	/**
	 * @return the listMatiere
	 */
	public Set<Professeur> getListProfesseur() {
		return listProfesseur;
	}

	/**
	 * @param listMatiere the listMatiere to set
	 */
	public void setListProfesseur(Set<Professeur> listProfesseur) {
		this.listProfesseur = listProfesseur;
	}
	

	/**
	 * @return the listMatiere
	 */
	public void addProfesseur(Professeur prof) {
		if(!listProfesseur.contains(prof))
			listProfesseur.add(prof);
	}

	/**
	 * @param listMatiere the listMatiere to set
	 */
	public void removeProfesseur(Professeur prof ) {
		this.listProfesseur.remove(prof);
	}
	

	/**
	 * @return the listMatiere
	 */
	public Set<Eleve> getListEleve() {
		return listEleve;
	}

	/**
	 * @param listMatiere the listMatiere to set
	 */
	public void setListEleve(Set<Eleve> listEleve) {
		this.listEleve = listEleve;
	}
	
	/**
	 * Ajoute un élève à la classe
	 * @param eleve
	 */
	public void addEleve(Eleve eleve){
		if(!this.listEleve.contains(eleve))
			this.listEleve.add(eleve);
	}
	
	/**
	 * Retire un élève de la classe
	 * @param eleve
	 */
	public void removeEleve(Eleve eleve){
		this.listEleve.remove(eleve);
	}
	
	/**
	 * Méthode equals
	 * @param cls
	 * @return
	 */
	public boolean equals(Classe cls){
		return this.getId() == cls.getId();
	}
	
}



Voilà, vous avez vos objets tout beaux tout propres !
Nous avons des objets prêts à l'emploi. Maintenant, comment faire en sorte que ces objets puissent recevoir les données de notre base ?
Au lieu de faire des essais à tâtons, nous allons définir le pattern DAO et voir comment il fonctionne avant de l'implémenter.
Retour en haut

Le pattern DAO : définition

Contexte



Vous avez des données sérialisées dans une base de données et vous souhaitez y accéder et les manipuler avec des objets Java. Cependant, votre entreprise est en pleine restructuration et vous ne savez pas si vos données vont :
  • rester où elles sont ;
  • migrer sur une autre base de données ;
  • être stockées dans des fichiers XML ;
  • ...

Comment faire en sorte de ne pas avoir à modifier toutes les utilisations de nos objets ?
Comment faire un système adaptatif aux futures modifications de supports de données ?
Comment faire en sorte que les objets que nous allons utiliser restent tels qu'ils sont ?

Il pourrait y avoir beaucoup de problématiques de ce genre, mais le pattern DAO est là pour vous ! :magicien:

La définition d'un design pattern est toujours un peu pompeuse et mystifiée ; par contre, et ceux qui ont lu les chapitres concernant les design patterns du tuto Java le confirmeront, ils apportent plus de souplesse et de robustesse à vos programmes !

Le pattern DAO


Ce pattern permet de faire le lien entre la couche d'accès aux données et la couche métier d'une application. Il permet de mieux maîtriser les changements susceptibles d'être opérés sur le système de stockage des données, donc, par extension, de préparer une migration d'un système à un autre (BDD vers fichiers XML par exemple...).
Ceci se fait en séparant accès aux données (BDD) et objets métiers (POJO).

Je me doute que tout ceci doit vous sembler très flou !
Euh... un peu... :euh:

C'est normal, mais ne vous en faites pas, je vais tout vous expliquer...
Déjà, il y a une histoire de séparation des "couches métiers et couches d'accès aux données". Il s'agit ni plus ni moins de faire en sorte qu'un type d'objet se charge de récupérer les données dans la base et qu'un autre type d'objet (souvent des POJO) soit utilisé pour manipuler ces données. Schématiquement, ça nous donne :

Image utilisateur


Si on comprend bien, nous allons avoir deux types d'objets !

Tout à fait.
Les objets que nous avons créés plus haut sont nos POJO, les objets utilisés par le programme pour manipuler les données de la base.
Il ne nous reste plus qu'à créer les objets qui vont rechercher les données dans la base !

Oui, mais nous n'allons pas faire n'importe comment...
Les dits objets devront être capables de faire des recherches, des insertions, des mises à jour et des suppressions ! Par conséquent, nous pouvons définir un super type d'objet afin d'utiliser au mieux le polymorphisme...
Nous allons devoir créer une classe abstraite (ou une interface) mettant en oeuvre toutes les méthodes sus-mentionnées !

Comment va-t-on faire pour demander à nos objets DAO de récupérer tel type d'objet ou d'en sérialiser tel autre ? Avec des cast ?

Soit en castant, soit en faisant une classe générique ! Comme ceci :

Image utilisateur


Ah... mais oui !


Vous aviez oublié que nous pouvions créer des classes génériques ? :colere2:
Bon, je vous pardonne. Maintenant, voyons un peu les codes sources de ces objets :

Secret (cliquez pour afficher)


Classe DAO.java


Code : Java
 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
package com.sdz.dao;

import java.sql.Connection;

import com.sdz.connection.SdzConnection;

public abstract class DAO<T> {
        
        protected Connection connect = null;
        
        /**
         * Constructeur
         * @param conn
         */
        public DAO(Connection conn){
                this.connect = conn;
        }
        
        /**
         * Méthode de création
         * @param obj
         * @return
         */
        public abstract boolean create(T obj);
        /**
         * Méthode pour effacer
         * @param obj
         * @return
         */
        public abstract boolean delete(T obj);
        /**
         * Méthode de mise à jour
         * @param obj
         * @return
         */
        public abstract boolean update(T obj);
        /**
         * Méthode de recherche des informations
         * @param id
         * @return
         */
        public abstract T find(int id);
}


Classe EleveDAO.java


Code : Java
 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
package com.sdz.dao.implement;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;

import com.sdz.bean.Eleve;
import com.sdz.dao.DAO;

public class EleveDAO extends DAO<Eleve> {

        public EleveDAO(Connection conn) {
                super(conn);
        }

        public boolean create(Eleve obj) {
                return false;
        }

        public boolean delete(Eleve obj) {
                return false;
        }

        public Eleve find(int id) {
                
                Eleve eleve = new Eleve();                
                
                try {
                        ResultSet result = this.connect        .createStatement(
                                                                                                        ResultSet.TYPE_SCROLL_INSENSITIVE, 
                                                                                                        ResultSet.CONCUR_READ_ONLY
                                                                                        ).executeQuery(
                                                                                                        "SELECT * FROM eleve WHERE elv_id = " + id
                                                                                        );
                        if(result.first())
                                eleve = new Eleve(id, result.getString("elv_nom"), result.getString("elv_prenom"));
                        
                } catch (SQLException e) {
                        e.printStackTrace();
                }
                return eleve;
        }

        public boolean update(Eleve obj) {
                return false;
        }

}


Classe MatiereDAO.java


Code : Java
 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
package com.sdz.dao.implement;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;

import com.sdz.bean.Eleve;
import com.sdz.bean.Matiere;
import com.sdz.dao.DAO;

public class MatiereDAO extends DAO<Matiere> {

        public MatiereDAO(Connection conn) {
                super(conn);
        }


        public boolean create(Matiere obj) {

                return false;
        }


        public boolean delete(Matiere obj) {

                return false;
        }


        public Matiere find(int id) {

                Matiere matiere = new Matiere();                
                
                try {
                        ResultSet result = this.connect        .createStatement(
                                                                                                        ResultSet.TYPE_SCROLL_INSENSITIVE, 
                                                                                                        ResultSet.CONCUR_READ_ONLY
                                                                                        ).executeQuery(
                                                                                                        "SELECT * FROM matiere WHERE mat_id = " + id
                                                                                        );
                        if(result.first())
                                matiere = new Matiere(id, result.getString("mat_nom"));
                        
                } catch (SQLException e) {
                        e.printStackTrace();
                }
                return matiere;
        }


        public boolean update(Matiere obj) {

                return false;
        }

}


Classe ProfesseurDAO.java


Code : Java
 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
package com.sdz.dao.implement;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;

import com.sdz.bean.Eleve;
import com.sdz.bean.Professeur;
import com.sdz.dao.DAO;

public class ProfesseurDAO extends DAO<Professeur> {

        public ProfesseurDAO(Connection conn) {
                super(conn);
        }

        public boolean create(Professeur obj) {

                return false;
        }


        public boolean delete(Professeur obj) {

                return false;
        }


        public Professeur find(int id) {

                Professeur professeur = new Professeur();                
                
                try {
                        ResultSet result = this.connect        .createStatement(
                                                                                                        ResultSet.TYPE_SCROLL_INSENSITIVE, 
                                                                                                        ResultSet.CONCUR_READ_ONLY
                                                                                        ).executeQuery(
                                                                                                        "select * from professeur "+
                                                                                                        "left join j_mat_prof on jmp_prof_k = prof_id AND prof_id = "+ id +
                                                                                                        " inner join matiere on jmp_mat_k = mat_id"
                                                                                        );
                        if(result.first()){
                                professeur = new Professeur(id, result.getString("prof_nom"), result.getString("prof_prenom"));
                                result.beforeFirst();
                                MatiereDAO matDao = new MatiereDAO(this.connect);
                                
                                while(result.next())
                                        professeur.addMatiere(matDao.find(result.getInt("mat_id")));
                        }
                } catch (SQLException e) {
                        e.printStackTrace();
                }
                return professeur;
        }


        public boolean update(Professeur obj) {
        
                return false;
        }
}


Classe ClasseDAO.java


Code : Java
 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
package com.sdz.dao.implement;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;

import com.sdz.bean.Classe;
import com.sdz.bean.Eleve;
import com.sdz.dao.DAO;

public class ClasseDAO extends DAO<Classe> {

        public ClasseDAO(Connection conn) {
                super(conn);
        }

        public boolean create(Classe obj) {

                return false;
        }


        public boolean delete(Classe obj) {

                return false;
        }


        public Classe find(int id) {

                Classe classe = new Classe();                
                
                try {
                        ResultSet result = this.connect        .createStatement(
                                                                                                        ResultSet.TYPE_SCROLL_INSENSITIVE, 
                                                                                                        ResultSet.CONCUR_READ_ONLY
                                                                                        ).executeQuery(
                                                                                                        "select * from classe WHERE cls_id = " + id
                                                                                        ); 
                                                                                                        
                        if(result.first()){
                                classe = new Classe(id, result.getString("cls_nom"));
                                
                                result = this.connect        .createStatement()
                                                                                .executeQuery(
                                                                                        "select prof_id, prof_nom, prof_prenom from professeur " +
                                                                                        "INNER JOIN j_mat_prof on prof_id = jmp_prof_k " +
                                                                                        "INNER JOIN j_cls_jmp on jmp_id = jcm_jmp_k AND jcm_cls_k = " + id
                                                                                );
                                
                                ProfesseurDAO profDao = new ProfesseurDAO(this.connect);
                                                                
                                while(result.next())                                        
                                        classe.addProfesseur(profDao.find(result.getInt("prof_id")));
                                
                                EleveDAO eleveDao = new EleveDAO(this.connect);
                                
                                
                                result = this.connect        .createStatement()
                                                                                .executeQuery(
                                                                                        "select elv_id, elv_nom, elv_prenom from eleve " +
                                                                                        "INNER JOIN classe on elv_cls_k = cls_id AND cls_id = " + id
                                                                                );

                                while(result.next())
                                        classe.addEleve(eleveDao.find(result.getInt("elv_id")));
                        }
                        
                } catch (SQLException e) {
                        e.printStackTrace();
                }
                return classe;
        }


        public boolean update(Classe obj) {

                return false;
        }

}




Pour ne pas compliquer la tâche, je n'ai détaillé que la méthode de recherche des données, les autres sont des coquilles vides...
Mais vous devriez être capables de faire ça tout seuls, normalement...


Retour en haut

Premier test

Bon : nous avons réalisé une bonne partie de ce pattern, nous allons pouvoir faire notre premier test. :)
Une bonne partie ? Tu veux dire qu'il y a encore des choses à faire ?

Oui, nous verrons ça dans le prochain chapitre : pour le moment, testons ce que nous avons.

Par contre, je tiens à préciser que j'utilise toujours le singleton créé quelques chapitres plus haut !


Voici un code de test :

Code : Java
 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
import com.sdz.bean.Classe;
import com.sdz.bean.Eleve;
import com.sdz.bean.Matiere;
import com.sdz.bean.Professeur;
import com.sdz.connection.SdzConnection;
import com.sdz.dao.DAO;
import com.sdz.dao.implement.ClasseDAO;
import com.sdz.dao.implement.EleveDAO;
import com.sdz.dao.implement.ProfesseurDAO;


public class FirstTest {
        
        public static void main(String[] args) {
                
                //testons des élèves
                DAO<Eleve> eleveDao = new EleveDAO(SdzConnection.getInstance());
                for(int i = 1; i < 5; i++){
                        Eleve eleve = eleveDao.find(i);
                        System.out.println("Elève N°" + eleve.getId() + "  - " + eleve.getNom() + " " + eleve.getPrenom());
                }
                
                System.out.println("\n******************************************\n");
                
                //Voyons voir les professeurs
                DAO<Professeur> profDao = new ProfesseurDAO(SdzConnection.getInstance());
                for(int i = 4; i < 8; i++){
                        Professeur prof = profDao.find(i);
                        System.out.println(prof.getNom() + " " + prof.getPrenom() + " enseigne : ");
                        for(Matiere mat : prof.getListMatiere())
                                System.out.println("\t * " + mat.getNom());
                }
                
                System.out.println("\n******************************************\n");
                
                //Et là, c'est la classe
                DAO<Classe> classeDao = new ClasseDAO(SdzConnection.getInstance());
                Classe classe = classeDao.find(11);
                
                System.out.println("Classe de " + classe.getNom());
                System.out.println("\nListe des élèves :");
                for(Eleve eleve : classe.getListEleve())
                        System.out.println("  - " + eleve.getNom() + " " + eleve.getPrenom());
                
                System.out.println("\nListe des professeurs :");
                for(Professeur prof : classe.getListProfesseur())
                        System.out.println("  - " + prof.getNom() + " " + prof.getPrenom());
                
        }

}


Qui me donne :

Image utilisateur


Vous avez compris comment tout ça fonctionnait ? Ce n'est pas très dur en fin de compte. Je vous laisse quelques instants pour lire, tester, relire, tester à nouveau...
Nous utilisons des objets spécifiques afin de rechercher dans la base des données qui nous servent à instancier des objets Java habituels. :)

Avant de poursuivre, nous allons faire un tour du côté du QCM...

Retour en haut

Q.C.M.

Qu'est-ce qu'un POJO ?
Qu'est-ce que la couche d'accès aux données ?
Qu'est-ce que la couche métier ?
À quoi sert le pattern DAO ?

Statistiques de réponses au QCM

Retour en haut
Bon, vous voyez un peu comment on va procéder.
Le truc, c'est que vous savez comment récupérer les données de votre base pour les utiliser dans des POJO, mais nous n'avons pas vu comment permettre l'utilisation de plusieurs systèmes de base de données, voire même de l'XML.

Ne prenez pas peur, le résultat sera à la hauteur de vos attentes... Même si ne connaissez rien à Java ni à XML (pour l'instant...). ;)
Chapitre précédent Sommaire Chapitre suivant
Retour en haut

Partager

Retour en haut
7 commentaires pour "Le pattern DAO (1/2)"
Note moyenne : 3.34 / 4 (178 votes)
Pseudo Commentaire
Hors ligne cysboy # Posté le 15/05/2009 à 20:35:06
tout est bô dans l' info
Avatar
Groupe : Auteurs

Ville : Tremeur
Pays : France métropolitaine
Études : CNAM

 oui, ça veut dire quelque chose... ^^

En effet, mon mapping est loin d'être parfait. :-°

Je partais du principe qu'il fallait présenter le pattern DAO, sans aller dans le fin fond du détail et c'est sûrement un tord, mais ceux, comme toi, qui on bien compris la façon de fonctionner de ce pattern, n'auront pas trop de difficulté à l'utiliser.
Image utilisateurImage utilisateur Image utilisateur Image utilisateur Image utilisateur Image utilisateur Image utilisateur Image utilisateur Image utilisateur Image utilisateur Image utilisateur
 
Hors ligne Jambo2 # Posté le 15/05/2009 à 20:51:13

Désolé j'avais édité mon post parce que je m'étais rendu compte que dans la classe "Classe" y'avait listEleve alors que j'avais cru lire listMatiere, je voulais donc réviser ma copie avant de poster des sottises.
Sinon merci pour la clarification, en effet maintenant je peux le faire par moi même.
Merci Maitre cysboy :)
Hors ligne cysboy # Posté le 15/05/2009 à 20:59:14
tout est bô dans l' info
Avatar
Groupe : Auteurs

Ville : Tremeur
Pays : France métropolitaine
Études : CNAM

 Pas de quoi, mais pas de "Maitre" entre nous...
Un simple cysboy suffit largement.

Rappelles-toi que mes tutos sont loin d'être parfait. ;)
Image utilisateurImage utilisateur Image utilisateur Image utilisateur Image utilisateur Image utilisateur Image utilisateur Image utilisateur Image utilisateur Image utilisateur Image utilisateur
 
Hors ligne jMetal # Posté le 25/04/2010 à 07:54:39

merci bcp. c'est excellent, ce tutor ^^
pourtant, j'ai la même question que Jambo2. c'est que:
- <<Pourquoi le champ cls_k a-t-il été omis dans la classe élève, d'autant plus que lors de l'usage de DAOEleve.create(Eleve elv), la base va s'attendre à une valeur pour ce champ qu'elle ne trouvera pas? >>

Donc, dans la classe "Eleve", doit-on ajouter un attribut , par example class_id, pour contenir le cls_k ? ou il y a une autre meilleure solution?

Je vous serai reconnaissant bcp si vous pourriez definir en détails les methods 'create' dans les DAO classes et donner des examples d'illustration.

- Comment peut-on faire si l'on veut dispenser un professeur de (+) chaque matière pour une classe?
Quel DAO va être utilisé? Doit-on ajouter une méthode, par example ajouter(int prof_id, int mat_id) dans le ClasseDAO ou créer un autre DAO pour faire ca?

- Quelle solution allez-vous choisir pour obtenir les matières d'une classe?
car le statement classeDao.find(cls_id) va retourner une classe avec une liste des profs dont un a une liste des matières. Mais ce n'est pas sur que toutes ces matières sont dispensés ENTIÈREMENT pour cette classe.
L'appel de la méthode professeurDao.find(prof_id) dans le corps du classeDao.find(cls_id) peut expliquer ce que je dis.

merci encore pour votre lecture.
Hors ligne Foufar # Posté le 26/10/2010 à 19:15:51

Salut,
premièrement ce cours est magnifique!!! :magicien:
j ai 2 questions :
1) Dans l'exemple de ce cours (le-pattern-dao 1 et 2), est ce que la classe qui contient la méthode Main représente la couche métier?

2) est ce qu il existe un autre cours ou livre approfondie dans ce domaine (accés aux base de données en java), je suis un zero qui veut apprendre :p ?

merci une autre fois; :soleil:

Voir tous les commentaires