Voici une petite revue du livre « Beginning Java EE 6 Platform with GlassFish 3 » édité chez APress, écrit par Antonio Goncalves, leader du Paris Java User Group, mais aussi expert sur les JSR-316 (Java EE 6), JSR-317 (JPA 2.0) et JSR-318 (EJB 3.1).
476 pages plus tard, après avoir pris mon temps pour le lire, j’ai été impressionné par la quantité et la qualité du travail. Expliquer un sujet comme la platfe-forme Java EE 6 en 500 pages, ce n’est pas une mince affaire mais un exercice réussi.
Ce livre s’adresse à un public assez large. Je pensais initialement qu’il faudrait avoir de bonnes connaissances au niveau de la plate-forme Java EE, mais le contenu étant très didactique, le livre s’adressera aussi sans problèmes aux débutants. A ma connaissance c’est le seul ouvrage en anglais sur ce sujet pour l’instant.
Vous avez remarqué que je parle de « plate-forme Java EE » plutôt que de Java EE 6 ? Qui se souvient de la JSR-151 ? Il s’agit la spécification de Java J2EE 1.4 qui date de 2004. 5 ans, c’est beaucoup dans le monde Java. La spécification JSR-244 spécifiant JEE5 date quant à elle de 2006.
La spécification de la plate-forme Java EE6 sort à peine, puisque la spécification JSR-317 (JPA2.0) a été proposé en final draft le 22 septembre dernier.
C’est donc un livre qui s’est terminé en même temps que le travail de spécification, avec certainement des précisions ou quelques changements l’année prochaine dans une réédition. Mais le contenu est vraiment complet.
Le livre est construit autour de 15 chapitres :
1 – Java EE 6 at a Glance
2 – Java Persistence
3 – Object-Relational Mapping
4 – Managing Persistent Objects
5 – Callbacks and Listeners
6 – Enterprise Java Beans
7 – Session Beans and the Timer Service
8 – Callbacks and Interceptors
9 – Transactions and Security
10 – JavaServer Faces
11 – Pages and Components
12 – Processing and Navigation
13 – Sending Messages
14 – SOAP Web Services
15 – RESTful Web Services
Moi qui suis sensible au style et à l’écriture, j’ai bien aimé le ton très didactique. Pour avoir lu pas mal de livres en Anglais et en Français, c’est vraiment bien écrit, les pages se tournent toutes seules.
Le premier chapitre vous guide dans l’installation de votre plate-forme pour coder ensuite les exemples du livre. Mes premières impressions sont que JEE 6 est plus léger que son cousin JEE 5. Plus facile à mettre en marche aussi.
Le chapitre 2 sur la persistence et JPA 2.0 nous guide dans l’écriture d’une petite application avec la gestion d’entité, l’écriture des tests avec Derby, les principes de requêtes, avec un résumé en fin de chapitre. C’est un chapitre orienté pratique.
La théorie au chapitre 3 permet de comprendre en 60 pages les principes de l’Object-Relational Mapping. En expliquant en détail le principe du mapping avec annotation et XML, la gestion des relations de 1 à n, c’est plutôt théorique, mais bien illustré avec des schémas.
Le chapitre 4 est dans la continuité du 3. Comment interroger des objets persistants ? Quel est le rôle de l’EntityManager, le langage JPQL, la création des Queries et enfin la gestion de la concurrence avec JPA 2.
Le chapitre 5 relativement court n’est pas le plus important, on y parle des callbacks et des listeners afin d’être notifié du cycle de vie des Entities.
C’est au chapitre 6 que l’on rentre dans le coeur de la spécification JSR-318 à mon avis. Avec tout d’abord un rappel des Enterprises Java Beans, réactualisé avec le recul dont nous bénéficions aujourd’hui. Le livre est construit en partant de la base de données, pour ensuite attaquer les EJBs et se termine par REST en passant par JSF. Tout au long du livre nous suivons la constructions d’un site marchand.
J’en appelle tout d’abord aux sceptiques qui pensent que Spring peut sauver le monde. Franchement, allez voir un peu les dernières nouveautés, car la simplicité et la beauté des EJB 3.1 en font de sérieux candidats pour virer nos copains les petits Beans. Comment dire ? En fait c’est plus mature. L’anatomie d’un EJB coule de source.
Je me souviens d’une présentation à Devoxx qui m’avait bluffé : l’écriture en 1h d’une application complète JEE6 avec au passage, de sérieux coups à notre bon vieux copain Spring. Il faut dire ce qu’il est : il serait dommage de ne vivre que sur la branche Spring et de ne pas regarder ce que Java propose désormais.
Page 171 par exemple, on se plonge dans la description d’un conteneur EJB avec plaisir. Etre concis c’est facile. Etre concis et précis, c’est plus dur. Le conteneur embarqué permet ainsi de travailler simplement avec les EJBs :
EJBContainer ec=EJBContainer.createEJBContainer();
Context ctx=new Context();
BookEJB bookEJB=(BookEJB) ctx.lookup("java:global/BookEJB");
bookEJB.createBook(newBook);
Le chapitre 6 se termine par un atelier où le lecteur est amené à coder la partie service de son application. La compilation du projet avec Maven 2, révisée aussi par Arnaud Lheritier, vous permet vraiment d’être productif. Ce n’est pas un livre qui vous dit : « bon et bien vous lancez néclipseu et puis zou… ça compile… ». Peut-être parce qu’Antonion est un fan d’IDEA IntelliJ ? Tant mieux !
Les chapitres 7,8 et 9 couvrent les services annexes de la plate-forme comme le Timer Service par exemple. Cela permet de créer des Beans qui s’activent de manière régulière, comme un cron. Très pratique. J’ai honnêtement survolé le chapitre 8, et j’ai regardé la gestion des Transactions et de la Sécurité.
Le chapitre 9 débute par un rappel des principes des transactions (ACID) toujours bon à revoir. Bon l’exemple du transfert bancaire sens un peu la naphtaline mais comme le principe est d’expliquer l’Atomicité, cela fonctionne.
Allez citez-moi les 6 attributs de démarcation des transactions gérées par le conteneur… Allez je vous attends : REQUIRED, REQUIRES_NEW, SUPPORTS, MANDATORY, NOT_SUPPORTED et NEVER.
Un schéma simple résume les différences entre chacun de ces attributs, et du code vous montre ensuite sa mise en oeuvre dans un EJB.
La sécurité est ensuite abordée. Les annotations bien entendu apportent une simplification, la possibilité de verrouiller le code de son application est bien expliquée.
La fin du livre aborde la couche de présentation. JSF 2 tout d’abord, qui sera aussi présenté le mardi 13 octobre au Paris JUG. Si vous venez, pensez à vous inscrire sur la liste de diffusion du Paris JUG afin d’être notifié lorsque les inscriptions seront ouvertes.
Revenons à JSF 2.0. Page 270, après un historique de JSF, nous entrons dans le vif du sujet. Les exemples de code me parlent, et là où il faut 3 interfaces, 2 DAO et je ne sais pas combien de machin pour afficher une liste, JSF 2.0 et les EJB 3.1 sont dramatiquement simples.
Oui je sais, tu es fan de Wicket et de GWT. Non de Spring MVC pardon. Et tu te dis que je rame pour présenter le sujet… Pas du tout.
Les gens ont longtemps pensé que la terre était plate, et lorsqu’un explorateur a prouvé le contraire, il s’est fait griller. Je m’attends donc à une levée de bois vert, où chacun avec son web framework et ses interfaces s’empressera de crucifier JSF 2.0. Et bien non, en 2009 la spécification a vraiment évolué.
Si vous sortez vos vieux numéros du Touilleur Express, regardez en 2006 ce que je m’amusais à écrire pour l’époque. Ou cet article de 2005 qui est vraiment vieux, après un passage chez Valtech et une présentation des EJB3.
Là où je préfère Wicket, c’est son intégration fine avec la page Web. JSF 2.0 n’est pas loin, mais il n’y a pas cette notion de balises standards décorées. Cela dit, la mise en page HTML s’effectue aussi sans problèmes. Le chapitre 11 parle de la mise en page, des styles, et aussi de JSP. Cependant comme expliqué à un point dans le livre, la plate-forme stratégique de rendu de JEE6 est JSF 2 plutôt que JSP. Pensez-y si vous souhaitez faire une formation de remise à niveau.
Vers les pages 299-306 on redécouvre aussi (pour moi) que les taglibs peuvent rendent service pour des exemples de code très simple. La suite se concentre sur JSF 2, la définition de la navigation, les Validators et Ajax. Et j’ai trouvé ce chapitre vraiment complet, le sujet est abordé très précisément. La question des annotations versus la déclaration statique dans les fichiers XML est aussi expliquée simplement.
Le chapitre 13 aborde la présentation du Messaging Layer de la plate-forme de Java EE6. De la définition d’un MDB en passant par une présentation détaillée de JMS, rien ne manque. L’injection de dépendance est au coeur de la plate-forma Java, avec l’injection des Resources de type ConnectionFactory ou Queue. Rien à redire, c’est similaire à Spring, mais plus intuitif. L’arbre JNDI remplace ce qu’il manque je pense dans la sauce des descripteurs XML de Spring : un annuaire. Mince j’ai critiqué Spring, je vais encore me faire crucifier…
Le chapitre 14 présente les Web Services. La mise en place de JAXB 2.0 et des annotations permet vraiment de rendre simple la création et l’appel des Web Services. C’est bien simple, comme un vendeur de Darty j’ai envie de vous dire : « et j’ai le même à la maison, et ça marche très bien… ».
Cependant quel est le recul et le retour sur cette partie ? Au niveau des performances ? De la simplicité de déploiement ?
Enfin le dernier chapitre parle de REST et des Web Services. On sort un peu de la norme puisque REST est un principe d’architecture. Le chapitre présente JAX-RS 1.1 avec l’implémentation Jersey proposée par SUN Microsystems.
Ce chapitre est vraiment intéressant à lire si l’architecture est un sujet qui vous intéresse. Il ouvre des portes vers de nouveaux services, une autre façon de concevoir nos applications. Le principe de REST date de 2000, mais est-ce à dire que nous en verrons que maintenant les premiers projets ?
@Path("/book")
public class BookResource {
@GET
@Produces("text/plain")
public String getBookTitle() {
return "GlassFish V3";
}
}
J’imagine une architecture avec un Web tiers, composé de Portlet, mon dada en ce moment. Et ces portlets ou même des Gadgets comme chez eXo, pourraient consommer des services de type REST qui exposeraient du json par exemple.
Cela résout un problème de rupture de protocole pour la sécurité, mais me semble plus élégant que des anciens EJB.
Conclusion
Le livre s’adresse donc à des débutants de la plate-forme JEE6, à des architectes qui souhaitent remettre leurs connaissances à jour. Honnêtement, ne faites pas la bêtise de vous enfermer dans une seule technologie comme Spring. Notre métier évolue très vite, et je ne dis pas que nous ferrons tous du Java EE 6 l’an prochain, mais au moins vous aurez pris le temps de regarder et de comprendre.
A quand aussi une version traduite en français, réactualisée l’année prochaine par exemple ?
0 no like
Merci pour ce feedback!
Le seul truc qu’il manque c’est la JSR 299 « Contexts and Dependency Injection »mais je pense que le livre a été écrit trop tôt pour ça… peut être dans la seconde édition!
Non, il manque aussi servlet 3.0! Plein de bonnes choses là bas.
Au boulot Antonio! 😉
Mouais, alors excuse-moi Nicolas, je vais me permettre de passer un petit coup de gueule.
Il n’y a pas de mal à casser du sucre sur le dos de Spring quand c’est justifié, mais j’ai là j’ai l’impression que tu t’es laissé emporter par les sirènes d’Antonio (y a-t-il des messages subliminaux entre les lignes dans le bouquin d’Antonio, comme dans « Stairway to heaven? » 😉 ).
As-tu vraiment comparé toutes les fonctionnalités que Spring te fournit par rapport à JEE6?
Pour te citer quelques détails, dans la déclaration des transactions avec Spring, on peut utiliser les expressions AspectJ pour avoir une déclaration générique, on peut fournir une annotation custom héritant de @Transactional (à partir de Spring 3.0). On peut aussi faire porter les transactions sur tout type de classe (y compris les classes qui ne sont pas des beans Spring, avec AspectJ). En conséquence, tu peux aussi avoir le code transactionnel injecté en phase de compilation, ce qui te permet de démarrer le serveur plus vite, sans avoir à tisser les proxies au démarrage du serveur.
Pour la sécurité, ça va même beaucoup plus loin. Je pense que la sécurité JEE ne propose qu’un petit sous-ensemble de ce que fait Spring Security.
Je trouve ça très bien qu’il y ait un standard de qualité, et on adaptera Spring pour qu’il soit compliant avec ce standard. Mais il faut pas sous-entendre que si tu enlèves Spring de ton application la semaine prochaine, tu retrouveras toutes les fonctionnalités que tu aimes bien.
Pour moi, le standard proposera un nombre de fonctionnalités minimum, et Spring permettra d’aller plus loin en rajoutant des annotations proposant des fonctionnalités plus avancées (un peu à la « Hibernate annotations »).
Mais bon tout ça c’est le futur, il faut pas oublier que tu t’emballes sur une spécification qui sera bientôt implémentée par Glassfish, et qui risque de ne pas être utilisable avec les autres serveurs d’application d’ici 1 à 3 ans (cf. le temps qu’il a fallu pour que Websphere, JBoss etc implémentent JEE5). Donc d’ici à ce que tu puisses l’utiliser chez ton client, on aura tous eu le temps de prendre quelques rides 🙂
Salut Michael,
Ce n’est pas Spring que j’attaque.
C’est la monogamie déclarée de nous, les développeurs, qui pensont de manière cyclique qu’il y a « un meilleur framework » sans prendre le temps de continuer à regarder autour de nous.
Le livre m’a fait prendre conscience qu’un gros retard a été rattrapé par JEE 6, certainement grâce à Spring. C’est vrai.
Je reconnais avoir dit « plus mature » et « plus intuitif » pour JEE6 par rapport à Spring, ce qui est très subjectif, pas argumenté pour un sous, donc tout à fait critiquable. C’est pour cela qu’un blog n’est pas un article de journal : j’ai le droit de me tromper, d’avoir un avis et une opinion.
En fait je ne crois pas une minute à un débat Spring vs JEE6. Ce serait une tentative de comparer 2 choses différentes, 2 organisations complètement différentes. On peut tenter mais c’est un peu perdre du temps.
Je lis aussi en ce moment Spring par la pratique v2, et j’ai par ailleurs aussi commenté un livre que j’ai bien aimé appelé « Spring par l’exemple » traduction de Gary Mak
http://www.touilleur-express.fr/2009/07/07/revue-du-livre-spring-par-lexemple-de-gary-mak
Est-ce que l’on devrait se lancer dans un comparo comme dans l’AutoJournal avec des notes de chacun des 2 technologies pour les départager ? Je ne pense pas que cela fasse avancer Spring ou JEE6.
Non, il faut combattre par contre cette tendance que l’on a, qui est de
chercher « un meilleur » alors qu’il n’y en a pas.
Spring aujourd’hui, J2EE hier, JEE6 demain ?
Je ne sais pas… en tous les cas je regarde
🙂
@Nicolas Merci pour ce post. Je prend note des remarques (il faut que je trouve un autre exemple que le transfert de compte bancaire pour expliquer JTA ;o) Par contre, pas de traduction en français de prévu.
@Loic @Alexis Lorsque j’ai terminé d’écrire le livre, JSR 299 et Servlet 3.0 n’étaient pas encore terminées, j’ai préféré ne rien écrire pour la 1ère édition. Il y a aura une 2e édition… mais pas tout de suite, il faut que je me repose ;o)
@Michael Non, pas de message subliminale dans mon livre ;o) Je ne parle pas du tout de Spring en fait. Peut-être une référence à droite à gauche pour raccorder les wagons, mais ce livre n’est pas du tout un manifest anti-spring (alors que les présentations SpringSource ont longtemps été un manifest anti-J2EE). Moi je vois une harmonisation coté serveur (Spring 3 et Java EE 6 se ressemblent beaucoup par endroit), ce qui est loin d’être le cas coté client. Comme tu dis, la sécurité Spring est plus riche que celle proposée par Java EE… il y a donc des choses à prendre d’un coté comme de l’autre.
@Antonio : oui, c’est clair qu’on a longtemps été un petit village d’Asterix dans un monde J2EE. Mais les choses semblent converger et tu as dû voir que Spring supportera les annotations JEE6 dès que la spec sera finalisée (ce qui correspondra à Spring 3.1). Donc on s’améliore :). On va même supporter @Inject par anticipation en Spring 3.0.
@Nicolas : suis pas trop fan de l’auto-journal non-plus :). certes il n’est pas bien de comparer, mais il est quand même utile de guider les gens qui vont avoir un choix à faire et je pense qu’il y a beaucoup de choses à dire sur le sujet (surtout pour ceux qui choisissent l’approche XML, qui ne permet pas de mixer Spring et JEE 6). C’est une thématique récurrente chez nos clients en ce moment.
Michael, il va falloir accorder les violons de SpringSource. Cet autre thread (http://www.adam-bien.com/roller/abien/entry/jsf_jpa_ejb_bloat) assure que rien n’est fait coté support Java EE 6 et que ce ne sera certainement pas dans le framework Spring (uniquement dans SpringDM)…
Pour une présentation Spring vs. Java EE 6 (pour ceux qui la veulent quand même) : http://www.redhat.com/f/pdf/jbw/rrahman_320_spring_framework.pdf
Reza est un indépendant.
@Michael, lorsque tu dis que Spring supportera les annotations Java EE 6, ça va tout et rien dire. Le discours de Spring est très ambigüe à ce sujet. JAX-RS ? oui mais non, Servlet 3.0 oui lorsque Tomcat 7 sera prêt, EJB 3.1 oui ou non ? Si tu lis les commentaires du blog d’Adam (http://www.adam-bien.com/roller/abien/entry/jsf_jpa_ejb_bloat) il y a quand même des retournements de veste de la part de Spring tout au long des conférences. Le discours change selon les intervenants.
Félicitations à Antonio pour le bouquin, j’espère qu’il me dédicacera un exemplaire au prochain PJUG 🙂
Les commentaires sont presque aussi intéressants et instructifs que l’article 🙂 .
Hello,
bon je pense avoir eu raison d’Antonio lors d’un déjeuner ce midi, il m’a même confié qu’il lisait secrêtement Spring par la pratique le soir pour s’endormir. Comme quoi une bonne bouteille de vin, ça arrange tout :).
Plus sérieusement, en disant qu’on va supporter les annotations JEE6, c’était une phrase vite dite, je n’avais pas creusé le sujet très en détail (mea culpa messieurs JEE, mais bon chacun son métier 🙂 ).
Je sais qu’on supporte déjà pas mal d’annotations standard comme @Resource, @RoleBased, @PostConstruct etc et ça va s’enrichir avec Spring 3.1. Ceci dit, j’ai comme l’impression que c’est un sujet qui va devenir de plus en plus récurrent, on aura l’occasion d’en reparler :).
Mic.
Par ailleurs, si vous êtes intéressés par le sujet : http://parisjug.org/xwiki/bin/view/Meeting/20091208