Ce blog entre dans les Top Blogs Logiciels Libres de Wikio
A la troisième place du classement du mois de décembre
Le lien est
Wikio : Top Blogs Logiciels Libres de décembre
Bien que le site n’est pas 100% open source (lire cet article pour comprendre ), cette année plus de la moitié des articles traitent de l’open source, pour un total de 113 pour le moment
Visiter le site
http://blog.opensyd.fr/wikio-top-blogs-logiciels-libres-de-decembre/
autres articles :
Pour ceux qui ne sont pas encore sûre, java 1.4 est mort. L’acte de décès est signé Spring 3.0
Les adeptes de Spring, ne pourront plus utiliser java 1.4, avec Spring 3.0, les annotations et les generics sont utilisés dans le cœur Ioc (Spring core). De plus Spring 3.0 offre plusieurs fonctionnalités pour exploiter au maximum le concept d’annotation en général.
Spring 3.0 requiert Java 5 et supporte Java 6. (JPA 2.0, …).
Autre nouvelles importantes, le support de REST dans Spring MVC..
Spring 3.0 renforce le support de la JSR 303 pour la définition et l’expression des contraintes et de validation basée sur les annotations..
Reste un questionnement sur l’intérêt d’un nouveau langage d’expression Spring Expression Language (SpEL) ? pour Spring peut être integration ?
Mais ceci est un autre sujet
Ci-dessous, la trame de « message que j’ai présenté, en tant que membres du premier panel de la conférence,
Deux parties
partie 1 : la place de l’open source chez OXIA,
et partie 2 : les tendances dans le domaine »
OXIA possède une grande expérience dans le monde open source. Le modèle open source a été adopté, avec réussite, dans de nombreux projets.
Nous avons mis en place des solutions répondant aux besoins de nos clients sen se basant sur des composantes open sources et des composantes propriétaires, dans le domaine du télécom et autour des architecture SOA, nous avons une démarche outillé avec des composantes open sources, la même démarche a été mise en place avec succès en se basant sur des outils propriétaires.
Nous avons une « practice architecture » très avancée et un processus de développement maitrisé qui nous permettent d’intégrer les besoins de nos clients dans nos choix et nos solutions
Le tout blanc ou noir ça on ne connait pas. Dans la majorité des cas, le projet exploite les meilleurs des deux modèles : open source et propriétaires à code fermé.
Les projets où la solution a été 100% open source sont très rares. L’exemple classique, en Tunisie, un projet Java EE, sous Tomcat avec une JVH HotSpot de SUN, mais déployé sous Windows avec une base de données Oracle.
Notre maitrise des technologies et des solutions packagés nous permettent de conseiller nos clients en tenant compte des besoins, de la stratégie et du ROI souhaité.
L’open source est surtout une histoire de business modèle.
L’innovation vient de là, du modèle économique.
Nous avons mis en place un centre de service orienté grand compte où nous supportons des composantes issues du monde open source : Tomcat, Jboss et des framewokrs Spring, Hibernate et des applications par exemple de Mifos de microfinance.
Nous réalisons des POC pour nos clients; sur les nouvelles plateformes PaaS et SaaS , que ce soit en open source avec googleApp engine ou de chez Microsoft Azure à travers la fondation Codeplex. Dans le domaine SOA nous avons mis en place une méthodologie de mise en ouvre qu’on réussi à déployer en utilisant des composantes open sources ou bien des solutions package propriétaire.
Dans tous ces exemples, ce qui a conduit à la réussite du projet, c’est un processus adéquat, la maitrise technique, un cycle de vie des applications outillé, une veille continue et surtout une qualité d’écoute du client.
C’est le modèle POS : professionnel open Source
La suite de la présentation a été de parler des 5 tendances, importantes dans le monde open source
- Le cloud computing (et ses variantes PaaS, SaaS, …)
- Les langages de programmation dynamiques (Grooy, grails, …)
- La gestion de projet de type Agile
- L’ALM
- Les modèles économiques (Souscription, …)
un petit bémol, il a fallu présenter toutes ces informations en 5 minutes
en relation avec le sujet
La plateforme la plus populaire du monde open source professionnel est à sa version 6, depuis le 10 décembre 2009.
Java EE comprend maintenant de nouvelles notions : de nouveaux profils (profil léger pour le web, ..) et de nouvelles possibilités d’extension, plus de fonctions avancées pour simplifier le développement, …
L’arrivée de la nouvelle version de Netbeans, la version 6.8 qui supporte Java EE 6, ne rassure pas les adepts sur son avenir (Oracle aura à faire des choix entre JDeveloper, Eclipse Workshop Studio de BEA et NetBeaans de SUN),
Reste à l‘ordre du jour la question de la gouvernance de Java, depuis la prise de contrôle de SUN par Oracle, …
Encore un bug informatique à la une des journaux.
L’histoire a été révélé en France, le 08/12/2009, un Bug de la Sécu : 400 millions d'euros de cotisations non réclamées à plus de 15000 artisans et commerçants.
400 millions d'euros de perte : Un exemple parmi d’ autres de l’impact d’un bug informatique.
Mais la vraie question : qu’est ce qui va se passer après la découverte de ce bug ?
Corriger et redéployer !
Ce n’est pas aussi simple.
Il va falloir tester de nouveau !
Mais est ce qu’on possède toutes les informations sur la matrice des exigences ?
Et ce qu’on a une idée claire sur les conséquences de la correction de ce bug sur le reste de l’application : quelles sont les parties du code à tester.
D’où, la nécessite de la mise en place d’une « vraie » gestion du cycle de vie des applications (ALM pour Application LifeCycle Management).
Rappelons que l’ALM (Application LifeCycle Management ) dépasse le simple périmètre du développement logiciel pour l’inclure.
Les cinq piliers de l’ALM 2.0:
Traçabilité,
Intégration,
Automatisation,
Communication
Visibilité
La traçabilité permet de maintenir les liens entre les exigences, la modélisation et la gestion des changements, ainsi qu’entre les tests et la gestion des changements, etc …
la traçabilité des exigences et des besoins est très importante durant le cycle de développement. Mais la vraie valeur de la traçabilité des artéfacts apparaissent, bien après la mise en production. C’est lors de la maintenance et des mises à jour qu’on a besoin de connaitre la version des spécifications actuellement en production et de pouvoir réaliser l’analyse d’impact d’un changement sur le reste du système.
L’intégration de la gestion des exigences avec les outils des tests facilite la création d’exigences plus efficaces et ciblées.
L’intégration de la gestion des changements avec le suivi des bogues et avec les outils d'analyse facilite les mesures et la hiérarchisation des demandes de modifications.
Lors du développement, l’automatisation des builds, des tests de non régressions permettent de soulager les développeurs des tâches réplétives.
La communication permettrait de réaliser des applications qui « fonctionnent correctement » et qui répondent aux besoins des utilisateurs : Livrer ce que l’utilisateur a demandé !
Échanger entre tous les membres de l’équipe est d’autant plus important que la taille de l’équipe est plus grande.
Le syndrome des 90% des fonctionnalités déclarées implémentées, alors que 90% reste à faire n’est plus acceptable. Du chef de projet jusqu’au « big boss », il est primordiale d’avoir en permanence les données sur l’avancement du projet et l’état de l’application. Que ce soit des pourcentages de fonctionnalités réalisés, testés ou reste à faire, la visibilité permettra aux décideurs de « trancher » et de prendre les bonnes décisions pour atteindre l’alignement du Business avec l’IT …
Une solution ALM répondant à ces exigences permettra de réduire les coûts de l’IT d’une entreprise et d’augmenter le ROI des applications.
Tous ces facteurs permettent potentiellement de réduire les coûts, mais plus fondamentalement, ils accroissent la réactivité de l’entreprise et sa capacité à s’adapter à des marchés globalisés extrêmement concurrentiels.
Ces cinq facteurs permettront d’aborder le facteur humain reste le principal obstacle à l’adoption d’une approche globale de l’ALM.
Plus jamais de mauvaises surprises de dernières minutes
Source :
Bug de la Sécu (à ne pas confondre avec le gouffre de sécu) : http://www.ladepeche.fr/article/2009/12/08/732469-Bug-de-la-Secu-400-millions-d-euros-non-percus.html
autres entrées sur l'ALM
La 5ème édition de la conférence annuelle sur les Logiciels Libres en Tunisie, organisée annuellement par le Ministère des Technologies de la Communication, aura lieu le 15 décembre 2009 à l'hôtel Karthago Le Palace Gammarth.
Le thème de cette année est "Logiciels Libres: Levier d'Innovation et de Croissance".
Ça va faire ma cinquième participation.
Le panel du matin, traitera principalement les nouvelles tendances dans le domaine des Logiciels Libres (Cloud Computing, SaaS, Social Networks, Logiciels embarqués,... ), du potentiel d'innovation et d'entrepreneuriat offert par les Logiciels Libres.
L’après midi les sujets traités seront contribution de ces logiciels dans les domaines de l'éducation, l'enseignement supérieure et la recherche scientifique.
Je serais parmi les panélistes du matin.
J’aurais l’occasion d’'évoquer des sujets autour des offres PaaS open source (Google AppEngine, Morph AppSpâce et grails, CloudFoundary de Spring ..), des codes sources disponibles sur sourceforge et codeplex, …, les nouvelles approches de développement rapide et le Cloud : Grails
Ma contribution permettra de mettre en valeur l'expérience de OXIA et les compétences technologiques des entreprises tunisiennes en matière de logiciels libres.
Je vais parler du Hype cycle du Gartner et du danger du dogmatisme open source : il s’agit toujours d’un modèle économique. PaaS, SaaS et IaaS, il faut montrer le business plan avant tout “show me the money’!
Mais ceci est un autre sujet
Le programme : http://www.opensource.tn/index.php?id=150
Selon le site : » les Objectifs de la conférence
Ce rendez-vous annuel vise à débattre et échanger des informations et connaissances sur plusieurs aspects importants autour du Logiciel Libre:
· Comment bénéficier des atouts des logiciels libres pour stimuler et favoriser l’innovation technologique ?
· Quels sont les atouts des logiciels libres pour renforcer la compétitivité et créer de nouvelles entreprises et de nouveaux emplois ?
· Comment intégrer les logiciels libres dans le cadre du développement durable et la formation de diplômés compétents dans le domaine du libre ?
La conférence sera composée de séances plénières et de séances d’ateliers qui s’adressent à une large audience composée de :
· Chercheurs talentueux qui souhaitent tirer avantage des potentiels des logiciels libres pour créer de nouvelles applications innovantes et répondant à des besoins de production et de service de différents secteurs.
· Enseignants et éducateurs qui veulent contribuer au développement durable intégrer les logiciels libres dans leur programme d’études pour former des diplômés capables de satisfaire aux critères du marché dans le domaine des logiciels libres.
· Entrepreneurs et décideurs informatiques qui souhaitent augmenter la compétitivité et stimuler la création de nouveaux emplois en utilisant et en développant des logiciels libres de qualité et à moindre coût.
Pour plus de détail : http://www.opensource.tn/index.php?id=151Qu’est ce qui empêche une entreprise, un groupe ou même un pays de profiter de l’offre open source ?
Une question simple, mais qui n’a pas qu’une seule réponse.
Ce qui est sûre, c’est que l’association de la gratuité à l’open source reste un vrai problème.
Cela masque l’aspect principal du monde open source : « il s’agit, avant tout, d’un modèle économique » où l’ouverture des codes sources est une différenciation avec le reste des modèles de fournitures de software.
Mais, à force de marteler d’une façon dogmatique l’open source et ses nombreux avantages, sa gratuité, sa sécurité, etc … , les décideurs oublient la raison même d’un logiciel?
Les « défenseurs dogmatiques » du logiciel libre endossent une part de la responsabilité.
Un décideur, n’a pas besoin, dans son SI, d’un logiciel mais d’une solution.
Une solution n’est qu’une réponse à un besoin.
Parler de l’open source avant de parler des besoins n’a aucun sens.
Le vrai problème se trouve dans les faiblesses de la définition des besoins et de la matrice des exigences, de la formulation des SLA, de la rédaction des contrats de supports, de la gestion des changements, du suivi d’un cycle de vie des applications …
C’est en « glorifiant » la fonction maitrise d’ouvrage, que les défenseurs de l’open source, pourront tirer profit de l’offre open source et surtout savoir à quel moment l’offre « propriétaire » est plus appropriée.
Tout dépend de l’adéquation de la solution proposé avec la matrice des exigences et du niveau de service demandé.
Mais dans tous, les cas, il vaut mieux parler d’offre commerciale, comprenant la solution, le contrat de garantie, le contrat de support, la formation …
Il est 22H15 à Tunis, le 30/11/2009, et Twitter est une nouvelle fois en panne.
en directe :http://twitter.com/
Too many tweets! Please wait a moment and try again.
ou à travers les Gadgets de iGoogle :
Question : Est ce qu’une autre personnalité célèbre est décédée ?
Alors, avant de lancer le mode publicitaire, il va falloir revoir l’architecture de déploiement et améliorer la robustesse …
pour suivre les pb de Twitter
http://status.twitter.com/post/263867698/responding-to-high-error-rate-lists-featureAprès eHcache, voici le Scheduler le plus populaire de la communauté open source java qui rejoint la famille de produits open source Terracotta.
Quartz est un framework open source de scheduling de travaux, très utilisé pour les travaux batch.
Quartz est utilisé pour créer tous types d’application Java et Java E, de la plus simple application swing, à complexes programmes lancé avec un code java.
Quartz est à sa version 1.6.6 sous la licence Apache 2.0.
Quartz s’intègre bien avec Spring et est supporté par des Templates Spring.
Terracotta propose des solutions de clustering d’objets et de JVM pour adresser les problématiques de haute disponibilité et de partage d’instance d’objets entre plusieurs JVM.
En quelques sortes Terracotta offre à l’application une mémoire distribuée sur toutes les JVM connectées (concept de Network Attach Memory).
Cette alliance entre Terrcotta et Quartz permettra (espérons) de corriger les limitations de clustering connue avec Quartz.
Encore une nouvelle surprise, à laquelle je ne m’attendais pas: Microsoft a décidé d’acheter la division Teamprise de SourceGear.
En assistant au WE Visual Studio Summit de Rome (du 1 au 4 novembre 2009), aucune information n’a filtré, mais la surprise était que Brian Harry (le Boss de VSTS), lui même avait présenté la solution Teamprise. Un entrainement peu être!
Teamprise est le pont entre le monde Eclipse et Java et Visual Studio. Teamprise permet de simplifier le travail dans un monde hétérogène et multiplateformes (développement .Net et Java), et de limiter les problèmes d'interopérabilité entre les composantes d’un ALM.
Teamprise permet à un développeur Java d’exploiter la solution TFS de Microsoft et à s’intégrer avec VSTS dans soucis.
Ainsi, la solution ALM de Microsoft, la fameux Visual Studio prend des options sérieuses pour jouer dans la cours des grands.
L 'ALM (Application Life-Cycle Management) permet aux entreprises de mieux gérer le cycle de vie des applications et de leurs projets de développement de logiciels, et d'accroître leur collaboration en équipe et la productivité tout en améliorant la qualité logicielle globale.
Dans se domaine, il est primordiale de développer une expertise, autour des problématiques suivantes :
· Industrialisation des développements et gestion du cycle de vie des applications (Software Factories…)
· Modélisation et mise en place de méthodologies de projet (UML, CMMI, MDA, etc…)
· Qualité des applications (audit de code, tests unitaires, tests de charge, intégration continue…)
· formation et de coaching et une capacité de transfert de savoir faire sur les technologies avancées
Je crois véritablement dans la pratique ALM pour le développement logiciel, et que cette discipline permet de fournir une valeur ajoutée à nos clients.
Reste à savoir si Teamprise sera intégré dans la version VS2010 de mars prochain.
Espérerons
Mais ceci est un autre sujet
information :
http://www.microsoft.com/presspass/press/2009/nov09/11-09TeamprisePR.mspxhttp://www.woodwardweb.com/teamprise/a_new_chapter_f.html
Microsoft a nommé OXIA, à son programme partenaire Inner Circle pour Application Lifecycle Management (ALM).
http://www.oxiasoft.com/site/fr/news.php?id_article=50&id_news=44
L’Europe est face à un dilemme, comment défendre son industrie de logiciel et respecter en même temps le droit à la libre initiative ?
Parler de position dominante dans le domaine des bases de données : Oracle ne sera pas seul sur le marché: il reste IBM et Mircosoft, même si MySQL venait à disparaitre …
Les américains eux n’y voient pas de problème : ils viennent d'approuver l'absorption de SUN par Oracle, pour eux, le pire est de voir SUN déposer le bilan!
Or, il s’agit de base de données et c’est la même offre des deux cotés de l’atlantique.
Pourquoi la commission européenne tarde à approuver le "deal".
En fait, il faut lire : position « américaine» dominante dans le domaine des bases de données, et cela pose un problème à la commission européenne.
Si elle venait à refuser l'achat de SUN par oracle, l’Europe doit trouver de meilleurs arguments !
Il faut rappeler que pour l’Europe, l’open source, est une opportunité à saisir pour préserver son industrie logicielle.
Mais ceci est une autre histoire
---------------MuleSoft a annoncé en cette fin de d’octobre 2009, Mule IDE 2.0 pour Mule ESB a été mise à jour.
Mule IDE 2.0 est l’environnement de développement et des tests de Mule.
Mule IDE 2.0 est basé sur Eclipse. Il supporte les fonctionnalités suivantes:
-Création d’un nouveau projet Mule dans Eclipse
-Création d'une copie des exemples de Mule en tant que projet Eclipse
-Création d’un nouveau fichier de configuration Mule avec les déclarations, au choix, des espaces de nommage à utiliser (jms, cxf, file, …)
-l’Intégration de l’IntelliSense et la complétion automatique lors du développement des fichier de configuration de Mule
-l’exécution des projets dans le serveur Mule à partir de Eclipse
- l’exécution en mode débogage des projets dans le serveur Mule à partir de Eclipse
Mule IDE 2.0 est compatible avec n'importe quel configuration de Mule 2.1 ou ultérieure collectivité ou une entreprise de distribution Mule.
----> Référence
http://www.mulesoft.org/display/MULEIDE/Mule+IDE+2.0+Installation+Guide
L’annonce est tombée Geocities a définitivement fermé son service de pages Web personnelles?
Certains diront c’est quoi Geocities ?
Comment interpréter cette annonce :
La fermeture d’un service pionnier dans son domaine ?
Au premier degrés : on pourra dire simplement que l'époque des sites web personnels est révolu, vive les blogs !
Et peut être dans quelques semaines : on dira le blogging est mort, vive le microblogging (twitter et compagnies)…en attendant l’effet wave de google …
Mais d'un point de vue stratégique, il s'agit d'un modèle économique qui n'a pas été capable de "monétiser" un service gratuit, et d'un modèle technologique qui n'a pas été capable de suivre la vague.
et c'est là la grande difficulté de l’avenir des services web gratuit.
"Geocities a définitivement fermé son service de pages Web personnelles"
- Geocities a définitivement fermé son service de pages Web personnelles - Actualités Internet - Le Monde Informatique (afficher sur Google Sidewiki)
MOM open source : ActiveMQ présente sa version 5.3.
Ce MOM (Message Oriented Middleware) open source reste l’un des MOM les plus activées et les plus populaires
ActiveMQ très utilisé par la communauté Java EE. ActiveMQ est écrit en langage java et implémente la spécification du standard JMS (Java Message Service) version 1.1 de Sun Microsystem’s.
ActiveMQ peut être déployé sur n’importe quel système OS (Windows, UNIX et Linux) compatible avec Java Virtual Machine (>= JDK 1.5).
Rappelons que les principaux composants de ActiveMQ sont :
· Client : application utilisant les services fournit par le broker. Un client peut être producteur ou consommateur de messages.
· Destination : Peut être considérée comme un canal logique permettant ainsi aux clients de communiquer entre eux. Une destination peut être queue (Point à Point) ou topic (publish & Subcribe).
· Message Broker : Responsable d’acheminer les messages vers les destinations demandées. Il permet aussi d’assurer une qualité de services adéquate liée à la persistance, intégrité, sécurité et la disponibilité.
En plus des protocoles classiques des MOM, ActiveMQ implémente, et y ajoute le protocole AMQP (Advanced Message Queuing Protocol).
AMQP est un nouveau protocole pour les systèmes de messagerie orientés Middleware à comparer au protocole SMTP (pour les gestionnaires des emails). L'objectif d'AMQP est de standardiser l'échange de messages entre serveurs de message
Les principales nouveautés de la version 5.3 d’ActiveMQ sont ;
Signalons en plus, que la version 5.3 d’ActiveMQ propose un lien plus important avec le projet EIP de Apache Camel 2.0.0
Mais ceci est un autre sujet.
------------------------------------
autres sujets sur les MOM et ActiveMQ
Cet article présente une série de présentations et de tutoriels pour démystifier Mule ESB : http://net-progress.blogspot.com/)
1 les projets d’intégration avec ESB.
1.1 de la nécessité d’un projet d’intégration dans un S.I. (Système d’information).
1.2 Les types d’intégration.
1.3 Intégration par les données :.
1.4 Intégration par les API :.
1.5 Intégration par les processus.
1.6 Un ESB est service de l’intégration.
2.1 Ce qu’est un ESB.
2.2 Rôle d’un ESB.
2.3 Mule ESB est il un ESB.
2.4 La concurrence open source.
2.5 Autres usages possible pour Mule.
3 Tutorial Mule ESB : une introduction.
3.1 C’est quoi Mule.
3.2 qu’est ce qu’un service Mule.
3.3 Séparer la logique métier de la logique de routage.
4 Tutorial Mule ESB : les principales composantes.
4.1 Présentation.
4.2 Installer Mule et son IDE.
4.2.1 Installer Mule.
4.3 Installer l’IDE de Mule.
5 Tutorial Mule ESB : Créer un projet d’intégration avec Mule en utilisant l’IDE Eclipse.
5.1 Créer un projet Mule.
5.2 Créer une configuration Mule.
5.3 Lancer l’exécution du projet à partir d’Eclipse.
5.4 Sélectionner la configuration Mule.
6 Tutorial Mule ESB & Eclipse : déployer un projet d’intégration avec Eclipse.
6.1 Déployer le projet à partir d’Eclipse.
6.2 Exécuter le projet.
7 Tutorial Mule ESB : Une application simple, Echo sans altération de message.
7.1 Introduction.
7.2 Présentation générale du fichier de configuration de Mule.
7.3 Construction pas à pas d’un exemple simple :
8 Tutorial Mule ESB : Une seconde application simple, Echo avec modification du message
9 Tutorial Mule ESB & Spring Ioc: Utilisation des beans Spring avec Mule.
10 Tutorial Mule ESB : illustration des capacités de Mule.
10.1 Description :.
10.2 Le sujet :
10.3 Pour commencer :
10.4 Configuration de Mule.
10.5 Définir les transformateurs.
10.6 Définir le modèle.
10.7 Définir un service.
10.8 Définir les entrées du service.
10.9 Définir le composant du service.
10.10 Définir la sortie du composant.
10.11 Finaliser le projet.
10.12 Exécuter le projet.
10.13 Retour sur les transformations.
La version 1.2.6 du SDK de Google App Engine est sortie.
Les trois principales nouveautés
Au même moment Microsoft annonce de nouvelles fonctionnalités sur sa plateforme Azure
Mais ceci est un autre sujet
NB : cet article fait partie d’une série de présentation et de tutorials pour démystifier Mule ESB : http://net-progress.blogspot.com/)
Dans l’exemple présenté dans cette partie, nous allons explorer les capacités d’un ESB : Protocol de transport, transformation et gestion des exceptions
L’exemple a pour objectif de répondre à une demande de résultat dans un examen pour un étudiant donnée. Les aspects suivants seront traités
1. Réception de l’invocation par deux méthodes (VM et http)
2. Développement et Utilisation de transformateurs spéciaux
3. Utilisation d’une stratégie de gestion des exceptions
4. Réponse synchrone par http et affichage directe dans la page web
Il s’agit d’un service en ligne de suivi des résultats des examens nationaux.
Un utilisateur pourra trouver les résultats de ses examens à travers une interface web dans son portail favoris.
Ce portail communique avec le serveur de l’université via un protocole de son choix : Mule est capable de varier le protocole d’exposition d’un service indépendamment de son implémentation
Créer un projet Mule vide et définir le fichier de configuration : resultat-examen-http-config.xml
Les Pojo en relation avec le projet sont :
Etudiant (sous sa forme la plus simple, pour les besoins du tutorial)
1: package com.oxia.att.mule.intro.beans;
2: import java.io.Serializable;
3: public class Etudiant implements Serializable {
4: private static final long serialVersionUID = 7010138636008560022L;
5: private String nom;
6: private String universite;
7: // getter & setter …
8: public boolean isValid() {
9: if (nom == null)
10: return false;
11: // accépter seulement si le nom a plus de 2 caractère
12: if (nom.length() > 1)
13: return true;
14: return false;
15: }
16: }
1: package com.oxia.att.mule.intro.beans;
2: import java.io.Serializable;
3: public class ResultatExamen implements Serializable {
4: private static final long serialVersionUID = -3140370545357738491L;
5: private StringBuffer resultat = new StringBuffer();
6: public StringBuffer append(String str) {
7: return resultat.append(str);
8: }
9: public StringBuffer append(StringBuffer sb) {
10: return resultat.append(sb);
11: }
12: public String toString() {
13: return resultat.toString();
14: }
15: }
1: <?xml version="1.0" encoding="UTF-8"?>
1: <mule xmlns="http://www.mulesource.org/schema/mule/core/2.2"
2: xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:spring="http://www.springframework.org/schema/beans"
3: xmlns:http="http://www.mulesource.org/schema/mule/http/2.2" xmlns:vm="http://www.mulesource.org/schema/mule/vm/2.2"
4: xmlns:stdio="http://www.mulesource.org/schema/mule/stdio/2.2"
5: xsi:schemaLocation="
6: http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
7: http://www.mulesource.org/schema/mule/core/2.2 http://www.mulesource.org/schema/mule/core/2.2/mule.xsd
8: http://www.mulesource.org/schema/mule/http/2.2 http://www.mulesource.org/schema/mule/http/2.2/mule-http.xsd
9: http://www.mulesource.org/schema/mule/vm/2.2 http://www.mulesource.org/schema/mule/vm/2.2/mule-vm.xsd
10: http://www.mulesource.org/schema/mule/stdio/2.2 http://www.mulesource.org/schema/mule/stdio/2.2/mule-stdio.xsd">
Définir les transformateurs à utiliser
1: <custom-transformer name="StringToEtudiant"
2: class="com.oxia.att.mule.intro.transofrmer.StringToEtudiant" />
3: <custom-transformer name="EtudiantToResultatExamen"
4: class="com.oxia.att.mule.intro.transofrmer.EtudiantToResultatExamen" />
5: <custom-transformer name="ResultatExamenToString"
6: class="com.oxia.att.mule.intro.transofrmer.ResultatExamenToString"/>
7: <custom-transformer name="HttpRequestToEtudiant"
8: class="com.oxia.att.mule.intro.transofrmer.HttpRequestToEtudiant" />
9: <custom-transformer name="ExceptionToString"
10: class="com.oxia.att.mule.intro.transofrmer.ExceptionToString" />
11: <custom-transformer name="HttpRequestToParameter"
12: class="org.mule.transport.servlet.transformers.HttpRequestToParameter" />
13: <custom-transformer name="ObjectToString"
14: class="org.mule.transformer.simple.ObjectToString" />
Donnons ici un exemple de transformateur qui reste, rappelons le, un code spécifique à Mule.
Exemple de code source d’un transformateur spécifique développe dans le cadre de ce tutorial
1: package com.oxia.att.mule.intro.transofrmer;
2: import org.mule.api.transformer.TransformerException;
3: import org.mule.transformer.AbstractTransformer;
4: import com.oxia.att.mule.intro.beans.ResultatExamen;
5: import com.oxia.att.mule.intro.beans.Etudiant;
6: public class EtudiantToResultatExamen extends AbstractTransformer {
7: public EtudiantToResultatExamen() {
8: super();
9: this.registerSourceType(Etudiant.class);
10: this.setReturnClass(ResultatExamen.class);
11: }
12: public Object doTransform(Object src, String encoding)
13: throws TransformerException {
14: ResultatExamen resultatExamen = new ResultatExamen();
15: Etudiant etudiant = (Etudiant) src;
16: resultatExamen.append("Le candidat : ");
17: resultatExamen.append(etudiant.getNom());
18: resultatExamen.append(" de L'universite : ");
19: resultatExamen.append(etudiant.getUniversite());
20: return resultatExamen;
21: }
22: }
· hérite de la classe AbstractTransformer
Cette classe a accès au Payload du message et suppose qu’il est de type Etudiant
Il est préférable de rester indépendant du protocole de transport afin de réutiliser les transformations dans d’autres situations :
1: Etudiant etudiant = (Etudiant) src;
1: <model name="ResultatExamenSample">
2: La définition des services
3: </model>
Rappelons, que dans un service il ya 4 parties
<component /> | Le composant |
<outbound> </outbound> | Le point de sortie |
<default-service-exception-strategy> </default-service-exception-strategy> | La gestion des exceptions |
</service> |
Définir les entrées du service
Dans le premier service nommé DonneesEtudiant, nous allons avoir deux points d’entrée :
· Un point d’entrée http
1: <inbound>
2: <inbound-endpoint address="http://localhost:8888"
3: transformer-refs="HttpRequestToEtudiant" synchronous="true">
4: </inbound-endpoint>
5: <vm:inbound-endpoint path="etudiant"
6: transformer-refs="StringToEtudiant" synchronous="true" />
7: </inbound>
Pour appeler le service avec HTTP, lancer cette URL dans un navigateur
http://localhost:8888?nom=Khalil
pour faire appel à ce service avec la programmation, utiliser la classe MuleClient:
MuleClient client = new MuleClient();
client.send("vm://etudiant", "Khalil", null);
UMOMessage response = client.send("vm://etudiant", "Ross", null);
1: <component class="com.oxia.att.mule.intro.service.VerifierCandidat" />
Les Filtres permettent de préciser les conditions qui doivent être remplies pour un message afin qu’il soit acheminé à un service. Il existe plusieurs types de filtres offerts par Mule que vous pouvez utiliser. Il est possible de créer vos propres filtres.
Nous utilisons ici un routeur spécial : le <filtering-router> : qui présente l’avantage de filtrer selon le contenu et dispatché vers le point de sortie approprié.
· Si le résultat est de type Etudiant alors tout va bien
· Si c’est une exception (ici de type com.oxia.att.mule.intro.exception.CandidatException) alors on passe en mode erreur
1:<outbound>
2:<filtering-router>
3: <vm:outbound-endpoint path="getResultatExamen" synchronous="true" />
4: <payload-type-filter
5: expectedType="com.oxia.att.mule.intro.beans.Etudiant" />
6:</filtering-router>
7:<filtering-router>
8: <vm:outbound-endpoint path="userErrorHandler" synchronous="true" />
9: <payload-type-filter
10: expectedType="com.oxia.att.mule.intro.exception.CandidatException" />
11: </filtering-router>
12:</outbound>
Et
1: default-service-exception-strategy>
2: <vm:outbound-endpoint path="systemErrorHandler" />
3: </default-service-exception-strategy>
Pour finaliser le projet, il reste à indiquer les destinations getResultatExamen, userErrorHandler et systemErrorHandler
Pour cela une solution est définir des nouveaux services :
1: <service name="ResultatExamen">
2: <inbound>
3: <vm:inbound-endpoint path="getResultatExamen"
4: transformer-refs="EtudiantToResultatExamen"
5: responseTransformer-refs="ResultatExamenToString"
6: synchronous="true" />
7: </inbound>
8: <component
9: class="com.oxia.att.mule.intro.service.ObtenirResultatExamen" />
10: </service>
11: <service name="UserErrorHandler">
12: <inbound>
13: <vm:inbound-endpoint path="userErrorHandler"
14: responseTransformer-refs="ExceptionToString" synchronous="true"/>
15: </inbound>
16: </service>
Dans ce dernier service, nous utilisons le fameux routeur <pass-through-router>
1: <service name="SystemErrorHandler">
2: <inbound>
3: <vm:inbound-endpoint path="systemErrorHandler" synchronous="true" />
4: </inbound>
5: <outbound>
6: <pass-through-router>
7: <stdio:outbound-endpoint system="ERR" />
8: </pass-through-router>
9: </outbound>
10: </service>
Une fois lancé il suffit d’utiliser une simple page HTML
1: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
2: <html xmlns="http://www.w3.org/1999/xhtml">
3: <head>
4: <title>Obtenir Résultat Examen</title>
5: </head>
6: <body>
7: <form method="GET" action="http://localhost:8888">
8: <input type="text" name="nom"/>
9: <input type="submit" value="Demander le Résultat de l'Examen" />
10: </form><br />
11: </body>
12: </html>
La réponse est alors la suivante
Le serveur indique que tout s’est bien passé
INFO 2009-07-12 00:08:53,890 [connector.http.0.receiver.2] org.mule.transport.vm.VMMessageDispatcher: Connected: endpoint.outbound.vm://getResultatExamen |
Si on provoque une exception (il suffit d’envoyer un nom de 1 caractère)
Le résultat est toujours affiché ( la situation est maitrisée)
Le serveur indique qu’on est passé en mode exception :
INFO 2009-07-12 00:12:24,000 [connector.http.0.receiver.2] org.mule.transport.vm.VMMessageDispatcher: Connected: endpoint.outbound.vm://userErrorHandler |
NB : cet article fait partie d’une série de présentation et de tutoriaux pour démystifier Mule ESB : http://net-progress.blogspot.com/)
Un des avantages de Mule est son choix stratégique de s’intégrer d’une manière native avec Spring, le plus célèbre des framework Ioc.
Mule gagne ainsi du terrain par rapport aux autres ESB open source, en facilitant l’intégration des adeptes de Spring dans sa communauté et en facilitant la réutilisation des codes source des applications métiers exploitant le framework Spring.
Je me pose encore la question, du moment que va choisir Spring (et maintenant Vmware) pour mettre la main sur Mule. Ce n’est pas pour diminuer de la qualité de Spring, mais pour que la communauté Spring bénéficie du savoir faire de Mule en la matière.
Avant d’indiquer la méthode d’injection des beans Spring, rappelons que Mule 2.0 est devenue très modulaire grâce à l’utilisation des namespaces
Lorsqu’on souhaite utiliser Spring, il faut ajouter les Xmlns
![clip_image001[4]](https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEh36FIYljRwvRrXrcLRDF4w95g90GlURy4_Ys3gdc4y0QI9kYGmkjJh0SqlUlDsbKgDMvk60U6S8o_0fzCkCQV-ZSybJ1XO4qAqiNq4trkauynyP3g447MHmqH7Ea-yRng-bcVXxsWerGk/s1600-h/clip_image001%5B4%5D%5B3%5D.jpg "clip_image001[4]")
1: xmlns:spring="http://www.springframework.org/schema/beans"
Ainsi, l’entête du fichier de configuration
1: <?xml version="1.0" encoding="UTF-8"?>
2: <mule xmlns="http://www.mulesource.org/schema/mule/core/2.2"
3: xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4: xmlns:spring="http://www.springframework.org/schema/beans"
5: xmlns:stdio="http://www.mulesource.org/schema/mule/stdio/2.2"
6: xsi:schemaLocation="
7: http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
8: http://www.mulesource.org/schema/mule/core/2.2 http://www.mulesource.org/schema/mule/core/2.2/mule.xsd
9: http://www.mulesource.org/schema/mule/stdio/2.2 http://www.mulesource.org/schema/mule/stdio/2.2/mule-stdio.xsd">
Deux méthodes permettent d’ajouter des beans Spring dans une configuration Mule
1) Déclarer les beans directement dans la configuration
1:<spring:bean id="composantSimple"
2: class=" com.oxia.att.mule.intro.ComposantSimple ">
3: <spring:property name="prefix" value="prefix injecté par Spring" />
4:</spring:bean>
2) Lier la configuration à un fichier externe de configuration de Spring. Exemple
1: <spring:beans>
2: <spring:import resource="applicatinContext-dao.xml"/>
3: <spring:import resource=" applicatinContext-service.xml "/>
4: </spring:beans>
Dans la suite nous allons utiliser la première méthode.
La configuration doit être changée pour ne plus indiquer la classe du Composant mais une référence vers le Bean Spring.
1: <component>
2: <spring-object bean="composantSimple"/>
3: </component>
Exécuter le projet :
On constate que
le message est « passé » au bean Spring et que l’injection des propriétés (dépendance : ici la définition de prefix) de bean Spring sont correctes
Est ce que la stratégie de Mule s’arrimer au numéro 1 de l’Ioc pour attire plus d’adepte va s’avérer gagnante,
le temps nous le dira …
La conférence eCommerce et Gouvernance de l’Internet 2009 - ECIG 2009, va se dérouler à Sousse (Tunisie , traduction : au Soleil), le 8, 9 et 10 octobre 2009.
ECIG 2009 est co-organisée par Le Groupe Sup de Co La Rochelle, l’Institut pour le Management de la Recherche et de l'Innovation (IMRI) – Université Paris - Dauphine, le CEntre de REcherche en sciences de GEstion (CEREGE) et l’Université de Sousse
Notons que cette conférence, qui traitera en autre du Risk Management des applications en ligne : Nouvelles menaces, fraudes et solutions, SaaS, a le soutien de l’Association Information et Management (AIM) et la collaboration de l’Institut Supérieur de Gestion (ISG) de Sousse, de l’Institut des Hautes Etudes Commerciales (IHEC) de Sousse et de l’Ecole Doctorale en Sciences Economiques et de Gestion de Sousse.
Le 09 octobre : un atelier professionnel sur le « Risk Management des applications en ligne : Nouvelles menaces, fraudes et solutions »
Le sujet s’inscrit dans le cadre de la maîtrise des risques opérationnels lors des échanges en ligne qui est devenu un facteur essentiel de développement des applications distantes.
L’atelier traitera des thèmes suivants :
Cet atelier professionnel va s’atteler à lancer le débat entre professionnels et académiciens autour de la thématique de la maîtrise des risques. En effet, le risk management est un facteur essentiel de développement du e-Business.
Au cours des débats j’aurais la chance de « présenter » le modèle SaaS (Software-as-a-Service), et la notion de gestion de risque, réel, imaginaire et perçu.
Le programme : en pdf
Le site : http://www.ecig2009.org/
For those who say that SOA is dead, the second edition International SOA Symposium sounds like a resurrection!
| This 2nd International SOA Symposium - Rotterdam, will be hold in October 22-23, 2009 | |
In the other side, for the French SOA community the demonstration that SOA is alive will be made by the “SOA Forum :
| | http://www.itnewsinfo.com/invitation/SOA2009/index.html Mardi 6 October 2009 Paris |
For 2nd International SOA Symposium, the topics are very varied: the traditional topics of SOA (Gouvernance, ESB, REST / SOAP, BAM...) and nails, SaaS and PaaS (Google Apps, Azure, ..):
in reference à : 2nd International SOA Symposium - Rotterdam, October 22-23, 2009 (made with the Google Sidewiki)
Voici quelques liens utiles pour débuter avec JBPM :
En français à partir du site :
En anglais liens très intéressants partir du site de Joram Barrez (jBPM core developer at JBoss/Red Hat ) http://www.jorambarrez.be/blog/about/
NB : cet article fait partie d’une série de présentation et de tutorial pour démystifier Mule ESB : http://net-progress.blogspot.com/)
Reprenons l’exemple précédent (voir lien suivant ), pour y ajouter un élément nouveau :
Traiter le message obtenu au niveau du point d’entrée (<inbound>) avant de le transférer vers le point de sortie </outbound>
C’est l’occasion d’utiliser le tag XML component :
| <component> </component>
| Le service métier à invoquer |
Avant de configurer le service « métier », il est temps de développer la classe Java qui sera responsable de traiter le message :
Il est très important de savoir que cette classe java est indépendante de Mule : il s’agit d’un simple POJO (on verra même comment l’injecter avec de l’Ioc et Spring)
La classe Java est la suivante : com.oxia.att.mule.intro.ComposantSimple
Avec Eclipse :
Préciser le package et le nom de la classe
Puis développer la classe :
Ceci est un exemple simple
![clip_image002[4]](https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhUduLkU6NcSZphcaNlMRjLnbKoyqnMojehXC_v_5Mccl_WQphoysUz_LbznOcgSfxtrsgiazJtsnq-W-QS8wqVjwC5lis9npcFQGgbKtIzpXprwcMAkUz3QRWO3Us9-oxoshV5L28ekMQ/s1600-h/clip_image002%5B4%5D%5B2%5D.jpg "clip_image002[4]")
![clip_image004[4]](https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjAbemYTZlQO2bTHyrY5FT5aWwnvQXbr3rGpSVVkumjJGsPEk0AaE2tAB-lMYrbj27NgZbpS_ywtVFKDnhtISzO3JzUDTmdoz1PrOb2X2QYiERfp1eoQeVFRn3OmWtnKrOs4K6Flt2HgRI/s1600-h/clip_image004%5B4%5D%5B2%5D.jpg "clip_image004[4]")
1: package com.oxia.att.mule.intro;
2: import java.util.UUID;
3: package com.oxia.att.mule.intro;
4: import java.util.UUID;
5: public class ComposantSimple {
6: private String prefix="Le préfix du message_";
7: private String numero;
8: /*
9: * exemple simple de méthode métier qui
10: * exploite le message obtenu ( Mule est responsable de tout transformer ...)
11: * et retourne un nouveau message ( Mule est responsable de tout transformer ...)
12: *
13: */
14: public String hello(String message) {
15: numero = "_"+ UUID.randomUUID().toString();
16: System.out.println("le message originale est : " +message);
17: message = prefix + message + numero ;
18: System.out.println("le message en sortie est : " +message);
19: return message ;
20: }
21: public void setPrefix(String prefix) {
22: this.prefix = prefix;
23: }
24: }
1: <component class="com.oxia.att.mule.intro.ComposantSimple"/>
Mule a découvert (tout seul) la méthode à utiliser, grâce à son algorithme de résolution :
En cas d’ambiguïté, il est possible d’indiquer la méthode dans la configuration du composant
mais ceci est un autre sujetJ’anime, à Tunis, du 26 au 30 octobre prochain un Atelier pratique de formation sur la mise en ouvre des architectures orienté service (SOA) avec des outils open source.
Bien que SOA n’est pas une histoire d’outils, l’objectif de cet Atelier est de mettre en pratique, par les participants des concepts de base de la démarche SOA et de l’intégration d’application d’entreprise. Les participants, exploiteront mettront en ouvre des web services avec la démarche Contract-First, utilseront l’ESB Mule pour réaliser des intégrations avec ou sans web service et mettront en place un outil de gouvernance,
La complexité croissante des Systèmes d’Information et les opportunités technologiques rendent de plus en plus indispensable de disposer d’un cadre pour organiser, structurer et fédérer les travaux sur le Système d’Information et d’instaurer une interopérabilité naturelle dans les services afin de réduire le besoin d’intégration.
Ce workshop apporte un retour d’expérience des meilleures pratiques pour la mise en œuvre des architectures orientées services avec des outils open source.
L’objectif de ce workshop est de former les participants à la pratique des architectures orientés services. Les outils open source suivants seront utilisés :
A l'issue de ce séminaire, les participants seront en mesure de:
· Développeur Java
· Intégrateur SI
· IT manager
· Architectes d'applications
Pour bénéficier pleinement de ce cours, les stagiaires doivent avoir :
Présenter des problématiques d’intégration des applications d’Entreprise (EAI)
Présenter la démarche SOA, et présenter des concepts et de la démarche SOA (architecture orientée services), des besoins en infrastructures et de la notion de maturité SOA
Articles
Commentaires
