Discussion :

[HadanMarv]

Bonjour,

Le titre n'est peut-être pas très clair, mais je vais tenter de l'expliquer ici.
Dans notre projet, nous avons configurer les transactions grâce à l'AOP.
Nous avons donc dans notre configuration :

Code :

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

1
2
3
4
5
6
<tx:advice id="daoTxAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="retrieve*" propagation="REQUIRED" read-only="true" />
	<tx:method name="*" propagation="REQUIRED" />
    </tx:attributes>
</tx:advice>

et

Code :

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

1
2
3
<aop:config proxy-target-class="true">
    <aop:advisor advice-ref="daoTxAdvice" pointcut="nos_points_coupes" />
</aop:config>

Tout fonctionne parfaitement jusque là.
Pour rajouter un peu de complexité nous avons besoin pour un traitement particulier de faire n opérations et un commit à la fin.

Question comment gèrer ce cas ?
D'avance merci de vos lumières.

HadanMarv

[bilgetz]

Met une transaction sur ton(tes) service(s).

Dans ton service tu fait tes n opérations et le commit sera fait tranquillement a la fin de la méthode ( et rollback en cas d'exception).

[HadanMarv]

Et de fait comment faire pour gérer soit même la transaction ?

[bilgetz]

Et de fait comment faire pour gérer soit même la transaction ?

Tu n'as pas besoin de le faire toi même, Spring le fait pour toi.

En plus de test transaction sur tes DAO, tu met transaction sur ton service.

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
 
<tx:advice id="serviceTxAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="retrieve*" propagation="REQUIRED" read-only="true" />
	<tx:method name="*" propagation="REQUIRED" />
    </tx:attributes>
</tx:advice>
 
<aop:config proxy-target-class="true">
     <aop:pointcut id="serviceMethods"
			expression="execution(* monpackage..*.Monservice.mamethode(..))" />
 
 
    <aop:advisor advice-ref="serviceTxAdvice" pointcut="serviceMethods" />
</aop:config>

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
 
public class Monservice implements IMonService{
 
  Idao1 dao1;
  Idao2 dao2;
 
@Autowired
public Monservice (Idao1 dao1, Idao2 dao2) {
 this.dao1 = dao1;
this.dao2 = dao2;
}
 
/**
 Ma methode qui sera transactionnelle vue qu'il y a le pointcut dessus.
 A NE SURTOUT PAS APPELER AVEC UN this.mamethode(); SINON ON PASSE PAS PAR COUCHE SPRING!
**/
public void maMethodeduService() {
 
  dao1.methode1();
  dao2.methode1();
  dao1.methode2();
 
}
 
}

quand tu va appeler ta methode maMethodeduService() voila comment ça se passe niveau transaction/ pile des appelle :


appel proxy spring de Monservice.maMethodeduService
debut transaction #1
appel reel implementation maMethodeduService

apel proxy dao1.mamethode1
debut transaction #2
appelle reel implementation dao1.mamethode1
fin reel implementation dao1.mamethode1
fin transaction #2

apel proxy dao2.mamethode1
debut transaction #3
appelle reel implementation dao2.mamethode1
fin reel implementation dao2.mamethode1
fin transaction #3


appel proxy dao1.mamethode2
debut transaction #4
appelle reel implementation dao1.mamethode2
fin reel implementation dao1.mamethode2
fin transaction #4

fin reel implementation maMethodeduService
fin transaction #1


ta méthode sera entouré d'une transaction et donc avec un commit a la fin.
Si dao2.methode1() pète en l'air pour une raison x ou y, il n'y aura pas de probleme sur la base car c'est toujours dans la transaction #1, donc il y aura un rollback.

Après si vraiment tu veux le gérer en code. tu peut regarder l'interface ResourceTransactionManager ou PlatformTransactionManager.
Tu peut l'autowired vue qu'il existe un bean de transaction manager qui l’implémente ( celui d'hibernate en tous cas le fait ).