Discussion :

[mcfly37]

Bonjour à tous.

Aujourd'hui je me pose une question... métaphysique

Je développe une application spring/hibernate de taille petite/moyenne mais qui devrais recevoir beaucoup de requêtes (plusieurs milliers/jours), donc l'utilisation des transactions est indispensable. Seuleument d'après mes lectures, il apparaitre que spring gère comme un grand les transaction (avec les annotations @transactional(params...) ). cela veut-il dire que je n'ais pas du tout à m'en préoccuper (excepté mettre les annotations au bon endroit bien sur), pas besoin de bous de codes dans 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
sf.getCurrentSession().beginTransaction();
 
			/* Ctrl. d'exitence de la borne */
			if (borneDao.findById(p.id, false) != null) {
				sf.getCurrentSession().getTransaction().rollback();
				throw new BusinessException(ErrorCode.BORNE_EXISTE_DEJA);
			}
 
			/* R�cup�ration de l'AO */
			AutoriteOrganisatrice ao = aoDao.findById(p.idAo, false);
			if (ao == null) {
				sf.getCurrentSession().getTransaction().rollback();
				throw new BusinessException(ErrorCode.AO_INTROUVABLE);
			}
			borne.setAutoriteOrganisatrice(ao);
 
			borneDao.makePersistent(borne);
 
			sf.getCurrentSession().getTransaction().commit();

Et dernière interrogation, ces transactions gérée par spring sont-elles vraiment efficaces? (enfin pour une appli pas trop grosse)?

voila, je veux une réponse en trois pages argumentées, calculatrice interdite, vous avez trois heures

Et merci d'avance de votre réponse bien évidement ^^

[JeitEmgie]

@Transactional et ses variantes AOP ne font qu'appeler les fonctions sous-jacentes à votre place…
en gérant de manière transparente pour vous la plomberie… (… les exceptions entre autres…)

donc il n'y a pas de pénalité notable à l'exécution…

en échange d'une plus grande lisibilité du code et de la facilité de maintenance…

(n'oubliez pas <tx:annotation-driven /> dans votre applicationContext qui contient le transactionManager…)

MAIS

cela ne vous prive pas de comprendre quel type de stratégie de propagation de transaction vous devez utilisez à chaque endroit…

et

@Transactional ne fonctionne qu'avec un seul PersistenceUnit/EntityManager/DataSource…

si vous devez gérer plusieurs bases de données dans la même application il faut, par exemple, descendre vers
<aop:aspectj-autoproxy />, <tx:advice> et <aop:config>

[mcfly37]

Merci pour les renseignements, effectivement la propagation n'est pas à oublier même si je ne gère pas directement les transactions.

Donc si j'ai bien compris l'annotation @transactional (avec les paramètres qui vont bien) sur une méthode (de Dao ou de service) permet de commencer une transaction et de déclarer une session au début de cette méthode, il suffira juste ensuite de faire un getcurrentSession pour accéder à la session en cours.

Par contre petite question : j'ai tenté d'intégrer <tx:annotation-driven/> Mais il me balance une exception :

org.springframework.beans.factory.xml.XmlBeanDefinitionStoreException: Line 10 in XML document from class path resource [applicationContextDao.xml] is invalid; nested exception is org.xml.sax.SAXParseException: Element type "tx:annotation-driven" must be declared.

Donc il faut apparemment le déclarer...

cette ligne il faut bien la mettre entre les balises <beans> hein?

Ou alors ça à peut être à voir avec l'en-tête de mon fichier qui ne va pas chercher les bonnes dtd...

en tête :

Code :

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

1
2
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

Pour info j'utilise spring 2.5.6 et j'ai bien la lib org.springframework.transaction (ça n'a surement pas grand chose à voir mais j'ai vérifié quand même ^^)

[JeitEmgie]

Par contre petite question : j'ai tenté d'intégrer <tx:annotation-driven/> Mais il me balance une exception :

il faut bien sûr compléter les déclarations de schema dans la balise <beans>

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
<beans …
	xmlns:tx="http://www.springframework.org/schema/tx"
…
 
	xsi:schemaLocation="
…
 
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
…"
>

[mcfly37]

Humm j'ai bien rajouter ce que tu m'a dit :

Code :

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

1
2
3
4
5
6
7
8
9
10
<?xml version="1.0" encoding="UTF-8"?>
<!-- Application context DAO layer -->
 
<beans
	 xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"
	>

Mais voila ce qu'il me sort :

org.springframework.beans.factory.xml.XmlBeanDefinitionStoreException: Line 10 in XML document from class path resource [applicationContextDao.xml] is invalid; nested exception is org.xml.sax.SAXParseException: cvc-elt.1: Cannot find the declaration of element 'beans'.

Il n'arrive plus à retrouver le déclaration de mon beans...

[JeitEmgie]

Humm j'ai bien rajouter ce que tu m'a dit :

Code :

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

1
2
3
4
5
6
7
8
9
10
<?xml version="1.0" encoding="UTF-8"?>
<!-- Application context DAO layer -->
 
<beans
	 xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"
	>

Mais voila ce qu'il me sort :



Il n'arrive plus à retrouver le déclaration de mon beans...

il manque sans doute et au moins le
http://www.springframework.org/schema/beans http://www.springframework.org/schem...-beans-2.5.xsd
dans le xsi:schemaLocation

ce que j'ai ici dans une application, mais plus complet que ce dont vous avez besoin :

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
 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:lang="http://www.springframework.org/schema/lang"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
		http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang-2.5.xsd
		">

[mcfly37]

et bien en effet c'était bien ça ^^

Du coup la ça marche parfaitement

En te remerciant de ta précieuse (et rapide) aide.

une toute dernière petite question tout de même : Si on définit un service comme transactionnel, alors est-ce que le dao lié à ce service a lui aussi besoin d'être transactionnel? Pour moi non car le service étant transactionnel, il ouvrira une transaction à l'appel de chaque méthode, et donc cette transaction restera ouverte lors de (des) appel aux dao à l'intérieur de cette méthode. Mais je ne suis pas encore bien sur de tout comprendre des transactions

[JeitEmgie]

et bien en effet c'était bien ça ^^

Du coup la ça marche parfaitement

En te remerciant de ta précieuse (et rapide) aide.

une toute dernière petite question tout de même : Si on définit un service comme transactionnel, alors est-ce que le dao lié à ce service a lui aussi besoin d'être transactionnel? Pour moi non car le service étant transactionnel, il ouvrira une transaction à l'appel de chaque méthode, et donc cette transaction restera ouverte lors de (des) appel aux dao à l'intérieur de cette méthode. Mais je ne suis pas encore bien sur de tout comprendre des transactions

les frontières de la transaction sont là où vous mettez l'annotation…

si une méthode de Service est transactionnelle, tous les appels DAO à l'intérieur de cette méthode seront dans le même scope transactionnel…

MAIS

rien ne vous empêche de définir AUSSI un niveau transactionnel sur certaines méthodes de DAO…
(mais les transactions imbriquées ne sont pas supportées par tous les RDBMS…)

disons que ce n'est pas la règle dans les cas simples… et que cela dépend de votre architecture de Facade, Service, Repository, DAO, …


Pour faire (très) simple, considérez une Transaction comme une unité de traitement : soit elle réussit dans son ensemble, soit le moindre problème (Exception) doit "annuler" tout ce qui a été fait depuis le début de la Transaction…

Notez qu'avec un ORM les frontières de transaction sont aussi celles de la gestion de la cache L1…
ce qui implique que faire de très lourds traitements (le cas classique étant l'importation "naïve" de gros volumes de données…) dans une seule transaction va vous conduire droit à des problèmes de gestion mémoire…

(voir tous les threads ici et ailleurs parlant de "out of memory", "lazy exception"… )