Utilité des classes DAO générées avec Hibernate Tools

**marooned** · 10/01/2013, 12h35

Bonjour,

Je voudrais connaitre l'utilité de générer des classe DAO avec hibernate tools. Étant novice dans le domaine, je demande votre aide pour mieux comprendre.

j'ai généré avec hibernate tools: UtilsateurHome= UtilisateurDAO comme suit:

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
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
package com.hibernate.dao;
 
// Generated 5 janv. 2013 19:54:10 by Hibernate Tools 3.4.0.CR1
 
import java.util.List;
import javax.naming.InitialContext;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.LockMode;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Example;
 
import com.hibernate.pojo.Utilisateur;
 
/**
 * Home object for domain model class Utilisateur.
 * @see com.hibernate.dao.Utilisateur
 * @author Hibernate Tools
 */
public class UtilisateurHome {
 
	private static final Log log = LogFactory.getLog(UtilisateurHome.class);
 
	private final SessionFactory sessionFactory = getSessionFactory();
 
	protected SessionFactory getSessionFactory() {
		try {
			return (SessionFactory) new InitialContext()
					.lookup("SessionFactory");
		} catch (Exception e) {
			log.error("Could not locate SessionFactory in JNDI", e);
			throw new IllegalStateException(
					"Could not locate SessionFactory in JNDI");
		}
	}
 
	public void persist(Utilisateur transientInstance) {
		log.debug("persisting Utilisateur instance");
		try {
			sessionFactory.getCurrentSession().persist(transientInstance);
			log.debug("persist successful");
		} catch (RuntimeException re) {
			log.error("persist failed", re);
			throw re;
		}
	}
 
	public void attachDirty(Utilisateur instance) {
		log.debug("attaching dirty Utilisateur instance");
		try {
			sessionFactory.getCurrentSession().saveOrUpdate(instance);
			log.debug("attach successful");
		} catch (RuntimeException re) {
			log.error("attach failed", re);
			throw re;
		}
	}
 
	public void attachClean(Utilisateur instance) {
		log.debug("attaching clean Utilisateur instance");
		try {
			sessionFactory.getCurrentSession().lock(instance, LockMode.NONE);
			log.debug("attach successful");
		} catch (RuntimeException re) {
			log.error("attach failed", re);
			throw re;
		}
	}
 
	public void delete(Utilisateur persistentInstance) {
		log.debug("deleting Utilisateur instance");
		try {
			sessionFactory.getCurrentSession().delete(persistentInstance);
			log.debug("delete successful");
		} catch (RuntimeException re) {
			log.error("delete failed", re);
			throw re;
		}
	}
 
	public Utilisateur merge(Utilisateur detachedInstance) {
		log.debug("merging Utilisateur instance");
		try {
			Utilisateur result = (Utilisateur) sessionFactory
					.getCurrentSession().merge(detachedInstance);
			log.debug("merge successful");
			return result;
		} catch (RuntimeException re) {
			log.error("merge failed", re);
			throw re;
		}
	}
 
	public Utilisateur findById(int id) {
		log.debug("getting Utilisateur instance with id: " + id);
		try {
			Utilisateur instance = (Utilisateur) sessionFactory
					.getCurrentSession().get("com.hibernate.dao.Utilisateur",
							id);
			if (instance == null) {
				log.debug("get successful, no instance found");
			} else {
				log.debug("get successful, instance found");
			}
			return instance;
		} catch (RuntimeException re) {
			log.error("get failed", re);
			throw re;
		}
	}
 
	public List findByExample(Utilisateur instance) {
		log.debug("finding Utilisateur instance by example");
		try {
			List results = sessionFactory.getCurrentSession()
					.createCriteria("com.hibernate.dao.Utilisateur")
					.add(Example.create(instance)).list();
			log.debug("find by example successful, result size: "
					+ results.size());
			return results;
		} catch (RuntimeException re) {
			log.error("find by example failed", re);
			throw re;
		}
	}
}

Puis il y la classe d'encapsulation Utilisateur :

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
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
package com.hibernate.pojo;
 
 
import java.util.HashSet;
import java.util.Set;
 
public class Utilisateur implements java.io.Serializable {
 
	private int idutilisateur;
	private String nom;
	private String prenom;
	private String email;
	private String pw;
	private String adresse;
	private boolean confirme;
	private boolean temporaire;
	private Set paniers = new HashSet(0);
 
	public Utilisateur() {
	}
 
	public Utilisateur(int idutilisateur, String nom, String prenom,
			String email, String pw, String adresse, boolean confirme,
			boolean temporaire) {
		this.idutilisateur = idutilisateur;
		this.nom = nom;
		this.prenom = prenom;
		this.email = email;
		this.pw = pw;
		this.adresse = adresse;
		this.confirme = confirme;
		this.temporaire = temporaire;
	}
 
	public Utilisateur(int idutilisateur, String nom, String prenom,
			String email, String pw, String adresse, boolean confirme,
			boolean temporaire, Set paniers) {
		this.idutilisateur = idutilisateur;
		this.nom = nom;
		this.prenom = prenom;
		this.email = email;
		this.pw = pw;
		this.adresse = adresse;
		this.confirme = confirme;
		this.temporaire = temporaire;
		this.paniers = paniers;
	}
 
	public int getIdutilisateur() {
		return this.idutilisateur;
	}
 
	public void setIdutilisateur(int idutilisateur) {
		this.idutilisateur = idutilisateur;
	}
 
	public String getNom() {
		return this.nom;
	}
 
	public void setNom(String nom) {
		this.nom = nom;
	}
 
	public String getPrenom() {
		return this.prenom;
	}
 
	public void setPrenom(String prenom) {
		this.prenom = prenom;
	}
 
	public String getEmail() {
		return this.email;
	}
 
	public void setEmail(String email) {
		this.email = email;
	}
 
	public String getPw() {
		return this.pw;
	}
 
	public void setPw(String pw) {
		this.pw = pw;
	}
 
	public String getAdresse() {
		return this.adresse;
	}
 
	public void setAdresse(String adresse) {
		this.adresse = adresse;
	}
 
	public boolean isConfirme() {
		return this.confirme;
	}
 
	public void setConfirme(boolean confirme) {
		this.confirme = confirme;
	}
 
	public boolean isTemporaire() {
		return this.temporaire;
	}
 
	public void setTemporaire(boolean temporaire) {
		this.temporaire = temporaire;
	}
 
	public Set getPaniers() {
		return this.paniers;
	}
 
	public void setPaniers(Set paniers) {
		this.paniers = paniers;
	}
 
}

Enfin, j'ai mi en place une classe de test:

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
/* Cette classe est dédié au test de l'API criteria */
//on doit avoir l'ensemble des users présents dans la BDD
package com.test;
 
import java.util.Iterator;
import java.util.List;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
 
import com.hibernate.pojo.*;
 
public class Test6JanvierCriteria {
 
	public static void main(String args[]) {
	    Configuration config = new Configuration();
	    SessionFactory sessionFactory = config.configure().buildSessionFactory();
 
	    Transaction transaction = null;
	    List personnes = null;
	    Session session = sessionFactory.openSession();
	    try {
	    	transaction = session.beginTransaction();
	    	personnes = session.createCriteria(Utilisateur.class).list();
	    	System.out.println("nbUsers = " + personnes.size());
	    	Iterator it = personnes.iterator();
	    	while (it.hasNext()) {
	    		Utilisateur personne = (Utilisateur) it.next();
	    		System.out.println("User : " + personne.getNom() +"  "+ personne.getPrenom());
	    		System.out.println("  Adresse : " + personne.getAdresse());
	    	}
	    	transaction.commit();
	    } catch (Exception e) {
	    	transaction.rollback();
	    	e.printStackTrace();
	    } finally {
	    	session.close();
	    }
	    sessionFactory.close();
 
	}
}

Donc, j'ai suivi quelques tuto sur le net comme http://docs.jboss.org/tools/OLD/3.3....refeng_codegen, malheureusement, je ne voit pas l'utilisation des classes DAO dans leurs codes, et l'utilité de leurs présences sur le projet.

Merci d'avance de votre aide

**ifsera** · 10/01/2013, 13h29

Salut,

Les DAO permettent de s'abstraire de la façon dont les données sont stockées au niveau des objets métier.

Tu aurais par exmple une interface IDaoUtilisateur et en dessous 2 classes concrètes qui l'implémentent, l'une pourrait taper dans une base de données, l'autre dans un fichier plat, ou bien encore toutes les 2 taper dans la même bd, mais l'une via jdbc, et l'autre via jpa.

http://fr.wikipedia.org/wiki/Objet_d'acc%C3%A8s_aux_donn%C3%A9es

Cela permet de séparer ce qui est du domaine de la présentation, de ce qui est du domaine bd. En général, on n'expose pas ce qui se trouve côté bd coté présentation.

Cela ajoute de la souplesse, de la modularité, et de la sécurité en somme.

Je te conseille cela http://cyrille-herby.developpez.com/...c-pattern-dao/

et aussi l'approche des pattern http://fr.wikipedia.org/wiki/Patron_...ception_du_GoF

Pour aller plus loin, en général, tu as un service au dessus qui va aller chercher ton dao. Et ta classe Utilisateur n'est au final qu'un POJO.

**marooned** · 10/01/2013, 13h52

Je pense que j'ai du mal m'exprimer, je connais l'utilité des classes DAO's, ma question concerne Hibernate. J'ai généré avec hibernate tools mes DAO's, mais le problème ce que je les utilise nulle part.

Donc, au vu de l'exemple que j'ai fourni, vous savez si je peux appeler ma classe UtilisateurHome dans ma classe Test??

Aussi, j'ai essayé de tester les DAO's dans la classe test, mais je n'arrive pas à affecter la "session factory" à la classe UtilisateurHome, je sais que c'est le pattern SingleTon qui veut ça, mais je ne vois comment appeler utilisateurHome dans ma classe de test. Sinon, peut etre qu'hibernate l'utilise en dessous, sans m'apercevoir.

J’espère que j'ai été clair.

**ifsera** · 10/01/2013, 15h09

Je m'en doutais un peu

, que j'avais pris ton truc dans le mauvais sens

Perso, et sans trop avoir le temps à cette heure

je supposerai que le problème vient du lookup, que ta ressource jndi n'est pas sur le serveur.

Mais bon faudrait voire ton code, et le log

**olivier.pitton** · 11/01/2013, 04h33

Il faut que tu ajoutes une ressource directement en passant par ton serveur. Cela permet de configurer des connexions sur le serveur, que les applications partagent entre elles.

Via la console d'administration, tu dois pouvoir créer une SessionFactory, surtout que JBoss utilise Hibernate.

Sinon le plus simple est de mettre ta configuration directement dans ton application, et de la charger au démarrage, au lieu de passer par JNDI. La connexion à la base devient alors propre à l'application, et non partagée sur le serveur.

**marooned** · 11/01/2013, 21h11

Envoyé par olivier.pitton

Il faut que tu ajoutes une ressource directement en passant par ton serveur. Cela permet de configurer des connexions sur le serveur, que les applications partagent entre elles.

Via la console d'administration, tu dois pouvoir créer une SessionFactory, surtout que JBoss utilise Hibernate.

Sinon le plus simple est de mettre ta configuration directement dans ton application, et de la charger au démarrage, au lieu de passer par JNDI. La connexion à la base devient alors propre à l'application, et non partagée sur le serveur.

C'est très intéressant ce que vous m'expliquer, mais ça se trouve ou la console d'administration?? dans ce cas la, il y a une sessionFactory qui est ouverte au déploiement de mon appli sur TomCat, et elle se ferme à la fermeture de TomCat?

**marooned** · 11/01/2013, 22h05

Envoyé par ifsera

Je m'en doutais un peu

, que j'avais pris ton truc dans le mauvais sens

Perso, et sans trop avoir le temps à cette heure

je supposerai que le problème vient du lookup, que ta ressource jndi n'est pas sur le serveur.

Mais bon faudrait voire ton code, et le log

mettre la ressource jndi sur le serveur, c'est mettre les jar de jndi dans web-inf/lib? Concernant le lookup, je dois changer (mettre le chemin "que je ne connais pas" de la SessionFactory) ?

**olivier.pitton** · 13/01/2013, 08h59

Plop,

JNDI est un "arbre de nommage". Il permet de déposer des ressources dans l'arbre (SessionFactory, EJB, ... ) et de les récupérer depuis une URL (en effectuant le lookup).

Depuis Tomcat, dans la console d'administration tu dois pouvoir créer des DataSources, qui sont des pool de connexion à la base de données (documentation ici). Enfin, tu devras "injecter" le datasource dans Hibernate pour que celui-ci l'utilise.

Si je me souviens bien, dans ta configuration Hibernate, tu ajoutes :

Code :

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

1
2
 
<property name="connection.datasource">SampleDS</property>

où SampleDS est l'URL JNDI du datasource à aller chercher.

Le résultat est qu'Hibernate utilisera donc le datasource du serveur Tomcat pour faire ce qu'il a à faire. La pure connexion à la base de données sera réalisée par le serveur, et non par ton application.

Attention cela implique que chaque serveur où tu déploies ton application devra avoir un datasource de disponible avec le nom spécifié dans la configuration Hibernate.

**Chris Mad** · 11/01/2013, 09h10

Effectivement, ton code de test utilise directement les mécanismes d'Hibernate. Et donc les DAO générés ne sont pas utilisés par ton code.
L'utilité de ces DAO est plutôt de donner une base de code (au sens exemple de code) pour pouvoir débuter des devs sur une appli sur serveur d'application.
Ce n'est qu'un point de vue personnel, mais le code de ces DAO est entièrement répétitif. Il serait préférable de s'en inspirer pour construire un DAO générique que chaque Dao étend pour y rajouter ses fonctionalités propres, c'est toujours moins lourd à maintenir, surtout si l'appli comporte de nombreuses entités.

**marooned** · 11/01/2013, 21h04

Envoyé par Chris Mad

Effectivement, ton code de test utilise directement les mécanismes d'Hibernate. Et donc les DAO générés ne sont pas utilisés par ton code.
L'utilité de ces DAO est plutôt de donner une base de code (au sens exemple de code) pour pouvoir débuter des devs sur une appli sur serveur d'application.
Ce n'est qu'un point de vue personnel, mais le code de ces DAO est entièrement répétitif. Il serait préférable de s'en inspirer pour construire un DAO générique que chaque Dao étend pour y rajouter ses fonctionalités propres, c'est toujours moins lourd à maintenir, surtout si l'appli comporte de nombreuses entités.

Merci pour la réponse, je comprends un peu mieux, donc, si je comprends bien, tu me conseilles de modifier ma DAO UtilisateurHome, pour pouvoir l'utiliser dans ma classe métier.

**Chris Mad** · 13/01/2013, 20h17

Bonsoir

Envoyé par marooned

tu me conseilles de modifier ma DAO UtilisateurHome, pour pouvoir l'utiliser dans ma classe métier.

C'est exactement ça. Tu crée un classe DaoUtilisateur en t'inspirant du code qu'à généré HibernateTools. Dans ta classe métier (supposons qu'elle s'appelle UtilisateurService), tu fera référence à une instance de cette classe pour lui déléguer le traitement des aspects de persistance.

Si tu n'est pas familier avec les notions de factory ou d'injection de dépendance (voir les commentaires), je te conseille d'utiliser un code de ce genre:

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
public class  UtilisateurService {
     // le dao à qui on va déléguer les traitements liés à la persistance
     private DaoUtilisateur daoUtilisateur;
 
     public UtilisateurService(){
          // le constructeur instancie le DAO.
          daoUtilisateur = new DaoUtilisateur();da
         // avec une factory, on aurait daoUtilsateur = DaoFactory.getDAOUtilisateur();
         // dans un conteneur comme Spring, on aurait eu... rien ici et une annotation
         // type @Inject pour le champ daoUtilisateur et 
         // une annotation type @Named pour la clase DaoUtilisateur
     }
 
     public void unTraitementMetier(){
           //... du code métier
           //... on a besoin d'une fonctionnalité de persistence
           daoUtilisateur.unMethodeDePersistance(....);
           //
     }
}

Cette manière de faire n'est pas la plus "propre" d'un point de vue architectural (ce n'est pas de la responsabilité d'une classe d'instancier ses collaborateurs), mais ça devrait te permettre d'avancer.
Si tu veux faire plus "propre", tu as plusieurs possibilités (utilisation de factories, utilisation d'un conteneur type spring, etc..). Mais si ton objectif est de découvrir l'utilisation d'Hibernate, ce que je te propose est simple à mettre en oeuvre et tu ne seras pas "pollué" par d'autres notions si tu ne les maîtrise pas totalement.

Bon courage!!

P.S. tu as bien fait de me contacter en MP, sinon j'aurais zappé ...

Utilité des classes DAO générées avec Hibernate Tools

Hibernate Java

Vue hybride

Discussions similaires

Partager

Partager