Auteur

Abderrazek CHINE

Chef de projet web Java/JEE, expérimenté sur de grands projets norme iso 900x, Abderrazek a découvert le monde Java à la fin des années 90 : JNI (Java Native Interface) et les premières applications JSP. Il a depuis réalisé et dirigé des projets JEE d'envergure (EJB2 et 3, Web Services, Spring  sur Tomcat, JBoss, Weblogic), en particulier chez des éditeurs et des clients institutionnels. Il rejoint Netapsys en octobre 2009 en qualité de chef de projet et intervient pour le compte du Ministère de la Santé.

Fil des billets

Par Abderrazek CHINE, le 28 février 2013
Catégorie : Java J2EE

Améliorez les performances avec Spring-Ehcache: Cache & @Cacheable

Le recours à l'emploi de caches dans nos projets permet d'améliorer significativement les performances.

logo-ehcache.png

Dans ce billet contrairement à celui-ci nous ne codons rien dans la partie métier pour éviter le couplage.

Spring sait rendre les choses simples plus simples et les choses complexes possibles.

Un cache sert à optimiser les accès aux données néanmoins ce n'est la solution miracle à tous les problèmes de performances.

Mais une fois mis en œuvre à bon escient, on se demande comment peut-on s'en passer.

Donc depuis Spring 3.1, implémenter une gestion de cache devient possible sans trop écrire du code.

La démo ci-après, sans aborder les détails d'implémentation de la couche DAO, présente un exemple concret de mise en (EH)cache.

Sachez néanmoins que les illustrations données reposent sur une implémentation basée sur spring-data.

Spring offre une implémentation light de mise en cache qui ne peut satisfaire les besoins de nos projets.

C'est pour cette raison qu'ici nous utilisons Ehcache.

L'annotation @Cacheable de Spring apposée sur les méthodes (finder par exemple) suffit.

L'AOP Spring rend la gestion du cache facile à l'instar des transactions déclaratives.

 
Lire la suite
Par Abderrazek CHINE, le 14 février 2013
Catégorie : Java J2EE

Camel SQL composant: Composant Camel-SQL

Ce billet illustre l'emploi du composant Camel-SQL. camel-logo.png

Dans notre démo le composant camel-sql s'appuie sur une datasource déclarée dans spring.

La démo est réalisée en cinq étapes:

I. CONFIGURER LE POM DU PROJET

II. CONFIGURER SPRING

III. DESSINER LA ROUTE CAMEL

IV. CONFIGURER L'ENVIRONNEMENT

V. TESTER

Passons à la pratique.

 
Lire la suite
Par Abderrazek CHINE, le 04 février 2013
Catégorie : Java J2EE

Améliorez les performances: Parallel processing with Camel & Spring (Partie 1/2)

Ce billet s'inscrit dans la catégorie optimisation des performances.

Il se fixe comme objectif d'illustrer avec démo détaillée comment améliorer significativement les performances de nos projets.

Et cela sans se lancer dans l'aventure d'écrire des kilomètres de code lourd de gestion du 'parallel processing' car nous allons laisser la puissance du framework Camel opérer.

Sachez néanmoins que de nombreux problèmes de mauvaise performance peuvent être traités sans recours aux implémentations complexes de parallélisme.

Voici deux situations où il faudrait réfléchir sur l'apport du parallélisme :

- Si les tâches ou opérations ne prennent que très peu de temps (échelle quelque sec). La gestion/monitoring des threads devient coûteux.

- Si les ressources mémoire, CPU et IO sont déjà fortement utilisées; sachez que le parallélisme consomme davantage de ressources.

Le billet veut s'inspirer (librement) des deux étapes décrites dans la démo du chapitre 10 du livre "Camel in action".

L'essentiel du code source est fourni ici.

Sachez néanmoins que le code présenté ci-après a été largement adapté et pour certaines parties complètement réécrits.

En effet, comme j'utilise Spring, toutes les parties de code sont adaptées ou réécrites en fonction.

En particulier j'utilise l'implémentation spring ThreadPoolTaskExecutor de l'interface TaskExecutor à la place de la méthode statique de Executors de java.

Le billet est organisée en deux parties:

- La première partie permet d'exécuter en séquentiel notre démo,

- La seconde permet adapte la première partie pour une exécution parallèle.

Nous donnons quelques indications sur le temps d'exécution de chacune des parties.

Avec les bons paramètres nous pouvons diviser par quatre le temps d'exécution voire plus.

Le framework Camel offre avec son java DSL des fonctions permettant d'obtenir simplement de meilleurs performances en parallélisant les tâches.

Comme d'habitude nous le combinons avec le framework Spring v3+ car peut-on faire autrement?

Dans le domaine de performance, il est utile d'identifier les deux limites: CPU-bound et IO-bound.

Distinguer ces deux limites permet d'identifier le bon choix pour améliorer les performances.

En guise de conclusion, dans le domaine d'exécution parallèle, Camel simplifie grandement la vie des développeurs.

Néanmoins, il leur reste la responsabilité de la cohésion des données.

Passons à la mise en pratique.

 
Lire la suite
Par Abderrazek CHINE, le 28 janvier 2013
Catégorie : Java J2EE

Spring parallel processing. Exécution parallèle avec Spring

Ce billet tente de démystifier l'utilisation en java5+ des exécutions en parallèle des tâches (parallel processing) en s'appuyant sur les classes de Spring qui masquent les difficultés du parallélisme en java.

Les machines de nos jours viennent avec plusieurs processeurs: des multi-core (quatre, huit ou plusieurs centaines cœurs).

Or la puissance de ces ressources n'est pas constamment utilisée.

L'exécution parallèle autorise des calculs parallèles qui consomment ces ressources pour améliorer les performances.

Mais c’est comme tout, le parallélisme ça se mérite. Même si c'est un petit chouia difficile!

En réalité, la difficulté n'est pas dans la mise en place technique mais réside dans la gestion de la cohésion des données.

Techniquement, c'est le développeur qui doit réaliser les calculs parallèles.

C'est sûr, demain apparaîtront côté JVM les méthodes de traitement du parallélisme comme c'était le cas de la gestion mémoire avec le garbage collector ou récemment la gestion des descripteurs de fichier avec try/catch en java7.

Java 8+ nous proposera (peut-être) de faire le calcul paralléle à notre place (nous développeurs).

Ce qui reste au développeur c'est de décrire les traitements atomiques (comme l'atomicité dans les transactions), et à partir de là c'est la JVM qui mène le traitement global parallélisé efficacement en fonction des ressources disponibles.

Bel enjeu de demain.

Signalons que nous n'utilisons pas directement la classe Executors de java qui offre des méthodes statiques pour instancier un Executor ou un ExecutorService.

A la place nous utiliserons les classes de Spring.

La démo ci-après est faite en java7 et spring 3.

Passons à la mise en pratique.

 
Lire la suite
Par Abderrazek CHINE, le 22 janvier 2013
Catégorie : Java J2EE

Composant Camel-Bindy: Comment transformer les données non structurées

On s'intéresse ici au composant 'camel-bindy' qui permet de transformer des données non structurées (csv par exemple) en objets java et inversement.

La démo est réalisée en quatre actes: configurer le pom du projet, dessiner et déclarer la route, annoter le bean du model et enfin tester.

la v2.10.2 de camel-bindy est utilisée.
camel-logo.png

Voici les détails de la démo.

 
Lire la suite
Par Abderrazek CHINE, le 09 janvier 2013
Catégorie : Java J2EE

Bean validation avec camel: Composant camel-bean-validator

L'objet de ce billet est de présenter la validation (jsr303) avec le composant camel-bean-validator.

camel-logo.png

Ce composant permet de valider des pojos ou beans annotés.

Deux démos sont fournies. La seconde un peu plus avancée.

Chaque démo est un projet maven réalisée en trois actes:

- Configurer la pom,

- Annoter le bean,

- Tester avec JUnit.

Voici dons les étapes.

 
Lire la suite
Par Abderrazek CHINE, le 04 janvier 2013
Catégorie : Java J2EE

Camel, Spring et tests JUnit pour les nuls (partie 1/3)

L'objet de ce billet est d'expliquer l'essentiel de Apache Camel avec Spring et accompagné de tests JUnit.

camel-logo.png Apache Camel est un framework puissant implémentant les patterns EIP (Enterprise Integration Patterns).

Apache Camel permet l'échange, le routage et la transformations des données avec une variété de protocoles et connecteurs.

L'architecture de Camel basée sur des composants pluggables. Il offre une panoplie de composants intégrables avec facilité à nos projets web ou non.

Apache Camel n'est pas réservée à des applications Client/Serveur, des Webservices ou des échanges JMS (Java Messaging Service).

En pratiquant Camel, on découvre que c'est un couteau suisse fort utile.

Les démos ci-après, projets java standards, aident à la prise en main rapide de Camel.

La dernière démo introduit néanmoins des notions avancées de Camel.

Chacune des démos de ce billet est organisé en trois actes :

- Acte 1: Dessiner une route Camel,

- Acte 2: Configurer Camel dans Spring,

- Acte3: Tester avec Junit

Camel v2.10, Spring v3.x et Java 7 sont utilisés bien que java 5 devrait suffire.

Les mots clés de ce billet sont : Camel, EIP, route, processor, exchange, body, header, spring, encodage, test JUnit.


Passons à la mise en pratique.

Lire la suite
Par Abderrazek CHINE, le 03 janvier 2013
Catégorie : Java J2EE

Lecture des proriétés: Simplifiez vous la vie avec Spring!


L'objectif de ce billet est triple:

a) Lire une valeur de propriété depuis un fichier .properties,

b) Lire les valeurs des JVM/System properties,

c) Surcharger les valeurs de propriété avec des JVM/SYSTEM properties ?

spring-mini-logo.png

Tout projet quelque soit sa nature repose sur un ou plusieurs fichiers de propriétés configurés aussi pour i18N.

Et dans ce domaine, encore une fois, Spring 3 avec ses nouveautés confirme l'adage:

Spring rend les choses simples simples et les choses complexes possibles

La version Spring 3.1 ou + est nécessaire et Java 5+.

Les exemples donnés ci-après ont été testés sous Win/java7. Le code des exemples sera fourni en fin de billet.

Passons à la mise en pratique.

 
Lire la suite
Par Abderrazek CHINE, le 02 janvier 2013
Catégorie : Java J2EE

Déclaration des listes et des maps en java: Simplifiez vous la vie avec Spring

L'objectif de ce billet est double:

1) Illustrer l'utilisation du namespace util: dans spring pour déclarer des listes / maps.

2) L'utilisation de @Resource (et non @Autowired) pour injecter ces listes / maps.

Encore une fois, l'adage Spring makes simple things simple, and complicated things possible se confirme.

spring-mini-logo.png

Passons à la pratique.

 
Lire la suite