J'ai un petit problème de design... Je travaille sur une application
J2SE swing qui tappe "directement" sur une BDD Oracle.
Cette application utilise plusieurs DAO, qui lui permettent de faire du
CRUD sur cette base. Ces DAO récupèrent des connexions dans un pool créé
au démarrage de l'application.
La gestion des transactions est assurée par l'implémentation de
l'interface Connection, qui nous permet de faire un commit ou un
rollback. Mon problème de design concerne l'implémentation des
transactions lorsque plusieurs DAO sont utilisés. En effet, dans ce cas
la, il faut pouvoir "passer" une transaction entre différentes méthodes,
et je ne vois que deux solutions : passer la connexion en paramètre ou
utiliser une implémentation de JTA, ce qui nous permettrait de committer
ou de rollbacker la transaction dans son ensemble (mais est ce que
cela est possible en J2SE ?).
La première solution me semble nuire à la lisibilité du code, et je ne
sais même pas si la seconde est possible techniquement...
Vos lumières sur ce sujet seraient vraiment les bienvenues ! Je cogite
depuis quelques jours sur ce sujet sans trouver de solution
satisfaisante... :)
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
pierre
tu as deux solutions: - Passer la connection de le constructeur (et non dans les méthodes) de tes classes d'implémentation des DAO - utiliser un ThreadLocal, classe qui te permet de récuprer une instance de connection (comme si tu attaquais une classe statique), mais thread safe. Voici un article d'introduction (http://www-128.ibm.com/developerworks/java/library/j-threads3.html) sur les ThreadLocal.
Je ne pourrai te conseiller l'une ou l'autre méthode. Affaire de gout peut-être. Perso, j'utilise la première solution car rien ne garantie que tu reste dans le même thread dans un conteneur Web J2EE même si dans la pratique ... Martin flowler (Un gourou ...) a une nette préférence pour la seconde.
En espèrant que ceci a pu t'aider ... Pierre.
Simon OUALID wrote:
Bonjour,
J'ai un petit problème de design... Je travaille sur une application J2SE swing qui tappe "directement" sur une BDD Oracle.
Cette application utilise plusieurs DAO, qui lui permettent de faire du CRUD sur cette base. Ces DAO récupèrent des connexions dans un pool créé au démarrage de l'application.
La gestion des transactions est assurée par l'implémentation de l'interface Connection, qui nous permet de faire un commit ou un rollback. Mon problème de design concerne l'implémentation des transactions lorsque plusieurs DAO sont utilisés. En effet, dans ce cas la, il faut pouvoir "passer" une transaction entre différentes méthodes, et je ne vois que deux solutions : passer la connexion en paramètre ou utiliser une implémentation de JTA, ce qui nous permettrait de committer ou de rollbacker la transaction dans son ensemble (mais est ce que cela est possible en J2SE ?).
La première solution me semble nuire à la lisibilité du code, et je ne sais même pas si la seconde est possible techniquement...
Vos lumières sur ce sujet seraient vraiment les bienvenues ! Je cogite depuis quelques jours sur ce sujet sans trouver de solution satisfaisante... :)
Merci
Symon
tu as deux solutions:
- Passer la connection de le constructeur (et non dans les méthodes)
de tes classes d'implémentation des DAO
- utiliser un ThreadLocal, classe qui te permet de récuprer une
instance de connection (comme si tu attaquais une classe statique), mais
thread safe. Voici un article d'introduction
(http://www-128.ibm.com/developerworks/java/library/j-threads3.html) sur
les ThreadLocal.
Je ne pourrai te conseiller l'une ou l'autre méthode. Affaire de
gout peut-être.
Perso, j'utilise la première solution car rien ne garantie que tu
reste dans le même thread dans un conteneur Web J2EE même si dans la
pratique ...
Martin flowler (Un gourou ...) a une nette préférence pour la seconde.
En espèrant que ceci a pu t'aider ...
Pierre.
Simon OUALID wrote:
Bonjour,
J'ai un petit problème de design... Je travaille sur une application
J2SE swing qui tappe "directement" sur une BDD Oracle.
Cette application utilise plusieurs DAO, qui lui permettent de faire du
CRUD sur cette base. Ces DAO récupèrent des connexions dans un pool créé
au démarrage de l'application.
La gestion des transactions est assurée par l'implémentation de
l'interface Connection, qui nous permet de faire un commit ou un
rollback. Mon problème de design concerne l'implémentation des
transactions lorsque plusieurs DAO sont utilisés. En effet, dans ce cas
la, il faut pouvoir "passer" une transaction entre différentes méthodes,
et je ne vois que deux solutions : passer la connexion en paramètre ou
utiliser une implémentation de JTA, ce qui nous permettrait de committer
ou de rollbacker la transaction dans son ensemble (mais est ce que cela
est possible en J2SE ?).
La première solution me semble nuire à la lisibilité du code, et je ne
sais même pas si la seconde est possible techniquement...
Vos lumières sur ce sujet seraient vraiment les bienvenues ! Je cogite
depuis quelques jours sur ce sujet sans trouver de solution
satisfaisante... :)
tu as deux solutions: - Passer la connection de le constructeur (et non dans les méthodes) de tes classes d'implémentation des DAO - utiliser un ThreadLocal, classe qui te permet de récuprer une instance de connection (comme si tu attaquais une classe statique), mais thread safe. Voici un article d'introduction (http://www-128.ibm.com/developerworks/java/library/j-threads3.html) sur les ThreadLocal.
Je ne pourrai te conseiller l'une ou l'autre méthode. Affaire de gout peut-être. Perso, j'utilise la première solution car rien ne garantie que tu reste dans le même thread dans un conteneur Web J2EE même si dans la pratique ... Martin flowler (Un gourou ...) a une nette préférence pour la seconde.
En espèrant que ceci a pu t'aider ... Pierre.
Simon OUALID wrote:
Bonjour,
J'ai un petit problème de design... Je travaille sur une application J2SE swing qui tappe "directement" sur une BDD Oracle.
Cette application utilise plusieurs DAO, qui lui permettent de faire du CRUD sur cette base. Ces DAO récupèrent des connexions dans un pool créé au démarrage de l'application.
La gestion des transactions est assurée par l'implémentation de l'interface Connection, qui nous permet de faire un commit ou un rollback. Mon problème de design concerne l'implémentation des transactions lorsque plusieurs DAO sont utilisés. En effet, dans ce cas la, il faut pouvoir "passer" une transaction entre différentes méthodes, et je ne vois que deux solutions : passer la connexion en paramètre ou utiliser une implémentation de JTA, ce qui nous permettrait de committer ou de rollbacker la transaction dans son ensemble (mais est ce que cela est possible en J2SE ?).
La première solution me semble nuire à la lisibilité du code, et je ne sais même pas si la seconde est possible techniquement...
Vos lumières sur ce sujet seraient vraiment les bienvenues ! Je cogite depuis quelques jours sur ce sujet sans trouver de solution satisfaisante... :)
