Étiquette : Spring

DEVOXX France 2017 : le débrief

devoxx

Les présentations se sont enchaînées lors du DEVOXX France 2017.

Nous avons participé au Devoxx France 2017 qui s’est déroulé du 5 au 7 avril 2017. Dans cet article, nous allons vous présenter quelques conférences intéressantes que nous avons pu suivre. Ces retours sont basés sur notre compréhension personnelle, chacun est accompagné de la présentation YouTube. Libre à vous de les regarder pour vous forger votre propre opinion !

 

PRÉPAREZ-VOUS A LA MODULARITÉ SELON JAVA 9 youtube

Alexis Hassler twitter ET Remi Forax

Cette université de 3h portait sur le projet Jigsaw de Java 9. Il est censé régler les problèmes de dépendances et classpath (en le remplaçant par un module path), les problèmes de librairies présentes dans différentes versions dans le classpath… Cela a permis un découpage du JDK pour pouvoir le distribuer sans forcément tout inclure, juste le nécessaire. Pour les librairies externes aussi, par exemple si on veut juste la partie injection de dépendances de Spring, cela pourra être un jar de quelques kilos au lieu de quelques mégas aujourd’hui.

La config des modules de nos applications va passer par la définition de fichiers « module descriptor » qui vont spécifier notamment quels packages exposer aux autres modules et quels modules importer. Dorénavant, les classes publiques ne le seront plus pour toute l’application, mais uniquement pour le module. Avec ceci, Java 9 va passer également pas mal d’API en deprecated. A partir de maintenant et des prochaines versions, il va avoir du ménage et des deprecated seront supprimés, il faut s’attendre à pas mal de breaking changes potentiellement.

Une bonne partie de la conférence était ensuite de migrer une appli en Java 8 vers Java 9 en la découpant en modules. A noter qu’un bypass de cette utilisation par module sera possible pour inclure d’anciens jar par le biais d’un classpath dédié, de façon à pouvoir toujours utiliser d’anciennes librairies qui ne migreraient pas sous ce style d’architecture.

 

TENSORFLOW ET L’APPRENTISSAGE PROFOND, SANS LES ÉQUATIONS DIFFÉRENTIELLES youtube

Martin Görner twitter

Le but de cette université était de présenter le framework Tensorflow, rendu opensource par Google. Il s’agit d’un framework qui permet de manipuler des réseaux de neurones « simplement » (ou en tout cas plus simplement que ce que cela pouvait l’être jusqu’à maintenant). La conférence a été illustrée par deux exemples qui ont permis de présenter pas mal de fonctionnalités et fonctions mathématiques intégrées au framework.

Le premier exemple était la reconnaissance de chiffres. Il y avait un jeu de données de plus de 60 000 chiffres écrits de façon manuscrite que le réseau devait reconnaître au mieux. Nous allons écrire quelques principes qui ont été décrits, mais pour l’explication assez complexe il faudra regarder la rediffusion de la conférence ! Malgré le fait que le conférencier a bien vulgarisé les principes, cela reste assez dur à retranscrire.

Il a évoqué les matrices multidimensionnelles, les fonctions Softmax, Sigmoid et RELU (Rectified Lineara Unit), la cross entropy, l’algorithme d’optimisation gradient descent, la fonction de régularisation Dropout… Les réseaux convolutionnels ont aussi été évoqués, ainsi que les réseaux récursifs. Ces derniers sont très puissants et permettent de mettre en relations des couches de réseaux de neurones afin d’analyser plus finement les données. A la moitié de la conférence, nous sommes arrivés à un taux de reconnaissance des chiffres de plus de 96%, avec seulement une trentaine de lignes de code.

Le deuxième exemple était de faire intégrer l’ensemble des oeuvres de Shakespeare à un réseau récursif, afin de générer de nouveaux textes. L’oeuvre qui a été générée en live était assez impressionnante, avec des actes, des personnages inventés, des dialogues… En regardant de plus près l’ensemble du texte n’avait pas vraiment de sens, mais on arrive à un résultat assez cohérent sur la structure, l’agencement des mots, etc. Le même principe avait d’ailleurs été appliqué aux oeuvres de Rembrandt, suite à quoi un réseau neuronal avait produit une peinture totalement inédite de cet artiste, respectant l’époque, sa manière de peindre, … On en vient à se demander si on peut considérer cette oeuvre comme un original de Rembrandt ou non.

Ces systèmes sont également utilisés de nos jours pour Google Traduction, la reconnaissance d’images, bientôt la médecine pour détecter des cancers… et bien d’autres domaines.

 

JAVA 8, C’EST BIEN. JAVASLANG, C’EST MIEUX youtube

Mathieu ANCELIN twitter

Cette conférence avait pour but de présenter la librairie Javaslang et son avantage par rapport aux API standards de Java 8. Cela a été fait sous la forme d’une démo de refactoring d’une application.

La librairie présente des fonctionnalités utilisées telles que des List.of ou HashMap.of pour instancier facilement des collections avec des données. On peut noter aussi un type Either<Trowable, Objet> qui permet à une fonction de retourner soit son résultat attendu soit l’erreur qui s’est produite. Il y a également des fonctionnalités pour faciliter l’utilisation des streams, qui permettent, entre autres, de se passer des collectors. A noter que toute collection de Javaslang peut être transformée en collection classique avec une méthode .toJavaList().

 

JAVA 9 MODULO LES MODULES youtube

Jean-Michel Doudoux twitter

Cette présentation consistait à lister les nouveautés de Java 9, sans parler du projet Jigsaw et ses modules. On va avoir :

  • Des try with ressources plus concis.
  • Les opérateurs diamants seront possibles sur les classes anonymes.
  • Les interfaces pourront avoir des méthodes privées.
  • Des factory seront disponibles pour créer des collections immuables.
  • De nouvelles méthodes seront disponibles sur les streams, comme les takeWhile et dropWhile, ou encore les Stream.ofNullable.
  • L’organisation des fichiers du JDK va changer, le JRE et le JDK ne seront plus séparés comme avant.
  • L’utilisation de java en ligne de commande supportera les options standards GNU.
  • Les jar pourront contenir plusieurs releases d’une même librairie.
  • L’outil jshell sera disponible pour avoir une console Java et exécuter des bouts de code.
  • Certains outils du JDK seront retirés, comme le rt.jar et tools.jar.
  • Les numéros de version du JDK auront un nouveau format, de type MAJOR.MINOR.SECURITY.PATCH, par exemple 9.2.3.1.
  • Les objets String prendront moins de place en mémoire.
  • L’outil jdeprscan permettra de scanner nos projets pour savoir si on utilise des API deprecated.
  • L’API StackWalker pour une meilleure lecture des stacks d’erreurs, mieux filtrées et plus claires.

 

LE STREAMING D’API : POURQUOI ET COMMENT TRANSFORMER VOS APIs STATIQUES EN DONNÉES EN TEMPS RÉEL ? youtube

Audrey Neveu twitter

Cette présentation consistait à présenter les différentes méthodes disponibles pour faire des API utilisables en streaming :

  • Long polling : à bannir car il bloque le client et la communication n’est que dans un sens. Une nouvelle connexion est créée à chaque fois, on a aucune idée de si une requête est nécessaire, si les données sont changées ou pas.
  • Webhooks : l’utilisateur renseigne au service l’URL qu’il doit appeler. Cela est assez contraignant, compliqué à debugger et ne fonctionne pas sur smartphone.
  • Websockets : la communication est bidirectionnelle et réalisée en binaire. Le client redémarre la connexion si elle est perdue. Un point négatif est la méthode de connexion un peu particulière qui peut nécessiter de devoir reconfigurer les firewalls. Cette méthode est généralement plus utilisée pour les chats et jeux vidéos.
  • Server Sent Event (SSE) : les performances sont meilleures mais la communication est unidirectionnelle (le serveur push les données au client). Cela fonctionne par le protocole HTTP standard. Pas de support par IE ni Edge mais des polyfills existent.

La présentation s’est terminée par l’utilisation d’une api SSE connectée au cours du Bitcoin et à un drone sur scène afin de le faire décoller ou atterrir en fonction de ce cours.

SPRING FRAMEWORK 5.0 youtube

Stéphane Nicoll twitter

La présentation a fait un petit overview de la nouvelle version de Spring à venir. La RC est disponible et la finale sortira légèrement avant Java 9.

Les performances de démarrage ont été grandement améliorées. Certains cas montrent un démarrage en 100ms au lieu de 6s, cela grâce à une meilleure gestion du contexte. Avant les classes étaient scannées au démarrage pour analyser toutes les annotations, maintenant cela est fait à la compilation en gardant un fichier mapping. Java 9 sera bien sûr supporté, ainsi que le protocole HTTP 2 et le langage Kotlin. Le framework pourra fonctionner avec une programmation Reactive de bout en bout. Il sera ainsi possible d’appeler une API qui streamera directement le contenu de la base en un flux infini (ou pas) de données, et non plus attendre que toutes les données soient transmises d’un coup. Des types Flux et Mono ont été ajoutés pour cela.

Les API pourront également être utilisées en mode fonctionnel et non plus forcément par annotations.

 

10 MÉTHODES POUR RENDRE HEUREUX LES DÉVELOPPEURS, LA 7EME VA VOUS ÉTONNER ! youtube

Cyril Lakech twitter ET Romain Linsolas twitter

Un développeur de chez Axa et un de la Société Générale nous ont parlé de leur vision pour rendre les développeurs heureux en entreprise. Il faut pour eux :

  • Investir dès le recrutement, ne pas mentir au candidat, parler de code avec lui pour savoir si les pratiques de l’entreprise correspondent à ce qu’il attend… Pourquoi pas l’intégrer une demi journée à l’équipe, parler de la culture, la vision, etc.
  • Proposer une perspective de carrière pour que les développeurs restent plusieurs années. Ne pas être toujours dans le rush, prévoir du temps pour qu’ils puissent apprendre, découvrir de nouvelles choses.
  • L’environnement est important. L’Open Space est déconseillé, ou il faut en tout cas mettre à disposition des bureaux flexibles (endroits pour s’isoler), des espaces de détente, des bureaux adaptés aux envies de chacun (debout ou assis). Un bon matériel et de bons logiciel sont aussi importants pour ne pas être frustré, permettre le télétravail.
  • Organiser son travail, découper en petites équipes, feature teams, devops.
  • Software Craftsmanship : bien concevoir le logiciel, penser à la valeur ajoutée de chaque évolution, faire des codes review, du pair programming.
  • Avoir une ouverture technologique.
  • Faire plaisir aux développeurs ce n’est pas que le café gratuit, les pizzas, les nerfs, le baby-foot… Tout ceci est juste un plus et il ne faut pas perdre de vue le reste. Les autres sociétés proposent la même chose et les autres éléments de cette liste vont aussi être déterminants.
  • S’organiser en communauté, pouvoir trouver de l’aide dans les équipes et se rendre utile en aidant les autres.
  • Contribuer à l’open source. Cela permettra de continuer l’apprentissage, de recevoir des critiques constructives et de s’améliorer.
  • Participer aux événements, Devoxx, Meetups, BBL, hackatons (1 à 3 jours), conférences interne, sponsoring d’événements… Toujours dans un but d’apprentissage, d’ouverture d’esprit.
  • Valoriser les développeurs pour qu’ils puissent apprendre tout le temps.

 

SOYEZ HOLOGRAPHIQUE ! youtube

Michel Rousseau twitter

Présentation des HoloLens par Microsoft. Très beau produit, unique en son genre qui permet une projection (et non un affichage) d’hologrammes sur des « lunettes ». L’orientation du produit est plus professionnelle pour l’instant et permet par exemple à un mécanicien d’avoir les plans d’une voiture sous les yeux en permanence, de faire des appels Skype… L’avantage ici est vraiment d’avoir des hologrammes qui se superposent au réel et qui enrichissent le quotidien. Le « casque » capte son environnement grâce à la même technologie qui avait été utilisé dans Kinect et il est complètement indépendant (environ 2h30 d’autonomie), il intègre CPU, GPU, RAM, DD, …

Il est cependant très cher : 3299€ pour l’édition de dev, 5499€ pour l’édition commerciale.

La conférence s’est finie avec la présentation d’un nouveau concept en cours de recherche par Microsoft. Il s’agit « simplement » de pouvoir afficher l’hologramme d’une autre personne, dans la pièce où vous êtes. Ils ont appelés ça l’Holoportation et cela ressemble très fortement à ce qui est montré dans les films Star Wars… C’est encore en développement et cela nécessite notamment une dizaine de Kinect dans toute la pièce pour fonctionner !

 

UNE APPLICATION QUI VOIT, ENTEND ET RÉPOND youtube

Christophe Jollivet twitter ET Mickael Debonnaire twitter

Cette présentation montrait comment construire simplement une application utilisant les dernières avancées en terme d’intelligence artificielle. Pour cela quatre services nous ont été présentés :

  • Beta face pour faire de la reconnaissance d’image, et de visages plus précisément.
  • Speech recognition afin de transformer en texte ce que dit l’utilisateur à voix haute.
  • Api.ai pour reconnaître ce texte et faire des actions en fonction de ce que demande l’utilisateur.
  • Les APIs standards des OS pour générer de la voix et répondre à l’utilisateur.

 

PATTERN MATCHING EN JAVA (10 ?) youtube

Remi Forax

Cette présentation nous a donnée un aperçu de ce qui est dans les chantiers pour Java et ce qui pourrait être intégré à la version 10 ou plus. Les trois projets les plus important ont été détaillés.

  • Valhalla, apportant les Value Types et la Generic Specialization.
  • Panama, pour pouvoir manipuler plus facilement le code natif, notamment pouvoir appeler des fonctions C/C++ depuis la JVM.
  • Amber, apportant l’inférence des types. On pourra faire var name = « Julien » au lieu de String name = « Julien ». Les énumérations sont améliorées avec la possibilité de les rendre génériques. Les lambdas seront améliorées avec quelques idées qui avaient été laissées de côté. Des classes « data » qui permettraient de pouvoir juste déclarer les champs, le compilateur générera les accesseurs et constructeurs. Le Pattern Matching pourra également être de la partie.

Une bonne partie de la présentation était dédiée à ce dernier, avec une proposition de l’implémentation future possible. Il permettrait d’améliorer grandement les switch et de se passer des if-else-if-else-if à la chaine.

 

DE BRONZE A LÉGENDAIRE, COMMENT RÉUSSIR VOS IA DE BOTS youtube

Grégory Ribéron twitter

La présentation était vouée à nous expliquer comment créer des IA de bots efficaces qui peuvent atteindre le top 100 sur des sites tels que CodinGame. L’essentiel est de progresser pas à pas, bien comprendre l’énoncé, mapper correctement les mécanismes du jeu, regarder notre bot jouer, s’inspirer des autres…

Une des techniques est notamment l’utilisation d’algorithmes génétiques, qui permettent de prévoir certaines issues du jeu et ainsi corriger le comportement du bot en temps réel.

 

RECETTES, OUTILS, API ET SERVICES POUR CONSTRUIRE SON EQUIPE OU SA STARTUP youtube

Nicolas Martignole twitter

Trois maîtres mots pour le conférencier : rapidité, transparence et intensité.

On dénombre certains outils et/ou api externes pour simplifier la vie des codeurs et de l’entreprise. Cela passe par des outils de gestions de mail avec Mailjet et Mailgun.
Un point était axé sur la sécurité avec la gestion de double authentification et les réinitialisations de mot de passe par sms.
Egalement le monitoring de services avec des scénarios pour la gestion des temps de traitements avec Runscope.

Puis un gros point sur la communication interne et externe avec des outils performants de live chat pour augmenter la réactivité comme Slack et ses différents modules connectés (runscope, jenkins, etc).

 

JUnit-Docker youtube

Xavier Detant twitter ET Vincent Demeester twitter

Présentation rapide de la libraire JUnit-docker pour JUnit 5. Elle permet grâce à des annotations de lancer des conteneurs au démarrage d’une suite de tests. Plusieurs options sont disponibles, notamment pour spécifier l’image à démarrer et les ports à exposer. Le conteneur peut être redémarré pour chaque test ou réutilisé pour l’ensemble.

 

Log me Tender youtube

Olivier Croisier twitter

Discussion intéressante sur la mise en place d’une couche de service pour gérer les logs au sein d’une application. Cela permettrait de faire évoluer tout un log orienté métier avec des précisions comme les horaires de démarrage et fin, la durée, etc.. Tout ceci par la modification d’une seule méthode appelante. Cela permettrait également d’utiliser du java 8 dans le traitement de la couche de log car actuellement Log4j n’est pas migré et donc pas d’utilisation possible de lambda par exemple.

 

Introduction au framework Grails

Grails_logo

 

L’objectif de cet article et de ceux à venir est de vous présenter les avantages que peut vous apporter le framework Grails. Pourquoi, quand et comment l’utiliser ? Nous verrons cela par la suite.

 

 

Présentation de GRAILS

 

Grails est un framework web open source, de développement rapide, basé sur le langage Groovy, lui-même basé sur le langage Java.

Il utilise plusieurs principes qui permettent une haute productivité :

– Don’t Repeat Yourself (DRY) : le framework est basé sur le modèle MVC.

– Convention plutôt que configuration (Convention over configuration ou coding by convention) : Grails propose de nombreux comportements par défaut, vous n’aurez presque rien à configurer lors du développement de votre application. Par exemple, une classe dont le nom termine par « Controller » sera automatiquement considérée comme un contrôleur web.

– Architecture orientée modèle : pour réaliser une application basique, vous aurez uniquement à vous préoccuper de vos modèles. Les vues, les contrôleurs et les tests seront générés.

– Prototypage : Grails vous permet de générer vos vues, contrôleurs et tests à partir de vos modèles grâce à des méthodes de scaffolding. Vous pouvez ainsi obtenir une application de CRUD très rapidement. Vous pouvez également créer vos propres templates pour ajouter des fonctionnalités à la génération, ou simplement modifier l’apparence de votre application.

– Plugins : de nombreux plugins sont disponibles pour Grails. Ils vous permettront d’implémenter rapidement des fonctionnalités, telles que l’authentification avec le plugin Spring Security Core.

 

Historique

 

Le développement de Grails a été débuté en juillet 2005 par Graeme Rocher. Le framework était alors connu sous le nom de “Groovy on Rails”, car inspiré de “Ruby on Rails”. La première version (0.1) a été publiée le 29 mars 2006. Le même mois, il est renommé en “Grails” sous la demande du créateur de Ruby on Rails, David Heinemeier Hansson. Les principales versions suivantes sont:

 

[table id=1 /]

 

Peu après la sortie de la version 1.0, la société G2One (The Groovy Grails Company) est rachetée en novembre 2008 par SpringSource, elle-même rachetée en août 2009 par VMware.

 

Architecture

 

Grails utilise de nombreuses technologies existantes. Les principales sont :
– Le langage Groovy
– Hibernate
– Spring
– Sitemesh pour gérer la mise en page
– Le célèbre système de logging Log4J
– JUnit pour les tests unitaires

Celles-ci sont organisées comme montré ci-dessous :

architecture_grails

 

Toute application Grails est organisée en quatre parties : les domaines (les modèles), les services, les contrôleurs et les vues. Nous verrons plus en détail cette organisation par la suite avec un exemple d’application.

Les vues sont gérées par le framework SiteMesh, permettant notamment de créer des layouts, tandis que le cœur de Grails est géré par le framework Spring. La persistance des données est facilitée par GORM (Grails Object Relational Mapping). Celui-ci est basé sur Hibernate et utilise par défaut sa base de données intégrée HSQLDB, il permet de faire la relation entre les domaines et la base de données. Nous le verrons plus en détail dans un article suivant. Gant quant à lui est basé sur Ant, il sera utilisé notamment lorsque nous exécuterons une commande pour gérer Grails telle que « grails run-app ».

Pour terminer, tout objet de votre application pourra être développé soit en Java soit en Groovy. Dans les deux cas, votre objet sera compilé en bytecode et exécuté par la JVM.

 

Installation

 

Nous allons maintenant voir comment mettre en place un environnement de développement pour utiliser Grails.

Avant de commencer, il faut bien évidemment avoir installé un JDK (en version 1.6 ou supérieure), avoir configuré la variable d’environnement JAVA_HOME, pointant vers le dossier d’installation de votre JDK, et avoir ajouté le dossier bin/ du JDK à votre variable PATH.

Il existe plusieurs solutions pour utiliser le framework Grails. La première, la plus simple, consiste à télécharger l’IDE Groovy/Grails Tool Suite (GGTS). Il s’agit d’un environnement de développement basé sur Eclipse, tout comme Spring Tool Suite (STS). Il vous suffit ensuite d’extraire l’archive téléchargée, et de lancer GGTS.

Si vous possédez déjà STS, vous pouvez facilement installer le plugin Grails en suivant ces directives.

Si vous souhaitez utiliser Grails avec un autre IDE comme IntelliJ IDEANetBeans ou TextMate, nous vous laissons consulter la documentation officielle à ce propos.

 

Conclusion

 

Après cette présentation, vous pouvez déjà apercevoir les avantages que peut fournir Grails. Il utilise le langage moderne Groovy, le réputé framework Spring, de nombreux plugins, le principe de « coding by convention », le prototypage… Il s’agit d’un framework bien adapté au développement très rapide d’applications basiques, vous laissant en même temps la possibilité de réaliser des fonctionnalités bien plus avancées que du simple CRUD.

Dans les prochains articles, nous verrons plus en détail le fonctionnement du framework par un exemple d’application.

 

Sources

http://grails.org/

http://en.wikipedia.org/wiki/Grails_(framework)

http://www-igm.univ-mlv.fr/~dr/XPOSE2009/Groovy_and_Grails/grails_architecture.php

Caches applicatifs avec Spring et ehcache

La recherche de performances applicatives passe souvent par la mise en place de caches applicatifs.

Ces caches permettent de maintenir en mémoire les données souvent requêtées par les utilisateurs mais peu mises à jour (paramétrages, villes, …).
Spring offre la mise en place d’un tel cache assez facilement par l’intégration d’un framework tel que ehcache.

Dans le fichier configuration de Spring on ajoute les lignes suivantes :

<ehcache:config failQuietly="false" />
<ehcache:annotations>
<ehcache:caching id="test" cacheName="testCache" />
<ehcache:flushing id="test" cacheNames="testCache" when="after" />
</ehcache:annotations>

Dans le fichier configuration de ehcache.xml, on retrouve la définition du cache : nombre d’objet en cache, écriture sur disque, politique d’éviction,…Le cacheName et ce que l’on va retrouver dans le fichier de configuration de ehcache,
L’id et ce que l’on va retrouver dans l’annotation,
caching l’id est utilisé pour la mise en cache,
flushing l’id est utilisé pour la libération du cache.

<cache name="testCache" maxElementsInMemory="1000"overflowToDisk="true" eternal="true" memoryStoreEvictionPolicy="LFU"/>
On ajoute les annotations suivantes dans le source Java afin de les mettre en cache après le premier appel :
@CacheFlush(modelId = "test")

public String saveObject(Object objet) {…}

 

@Cacheable(modelId = "test")

public User findObject(String idObject) {…}

Gestion des logs

Au sujet de la gestion des logs

La gestion des logs est un sujet qui est souvent sous estimé de la part des équipes de développement. Avec l’utilisation des outils de développement moderne et leur débugger intégré, les logs applicatives ont bien moins d’intérêts au moment du développement. Par contre, lorsque l’application est testée ou déployée, les logs reprennent tout leur sens.

L’apparition de framework Java tels que Log4J ou celui intégré au JDK facilite grandement la vie du développeur, mais l’écriture de logs reste toujours à la discrétion de ce dernier.

L’AOP (Programmation Orientée Aspect) apporte une réponse à cette problématique. Nous pouvons grâce à celle-ci générer des logs à chaque entrée/sortie de méthode et à chaque levée d’exception. Voici un exemple d’implémentation de gestion des logs utilisant Spring et Spring AOP :

Nous définissons tout d’abord un greffon (advice) qui implémente MethodBeforeAdvice, AfterReturningAdvice et ThrowsAdvice. Ceci nous permet de redéfinir les trois méthodes before, afterReturning et afterThrowing afin de générer les logs à chaque entrée/sortie de méthode et à chaque levée d’exception.

package com.viaxoft.ext.logging;

import java.lang.reflect.Method;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.aop.ThrowsAdvice;

public class LoggingAdvice implements MethodBeforeAdvice, AfterReturningAdvice,
ThrowsAdvice {
private static Log logger = null;

public LoggingAdvice() {
}

public void before(Method arg0, Object[] arg1, Object arg2)
throws Throwable {
logger = LogFactory.getLog(arg2.getClass());
logger.info("Entrée dans la méthode : " + arg0.getName());
}

public void afterReturning(Object arg0, Method arg1, Object[] arg2,
Object arg3) throws Throwable {
logger = LogFactory.getLog(arg3.getClass());
logger.info("Sortie de la méthode : " + arg1.getName());
}

public void afterThrowing(Method m, Object[] args, Object target,
Throwable ex) {
logger = LogFactory.getLog(target.getClass());
logger.error("Exceptiondans la méthode : " + m.getName() + " L'exception : "
+ ex.getMessage());
}
}

Nous devons ensuite définir notre aspect sous forme de bean au sein du fichier de config Spring. Nous utilisons l’implémentation RegexpMethodPointcutAdvisor qui nous permet de matcher les méthodes sur lesquelles notre aspects doit s’appliquer grâce à une expression régulière :

<bean id="loggingAdvisor"   class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<property name="advice" ref="loggingAdvice" />
<property name="patterns" value=".*" />
</bean>

A noter ici que nous générons la log pour toutes les méthodes. On pourrait imaginer générer plusieurs niveau de log (DEBUG, INFO, …), en fonction de la méthode à laquelle on s’adresse ; par exemple les méthodes du layer DAO seraient en DEBUG, alors que celles de la couche service en INFO.

L’implémentation RegexpMethodPointcutAdvisor permet de définir à la fois l’aspect et la coupe au sens AOP.

Nous définissons également le greffon :

<bean id="loggingAdvice"
class="com.viaxoft.ext.logging.LoggingAdvice">
</bean>

Il ne nous reste plus ensuite qu’à tisser les aspects. Nous utilisons DefaultAdvisorAutoProxyCreator pour un tissage automatique :

<bean   class="org.springframework.aop.framework.autoproxy.
DefaultAdvisorAutoProxyCreator" />

Le résultat dans le fichier de log :

juin 06 08:54:25 INFO iaxoft.dao.impl.AddressDaoImpl before Entrée dans la méthode: saveAddress
juin 06 08:54:25 INFO ernate.impl.SessionFactoryImpl before Entrée dans la méthode: openSession
juin 06 08:54:25 INFO ernate.impl.SessionFactoryImpl afterReturning Sortie de la méthode : openSession
juin 06 08:54:25 INFO ernate.impl.SessionFactoryImpl before Entrée dans la méthode: getTransactionManager
juin 06 08:54:25 INFO ernate.impl.SessionFactoryImpl afterReturning Sortie de la méthode : getTransactionManager
juin 06 08:54:25 INFO iaxoft.dao.impl.AddressDaoImpl afterReturning Sortie de la méthode : saveAddress
Loading...
X