ELEPHANT technologies, l’ESN locale et à taille humaine spécialisée sur 2 métiers : le développement et le pilotage autour de 4 expertises : hardware, embarqué, software et web.

 

Aujourd'hui on retrouve Robert notre elephantech en développement web fullstack (java/angular) qui nous présente rapidement la programmation orientée aspects.

 

La mise en application fera l’objet d’un prochain article.

 

Let’s go !

 

 

Programmation Orientée Aspects : Spring AOP – Concepts

 

 

Retrouvez les concepts de base de l'AOP avec la présentation des jointpoint, pointcut, wilcards, codes advices et les mécanismes d'introduction.

 

Généralement, le code d’une application peut être regroupé dans deux catégories : les traitements fonctionnels qui permettent à l’application de répondre aux besoins des utilisateurs finaux et les traitements techniques.

 

Avant la programmation orientée aspect, on ne savait pas comment séparer le code technique du code métier. On avait le code technique qui se répétait dans plusieurs parties de notre application. Une application était donc un mélange de code technique du code métier.

 

L’AOP est venue résoudre ce problème. Elle permet de traiter séparément les préoccupations transversales (cross-cutting-concerns) qui relèvent des aspects techniques (Journalisation, sécurité, transaction…) des préoccupations métiers qui constituent le cœur même de l’application. L’AOP permet de facilement mettre en place des fonctionnalités dans différents points de  l’application.

 

Schématiquement on a :

 

 

Pour ne pas mélanger le code métier du code technique dans l’application, on va créer des classes dans laquelle on aura seulement le code métier et après tout ce qui concerne les aspects techniques, on va créer d’autres classes séparées appelé « aspects ». On aura un aspect pour la gestion de la sécurité, un aspect pour la journalisation, un aspect pour gérer le cache etc.  

 

Par la suite, pour pouvoir obtenir notre application on est obligé d’utiliser un tisseur d’aspect. Un tisseur d’aspect va nous permettre de faire le tissage c’est-à-dire prendre les aspects et les greffer quelques part dans le code métier. Parmi les tisseurs les plus connus on a AspectJ et Spring AOP.

 

Pour des raisons de maintenabilité/performance de l’application, l’AOP permet de séparer le code métier du code technique.

 

La programmation orientée aspect est une technique transversale et n’est pas liée à un langage de programmation particulier. On peut bien mettre en œuvre l’AOP aussi bien avec un langage orienté objet comme le Java qu’avec un langage procédurale comme le C. le seul prérequis est l’existence d’un tisseur dans le langage cible.

 

  • Tisseurs d’aspects 

Un programme codé en orienté aspect peut être découpé en deux parties disjoints : des classes fonctionnelles pour la logique métier et des aspects pour les aspects techniques.

 

Le programme ne doit pas avoir connaissance des aspects, ils ne sont jamais appelés dans les classes du programme. Nous pouvons nous demander comment les aspects sont appliqués sur les programmes ? C’est le but des tisseurs d’aspects. Les tisseurs d’aspects ont pour rôle de greffer l’ensemble des aspects sur l’ensemble des classes du programme. Les tisseurs d’aspects se différentient sur deux points : le langage de programmation utilisé et le moment où le tissage est réalisé ; est ce que le tissage se fait au moment de la compilation ? ou au moment de l’exécution ? Spring AOP fait le tissage au moment de l’exécution tant disque AspectJ, lombok font le tissage au moment de la compilation. On va parler de deux types de tisseurs : les tisseurs statiques et les tisseurs dynamiques.

 

Les tisseurs statiques s’appliquent à la compilation du programme. Le principe est le suivant, un tisseur statique prends en entrée un ensemble de classes métiers et un ensemble d’aspects pour fournir un programme compilé augmenté d’aspects.

 

Les tisseurs dynamiques sont capables d’appliquer les aspects dynamiquement pendant l’exécution du programme. Leur principale atout est leur capacité à ajouter, supprimer ou modifier les aspects à chaud pendant l’exécution du programme, ce qui est très utile pour les serveurs d’applications.

 

 

Les concepts de base de l’AOP

 

  •   Les Point de jonction(JointPoint) :

sont des points du programme autour desquels un ou des aspects ont été greffés. Ils peuvent être référencés par les évènements du programme : au moment de l’appel d’une méthode, greffe moi tel aspects, au moment de l’instanciation d’une classe (appels de constructeurs), greffe moi tel aspect, au moment de l’appel de toutes les méthodes get ou set de la classe, fais-moi çà .les attributs (get, set), au moment de la levée des exceptions, greffe moi tel aspect. La définition des points de jonction se fait en utilisant des expressions régulières pour définir les méthodes concernées. Plusieurs caractères peuvent être utilisés pour définir un filtre sur les classes et les signatures des méthodes.

➜ Le caractère « * » indique n’importe quel caractère sauf le caractère * lui-même.

➜ Le caractère «.. » indique n’importe quelle signature ou sous-package

➜ Le caractère « + » indique n’importe quel sous type.

 

Exemple :

 :

 

  • Les points de coupure(PoinCut) :

désignent un ensemble de point de jonction. Il existe plusieurs types de point de coupure : les coupes d’appels de méthodes désignant un ensemble d’appels de méthodes(Call). Les coupes d’exécution de méthodes désignant l’exécution d’une méthode (exec). Les coupes de modification de données désignant les instructions d’écritures sur un ensemble d’attributs (get, set). La différence entre les coupes d’exécution et d’appels de méthodes est le contexte dans lequel sera le programme. Dans le cas de coupe d’appel de méthodes, le contexte sera celui qui a appelé la méthode. Dans le cas de coupe à l’exécution, le contexte sera celui de la méthode appelée.

 

  •  Les wilcards :

c’est une structure syntaxique qui permet de déclarer une coupe. Les wilcards permettent de définir les points de coupure. Les wilcards ressemblent à des expressions régulières permettant de caractériser un programme. Nous pouvons par exemple, à l’aide du wilcard get*(..) pour définir  l’ensemble de méthode de programme commençant par get. * *..Point.get*(..)

 

  • Les codes advices :

sont les blocs de code qui vont être exécuté par l’aspect. Les codes advices caractérisent le comportement de l’aspect. Chaque code advice doit être associé à une coupe pour être exécuter. Ils ne seront exécutés que si un évènement défini par un point de coupure a été intercepté. Le code advice peut être exécuté selon trois modes : avant, après et autour de d’un point de jonction.

 

  • Les mécanismes d’introductions :

est pour l’orienté aspects ce que l’héritage est pour l’orienté objet car des deux derniers permettent d’étendre la structure et non par le comportement de l’application.

 

 

 

Dans une application classique, toutes les méthodes contiennent du code qui permet de loger des messages en début et en 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. Grâce à 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é par la suite pour doter l’application de cet aspect de journalisation. Nous allons vous proposer dans le prochain de cas comme cas d’usage.

                    

Grâce à l’AOP, le couplage entre le code métier et le code technique peut être réduit de façon très significative. Ceci présente de nombreux avantages : l’amélioration de la qualité du code, gain de productivité et maintenabilité de l’application.

 

 

🐘Merci à Robert pour cet article, vous pouvez retrouvez d'autres articles tech juste ici : https://www.elephant-technologies.fr/les-actualites?news_category_filter%5Bcategory%5D=TECH

 

 

Sources :