AOP Génie logiciel

1. Programmation Orientée Aspect
AOP

2. Les techniques de conception logicielles actuelles tentent d'architecturer
les applications en modules indépendants les uns des autres.
C'est le principe même de la programmation orientée objet ou le logiciel
est découpé en objets.
Dans la pratique, on s'aperçoit que ces couches logicielles sont en fait
liées
Ainsi, une couche logicielle initialement dédiée à gérer la logique métier
applicative, va se retrouver dépendante de modules gérant les aspects
transactionnels, journalisation, etc.

3. La programmation orientée aspect (Aspect Oriented Programming ou AOP)
permet de traiter séparément
• des préoccupations métiers, qui constituent le cœur d'une application1.
• Les préoccupations transversales (Cross Cutting Concerns CCC), qui
relèvent souvent des aspects technique (Journalisation, Sécurité,
Transaction, …)
Le AOP Permet de Séparer le code métier du code technique
Pourquoi AOP ?

4. • Les méthodes d’une application peuvent contenir du code qui permet de loger des
messages au début et la fin de la méthode.
• Ce qui constitue une répétition du même code à tous les niveaux de l’application. Ce
qui peut engendrer des problèmes au niveau de la maintenance.
• Grace à la programmation orientée aspect, on peut développer notre application
sans se préoccuper de la journalisation.
• Une classe séparée (Aspect) pourra être développée par la suite pour doter
l’application de cet aspect de journalisation
• Il serait de même pour ajouter d’autres aspect techniques comme : La sécurité,
Gestion de transaction, Gestion des exceptions,
Exemple :

5. L'opération de tissage peut être faite à la compilation ou à l'exécution du
programme.
Les tisseurs statiques s'appliquent à la compilation du programme. Ils
prennent en entrée un ensemble de classes et un ensemble d'aspects pour
fournir un programme compilé augmenté d'aspects.
Les tisseurs dynamiques sont, quant à eux, capables d'appliquer les
aspects dynamiquement, pendant l'exécution du programme. Leur principal
atout est leur capacité à ajouter, supprimer ou modifier les aspects à chaud
pendant l'exécution du programme.
Tisseurs d’aspects

6. Les tisseurs statiques

7. • Les points de jonction (JoinPoint)
• Les points de coupures (PointCut)
• Les Codes Advices (greffon)
Concepts de l’AOP

8. Point de jonction ou endroit spécifique dans le flot d'exécution du système, où il est valide d'insérer un
greffon.
Il n'est pas possible, par exemple, d'insérer un greffon au milieu du code d'une fonction. Par contre on
pourra le faire avant, autour de, à la place ou après l'appel de la fonction.
Point de jonction
Les points de coupure (JoinCut)
Un point de coupure désigne un ensemble de point de jonctions. Il existe plusieurs types de points de
coupures :
• Les coupes d’execution de méthodes désignant un ensemble d’execution de méthodes.

9. • Les blocs Advices sont des blocs de code qu'exécutera un aspect. Les
codes Advices caractérisent le comportement de l’aspect.
• Chaque code Advice d'un aspect doit être associé à une coupe pour
être exécuté. Ils ne seront exécutés que si un évènement définie par un
point de coupure à été intercepté.
• Un code advice peut être exécuté selon trois modes : avant, après, ou
autour d'un point de jonction.
• Lorsqu'il est exécuté autour du point de jonction, il peut carrément
remplacer l'exécution de ce dernier, ou bien lui redonner le contrôle.
Les Codes Advices

10. Spring AOP
Design Pattern Proxy

11. • Le pattern Proxy a pour objectif la conception d’un objet qui se
substitue à un autre objet (le sujet/target) et qui en contrôle l’accès.
• L’objet qui effectue la substitution possède la même interface que le
sujet, ce qui rend cette substitution transparente vis-à-vis des clients.
Description du Design Pattern

12. Le proxy reçoit les appels du client à la place du sujet réel. Quand il le
juge approprié, il délègue ces messages au sujet réel. Il doit, dans ce
cas, créer préalablement le sujet réel si ce n’est déjà fait.
Modèle

13. Domaine d’application
• Les proxys sont très utilisés en programmation par objets. Il existe différents types de
proxy :
• proxy virtuel : permet de créer un objet de taille importante au moment approprié ;
• proxy de protection : permet de sécuriser l’accès à un objet, par exemple par des
techniques d’authentification.
• Proxy pour AOP
• …

14. • Nous pouvons appliquer le design pattern Proxy pour séparer les
préoccupations transversales des préoccupations métiers.
• Le principe du design pattern Proxy est d’envelopper un objet dans un
mandataire et d’utiliser celui-ci à la place de l’objet original. Tous les appels
effectués sur l’objet original passent tout d’abord au travers du proxy.
Proxy et AOP

15. • Le proxy décide si les appels de méthodes doivent être transmis à l’objet
original, ainsi que du moment où cela se produit. Au même temps, le proxy
peut également effectuer des opérations supplémentaires avant et après
chaque appel de méthode.
• C’est pourquoi le proxy représente un bon endroit où mettre en œuvre les
préoccupations transversales.

16. En Java, il existe deux types de proxies dynamiques : les proxies basés sur les
interfaces et les proxies basés sur les classes.
• Les proxies basés sur les interfaces sont une solution JDK native et permettent
de créer des proxies à partir d'interfaces. Le proxy intercepte ensuite les appels
à ces méthodes et les redirige vers l'implémentation fournie.
• Les proxies basés sur les classes, en revanche, sont une solution tierce, telle
que CGLIB ou ASM. Les proxies basés sur les classes permettent de créer des
proxies pour des classes Java existantes, en créant une sous-classe de la classe
cible et en y insérant du code pour intercepter les appels à des méthodes
spécifiques.

17. Proxy dynamique
La solution jdk

18. création de proxy dynamique basé sur l'interface avec la solution native
JDK sans utiliser Spring AOP :
Supposons que nous avons la classe UserService et son interface IUserService :
public interface IUserService {
void saveUser(User user);
}
public class UserService implements IUserService {
@Override
public void saveUser(User user) {
// Code pour sauvegarder l'utilisateur dans la base de données
}
}

19. Créer une classe UserServiceProxy qui étend InvocationHandler. Cette classe interceptera les appels à la
méthode saveUser de l'interface IUserService et ajoutera du code avant et après l'exécution de la méthode :
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class UserServiceProxy implements InvocationHandler {
private final IUserService target;
public UserServiceProxy(IUserService target) {
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Before invoking " + method.getName() + "...");
Object result = method.invoke(target, args);
System.out.println("After invoking " + method.getName() + "...");
return result;
}
}

20. IUserService userService = new UserService();
UserServiceProxy proxy = new UserServiceProxy(userService);
IUserService userServiceProxy = (IUserService) Proxy.newProxyInstance(
IUserService.class.getClassLoader(),
new Class[]{IUserService.class},
proxy);
userServiceProxy.saveUser(new User("John", "Doe"));

21. Proxy dynamique
La solution CGLIB

22. public class UserService {
public void saveUser(User user) {
// Code pour sauvegarder l'utilisateur dans la base de données
}
}

23. Créer une classe UserServiceInterceptor qui étend MethodInterceptor. Cette classe interceptera les
appels à la méthode saveUser et ajoutera du code avant et après l'exécution de la méthode :
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class UserServiceInterceptor implements MethodInterceptor {
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy)
throws Throwable {
System.out.println("Before invoking " + method.getName() + "...");
Object result = proxy.invokeSuper(obj, args);
System.out.println("After invoking " + method.getName() + "...");
return result;
}
}

24. créer une instance de UserService et une instance de Enhancer :
UserService userService = new UserService();
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(UserService.class);
enhancer.setCallback(new UserServiceInterceptor());
UserService userServiceProxy = (UserService) enhancer.create();
userServiceProxy.saveUser(new User("John", "Doe"));
Lorsque nous appelons la méthode saveUser sur le proxy userServiceProxy, le
code ajouté dans la méthode intercept de la classe UserServiceInterceptor sera
exécuté avant et après l'appel à la méthode saveUser de l'objet cible
userService. Le résultat sera l'affichage des messages "Before invoking
saveUser..." et "After invoking saveUser..." dans la console, ainsi que l'affichage
du message "User saved: John Doe".

25. Spring AOP

26. Supposons que nous avons une interface Java appelée UserService qui a une méthode appelée
createUser qui crée un nouvel utilisateur dans notre système. Nous voulons journaliser les
appels à cette méthode afin de pouvoir suivre qui a créé chaque utilisateur.
Nous pouvons créer un aspect avec Spring AOP qui intercepte les appels à cette méthode et
ajoute une entrée de journalisation avant d'appeler la méthode elle-même. Voici un exemple
de code pour créer cet aspect: @Component
@Aspect
public class LoggingAspect {
private static Logger logger = LoggerFactory.getLogger(UserService.class);
@Poincut("execution(* com.example.UserService.createUser(..))")
public void pointServiceLayer(){}
@Before("pointServiceLayer() ")
public void logCreateUser(JoinPoint joinPoint) {
Object[] args = joinPoint.getArgs();
String username = (String) args[0];
Logger.info("User { } created at [ } ,username , new Date());
} }

27. Dans Spring AOP, JoinPoint est un objet qui représente le point d'exécution d'une méthode interceptée
par un aspect. L'objet JoinPoint est passé en tant que paramètre dans les méthodes advice de l'aspect,
telles que @Before, @After, @Around, etc.
L'objet JoinPoint contient des informations sur la méthode interceptée, telles que :
• Le nom de la méthode joinPoint.getSignature().getName();
• Les arguments de la méthode joinPoint.getArgs();
• La signature de la méthode joinPoint.getSignature();
• La classe qui contient la méthode interceptée joinPoint.getTarget();
• L'objet cible sur lequel la méthode est appelée joinPoint.getThis();
En utilisant ces informations, vous pouvez effectuer des opérations dans les méthodes conseil de l'aspect,
telles que la journalisation, la validation des arguments, l'audit, etc.
JoinPoint

28. @Before("execution(* com.example.service.*.*(..))")
public void logMethodCall(JoinPoint joinPoint) {
String methodName = joinPoint.getSignature().getName();
Object[] args = joinPoint.getArgs();
String argsString = Arrays.toString(args);
String message = "Method " + methodName + " called with arguments " + argsString;
logger.info(message);
}

29. @Component
@Aspect
public class LoggingAspect {
private static Logger logger = LoggerFactory.getLogger(ConduteurController.class);
@Pointcut("execution(@org.springframework.web.bind.annotation.GetMapping * com.parckauto.web.*.*(..))")
public void webLayer() {}
@Before("webLayer()")
public void logAccess(JoinPoint joinPoint) {
String url = getRequestUrl(joinPoint);
logger.info("Accessed {} at {} ",url,new Date());
}
private String getRequestUrl(JoinPoint joinPoint) {
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
Method method = signature.getMethod();
GetMapping annotation = method.getAnnotation(GetMapping.class);
return annotation.value()[0];
}
}

30. ProceedingJoinPoint est une sous-classe de JoinPoint dans Spring AOP. Il est
utilisé dans les méthodes advice de type @Around pour fournir un contrôle fin
sur le point de coupe intercepté.
Contrairement à JoinPoint, qui fournit uniquement des informations sur le point
d'exécution de la méthode interceptée, ProceedingJoinPoint permet également
de contrôler l'exécution de la méthode interceptée. Il permet à l'aspect de
décider s'il doit continuer ou non l'exécution de la méthode interceptée, ainsi que
de fournir des paramètres de retour à la méthode appelante.
Voici un exemple de méthode conseil @Around qui utilise l'objet
ProceedingJoinPoint pour contrôler l'exécution de la méthode interceptée :

31. @Around("execution(* com.example.service.*.*(..))")
public Object logMethodCall(ProceedingJoinPoint joinPoint) throws Throwable {
String methodName = joinPoint.getSignature().getName();
Object[] args = joinPoint.getArgs();
String argsString = Arrays.toString(args);
String message = "Method " + methodName + " called with arguments " + argsString;
logger.info(message);
Object result = joinPoint.proceed(); // Appelle la méthode interceptée
logger.info("Method " + methodName + " returned " + result.toString());
return result;
}

32. spring.aop.proxy-target-class=true
En général, si vous utilisez Spring AOP dans votre application Spring Boot, le tissage se
fait via un proxy. Cela signifie que Spring crée un objet proxy qui enveloppe l'objet
d'origine et intercepte les appels à ses méthodes, en appliquant les aspects
correspondants.
Pour indiquer à Spring d'utiliser une implémentation de proxy basée sur la
classe plutôt que sur l'interface :

33. @Before
@After
@Around
@AfterReturning
@AfterThrowing
Annotations d’advice

34. @Pointcut(
"execution(public void com.parckvehicule.service.disponibilteService()”)
@Pointcut(
"execution(public void com.parckvehicule.service.*()”)
@Pointcut(
"execution(public void com.parckvehicule.service.*(..)”)
@Pointcut(
"within(public void com.parckvehicule.service”)
@Pointcut(
"@ (GetMapping)")