Technologies et Applications d'entreprise

Java/Jee XML Webservices SOA

Posted on by Rabii


Mockito , EasyMock ou PowerMock ?

 

 

Les tests  sont une phase très importante dans les cycles de développement et de maintenance de l'application. Ils permettent de détecter des anomalies et de s'assurer que l'application est conforme au spécifications.

La mise en œuvre de ces tests peut se faire facilement via plusieurs frameworks comme Mockito, cet article vous présente les avantages et les inconvénients de cet outil. Vous pouvez trouvez avec une comparaison est disponible avec EasyMock.

J'ai pu utiliser EasyMock avec PowerMock dans quelques projets.
 Le code est  assez complexe à appréhender, mais ça reste un bon investissement
Apparemment  Mockito permet de gagner quelques lignes de code. Vous pouvez trouver un bon comparatif  ici

Posted on by Rabii | Posted in Java, JEE | Tagged , , ,


Posted on by Rabii


On peut trouver beaucoup de tutoriaux de spring AOP avec l’exemple de logger.
Mais, quelque part,cette  exemple était peu déroutant pour les nouveaux arrivants. Alors, je vais vous présenter ici un exemple qui explique comment utiliser Spring AOP pour le profilage de temps d'exécution d’une fonction. L’exemple servira aussi pour  connaitre simplement le temps d’exécution de certains de vos fonctions si vous avez pas accées à JProfiler ou autres outils de profilage. Si vous voulez connaitre les principes fondamentaux de l’aop je vous invite à lire l’article : “AOP Concepts et implémentations

Utilisation de spring AOP pour profiler le temps d’exécution d’une fonction

L'exemple  est très simple - notre application a une classe métier avec une fonction implémentant le métier. Nous allons profiler le temps d’exécution de la fonction .
Le profilage (profiling) est un bon exemple pour les  préoccupation transversales de l’application.
L'utilisation de spring AOP est un bon choix pour l’implémenter. On verra par la suite étape par étape l’implémentation de notre exemple.

Environnement et structure de projet

Lancez votre IDE  préféré IDE (j'utilise Eclipse Helios) et Créer un nouveau projet Java. Et puis créer la structure comme indiqué ci-dessous.

Vous aurez besoin de télécharger tous les jar qui sont dans Referenced Libraries et les ajouter au classpath. Vous pouvez trouver ces jar ici: Spring, Commons-logging, aspectjrt, aspectjweaver. Aussi, noter que le fichier Metier.java est une interface.

Vous pouvez télécharger les sources de projet ici.

La Logique métier

Nous allons commencer par écrire notre logique métier et ensuite nous allons ajouter Spring AOP pour profiler notre fonction métier. Ouvrez l’interface Metier.java et copier le code ci-dessous :


package com.soat.spring.aop.demo;

public interface Metier {

void jeTravaille();

}

Maintenant, ouvrez le MetierImpl.java et copiez-y le code ci-dessous :

package com.soat.spring.aop.demo;

public class MetierImpl implements Metier {

public void jeTravaille() {

System.out.println("== Je commence le travaille ..");
try {
// traitements métiers
System.out.println(" .... traitements metiers .... ");
Thread.sleep(3500);
} catch (InterruptedException e) {
System.out.println("Erreur");
}
System.out.println("== Travaille finie");

}

}

Ce code est assez explicite. Notre méthode dort juste pour quelques  secondes et  affiche un texte sur la console.

Un aspect spring pour profiler notre fonction

Écrivons maintenant un aspect qui va profiler notre fonction “jeTravaille ()”. On va utiliser le greffon @ Autour ( advice en anaglais) (Perdu dans le jargon ? Spring AOP basics ). Ouvrez le fichier MetierProfiler .java et copiez y le code ci-dessous :


package com.soat.spring.aop.demo;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class MetierProfiler {

        @Pointcut("execution(* com.soat.spring.aop.demo.*.*(..))")
        public void fonctionMetier() { }

        @Around("fonctionMetier()")
        public Object profile(ProceedingJoinPoint joinPoint) throws Throwable {
                long debut = System.currentTimeMillis();
                System.out.println("//Apelle de la fonction ...");
                Object sortie = joinPoint.proceed();
                System.out.println("//Fonction executee avec succees");
                long tempsPasse = System.currentTimeMillis() - debut;
                System.out.println("Temps d'exécution de la fonction: " + tempsPasse + " milliseconds.");
                return sortie;
        }

}

Voici ce que ce code fait :

  1. Utilisation de l’annotation @AspectJ pour  déclaré que cette classe est un aspect.
  2. En utilisant l'annotation @Pointcut, nous avons défini une “pointcut” qui correspondent à l'exécution de toutes les méthodes publiques appartenant au package com.soat.spring.aop.demo [ point de coupure]
  3. Utilisation de l’annotation  @Around pour définir un greffon qui sera appelée avant et après notre fonction métier. Le greffon @Around va envelopper notre fonction.

Configuration de Spring AOP et @AspectJ

Ouvrez le fichier applicationContext.xml et copiez le code ci-dessous :


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

        <!-- @AspectJ support -->
        <aop:aspectj-autoproxy />

        <bean id="MetierProfiler" />
        <bean id="classMetier" />
</beans>

&nbsp;

Voici ce que nous faisons dans le fichier XML ci-dessus:

  1. Nous avons ajouté les schémas AOP nécessaires  sur le haut du fichier XML.
  2. Utiliser <aop:aspectj-autoproxy />, nous avons activé le support @ AspectJ pour notre application.
  3. Et puis nous avons défini deux beans Spring normeaux - une pour notre classe métier et l'autre pour notre métier Profiler (c'est à dire notre aspect).

Félicitations nous avons finis ! A ce stade, nous avons ajouté avec succès Spring AOP à notre projet et nous l’avons configuré. Dans l'étape suivante, nous allons pouvoir tester notre code !

Testons notre Spring AOP profiler

Ouvrez le fichier et Test.java  et copiez y les lignes ci-dessous :


package com.soat.spring.aop.demo;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

        public static void main(String[] args) {
                ApplicationContext context = new ClassPathXmlApplicationContext(
                                "applicationContext.xml");
                Metier t1 = (Metier) context.getBean("classMetier");
                t1.jeTravaille();
        }

}

Dans le code ci-dessus nous chargeons notre bean Métier à partir du context spring, puis on apelle notre fonction. Si vous exécutez cette classe (Test.java) , on voit produire sur la console :


//Apelle de la fonction ...
==> Je commence le travaille ..
 .... traitements metiers ....
==> Travaille finie
//Fonction executee avec succees
Temps d'exécution de la fonction: 3502 milliseconds.

Spring AOP Flow - expliqué dans un diagramme de séquence

Conclusion

Spring Aop offre bien plus de fonctionnalités qui vous permettent de séparer tout les préoccupations transverses. On peut se préoccuper que de l'aspect  de l'application qui nous concerne, ce qui simplifie le travail, et permet d'augmenter la parallélisation du développement.

L’apprentissage de Spring Aop demande un certain temps mais le ROTI (Return Of Time Invested ) est considérable.
J'espère que ce tutoriel vous aide à comprendre les bases de la programmation Orientée Aspect Spring. Si vous avez des questions concernant n'hésitez pas à laisser un commentaire.

Posted on by Rabii | Posted in JEE | Tagged , ,


Posted on by Rabii



e

NoSQL (« Not Only SQL ») est un mouvement relatif aux bases de données, entamé au printemps 2009. Le terme se réfère à certaines données non relationnelles stockées.
Des tendances dans les architectures informatiques visent à améliorer les bases de données dans une direction nécessitant une évolutivité horizontale. NoSQL tente de répondre à cette exigence.
Google BigTable et Amazon Dynamo (en) exploitent des bases de données de type NoSQL.
Le meetup NoSQL de San Francisco du 11 juin 2009 a été particulièrement important au développement de cette tendance. Plus de 100 développeurs de logiciels ont assisté à des présentations de solutions telles que Project Voldemort, Cassandra Project, Dynomite, HBase, Hypertable, CouchDB et MongoDB.
tout l'article sur wikipedia

plus d'informations sur le site officiel

Posted on by Rabii | Posted in base de données | Tagged ,


Posted on by Rabii


Lors de son congrès européen à Cannes, Microstrategy, l’un des rares éditeurs de BI encore indépendant, a lancé une offensive sur le décisionnel mobile, en ciblant l’iPad et l’iPhone.

system

Le fondateur et PDG de Microstrategy, Michael Saylor, est l’un des meilleurs ambassadeurs de terminaux mobile Apple. C’est sous ce jour qu’il est en tout cas apparu à Cannes, lors du congrès européen de sa société. Sur scène, il n’a eu de cesse que de vanter les vertus de la BI (Business Intelligence) mobile, de l’iPad, de l’iPhone et surtout de sa nouvelle plate-forme décisionnelle spécialement conçue pour la tablette et le téléphone d'Apple. Et, reconnaissons-le, cette version – Microstrategy Mobile for iPhone & iPad – a de quoi séduire.
S’adapter à la taille de l’écran
La visualisation classique du client web de Microstrategy a été ici repensée de manière à exploiter avantageusement le contact tactile des écrans (en particulier les aspects multi touch) et les différents capteurs sensoriels embarqués dans les terminaux. Et ce pour les trois grandes fonctions de la BI : les tableaux, les rapports et les analyses multidimensionnelles.
Quelques exemples : pour visualiser un large tableau impossible à restituer en l’état sur un iPhone, les différentes colonnes s’affichent et s’effacent en tapant sur les intitulés en abscisse. De la même façon, des éléments de zoom et d’incrustation d’histogramme s’affichent automatiquement au contact du doigt sur les lignes. Quant aux dimensions des environnements multidimensionnels, elles passent de l’une à l’autre par un simple balayage.

source

Posted on by Rabii | Posted in base de données