Daos

Version imprimable

26/01/2011, 14h32
libuma

Utilisation des Controllers/managers/Daos

Bonjour,

C'est la première fois que j'utilise Spring, j'expérimente donc un peu la chose.

Je veux créer un formulaire avec différents menus déroulants.
Prenons par exemple une liste de clients et une liste de produits proposés.

Pour l'instant, dans mon controller, j'ai une instance de clientManager et de ProductManager avec leurs getters & setters.
Dans chacune de ces classes managers, j'ai une instance de clientDAO et productDAO et leurs getters & setters.
Dans ces daos, j'ai une méthode getList qui va me récupérer la liste désirée.
(Précision, j'utilise Hibernate et Criterion)

J'ai bien sûr un fichier de config qui reférence les beans appropriés pour injecter les dépendances..

ça fonctionne mais j'ai plusieurs questions :

1) Chaque fois que j'ai un controlleur qui manipule des objets venant de tables différentes, vais-je devoir avoir des setManagers & getManagers pour chacun d'eux ? (ex: Form avec 10 listes -> 10 setters & 10 getters ?)

2) Si je ne fais jamais QUE lire (récupérer) ma liste de produits, que je ne dois jamais faire d'update/delete/insert, dois-je malgré tout passer par un Manager ?

3) La structure actuelle est-elle propre ?

Merci d'avance pour votre réactivité !
26/01/2011, 23h09
ray_fab

Bonsoir la réponse à ta première question est non, tu n'es pas obligé de préciser les getters et les setters une fois que tes classes dao sont déclarées dans le conteneur de Spring. il suffit de les precédés de l'annotation @Autowired ou @Resource, leur utilisation dépends de toi...Cela est valable pour toutes les classes qui sont déclarées dans les conteneurs.
Ta deuxième question est mal posée, mais tu crois qu'il existe une magie sans utiliser les dao ou les manager, se connecter à la base de données récupérer des objets?Si cela était possible le design pattern DAO ne devrait pas exister, Hibernate devient inutile, donc si jai bien compris ta question la réponse est oui tu dois passer par le manager sinon reformule la.
27/01/2011, 10h57
libuma

Effectivement, Autowired est pas mal :)
Merci pour ta réponse.

Par contre, pourquoi autant de sarcasme pour la deuxième question?
Entre nous, un manager n'est qu'une classe qui fait le lien entre le controlleur et le DAO, on pourrait très bien s'en passer (pas propre..).
De plus, Des frameworks comme spring permettent d'utiliser un controlleur propre au framework, qu'on doit juste définir et qu'on ne doit même plus créer...
Alors, pourquoi pas ? Je ne connais pas encore spring, je m'informe...

Je ne comprends pas pourquoi ce genre de réaction..
27/01/2011, 12h29
ray_fab

Désolé si tu as mal pris ma réponse.
En fait pourquoi utiliser un Service, l'objectif est d'apporter une séparation totale entre les différentes couches d'une application, c'est à dire la couche Web ne doit rien savoir sur la couche Dao, le contrôleur ne doit pas se soucier de savoir d'où viennent les données dont on lui donne et où vont les données qu'il donne au Service, et la couche Dao ne doit pas non plus savoir d'où proviennent les données et où vont elles. Cela permet de garantir la flexibilité pour les données donc l'application. Si un Service n'était pas essentiel, on ne se préoccupera pas de créer sa couche, qui est le centre d'une application. Maintenant avoir une couche Service ou non ne dépends que de toi et de ce que t'as envie de faire.
27/01/2011, 15h38
libuma

Oui tout à fait d'accord...
Simplement, 10 Managers, 10 DAO, pour un form me semblait beaucoup, d'où ma question.
C'est vrai qu'en utiliser déjà @Autowired, on a 10 getters & 10 setters en moins, la classe est déjà plus propre :)

Petite question,
J'ai donc deux DAOs qui gère chacune une table :

Atmosphère
Satisfaction

Est-ce que c'est plus propre de créer un Manager pour chacun d'eux Comme ceci...
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 @Transactional (readOnly=true, propagation=Propagation.REQUIRED) public class SatisManager{ @Autowired private SatisDao satisDao = null; public List<Satisfaction> getSatisList() { return satisDao.getSatisList(); } public Satisfaction getSatisById(Long id) { return satisDao.getSatisById(id); } } @Transactional (readOnly=true, propagation=Propagation.REQUIRED) public class AtmosManager{ @Autowired private AtmosManagersatisDao = null; public List<Atmosphere> getAtmosList() { return atmosDao.getAtmosList(); } public Atmosphere getAtmosById(Long id) { return atmosDao.getAtmosById(id); } }
Ou est-ce que cela à du sens de les rassembler dans le même manager comme ceci :
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 @Transactional (readOnly=true, propagation=Propagation.REQUIRED) public class DetailManager{ @Autowired private SatisDao satisDao = null; private AtmosDao atmosDao = null; public List<Satisfaction> getSatisList() { return satisDao.getSatisList(); } public Satisfaction getSatisById(Long id) { return satisDao.getSatisById(id); } public List<Atmosphere> getAtmosList() { return atmosDao.getAtmosList(); } public Atmosphere getAtmosById(Long id) { return atmosDao.getAtmosById(id); } }
Sachant que ce sont tous deux des éléments "détails" qu'on utilisera en readonly.
Ou même un manager commun et un DAO commun ?
La chose importante à savoir est : A quelle moment Hibernate effectue-t-il ses connexions vers la base de données ? (pour éviter les accès inutiles et donc les ralentissement...
Seulement quand il accède aux méthodes du DAO je suppose?

Merci d'avance!

28/01/2011, 10h26
ray_fab
Citation:

Envoyé par libuma

Oui tout à fait d'accord...
Simplement, 10 Managers, 10 DAO, pour un form me semblait beaucoup, d'où ma question.

Tu peux créer un DAO et un Manager générique donc pas besoin de créer une implémentation pour chaque classe persistante.
Par exemple
Code:

1 2 3 4 public interface IDao<R>{ public void save(R r); }
Code:

1 2 3 4 5 6 7 public class Dao<R> implements IDao<R>{ public void save(R r){ em.persist(r); //session.save(r); } }
Perso je n'utilise plus une classe générique de cette manière car elle implique de créer pas 10 implémentations mais 10 instances de la classe Dao c'est déjà mieux vu qu'on peux ne pas avoir à utiliser toutes les classes persistantes en un seul coup dans un contrôleur par example. Il ya mieux à faire pour avoir seulement un seul Dao, une seule instance pour toutes les classes persistantes.
28/01/2011, 10h53
ray_fab

1)La première remarque est la suivante: Il faut créer une interface pour chacune de tes classes Dao ou Manager, puis les implémenter. Cela ne dois pas changer tes déclarations dans le conteneur de Spring (En effet il faut seulement déclarer la classe d'implémentation en non l'interface) mais tu dois seulement utiliser l'interface c'est à dire l'annotation @Autowired doit se faire sur l'interface mais pas la classe d'implémntation. Seule l'interface doit être utilisée.
2) Tu peux regrouper tous tes managers en un seul manager mais ca dépends que de toi. En regardant les méthodes de tes managers je me rend compte qu'il y a un soucis de programmation réccurente, c'est à dire que tu écris deux fois les mêmes choses. La méthode getSatisList et getAtmosList font approximativement la même chose coté ordre SQL sauf que les classes persistances ne sont pas les mêmes, il en est de même pour les méthodes getSatisById et getAtmosById. Tu peux faire comme je t'ai dit précédement en ayant un Dao générique ce qui transforme tes methodes qui renvoient une List en getList tout court et les 2 dernières en getId tout simplement, la tu optimises ton code et ca le rend plus propre. Même si tu peux encore faire mieux mais c'est déjà mieux.

Bonjour,

Merci pour votre réponse.
J'ai tenté de mettre tout ça en musique mais je bloque..

Mon DAO Commun :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
public interface CommonDao<R> {
 
    /**
     * Return an Object List.
     * @return the Object List object.
     * @throws DataAccessException in case of Data access errors 
     * (database unreachable, etc.)
     */
	public List<R> getList();
 
	 /**
     * Return an Object for the specific Id.
     * @return the Object object.
     * @param desired Object ident
     * @throws DataAccessException in case of Data access errors 
     * (database unreachable, etc.)
     */
	public R getObjById(long ident);
}

Jusque là.. tout va bien. Maintenant pour l'implémentation, je suis obligé d'utiliser une implémentation par type d'objet puisque je dois accéder à mon objet.class Voici donc un exemple : AtmosphDaoImpl

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
 
public class AtmosphDaoImpl extends HibernateDaoSupport implements CommonDao<Atmosphere>{
 
    /**
     * Return an Object List.
     * @return the Object List object.
     * @throws DataAccessException in case of Data access errors 
     * (database unreachable, etc.)
     */
	@SuppressWarnings("unchecked")
	public List<Atmosphere> getList()
	{
		try{
			Session session = getHibernateTemplate().getSessionFactory().getCurrentSession();
			// create a new criteria
			Criteria crit = session.createCriteria(Atmosphere.class);
			return crit.list();
		}catch(DataAccessException e) {
			// Critical errors : database unreachable, etc.
			System.out.print("Exception - DataAccessException occurs : "+e.getMessage()
					+" on complete getUser().");
			return null;
		}
	}
 
	 /**
     * Return an Object for the specific Id.
     * @return the Object object.
     * @param desired Object ident
     * @throws DataAccessException in case of Data access errors 
     * (database unreachable, etc.)
     */
	public Atmosphere getObjById(long id)
	{
		try{
			Session session = getHibernateTemplate().getSessionFactory().getCurrentSession();
			// create a new criteria
			Criteria crit = session.createCriteria(Atmosphere.class);
			crit.add(Expression.eq("id", id));
			return (Atmosphere)crit.uniqueResult();
		}catch(DataAccessException e) {
			// Critical errors : database unreachable, etc.
			System.out.print("Exception - DataAccessException occurs : "+e.getMessage()
					+" on complete getAtmosById().");
			return null;
		}
	}
}

Ensuite, je passe au Manager générique que voici :

Code:

1
2
3
4
5
6
7
8
9
 
@Transactional (readOnly=true, propagation=Propagation.REQUIRED)
public interface CommonManager<R>{ 
 
	public List<R> getList();
 
	public R getObjById(Long id);
 
}

Ici, je dois donc aussi utiliser une implémentation spécifique par type d'objet?
Car sinon, comment pourrait-il faire le lien avec le bon Dao avec @Autowired?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
public class CommonManagerImpl<RA> implements CommonManager<RA>{
 
	@Autowired
	private CommonDao<RA> myDao=null;
 
	public List<RA> getList() {
 
		return myDao.getList();
	}
 
	public RA getObjById(Long id) {
 
		return myDao.getObjById(id);
	}
 
}
 
Je me retrouverai donc aussi avec de la redondance, mais c'est vrai qu'on a plus qu'une interface au lieu de X.
 
Est-ce bien à celà qu'il faut arriver?
Merci d'avance

Bon je te donne la bonne la pratique définitive et oublie pas de mettre comme problème résolu.
Seules les méthodes sont génériques et tu as une autres méthodes permettant d'injecter l'instance de chaque classe.
Ton interface Dao devient:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
public interface CommonDao {
 
    /**
     * Return an Object List.
     * @return the Object List object.
     * @throws DataAccessException in case of Data access errors 
     * (database unreachable, etc.)
     */
	public <R> List<R> getList();
 
	 /**
     * Return an Object for the specific Id.
     * @return the Object object.
     * @param desired Object ident
     * @throws DataAccessException in case of Data access errors 
     * (database unreachable, etc.)
     */
	public <R> R getObjById(long ident);
 
             public void loadClass(Class classBean);
 
}

et son implémentation comme ceci

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
 
public class CommonDaoImpl extends HibernateDaoSupport implements CommonDao{
    private Class classBean;
 
    private void loadClass(Class classBean){
            this.classBean=classBean;
     }
    /**
     * Return an Object List.
     * @return the Object List object.
     * @throws DataAccessException in case of Data access errors 
     * (database unreachable, etc.)
     */
	@SuppressWarnings("unchecked")
	public <R> List<R> getList(){
		try{
			Session session = getHibernateTemplate().getSessionFactory().getCurrentSession();
			// create a new criteria
			Criteria crit = session.createCriteria(classBean);
			return crit.list();
		}catch(DataAccessException e) {
			// Critical errors : database unreachable, etc.
			System.out.print("Exception - DataAccessException occurs : "+e.getMessage()
					+" on complete getUser().");
			return null;
		}
	}
 
	 /**
     * Return an Object for the specific Id.
     * @return the Object object.
     * @param desired Object ident
     * @throws DataAccessException in case of Data access errors 
     * (database unreachable, etc.)
     */
	public R getObjById(long id)	{
 
		try{
			Session session = getHibernateTemplate().getSessionFactory().getCurrentSession();
			// create a new criteria
			Criteria crit = session.createCriteria(classBean);
			crit.add(Expression.eq("id", id));
			return (R)crit.uniqueResult();
		}catch(DataAccessException e) {
			// Critical errors : database unreachable, etc.
			System.out.print("Exception - DataAccessException occurs : "+e.getMessage()
					+" on complete getAtmosById().");
			return null;
		}
	}
}

Et ton interface Manager comme ceci

Code:

1
2
3
4
5
6
7
8
 
public interface CommonManager{ 
 
	public <R> List<R> getList();
 
	public <R> R getObjById(Long id);
	public void loadClass(Class classBean);
}

Et son implémentation comme ceci

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
@Transactional (readOnly=true, propagation=Propagation.REQUIRED)
public class CommonManagerImpl implements CommonManager{
 
	@Autowired
	private CommonDao<R> myDao;
 
	public List<R> getList() {
 
		return myDao.getList();
	}
 
	public R getObjById(Long id) {
 
		return myDao.getObjById(id);
	}
             public void loadClass(Class classBean){
                    this.classBean=classBean;
             }
             private Class classBean;
 
}

Tu n'as plus à créer d'autres implémentations celle ci est valable pour n'importe quel bean.
Avant l'utilisarion de chaque classe il faut lui faire un loadClass pour injecter la classe dans le Manager, et tu te retrouves à créer une seule instance de ton manager. Bon la dis moi que t'a la bonne practrice et tu peux mettre comme problème résolu.

J'ai dû adapter un peu mais ça fonctionne très bien merci! :)

Aussi, dans l'implémentation du manager, j'ai procédé comme ceci :
Code:

1 2 3 4 5 public void loadClass(Class classBean) { this.classBean = classBean; myDao.loadClass(classBean); }
Pour que le classBean du DAO soit automatiquement instancé.

Et dans le controlleur alors :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 @Autowired @Qualifier("commonManager") private CommonManager<Satisfaction> commonManager; public ModelAndView handleRequest(HttpServletRequest arg0, HttpServletResponse arg1) throws Exception { ModelAndView modelAndView = new ModelAndView("newReport"); commonManager.loadClass(Satisfaction.class); modelAndView.addObject("commonList",this.commonManager.getList()); return modelAndView; }
Un grand merci !