 |
 |
Florent, qui dirige le projet EasyBeans hébergé par ObjectWeb, détaille dans cet article les grands enjeux de l’évolution des Enterprise Java Beans (EJB) et la contribution de Bull et d’ObjectWeb avec EasyBeans. |
Aujourd’hui, la plupart des grandes applications d’entreprise sont amenées à être interopérables et centralisées. Pour faciliter leur développement, leur déploiement et leur exploitation, elles sont ainsi de plus en plus regroupées sur des serveurs d'applications ou des framework applicatifs, qui offrent une infrastructure technique robuste et permettent aux DSIs de se concentrer sur les logiques métiers. Les principaux serveurs d'applications du marché utilisent la technologie J2EE (monde Java) mais il existe d'autres frameworks concurrents, tels que la technologie.Net de Microsoft, Zope avec le langage Python ainsi que Ruby On Rails sans oublier le langage PHP.
J2EE : la plate-forme de référence pour les grandes applications distribuées
Apparue il y environ 8 ans, la technologie J2EE s’est aujourd’hui imposée comme une référence incontournable. Interopérable, standardisée, supportée par la majorité des éditeurs du marché, elle est particulièrement adaptée aux applications transactionnelles robustes et distribuées. Le principal atout des serveurs J2EE est leur architecture multi plate-forme liée à l'utilisation du langage Java. La plate-forme J2EE offre aussi la portabilité des applications d'un serveur à l'autre. De plus, l'ensemble du cycle de vie d'une application est couvert : développement, assemblage, déploiement et administration.
L'architecture J2EE est décomposée en différentes parties. La partie métier et l’interface avec les bases de données ("persistance") est réalisée sur le serveur avec des composants distribués transactionnels, les EJBs (Enterprise Java Beans), dont la spécification permet d’assurer l’intégrité transactionnelle des données accédées, propriétés ACID) et la partie présentation avec les Servlets/JSP (Java Server Pages), générant le code HTML qui sera affiché dans les navigateurs Web (clients légers). Il existe aussi les clients lourds avec une interface beaucoup plus riche mais nécessitant des bibliothèques côté client.
Les composants EJB peuvent accomplir des tâches diverses comme la vérification du crédit d’un compte, un calcul de taux de TVA ou l’accès à une base de tarifs. Ils sont conçus pour être portables et réutilisables sur tout type de serveur d’application Java. En production, les EJB sont exécutés dans les "conteneurs" gérés par les serveurs d’application. Ces conteneurs assurent les tâches techniques et les communications entre EJB, afin de permettre aux développeurs de se focaliser sur les aspects métiers du code.
Les limites de J2EE : la complexité
Si Java et J2EE ont connu un fort succès depuis plusieurs années grâce à leur solution puissante pour les applications critiques distribuées, ces technologies sont cependant jugées complexes et réservées aux développeurs avertis. Un exemple en est la création d'un EJB. En effet, jusqu’à la version J2EE 1.4 incluse, il fallait pour créer un objet métier (EJB), écrire des fichiers XML (un fichier standard et un fichier spécifique pour chaque serveur d'application) ainsi que plusieurs classes et interfaces Java. Les EJB ne proposaient pas non plus de mécanisme simple pour accéder aux données relationnelles et les conserver en mémoire. D’où un processus de développement lourd, créant un frein à l'adoption de ce sous-ensemble de la spécification J2EE, bien que des outils annexes soient apparus progressivement afin de simplifier la vie des développeurs J2EE, tels que XDoclet[http://www.xdoclet.org] pour écrire plus rapidement des EJBs ou Hibernate[http://www.hibernate.org] pour simplifier la persistance.
Jusqu’à présent, beaucoup d’entreprises n’hésitaient pas à s’appuyer sur un framework Java pur pour remplacer les services J2EE complexes : elles remplaçaient les EJB par des conteneurs légers tels que Spring, Struts ou Hivemind d’Apache. Elles avaient également recours aux systèmes de persistance Hibernate ou JDO (par exemple OJB d’Apache).
Java EE 5 et EJB3 : un développement fortement simplifié
La prochaine version de J2EE, appelée Java EE 5.0, est conçue pour apporter des réponses à ces contraintes et simplifier enfin le déploiement des EJB.
Grâce à l’adoption de méta données, le code est directement annoté sans passer par un fichier externe (XML). Par exemple, pour définir un EJB, la déclaration de la classe sera préfixée avec l'annotation @Stateless si c'est un EJB sans état. Les descripteurs de déploiement (fichiers XML) deviennent obsolètes, même s'ils sont toujours supportés. La persistance concernera tous les objets Java et sera aussi plus simple à construire grâce au concept d’annotation introduit par Java 5. Les EJB3 offriront notamment un modèle de persistance proche de celui utilisé par Hibernate. Celui-ci consiste à utiliser des objets standards (POJO : Plain Old Java Object). On crée un objet banalisé, on lui affecte des valeurs et au final, pour le rendre persistant, on le transmet à un objet se chargeant de gérer la persistance, un EntityManager : entityManager.persist(entityBean); l'objet est alors stocké dans une base de données.
La spécification EJB3 est dans sa dernière phase de finalisation; la version officielle étant attendue pour la conférence annuelle JavaOne 2006, se déroulant cette année au mois de mai prochain. Pour implémenter le draft de spécification et permettre aux développeurs d’en tirer parti pour simplifier leurs développements, seules de premières solutions propriétaires ou semi propriétaires, étaient apparues sur le marché depuis quelques mois : Oracle EJB3 et JBoss EJB3.
EasyBeans : première implémentation pleinement Open Source d’EJB3
Participant au développement de la spécification J2EE (désormais Java EE) au travers du Java Community Process (JCP) et la spécification EJB3 étant maintenant stabilisée, Bull et ObjectWeb ont décidé de développer une première implémentation pleinement ouverte et Open Source d’EJB3 : EasyBeans. [http://www.easybeans.org].
EasyBeans est la première implémentation pleinement Open Source du conteneur EJB3.0. Il s’interface aux solutions tierces permettant d’assurer la persistance, telles que Speedo d’ObjectWeb ou Hibernate. D'autres implémentations de la partie persistance pourront par la suite être rattachés à EasyBeans (par exemple OpenJPA, mis à disposition par BEA en Open Source), la spécification EJB3 définissant une API pour un échange entre les deux composants (conteneur et "persistance provider").
EasyBeans est spécifiquement conçu pour être facile d'emploi afin de rendre le développement plus rapide mais aussi léger et modulaire, répondant ainsi à la demande croissante des conteneurs légers.
Une technique avancée : l’injection de ‘bytecode’
Une technique avancée utilisée de façon intensive par EasyBeans est l'injection de bytecode. En langage Java, le code source d'une classe objet est transformé en un fichier nommé.class lors de la compilation. Ce fichier contient les instructions, le bytecode que l'interpréteur (JVM / Java Virtual Machine) va interpréter et exécuter. Avec la technique d'injection de bytecode, il est possible de manipuler le bytecode de l'objet et ainsi d'ajouter, modifier ou supprimer des attributs ou méthodes de la classe ou même de générer une classe entière. Cela est beaucoup plus performant que de devoir créer un fichier source Java puis le compiler. On modifie directement l'objet. Outre l'aspect performance, cela permet d'être dynamique (aucune phase de pré déploiement à réaliser), mais aussi d'être totalement transparent pour l'utilisateur. Cette modification de bytecode est réalisée avec l'aide du projet ASM d’ObjectWeb [http://asm.objectweb.org]. Un exemple est donné plus loin*.
Une réponse simple pour faciliter les développements Java, avec ou sans serveur d’application
EasyBeans, en implémentant une version stabilisée de la nouvelle spécification EJB3, redonne ainsi un intérêt certain à l'utilisation des EJB, en offrant aux développeurs un moyen à la fois très simple et très puissant pour développer leurs applications transactionnelles distribuées.
EasyBeans est bien sûr intégré et disponible dans le cadre du serveur d'application JOnAS, hébergé par ObjectWeb et dont Bull est responsable et contributeur majeur. Mais il est également possible d’utiliser directement EasyBeans pour les applications plus légères, sans serveur d'application (standalone) ou avec des serveurs J2EE partiels tels que Tomcat [http://tomcat.apache.org] (l’intégration avec Tomcat sera disponible dans les prochaines semaines).
EasyBeans offre ainsi une opportunité pour les développeurs J2EE d’accroître la rapidité des projets, et pour les autres développeurs de découvrir désormais en toute simplicité toute la puissance et l’ouverture de J2EE.
Un guide d'explication complet est disponible en ligne : http://www.easybeans.org/GettingStarted/GettingStarted.html, de même qu'un guide utilisateur et de développeur permettant de contribuer au projet.
La meilleure façon de découvrir les EJB3 est de télécharger EasyBeans et de tester par vous-même la simplicité de développement.
URL du projet : http://www.easybeans.org
Téléchargement : http://www.easybeans.org/download.html
Documentation : http://wiki.easybeans.objectweb.org/xwiki/bin/Main/Documentation
* Cas concret d'utilisation de manipulation de bytecode
Avec les EJB3, l’une des nouveautés est l'injection de ressource (ou dependency injection). Le bean demande au conteneur qui va exécuter le bean, d'injecter des ressources. Injecter une ressource consiste à initialiser des variables avec des objets donnant accès à des ressources externes : Base de données, Transaction, etc). Auparavant, le bean devait de lui-même rechercher la ressource.
Un exemple d'injection est la déclaration d'une variable permettant d'avoir accès à une base de données. Cette variable est de type Java javax.sql.DataSource.
Dans le code de l'EJB, il suffit d'ajouter une annotation sur un attribut, le conteneur va ensuite savoir qu'il doit injecter la ressource.
Exemple : @Resource(name="database") private DataSource dataSource. L'annotation étant @Resource.
EasyBeans injecte alors via ASM une nouvelle méthode dans le bean, nommé par exemple injectedByEasyBeans(); cette méthode s'occupant d'initialiser l'objet de type DataSource. Pour chaque annotation nécessitant l'injection de ressource, une instruction est ajoutée dans la méthode générée par EasyBeans. Le conteneur n'a alors plus qu'à instancier l'objet puis appeler la méthode injectedByEasyBeans(), le bean aura tous ses attributs initialisés. Aucun fichier Java n'a alors été généré, l'objet fourni par le développeur ayant été directement modifié, le tout étant totalement transparent pour l'utilisateur.
|
|
|
