Discussion :

[JamesP]

Bonjour,

Je reviens à l'attaque avec mes questions tordues ...

Voila je souhaiterais intégrer les fonctionnalités de DAO dans le bean correspondant mais sans y intégrer le code.

Donc je voudrais pouvoir faire :

Code :

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

1
2
3
User u = User.find(1);
u.setName("toto");
u.save();

Mais je souhaiterais (grâce à l'héritage, aux implémentations et aux classes abstraites) que les fichiers restent séparés !

Voila comment je voudrais que ça marche :

-----> 1 : PojoItem
C'est mon conteneur de bean de base, tous mes beans étendront cette classe !
(C'est avec cette classe et du typage que je clone sans cast, etc ... cf le thread ==> ICI <==)

-----> 2 : HibernateFactory
C'est uniquement des méthodes permettant de faire mes connexions et mes transactions avec hibernate.

-----> 3 : DAO
C'est une classe basique permettant de manipuler mes beans (ou tout ce qui étend PojoItem dans mon cas)
Les méthodes find() et findAll() seront publiques (et statique ???)
Les méthodes delete(), save(), update() seront protégées et devront être surchargées pour être utilisées.
C'est ici qu'on appelle les factory, dont HibernateFactory !

Maintenant, les classes propres à la logique métier, donc des exemples.

-----> 4 : UserDAO
Elle étend ou surcharge la classe DAO, ici on trouvera tout le code métier de travail avec les beans.
On pourra surcharger ou non les méthodes qui nous intéressent.

-----> 5 : User
Elle étend PojoItem au minima, car c'est un objet qui sera manipulé par la DAO.
C'est un pur bean donc champs, getters, setters ....

Voila ce que j'ai aujourd'hui (j'ai pas spécifié tous les typages de classes qui me permettent de pas caster toutes les 10 lignes et qui simplifient bien la manipulation ensuite !)

J'aimerais donc, par un moyen que je ne trouve pas, que mon Objet "User" intègre directement (sans possibilité de surcharge, juste possibilité d'appel) toutes les méthodes qui sont dans "UserDAO".

Ainsi, chacun son job, "User" est le bean de données et "UserDAO" le service métier qui manipule.

Mais avec l'avantage de pouvoir utiliser la DAO directement depuis le bean !

J'espère que je suis assez clair, et aussi que c'est possible !!!

Je met en pièce jointe de quoi voir d'où j'en suit avec les typages et tout.

Toute critique est bienvenue.

Merci à vous d'avance !

[thelvin]

Mais avec l'avantage de pouvoir utiliser la DAO directement depuis le bean !

C'est inutile et anti-objet.

Un User n'a pas à savoir comment se sauvegarder lui-même. C'est le travail du sauvegardeur de User.

[JamesP]

Merci pour la réponse, je comprends bien ...

Mais moi je cherche à le faire tout de même ...

Merci encore d'avance !

[JamesP]

Pas d'idées ???

[_xme_]

Bonjour
Je ne suis pas sur d'avoir tout saisi dans ton problème.
Ce que j'ai compris
Tu as tes beans qui map une base de données, mais afin de les rendre tous clonable, tu les fais tous étendre une classe abstraite permettant le clonage.
Tu as tes DAO qui implémentent tous une interface de DAO commune.
Mais tu veux également que tes beans implémentent directement les méthodes des DAO
quel est l’intérêt de tes DAO alors?

En tout cas d'après ce que je lis, j'ai l'impression que tu as besoin de faire deux interfaces.
Une première genre :
save();
delete();
qui est implémentée par tout le monde DAO et bean (le DAO ne fait qu'appeler ta factory hibernate pour gérer les transactions et appeler les méthodes save et delete des différents beans qu'il manipule)

et une autre interface réservée au DAO genre :
find();
findAll();

Ai-je plus ou moins compris ton problème?

[JamesP]

Oui c'est quasi ça ...

Mon but c'est juste d'appeler les méthodes DAO directement depuis le bean.

Mais je ne veux pas partager le code, et donc ne PAS intégrer du code DAO (save, update, find, delete, etc ...) dans mon bean !

Je veux juste garder un système bien scindé, le bean d'un côté, la DAO de l'autre, mais pouvoir faire des trucs du genre :

Code :

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

1
2
3
4
5
User u = User.find("toto");
System.out.println(u.toString());
u.setCountry("France");
u.saveOrUpdate();
System.out.println(u.toString());

Voila, en fait je veux simplifier le code pour qu'en fait la DAOsoit présente et faite comme il faut (structurée et dans des fichiers séparés) mais que le code soit plus simple !

Le pourquoi est que je fait un framework, et que je veux simplifier au maxi le code !

Merci encore ...

[_xme_]

Ta demande me semble vraiment bizarre

Code :

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

u.setCountry("France")

est bien typiquement une méthode métier, et mérite d'être dans le bean mais le

Code :

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

u.saveOrUpdate();

alors que tu fais du MVC me semble incorrecte, car suppose que le bean connait le DAO qui l'utilise! Or il n'y a aucune raison pour qu'il n'y ai qu'un seul DAO qui l'utilise.

Une solution technique que je verrais serait de faire des listeners
genre le bean possède une liste privé de DAO et deux méthodes l'une pour ajouter un DAO à cette liste et l'autre pour l'enlever.
Ensuite une méthode que je n'approuve que modérément utiliser l’introspection.
Tu rajoutes une méthode dans ton bean genre call(String methodName).

Code :

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

1
2
3
4
5
6
7
8
9
10
 public void call(String methodName){
    for (Dao d : listeDao){
        List<Method> methods = d.getclass().getMethods()
        for (Method m : methods){
            if (m.getName().equals(methodName)){
                m.invoke()
            }
        }
    }
}

Attention code non testé, tapé à la volée
je ne sais pas trop comment fonctionne l'introspection, je te laisse le plaisir de découvrir ^^ (je serais intéressé par un code fonctionnel )

De plus je ne cautionne pas trop car c'est vraiment sortir l'artillerie lourde pour pas grand chose et surtout magnifique problème de maintenabilité en perspective

Du coup ca changerait ton code final en :

Code :

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

1
2
3
4
5
6
7
User u = User.find("toto");
System.out.println(u.toString());
u.setCountry("France");
DaoUser d = new DaoUser();
u.addDao(d);
u.call(saveOrUpdate);
System.out.println(u.toString());

Est ce que cela se rapproche de ce que tu voudrais?

[EDIT]
Après réflexion ce qui me semble le mieux, serait quand même de transmettre une méthode et non le nom de la méthode.
genre:

Code :

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

1
2
3
4
5
6
7
User u = User.find("toto");
System.out.println(u.toString());
u.setCountry("France");
DaoUser d = new DaoUser();
Method m = d.getClass().getMethod("saveorUpdate");
u.call(m);
System.out.println(u.toString());

mais ca reste moche
[/EDIT]

[JamesP]

Tout d'abord merci bien de la réponse !!!

Effectivement, j'ai pas de solution, et quand bien même je trouve également que c'est pas dans les normes et dans les règles de l'art, pour moi c'est intéressant avec ma problématique ...

Je sais moi que je vais avoir 1 seul DAO par Bean, j'en suis sur et certain !!!

Donc même si dans la définition de la classe du bean, je lui mettait un truc du genre :

Code :

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

private UserDao = new UserDao();

Pas de soucis, mais je cherche le moyen le plus "propre" (tant que faire se peut) et le plus pratique.

C'est pour ça qu'un truc du genre :

Code :

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

class User extends PojoItem implements UserDao

Peut convenir aussi ...
Mais je n'arrive pas à trouver un façon de faire qui soit pile poil à mes besoins ...

Sinon j'ai déjà fait de l'introspection ... Ta méthode marcherait mais moi je ferai un truc du 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
 public void call(String methodName){
    for (Dao d : listeDao){
		try
		{
			Method m = this.getClass().getMethod(methodName);
			m.invoke();
		} catch (SecurityException e)
		{
			e.printStackTrace();
		} catch (NoSuchMethodException e)
		{
			e.printStackTrace();
		}
    }
}

Pour éviter de boucler sur toutes les méthodes ...
Ou alors autre sokution, utiliser un

Code :

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

list.contains(methodName);