Les livres Java Web en Anglais

Ce livre couvre les nouveautés de JSF 2 à travers environ 100 recetttes. A mon avis ces recettes fournissent un bon aperçu des nouvelles possibilités de la dernière version de JSF.
Les chapitres apportent des solutions immédiates à des problèmes et des pré-requis très courants dans le développement web.
Bien sûr il est nécessaire de lire plus de documentation sur JSF 2 (telle que la référence complète) pour être capable de complètement comprendre et connaître les différentes options.
Le principal IDE et le serveur utilisés dans le livre sont NetBeans 6.8 et GlassFish 3, respectivement. L'IDE Eclipse Ganymede est utilisé dans une recette (utilisation de JSF ID generator).

Les deux premiers chapitres donnent une bonne idée des validators et des converters, personnalisés et standards. Apache MyFaces Trinidad et RichFaces sont utilisés. La validation est également mise en oeuvre à travers l'intégration de la JSR-303 (Bean validation) dans JSF 2.

Le chapitre 3 concerne la gestion des fichiers (envoi, téléchargement, extraction, export) avec l'aide des librairies Mojarra Scales et de composants dans RichFaces et PrimeFaces.

Le chapitre 4 est un autre chapitre intéressant qui explore les différents moyens de protéger un site. Il met en oeuvre l'utilisation des expressions EL qui font partie du projet JSF Security et qui utilisent une portée séparée et appelée securityscope. Les rôles sont basés sur JAAS, stockés dans une base ou ajoutés à la HttpSession. La dernière recette utilise Spring Security pour gérer une page de login.

Le chapitre 5 fournit des recettes pour la création de divers composants personnalisés (hello world, un visualiseur d'images avec des fonctionnalités Ajax en utilisant le projet Dynamic Faces project, etc) et également des composants composites personnalisés.

Le chapitre 6 concerne Ajax. Il couvre le nouveau tag <f:ajax> et utilise de nouveau plusieurs autres librairies de composants pour ajouter des fonctionnalités Ajax (Dynamic Faces, Tomahawk, ajax4jsf, PrimeFaces ...).

Le chapitre 7 traite des besoins fréquents en matière de site que sont l'internationalisation et la localisation. Il utilise le tag core f:loadBundle, les fichiers de messages properties, l'encoding ...

Le chapitre 8 montre comment ajouter des styles CSS à des tags JSF, peupler des grids avec des styles CSS, intégrer JavaScript dans JSF avec divers exemples, récupérer des images d'une base et les envoyer de façon dynamique à une page JSF. Il y a même une recette qui montre comment utiliser la librairie de tag rss4jsf pour montrer du contenu RSS dans des pages JSF.

Le chapitre 9 introduit diverses applications :
- l'outil Faces Console pour éditer de façon visuelle les fichiers de configuration JSF
- JSFUnit (un framework JBoss pour tester des applications JSF)
- JMeter pour mesurer la performance
- JSF Chart Creator pour afficher des graphes

Le chapitre 10 est un chapitre important puisqu'il traite des Facelets qui, à partir de la version 2.0 de JSF, font partie de la spécification JSF et sont la technologie de présentation recommandée avec JSF. Le templating et les composants de composition sont les sujets les plus traités dans ce chapitre.

Le chapitre 11 est un ensemble de sept recettes autour des nouveautés de JSF 2.0 qui n'ont pas été abordées dans les précédents chapitres.

Enfin le chapitre 12 est un autre chapitre utile puisqu'il montre l'intégration de JSF avec d'autres technologies telles que Spring et les EJB.

L'appendix contient des listings des fichiers de configuration pour les frameworks basés sur JSF.

Ce que j'ai le plus aimé : les recettes sont basées sur des besoins et des problèmes fréquemment rencontrés lors du développement. Elles sont donc très utiles.

Ce que j'ai moins aimé : je n'ai rien de particulièrement négatif à signaler. Ce livre de recettes correspond à l'idée et aux attentes que j'avais avant de le lire.

English version :

This book covers the new features of JSF 2 in the form of about 1OO hundred recipes. In my opinion these recipes give a good overview of the new capabilities of the latest version of JSF.
The chapters get right to the point with very common problems/requirements in web development and their solutions.
Of course you still need to read more documentation about JSF 2 (such as the complete reference) to be able to completely understand and know the different options.
The main IDE and the server used in the book are NetBeans 6.8 and GlassFish 3, respectively. The IDE Eclipse Ganymede is used in one recipe (Using JSF ID generator).

The first two chapters give a good idea of the custom and standard validators and converters. Apache MyFaces Trinidad and RichFaces are used. Validation is also demonstrated through the built-in integration of JSR-303 (Bean validation) in JSF 2.

Chapter 3 is about file management (uploading, downloading, extraction, export) with the help of Mojarra Scales libraries, RichFaces and PrimeFaces components.

Chapter 4 is another interesting chapter that explores various ways to protect a site. It demonstrates the use of EL expressions part of the JSF Security project which uses a separate scope called securityscope. Roles are based on JAAS, stored in a database or added to the HttpSession. The last recipe makes use of Spring Security to manage a login page.

Chapter 5 provides recipes to demonstrate the creation of various custom components (hello world, image slide viewer with Ajax functionality using the Dynamic Faces project etc) and also composite custom components.

Chapter 6 is about Ajax. It covers the new tag <f:ajax> and again uses several other component libraries to add Ajax features (Dynamic Faces, Tomahawk, ajax4jsf, PrimeFaces ...).

Chapter 7 is about the frequent site requirements that are internationalization and localization. It uses the core tag f:loadBundle, messages properties files, encoding ...

Chapter 8 shows how to add CSS styles to JSF tags, populate grids with CSS styles, integrate JavaScript to JSF with various examples, retrieve images from a database and provide them dynamically to a JSF page. There is even a recipe that shows how to use the tag libary rss4jsf to show RSS content in JSF pages.

Chapter 9 introduces various applications :
- the Faces Console tool to visually edit JSF configuration files
- JSFUnit (JBoss framework for testing JSF applications)
- JMeter to measure performance
- JSF Chart Creator to diplay charts

Chapter 10 is an important one since it is about Facelets which, starting with JSF 2.0, is a part of the JSF specification and the recommended presentation technology to use in conjunction with JSF. Templating and composition components are the topics most discussed in this chapter.

Chapter 11 is a set of seven recipes about new features in JSF 2.0 that were not seen in the previous chapters.

Finally chapter 12 is another useful chapter since it shows how to integrate JSF with other technologies such as Spring and EJB

The appendix contains listings of the configuration files for JSF-related frameworks.

What i liked most : the recipes are based on frequent requirements and problems encountered when developing. So they are really useful.

What i liked the least : nothing really negative to report. This book of recipes meets the idea and expectations I had of it before reading it.

Efficace, le livre de Bill Burke ! Structuré et de longueur idéale (moins de 200 pages sans le Workbook), l'ouvrage publié par O'Reilly constitue une très bonne introduction aux services RESTful et à leur implémentation en Java. Après de brefs rappels sur l'architecture de l'information Web et sur les principes de REST (Adressability, Uniform interface, Representation-oriented, Statelessly communication, HATEOAS), l'auteur détaille clairement et de façon illustrée la réalisation de services JAX-RS simples (programmation, déploiement) puis introduit les autres composantes de l'architecture (annotations disponibles, injections JAX-RS, traitement du contenu du message et IOs, JAXB, JSon, Marshalling, etc.). Le professionnel ne sera pas en reste, avec des chapitres consacrés aux problématiques d'entreprise, comme la montée en charge, le caching, le déploiement, la sécurité. Une dernière partie particulièrement étoffée "JAX-RS Workbook" accompagne chaque chapitre avec l'intégralité des codes sources et exemples. Un livre sérieux donc, même si le sujet est d'apparence relativement simple, et qui conviendra selon moi à un public technique, débutant ou confirmé. Le seul petit regret est l'absence d'exemples concernant l'écriture de tests unitaires pour des services RESTful et les bonnes pratiques dans ce domaine.

Ce livre est composé de 15 chapitres. On peut considérer que les 9 premiers chapitres (205 pages) présentent les nouveautés de Struts 2 et le reste du livre est un mélange d'apprentissage de JavaScript/Ajax et de bonnes pratiques pour documenter et tester une application web.
Il repose sur la version 2.1.6 de Struts.
Les exemples du livre sont téléchargeables à l'adresse : http://www.packtpub.com/sites/defaul.../3391_Code.zip

Chapitre 1 :
Le chapitre 1 est une première introduction à Struts 2 avec une liste des principales nouveautés. Le lecteur est également introduit aux pratiques agiles .

Chapitre 2 :
Ce chapitre continue sur les nouveautés de Struts 2. L'auteur commence à développer l'application RecipeBox, un site d'échanges de recettes de cuisine, en suivant les pratiques agiles avec des user stories.
Les plug-ins Configuration Browser et Convention sont utilisés.

Chapitre 3 :
Ce chapitre fait le tour de la classe ActionSupport (validation, internationalisation ...). L'auteur fournit également des conseils pour le développement avec l'utilisation de Cygwin et d'Eclipse.

Chapitre 4 :
Ce chapitre se concentre sur les Results qui sont les retours des actions. Différents types de Results sont examinés, notamment FreeMarker. Le plug-in Convention est largement utilisé dans les exemples (annotations @Result, @Action ...).

Chapitre 5 :
Dans ce chapitre, l'auteur examine OGNL, la value stack et plusieurs tags (<s:include>, <s:sort>, <s:append>, <s:merge>, <s:action>, <s:generator>, <s:url>, ...). Ces tags génériques sont richement expliqués, même ceux qui ne sont pas fréquemment utilisés.

Chapitre 6 :
Ce chapitre examine les tags UI qui font partie du formulaire. Chaque tag UI (<s:form>, <s:textfield>, <s:checkbox>, ...) est bien expliqué, avec des exemples. L'auteur apporte une petite introduction aux thèmes et templates (ils sont abordés en détails dans le chapitre 12). Il apporte également des explications pour l'upload de fichiers et le traitement des soumissions en double (tag <s:token>).

Chapitre 7 :
Ce chapitre fait le tour de la validation et de la conversion des données. Les différentes méthodes de validation sont abordées (fichier XML, validation manuelle, annotations), que ce soit côté serveur ou côté client (JavaScript). J'ai trouvé les explications suffisantes et les remarques pertinentes.

Chapitre 8 :
Ce chapitre présente les intercepteurs, examine ceux disponible dans la pile par défaut et décrit comment écrire ses propres intercepteurs à partir d'un exemple (interceptor trim) bien fourni en explications (tant dans le code que dans la configuration).

Chapitre 9 :
Les différentes techniques de gestion des exceptions et la gestion des logs sont examinées dans ce chapitre. L'auteur explique la configuration des logs avec Log4J.

Chapitre 10 :
Dans ce chapitre entièrement consacré à JavaScript, l'auteur explique la syntaxe de ce langage très utilisé dans la construction d'applications Web.

Chapitre 11 :
Ce chapitre aborde encore JavaScript mais aussi CSS et la librairie jQuery. J'ai bien aimé l'exemple donné à la fin du chapitre pour l'ajout d'une ligne, de façon dynamique, dans un formulaire, ce qui est un besoin courant.

Chapitre 12 :
Lors de mes précédentes recherches, j'avais trouvé peu d'informations sur la création de thèmes. C'est pourquoi je trouve que ce court chapitre, consacré aux thèmes et aux templates, fournit une aide précieuse.

Chapitre 13 :
Ce chapitre présente la librairie JavaScript Dojo et jette un regard sur les tags Dojo dans Struts 2 pour faire de l'AJAX. Le plug-in REST est également présenté, avec ses différents types de réponse (JSON, XML, XHTML).

Chapitre 14 :
Ce chapitre est dédié aux tests et examine le développement dirigé par les tests. Pour cela les frameworks JUnit et TestNG sont utilisés. L'injection de dépendance est également expliquée et utilisée pour les tests. L'auteur en profite alors pour introduire le plug-in Spring pour Struts 2.
Enfin d'autres formes de tests sont présentées : les tests fonctionnels à l'aide de Selenium, les tests de montée en charge avec JMeter.

Chapitre 15 :
Ce chapitre s'écarte un peu du sujet principal du livre (Struts 2) pour aborder la documentation dans un projet. C'est donc l'occasion pour l'auteur de présenter l'AOP, l'outil Javadoc, la modélisation UML, la gestion des sources ...

Ce que j'ai aimé :
Les références données à la fin de chaque chapitre. Ce sont des liens qui permettent d'approfondir des notions.

Ce que j'ai moins aimé :
Je n'ai pas vraiment de critique négative à faire sur le contenu de ce livre, je pense en effet qu'il représente un bel effort pour présenter les nouveautés de Struts 2 et donc faciliter l'apprentissage de la nouvelle version de ce framework auquel on a souvent reproché son manque de documentation.

English version :

This book is made of 15 chapters. One might consider that the first nine chapters (205 pages) explain what's new with Struts 2 and that the rest of the book is a mix of JavaScript/Ajax learning and good practices to document and test a web application.
It is based on the 2.1.6 version of Struts.
The book samples can be downloaded at the following address : http://www.packtpub.com/sites/defaul.../3391_Code.zip

Chapter 1 :
This chapter 1 is a first introduction to Struts 2 with a list of the main new features. The reader is also introduced to the Agile method.

Chapter 2 :
This chapter is still about the new features in Struts 2. The author begins the development of a RecipeBox application, a recipe swapping website, following the Agile method with user stories.
The Configuration Browser and Convention plug-ins are used.

Chapter 3 :
This chapter is about the ActionSupport class (validation, internationalization ...). The author also provides tips for development with the use of Cygwin and Eclipse.

Chapter 4 :
This chapter focuses on Results which are the actions' responses. Different Result types are examined, in particular FreeMarker. The Convention plug-in is widely used in the samples (annotations @Result, @Action ...).

Chapter 5 :
In this chapter, the autheur examines OGNL, the value stach and several tags (<s:include>, <s:sort>, <s:append>, <s:merge>, <s:action>, <s:generator>, <s:url>, ...). These generic tags are richly explained, even those that are not frequently used.

Chapter 6 :
This chapter examines the UI tags that are part of the "form". Each UI tag(<s:form>, <s:textfield>, <s:checkbox>, ...) is well explained, with samples. The author gives a small introduction to themes and templates (they are detailed in chapter 12). He also gives explanations to upload files and to handle double submits (<s:token> tag).

Chapter 7 :
This chapter looks at the validation and the conversion of data. The different methods of validation are explained (XML file, manual validation, annotations), whether it is server-side or client-side (JavaScript). I found the explanations sufficient and the remarks pertinent.

Chapter 8 :
This chapter is about interceptors and examines those that are available in the default stack. It explains how to write your own interceptors with a sample (trim interceptor) that i found well documented with code and configuration explanations.

Chapter 9 :
The different mecanisms to handle exceptions and logs are examined in this chapter. The author explains the logs configuration with Log4J.

Chapter 10 :
In this chapter entirely dedicated to JavaScript, the author explains the syntax of this widely used language for the development of Web applications.

Chapter 11 :
This chapter is still about JavaScript but also CSS and the jQuery library. I liked the example, at the end of the chapter, to add a line, in a dynamic way, in a form and which is a frequent requirement.

Chapter 12 :
During my previous researches, I found very little information for the creation of themes. That is why I think this short chapter, dedicated to themes and templates, provides a precious help.

Chapter 13 :
This chapter describes the Dojo JavaScript library and takes a look at the Dojo tags in Struts 2 to create Ajax applications. The REST plug-in is also introduced, with its different return types (JSON, XML, XHTML).

Chapter 14 :
This chapter is dedicated to tests and examines test-driven development. For this purpose the JUnit and TestNG frameworks are used. Dependency injection is also explained and used in tests. The author takes this opportunity to introduce the Spring plug-in for Struts 2. Finally, other forms of testing are introduced : functional testing with the help of Selenium, load testing with JMeter.

Chapter 15 :
This chapter diverges a bit from the main topic of the book (Struts 2) to look at ways to document a project. It is then an opportunity for the author to introduce AOP, the Javadoc tool, UML modeling, source code control systems ...

What I liked the most :
The references that are given at the end of each chapter. They are links for the reader to check if he wants to take a deeper look into topics of the current chapter.

What I liked the least :
I do not really have any negative critic to make on the content of the book. I think it represents a real nice effort to explain the new features of Struts 2 and that it will help developers who want to learn the framework in this latest version, which has often been criticized for its lack of documentation.

Ce livre est une très bonne introduction à la création d'applications modulaires en Java. Ce livre présente tous les principaux concepts de la technologie OSGi, de Spring Dynamic Modules ainsi que des outils permettant de faciliter le développement d'applications OSGi.
Le premier chapitre présente la problématique de modularité et présente comment OSGi tente de résoudre ce problème. Les concepts principaux de la technologie y sont également décrits.

Le second chapitre présente différents conteneurs OSGi. Dans ce chapitre, on crée un premier programme Hello World en utilisant OSGi. On améliore ensuite ce programme en utilisant la publication et la consommation de services OSGI.
Le troisième chapitre introduit l'application "Dude, Where's my Jar ?" qui nous suivra tout au long du livre. Cette application est une application web permettant d'effectuer des recherches de fichier Jar dans des repository Maven. En plus de cela, le chapitre présente la série d'outils Pax qui permettent de faciliter le développement d'applications OSGi.

Le chapitre suivant voit la création du premier bundle de notre application grâce auquel on adresse les premières problématiques du développement OSGi, à savoir l'utilisation de dépendances non-OSGi.

Le chapitre cinq développe le bundle suivant. Ce chapitre se focalise sur la publication et la consommation de services OSGi. En plus de cela, on apprend également à tester une application et des services OSGi.
Il est maintenant temps de passer à Spring Dynamic Modules avec le chapitre suivant. On y voit comment faciliter la consommation et la déclaration de services sous forme de beans Spring.

Avec le chapitre 7, on commence à développer le bundle web. Pour cela, on va inclure Tomcat ou Jetty sous forme de bundles OSGi. On va ensuite voir les différences qu'il y a entre déclarer un bundle simple (JAR) et un bundle web (WAR).
Le chapitre suivant traite de l'extension de bundle OSGI au moyen de fragment. On va notamment voir comment découpler la partie JSP et design de la partie applicative.

L'avant dernier chapitre permet de voir comment déployer une application OSGi en production. Il présente l'ajout d'une console web à l'application pour administer directement les modules.
Le dernier chapitre présente les services de journalisation et d'administration qui font partie de la norme OSGi.
En conclusion, ce livre vous permettra de commencer à développer des applications utilisant OSGi.
C'est très agréable de suivre le développement d'une application tout au long du livre, tout en découvrant au fur et à mesure ce qu'OSGi permet de faire pour faciliter le développement d'une application.

Néanmoins, je trouve qu'on aurait pu éviter de se baser tant que ça sur les outils Pax. On perd presque de vue OSGi à partir de l'utilisation de Pax. Il se peut qu'on ne puisse utiliser Pax dans une application et dans ce cas, on pourrait ne pas savoir tout faire.
Certes, il est utile de voir le déroulement Maven les premières fois, mais ce n'est pas utile de les afficher systématiquement. Certaines pages ne contiennent presque que des traces Maven qui ne correspondent ni à des erreurs, ni à des informations intéressantes. Mais malgré cela, la lecture du livre reste très fluide et intéressante.

Antonio Goncalves, pour ceux qui ne le savent pas encore, est le co-créateur du Paris JUG et est membre des comités d'experts autour des JSR suivantes: JSR-316 (Java EE 6), JSR-317 (JPA 2.0) et JSR-318 (EJB 3.1). C'est son deuxième livre. Il vient récemment d'avoir le titre de Java champion.
Alexis Moussine-Pouchkine (équipe GlassFish) en a écrit la préface.

Le 1er chapitre dresse une liste des nouveautés introduites dans Java EE 6. Une application d'e-commerce (vente de CDs et livres) est développée au fur et à mesure des chapitres. Et l'installation des outils utilisés est décrite.
Le serveur d'application choisi est GlassFish v3 bien sûr, le premier à supporter Java EE 6 et le seul à l'heure actuelle.

Les chapitres 2 à 5 traitent de la Java Persistence API (JPA), dans sa version 2.0. Pour rappel la version de JPA dans Java EE 5 est la 1.0.

Le 2ème chapitre présente un petit exemple de persistence d'un entity bean, avec l'aide de JUnit pour les tests, Maven pour la compilation et l'exécution, Derby pour la base.

Dans le 3ème chapitre l'auteur explique de nombreuses annotations ORM de la version 1.0 de la JPA mais aussi les nouvelles annotations de la JPA 2.0 (@ElementCollection, @MapKeyColumn, ...). La section sur le mapping des relations entre entités est bien détaillée et elle est certainement très utile pour quiconque aurait un peu oublié ces annotations et souhaiterait s'y remettre rapidement.

Idem pour le 4ème chapitre, très complet dans ses explications de la persistence. Les nouveautés de JPA 2.0 sont évidemment présentées (cache de second niveau, pessimistic locking ...).

Le chapitre 5 offre également des explications complètes sur les méthodes callbacks et les entity listeners.

Les chapitres 6 à 9 se focalisent sur les session beans et les EJB timer service. L'auteur montre l'utilisation du container embarqué, une nouveauté de la version 3.1.

Le chapitre 6 est un très court chapitre qui présente de façon sommaire des nouveautés dans EJB 3.1. Ces nouveautés sont utilisées dans les chapitres suivants.
Un premier petit exemple montre l'utilisation du container embarqué et le lookup JNDI via un nom standard.

Le chapitre 7 fait une description des stateless et stateful session beans, avec des exemples.
Les singletons session beans sont étudiés dans le détail, avec pas mal de code pour illustrer les concepts qui tournent autour (initialisation, chaînage, concurrence). Les autres concepts (JNDI standardisé, injection de dépendance, appels asynchrones avec les session beans, container embarqué, service timer amélioré) sont également riches en exemples de code.

Rien de particulier à signaler sur le chapitre 8. L'auteur fait une description classique des cycles de vie des session beans et des singletons, des méthodes callbacks et des interceptors (chaînage, exclusion).

Chapitre 9 : Encore une fois, une description classique et bien complète des 2 modes de transactions (container ou bean) des EJBs est faite. Et également des explications claires sur les annotations relatives à la sécurité.

Chapitre 10 : présentation de JSF 2.0. Un exemple montre le développement d'une application web JSF 2.0 en utilisant un business tiers basé sur les EJB 3.1 et une couche de persistance reposant sur JPA 2.0.

Dans le chapitre 11, l'auteur fait de nombreux rappels autour d'HTML, des CSS, des JSP, EL et JSTL.
Les facelets sont préférées aux JSP en tant que PDL (Presentation Declaration Language) pour JSF. L'auteur fait également une revue des composants JSF HTML et montre la création et l'utilisation de composants / widgets avec JSF 2.0.

Chapitre 12 : beaucoup d'explications accompagnent la présentation des capacités de JSF 2.0 tant dans le traitement des requêtes (cycle de vie) que dans la navigation, la conversion et la validation de données, ainsi que le support AJAX.

Chapitre 13 : La JMS API est abordée en détails avant de voir l'utilisation des EJB MDB avec OpenMQ, le fournisseur de messages par défaut de GlassFish, et leur compilation et déploiement avec Maven.

Chapitre 14 : Les généralités sur les Web Services (WSDL, SOAP ...) sont passées en revue. L'auteur montre l'utilisation des annotations du modèle JAX-WS, suivant la spécification JSR-181, pour la création et l'appel de web services par un consommateur.

Chapitre 15 : ce dernier chapitre ne manque pas d'intérêt puisqu'il introduit le nouveau type de Web Service, RESTful.
Il est décrit en faisant usage des annotations de l'API JAX-RS qui fait partie de Java EE 6.

Conclusion : Le code est téléchargeable sur le site des éditions Apress.
J'ai bien aimé l'aspect pédagogique du livre : dans certains chapitres, il y a une section "Putting it all together" qui met en pratique les notions vues précédemment.

English version :

Antonio Goncalves, if you do not know him yet, is the co-founder of the Paris JUG and is a member of the experts committees regarding the following JSRs : JSR-316 (Java EE 6), JSR-317 (JPA 2.0) et JSR-318 (EJB 3.1). This is his second book. He has been recently awarded the title of Java champion.
Alexis Moussine-Pouchkine (GlassFish team) wrote the foreword.

The 1st chapter enumerates a list of new features introduced in Java EE 6. An e-commerce application (CDs and books sales) is developed in the chapters. And the installation of the used softwares is described.
The chosen application server is GlassFish v3 of course, the first one to support Java EE 6 and also the only one at the moment.

Chapters 2 to 5 deal with the Java Persistence API (JPA), in its version 2.0. As a reminder, the JPA version in Java EE 5 is 1.0 .

The 2nd chapter offers a small sample of persistance of an entity bean, with the help of JUnit for the tests, Maven for the compilation and the execution, Derby for the database.

In the 3rd chapter the author explains numerous ORM annotations of the version 1.0 of the JPA but also the new annotations of the JPA 2.0 (@ElementCollection, @MapKeyColumn, ...). The section on the mapping of relations between entities is well detailed and is certainly very useful for anyone who has forgotten these annotations and wishes to quickly learn them again. rapidement.

Same thing for the 4th chapter, it is very exhaustive in its explications of the persistance. The new features of JPA 2.0 are of course introduced (second-level caching, pessimistic locking ...).

The 5th chapter also gives exhaustive explanations on callback methods and entity listeners.

Chapters 6 to 9 focus on session beans and EJB timer services. The author shows the use of an embedded container, a new feature in the 3.1 version.

Chapter 6 is a very short chapter which explains briefly the new features in EJB 3.1. These new features are used in the next chapters.
A first small example shows the user of the embedded container and the JNDI lookup JNDI through a standard name.

Chapter 7 does a description of stateless and stateful session beans, with examples.
Session beans singletons are explained in details, with a lot of code to illustrate the features around them (initialisation, chaining, concurrence). The other features (standardized JNDI, dependency injection, asynchrones calls with session beans, embedded container, improved timer service) are also rich in examples of code.

Nothing particular to mention about chapter 8. The author does a classical description of the lifecycles of session beans and singletons, callback methods and interceptors (chaining, exclusion).

Chapitre 9 : Once again, a classical and exhaustive description of the 2 transaction modes (container or bean) in EJBs is done. And it also provides good explanations about security-related annotations.

Chapitre 10 : presentation of JSF 2.0. An example shows the development of a JSF 2.0 web application using a business tier based on EJB 3.1 and a persistence layer based on JPA 2.0.

In chapter 11, the author writes some reminders about HTML, CSS, JSP, EL and JSTL.
Facelets are favored against JSP as PDL (Presentation Declaration Language) for JSF. The author also tells us about the JSF HTML components and shows the creation and use of components / widgets with JSF 2.0.

Chapter 12 : a lot of explanations support the presentation of the capabilities in JSF 2.0 regarding the treatment of requests (lifecycle), the navigation, conversion and validation of data, as well as AJAX support.

Chapter 13 : The JMS API is explained in details before the use of MDB EJBs with OpenMQ, the default messaging provider for GlassFish, and their compilation and deployment with Maven.

Chapter 14 : Main features of Web Services (WSDL, SOAP ...) are explained. The author shows the use of annotations of the JAX-WS model, according to the JSR-181 specification, for the creation and the call of web services by a consumer.

Chapter 15 : this last chapter does not lack any interest since it introduces the new type of Web Service, RESTful.
It is detailed using the annotations of the JAX-RS API which is part of Java EE 6.

Conclusion : The code is available on the Apress editions website.
I liked the educational approach of the book : in certain chapters, there is a "Putting it all together" section which makes use of the notions explained previously.

Contributeur pour 97 Things Every Software Architect Should Know, Eben Hewitt nous gratifie là d'un bel ouvrage de plus de 700 pages qui vous aidera à mettre en ?uvre des cas pratiques autour de la SOA.

La structure de la collection Cookbook de chez O'Reilly est la suivante : exposition des problèmes suivis de leurs solutions, des fragments de code ; le tout agrémenté d'explications et de comparaisons entre les différentes opportunités offertes dans le vaste domaine de la gestion des services.

Le contenu de "Java SOA Cookbook" est le suivant :

[list][*]La première partie du livre aborde les fondamentaux de la SOA (définitions, XML, schémas, interaction avec Java).[*]La deuxième partie se focalise sur les Web Services (déploiement, WSDL, SOAP, SAAJ, JAX-WS, REST).[*]La partie suivante est orientée business avec l'orchestration des services via BPEL (Business Process Execution Language, que l'on prononce "bipeul" ) et la gouvernance.[*]La dernière partie discute autour de l'interopérabilité des Web Services, de la qualité de service, et d'ESB.
[list]

D'un point de vue programmatique, le lecteur trouvera beaucoup d'exemples de codes (téléchargeables sur Internet) et des discussions autour de ceux-ci. Une remarque cependant : même si les recettes sont très bien expliquées, il faut être familier avec Java 5 ou 6, J2E et les concepts de développement Web (EARs, WARs...).

Voilà donc un livre que j'ai apprécié, par sa structure efficace, la richesse et la qualité de son contenu. Et comme en cuisine, vous utiliserez ce livre comme un ouvrage de référence quand des problèmes précis seront à résoudre, une lecture linéaire est, je pense, trop ennuyante.

Français

Pour apprécier à sa juste valeur le livre Java SOA Cookbook, il faut bien comprendre que tous les termes du titre sont importants. Pour ma part, je me suis attaché uniquement à Java SOA, et j'ai été un peu surpris...

Le mot cookbook est plutôt judicieusement choisi, car on peut réellement le comparer à un livre de cuisine : une liste de recettes, sans avoir forcement tout le temps une suite logique entres elles. Par exemple, dans le chapitre concernant les gâteaux, on peut trouver 4 recettes de gâteaux au chocolat, et la 5ème est un gâteau au citron.

Dans le livre Java SOA Cookbook, c'est un peu pareil. Par exemple, dans le chapitre sur BPEL, on utilise d'abord le BPEL Engine de Apache 2-3 recettes, pour ensuite utiliser NetBean et OpenESB, puis encore un autre outil commercial pour la suite.

Et c'est comme cela dans l'ensemble du livre, ce qui est un peu déstabilisant pour "découvrir" la SOA et les sujets du livre.

Mais cela n'empêche pas l'ouvrage d'être un bon livre sur le sujet.
Les Web Services sont bien représentés, tant les services SOAP que les services REST
La partie Business Process Management, malgré mes remarques, est très intéressante elle-aussi. N'ayant personnellement jamais travaillé avec ceux-ci, j'ai appris beaucoup de choses.

Java SOA Cookbook, une fois la surprise passée du format, est un excellent livre qui permettra d'appréhender facilement les Web services, la gestion de processus métier ou, de manière plus générale, la SOA par le biais d'exemples concrets très bien détaillés.

English

To appreciate the book Java SOA Cookbook with its real value, it should be understood that all terms of the title are important. For my part, I have given attention only on Java SOA, and I was a little surprised ..

The term cookbook is carefully chosen, because you can really compare it to a cookbook: a list of recipes, without necessarily having all the time a logical sequence between them. For example, in the chapter on cakes, there are 4 recipes with chocolate, and the 5th is a lemon cake.

In the book "Java SOA Cookbook" is just the same. For example, in the chapter about BPEL, the firsts recipes use the Apache BPEL Engine, the next ones use NetBeans Designer and OpenESB, and the lasts use a commercial product for BPEL.

And it's like this in the entire book, which is a little unsettling for "discovering" the SOA and the subjects of the book.

But this does not prevent the book from being a good book on the subject. The Web Services are well covered, both the services that services SOAP REST.
The Business Process Management part, despite my remarks, is very interesting too. Having personally never worked with BPM/BPEL, I learned many things.

Java SOA Cookbook, once past the surprise of the format, is an excellent book which will easily understand Web services, management of business processes or more generally SOA through examples and very well detailed.

Critique en français
Vous avez entendu parler d'OSGi mais vous ne savez pas ce que c'est ? Ou vous pensez que cela est trop compliqué ? Alors le livre de Daniel Rubio est surement un moyen d'appréhender OSGi de manière simple grâce à Spring Dm.
Ce livre est bien écrit et permet d'avoir une première approche sur le sujet. Dès les premiers chapitres, OSGi est expliqué très simplement et vous apprendrez quels sont les avantages de cette technologie face à JEE.
Ensuite, Spring Dm sera présenté. Celui-ci apporte la simplicité POJOs dans le monde OSGi, à la manière des projets Spring.
Vous ne connaissez pas du tout Spring ? Pas de soucis ! Une introduction succincte mais suffisante du Framework sera faite, ce qui vous permettra de suivre correctement le reste du livre sans problème.
D'autres sujets, toujours gravitant autour de OSGi et Spring seront abordés. C'est le cas du serveur de SpringSource par exemple. C'est ainsi que vous apprendrez les extensions d'OSGi qu'il apporte pour faciliter le développement, en particulier avec JPA. L'utilitaire bnd sera lui aussi au sommaire, afin de vous expliquer comment rendre un JAR compatible OSGi sans trop d'effort.
Bref, c'est un excellent livre pour débuter avec OSGi et Spring Dm, mais pour moi il ne va pas assez en profondeur pour un livre de la collection "Pro".

English review
You've heard about OSGi but do not know what it is? Or do you think this is too complicated? Then the Daniel Rubio's book is probably a simple way to learn OSGi thanks to Spring Dm.
This book is well written and gives a first approach on the subject. In the first chapters, OSGi is explained very simply and you will learn what are the benefits of this technology face to JEE.
Then Dm Spring will be presented. This brings the simplicity of POJOs in the OSGi world, like all the Spring projects.
You do not know anything of Spring? No worries! A brief but sufficient introduction of the Framework will be made, allowing you to follow the book without difficulty.
Other subjects, always revolving around OSGi and Spring, will be covered. This is the case SpringSource server for example. Thus you will learn the extensions it provides to OSGi to facilitate development, especially for JPA.
The tool 'bnd' is also introduced in summary, to explain you how to make a OSGi-compatible JARs without too much effort.
In short, it is an excellent book to start with OSGi and Spring Dm, but for me it does not go deep enough for a book of the "Pro" collection.

Ce livre s'adresse aux développeurs Java qui veulent rapidement développer une application Web riche en utilisant la librairie Ext-GWT.

Le point fort des ouvrages de cette collection, c'est de suivre l'évolution technologique au plus près. Celui-ci ne déroge pas à la règle et utilise les librairies GWT et Ext-GWT dans leurs dernières versions. Pour GWT, c'est la 1.6 et pour Ext-GWT, c'est la 2.0 (encore au stade M2). Si vous envisagez de l'acheter, c'est donc le moment !

Ce livre a une approche didactique classique, il commence par une présentation générale, explique comment installer cette librairie, présente les composants simples et avancés et termine avec un exemple concret.

Le premier chapitre présente à la fois les librairies Ext-GWT et GWT. Comme le sujet de ce livre est Ext-GWT, c'est d'abord elle qui est présentée. On sent bien que cette librairie n'est qu'une sur couche de GWT car l'auteur a beaucoup plus de généralités à dire sur GWT. Si cette présentation de GWT ne remplace pas un livre dédié, elle en demeure néanmoins un bon résumé.

Le deuxième chapitre est un tutoriel très pratique qui vous explique comment configurer un environnement de développement Ext-GWT sous eclipse et comment commencer une première application. L'auteur a semble t'il préféré le côté didactique des batchs de GWT à la simplicité du plugin Eclipse-GWT.

Les troisième et quatrième chapitres présentent les composants de la librairie, des plus simples ou plus avancés. La présentation est progressive et la lecture facile. Quelques captures d'écran et exemples de code viennent compléter les explications.

Le cinquième chapitre présente les composants Ext-GWT qui font le lien entre les widgets graphiques et le serveur. Comme la librairie, l'auteur fait le choix du "full gwt" et ne traite donc que du mode RPC de GWT. Ne cherchez donc pas dans ce livre d'exemple d'échanges de données avec XML ou JSON, vous n'en trouverez pas !

Le sixième et dernier chapitre se veut être un exemple concret qui reprend un peu tout ce qui a été présenté dans les chapitres précédents. Bien que synthétique, il apporte également les quelques informations complémentaires nécessaires à la construction d'une application réelle.

Avant de lire ce livre, j'avais réalisé des applications Ext-GWT en utilisant tous les composants qu'elle propose. L'avantage pour vous, c'est que j'ai pu écrire une meilleure critique vis à vis de ce que dit ou ne dit pas l'auteur ! L'inconvénient pour moi, c'est que du coup, ce livre m'a un peu laissé sur ma faim ... Il faut croire que je ne suis pas la cible !

Ceci dit, ce qui est super dans ce livre, c'est toutes les remarques, trucs et astuces qu'il recèle. J'ai été agréablement surpris de voir qu'il dresse tous les pièges dans lesquels je suis tombé moi-même. Je le recommande donc principalement à ceux qui veulent écrire leur première application avec Ext-GWT.

English version :

This book is intended for Java developers who want to quickly develop a rich web application using GWT-Ext library.

The particularity of this collection is to follow technological developments as closely as possible. This book is not an exception to the rule and uses GWT and GWT-Ext in their latest versions (GWT is 1.6 and GWT-Ext is 2.0). If you plan to buy, so this is the moment !

This book has a didactic style, it begins with an overview, how to install this library, introduces the simple and advanced components and ends with a concrete example.

The first chapter describes both GWT-Ext and GWT. Since the topic of this book is Ext-GWT, author begins with it. We can see that this library is a layer of GWT because the author has much more to say about general GWT. If this presentation of GWT does not replace a book dedicated, it remains a good summary.

The second chapter is a useful tutorial that explains how to configure a development environment GWT-Ext in Eclipse and how to start a first application. The author seems to prefer the didactic GWT batches to the simplicity of the GWT Eclipse-plugin.

The third and fourth chapters gradually introduces the components of the library, from the simplest to the more advanced one. The presentation is progressive and easy reading. Some screenshots and code examples complement the explanations.

The fifth chapter describes the GWT-Ext components which link the graphical widgets to the server components. As the library does, the author decided to follow a "full GWT" way and therefore does only cover the GWT RPC mode. Do not try to find in this book an example of data exchange with XML or JSON, you won't find any !

The sixth and final section provides a concrete example which aims to sumamarize all the things presented in previous chapters. Although synthetic, it also provides some additional information needed to build a real application.

Before reading this book, I had built GWT-Ext applications, using all the Ext components. The benefit to you is that I could write a better review with respect to what is said or not by the author! The downside for me is that suddenly, I'm left wanting more ... Must believe that I am not the target !

What is great in this book is all the comments, tips and tricks it contains. I was pleasantly surprised to see that it gives all the traps in which I fall myself. I therefore recommend mainly to those who want to write their first application with GWT-Ext.

Si vous cherchez un très bon livre sur Tomcat, Professional Apache Tomcat 6 est clairement un très bon choix.

Présenté par ses auteurs comme une réponse au manque cruel d'une documentation de qualité sur ce serveur de Servlet, ce livre couvre effectivement tout les points intéressants.
L'audience cible est aussi très vaste : le non initié trouvera ses marques dans les premiers chapitres où les origines de Tomcat, les bases de Servlet/JSP ou encore l'installation sont présentées.

Les chapitres suivants intéresseront un public beaucoup plus vaste : l'architecture de Tomcat, sa configuration et ses principales fonctionnalités sont détaillées et expliquées.
Dans ces chapitres, les fichiers server.xml et context.xml ou encore web.xml sont décryptés, balises par balises, attributs par attributs, le tout avec des explications complètes et claires.
Des fonctionnalités moins communes mais tout aussi intéressantes, telles que la gestion de Single Sign On ou la persistance des sessions, sont aussi au sommaire.

Mais le livre ne s'arrête pas à une vue développeur de Tomcat, des sujets plus orientés administrateurs complètent la portée de ce livre : présentation des différents connecteurs, intégration de Tomcat avec Apache Http Server ou Microsoft IIS, Monitoring avec JMX, mise en clusters et optimisation.

Bref, ce livre est un très bon investissement si vous vous intéressez à Tomcat : très bon support pour le découvrir, et excellente bible Tomcat par la suite.

Le livre est divisé en 4 parties.

D'abord j'aimerais dire que j'ai bien aimé la table des matières. Elle montre bien que JBoss est plus qu'un serveur d'application puisqu'une partie entière est consacrée à JBoss Portal.

Dans la première partie les auteurs racontent les origines du serveur JBoss (saviez-vous que JBoss s'appelait EJBoss à l'origine et que cela signifiait Enterprise Java Beans Open Source Software ?) et décrivent l'installation de la version 5, le déploiement d'applications et la configuration.
La structure du serveur est abordée en détails avec des explications sur les MBeans (managed beans, issus de la JSR 3) et la console JMX, illustrée par des captures d'écran.
Ensuite vient le tour du déploiement d'une application, la déclaration d'une source de données, la création d'une archive HIbernate (.har) ... Les auteurs en profitent pour montrer les avantages d'un serveur d'application.
Le chapitre sur la sécurité est très intéressant. Les modules de login du framework JBoss SX, qui repose sur JAAS, sont décrits et illustrés par des exemples de configuration XML, suivant la source de données (base, LDAP, certificat ...).

La deuxième partie traite des éléments de configuration du serveur Web dans JBoss. Tout est bien passé en revue : fichiers, de configuration, archive WAR, structure d'une URL et même la configuration de JSF.
Les applications d'entreprise ne sont pas oubliées. Bien au contraire, puisque les auteurs vont même jusqu'à présenter les EJB 3 et à packager et déployer des session beans.
La sécurité des applications, aux niveaux entreprise (EJB) et web, de façon programmatique et de façon déclarative, est bien détaillée.
JBoss Messaging et les Web Services sont vus aussi. Les auteurs prennent le temps d'expliquer les technologies avant d'en parler par rapport à JBoss. C'est une approche très sympa.

La troisième partie est entièrement dédiée à JBoss Portal et c'est assez sympa puisque là encore les technologies sont présentées (Portlets, JSR-169, CMS ...).

La quatrième partie comporte un chapitre sur le clustering, avec une description d'un exemple à faire sur un serveur unique (clustering vertical). Très intéressant, tant sur la partie théorique du clustering que sur la partie configuration JBoss. Plein de petites notes sur le tuning dans JBoss, pour améliorer les performances.
Et enfin un chapitre sur des choses à faire avant de passer en production.

Ce que j'ai aimé dans ce livre : les auteurs sont sincères pour évoquer les avantages mais aussi les faiblesses de ce serveur d'application, par rapport à d'autres. Par exemple, ils admettent qu'il n'y a pas de console d'administration aussi puissante que dans Weblogic ou Websphere, mais on y vient avec Jopr.
Chaque chapitre se termine par un résumé et des liens sur les sujets qui ont été vus.

Ce que j'ai moins aimé dans ce livre : l'absence de chapitre dédié à la nouvelle console d'administration, Jopr. Mais cela est dû au fait qu'elle n'était pas encore disponible au moment de l'écriture du livre.

English version :

I would like to begin by saying that I like the table of contents. It shows that JBoss is more than an application server since a full part is about JBoss Portal.

In the first part the authors tell us about the origins of the server (did you know that JBoss was originally called EJBoss and that it meant Enterprise Java Beans Open Source Software ?) and describe the installation of version 5, the deployment of applications and the configuration.
The structure of the server is described in detail with explanations on MBeans (managed beans, from the JSR 3) and the JMX console, illustrated with screenshots.
Then comes the deployment of an application, the declaration of a data source, the creation of an Hibernate archive (.har) ... All along, the authors explain the advantages of an application server.
The chapter on security is very interesting. The login modules of the JBoss SX framework, which uses JAAS, are described and illustrated with examples of XML configuration for each type of data source (database, LDAP, certificate ...).

The second part is about the configuration of JBoss Web server. Everything is explained : configuration files, WAR archive, the structure of an URL and even the JSF configuration.
The enterprise applications are not forgotten. On the contrary, since the authors go as far as giving us a nice overview of EJB 3 and packaging and deploying session beans.
The security of applications, at the enterprise (EJB) and web levels, programmatically and declaratively, is very detailed.
JBoss Messaging and Web Services are also detailed. The authors take the time to explain the technologies before explaining them with JBoss. That is a very nice approach.

The third part is entirely dedicated to JBoss Portal and it is nice again to see that the technologies are first introduced (Portlets, JSR-169, CMS ...).

The fourth part has a chapter about clustering, with the description of an example to do on a single server (vertical clustering). Very interesting, as much in the theorical part of clustering as in the JBoss configuration part. Plenty of notes on the tuning of JBoss, to improve the performances, are also provided.
And a chapter on things to do before going into production concludes this part.

What I liked in this book : the authors are sincere when they discuss the advantages but also the weaknesses of the application server, in comparison with others. For instance, they admit that there is no administration console as powerful as in Weblogic or Websphere, but Jopr is going in the right direction.
Each chapter ends with a summary and links about the reviewed topics.

What I liked the least in this book : the lack of chapter about the new administration console, Jopr. But that is due to the fact that it was not yet available when the book was being written.

Le livre est divisé en 5 parties.

Dans la 1ère partie les auteurs apportent une présentation sommaire de l'architecture du framework Sruts 2 (MVC pattern, interceptors, ValueStack, OGNL) et abordent un exemple Hello World. Les 2 types de configuration sont détaillés: configuration via des fichiers XML (struts.xml) et configuration par des annotations Java.

Dans la 2ème partie les auteurs couvrent l'action dans Struts 2, de façon relativement bien détaillée et bien expliquée. Ensuite un chapitre traite des interceptors : le principe, la déclaration, les avantages, les interceptors existants et comment créer un interceptor si aucun des interceptors existants ne répond aux besoins. Le langage OGNL, qui permet d'utiliser les objets stockés dans la pile (ValueStack) est abordé pour la première fois dans le livre.

La 3ème partie traite des différents tags. J'ai bien aimé d'abord le découpage rationnel des paragraphes et chapitres suivant les 4 catégories de tags : data tags, control-flow tags, UI tags et autres tags. Ensuite j'ai bien aimé la présentation de chaque tag: d'abord une explication, ensuite un petit tableau décrivant les attributs, types, (...), du tag et enfin un petit extrait de code pour montrer une utilisation concrète. Les auteurs reviennent ensuite sur OGNL et son utilisation pour l'accès aux données provenant de la pile ValueStack (incluse dans ActionContext) mais aussi d'un objet différent d'ActionContext, qui "contient toutes les données qui constituent le contexte d'exécution d'une action". J'ai aussi bien apprécié la présentation rapide d'alternatives aux JSPs telles que Velocity et Freemarker, au niveau des pages de résultats.

La 4ème partie montre comment intégrer les applications Struts 2 avec le plug-in Spring et JPA. Un chapitre entier est consacré au framework bien pratique de validation qui vient avec Struts 2, avec les fichiers XML et les annotations. Le chapitre est lui aussi bien fait, avec abondance de code. Idem pour le chapitre suivant sur l'internationalisation.

Enfin, la 5ème et dernière partie est un peu plus fourre-tout puisqu'elle couvre divers sujets qui, comme le disent les auteurs, nous aident "à travailler plus intelligemment". A savoir l'utilisation de plug-ins (comme le classique Tiles pour la présentation, ou JFreeChart pour la création de graphes), les tests unitaires avec JUnit, comment migrer de Struts 1.X vers Struts 2, comment empêcher le double submit ...

Ce que j'ai aimé dans ce livre : le code source de chaque chapitre est packagé de façon appropriée dans l'archive (fichier war) de l'application finale, sauf les derniers chapitres.

Ce que j'ai moins aimé dans ce livre : J'ai trouvé le livre peut-être un peu trop verbeux à mon goût, dans certains passages. J'aurais préféré que les auteurs aillent d'avantage directement à l'essentiel parfois, surtout quand on dispose de peu de temps pour se former ou que l'on cherche uniquement à acquérir le minimum pour pouvoir développer. L'absence de chapitre au sujet de l'intégration de librairies Javascript et de composants Ajax dans Struts 2.

Le site du livre : http://www.manning.com/Struts2inAction/

Commentez Donner une note à l'article (5)

English version :

The book is divided in 5 parts.

In the first part, the authors give us a quick overview of the Struts 2 framework architecture (MVC pattern, interceptors, ValueStack, OGNL) and start with an Hello World sample. The 2 types of configuration are detailed : configuration through XML-based files (struts.xml) and configuration through Java annotations.

In the second part, the authors cover the action in Struts 2. It is relatively well detailed and well explained. Then a chapter deals with interceptors : their principle, the declaration, the advantages, the existing interceptors and how to create an interceptor if none of the existing ones meets the requirements. The OGNL language, which makes it possible to use the objects stored in the ValueStack, is presented for the first time in the book.

The third part deals with the different tags. I appreciated the rational indentation of paragraphs and chapters based on the 4 categories of tags : data tags, control-flow tags, UI tags and miscellaneous tags. Then I did like the presentation of each tag: first an explanation, then a small array describing the attributes, types, (...), and finally a small snippet of code to illustrate a concrete usage. Then the authors discuss again about OGNL and its utilisation to access data items not only coming from the ValueStack (included in te ActionContext) but also from a different object from the ActionContext, which "contains all the data that makes up the context in which an action occurs". I also liked the quick presentation of JSP alternatives such as Velocity and Freemarker, for the rendering of the result pages.

The fourth part shows how to integrate Struts 2 applications with the Spring plug-in and JPA. An entire chapter is dedicated to the very useful validation framework that comes with Struts 2, with XML files and annotations. The chapter is well written, with abundance of code. Same thing about the next chapter regarding internationalization.

Finally the last and fifth part is a bit more catch-all since it covers various subjects which, as the authors put it, "help us work smarter." Such as the use of plug-ins (like the classic Tiles framework for the presentation, or JFreeChart for the creation of graphs), unit tests with JUnit, how to migrate from Struts 1.X to Struts 2, how to prevent duplicate form submits ...

What I liked about this book : The source code of each chapter is appropriately packaged in the archive (war file) of the final application, except for the last chapters.

What I liked the least in this book :I found the book maybe a bit too verbose for my taste, regarding a few passages. I mean I would have preferred that the authors went directly to the main points, especially when the reader lacks time to go through all the details and learn or when the reader only wants the minimum knowledge in order to develop. The lack of chapter dedicated to the integration of Javascript libraries and Ajax components in Struts 2.

The book's website : http://www.manning.com/Struts2inAction/

Seam veut dire suture en anglais. Mais depuis 3 ans, ce mot revêt une autre signification pour les développeurs puisqu'il désigne aussi un framework. C'est un framework assez récent, la version 1.0.0 Beta 1 date de septembre 2005, dont le project leader est Gavin King (l'un des créateurs d'Hibernate), qui intègre JSF et les EJB 3, et c'est donc avec beaucoup d'intérêt et de curiosité que j'ai lu ce livre. L'auteur, Dan Allen, sait de quoi il parle puisqu'il est un committer sur le projet. On apprend qu'à l'origine le terme Seam a été choisi pour désigner l'effort d'intégration entre JSF et les EJB 3. Les applications JBoss Seam peuvent tourner sur Websphere, Weblogic, Tomcat. Le livre se veut pratique puisqu'il propose de développer une application de golf (Open 18) pour illustrer les fonctionnalités de Seam. Le livre est divisé en 4 parties.

Dans la 1ère partie (chapitres 1, 2), l'outil seam-gen est détaillé et utilisé dès le départ pour la mise en place de l'environnement de développement, à partir d'une base de données Hypersonic H2.

Dans la 2ème partie (chapitres 3, 4, 5, 6), l'auteur explique ce que Seam apporte à JSF, en corrigeant certaines « lourdeurs », tel qu'un fichier XML trop verbeux (faces-config.xml), en supprimant les tags <managed-bean> du fichier. On peut grâce à Seam se passer de définir les backed beans dans un fichier XML. Le cycle de vie JSF avec Seam est décrit également pour expliquer les avantages de Seam. Le chapitre 4 traite des components, les annotations concernées (@Name, @Scope ...), le cycle de vie des components, etc. Dans le chapitre 5 les tags du fichier de configuration components.xml (une alternative aux annotations) sont largement détaillés. Le chapitre 6 traite des interceptors et de la notion de bijection (= injection + outjection, avec les annotations @In, @Out) en introduisant le nouveau terme outjection qui désigne la possibilité de mettre une propriété de component dans une variable de contexte pour être ensuite utilisée dans un autre component, une vue JSF ... Avec la bijection, les valeurs sont injectées depuis les variables de contexte quand le component est invoqué et réinjectées vers les variables de contexte. Une distinction nette est faite entre injection statique (assignation d'une variable quand le component est instancié) et injection dynamique (chaque fois qu'une méthode d'un component est invoquée).

Dans la 3ème partie (chapitres 7, 8, 9, 10), un chapitre entier (chapitre 7) est dédié à l'état Conversation, un des 2 états/contextes introduits par Seam (l'autre état étant business process, qui est plus long que la session), en plus des 4 états classiques que sont Request, Page, Session, Application. Cet état permet de lier des requêtes individuelles. Les 6 états classés par portée croissante sont donc : Request (event), Page, Conversation, Session, Business Process, Application. La notion de conversation, les page flows et les annotations concernées (@Begin, @Conversational, @End etc) sont systématiquement et largement expliquées avec des extraits de code s'articulant autour de l'application Open 18. Le chapitre 8 est un rappel nécessaire sur JPA et Hibernate. J'ai particulièrement apprécié le rappel sur l'extended persistence context et les différences entre ces 2 APIs car c'est bien expliqué. Le chapitre suivant aborde la gestion de la persistence et les transactions avec Seam, notamment dans la conversation, et est largement illustré par des extraits de code. Le chapitre 10 présente le Seam Application Framework au travers d'un exercice.

Dans la 4ème partie (chapitres 11, 12, 13), on apprend que Seam s'appuie sur JAAS pour l'authentication (chapitre 11). Un exemple avec une page de login JSF est utilisé. Une distinction est faite entre les authorisations basées sur des rôles et les authorisations basées sur des règles. Le moteur de règles Drools (qui tire son nom du terme "Dynamic rules") est présenté et utilisé pour créer des règles. Un exemple rapide d'utilisation du component org.jboss.seam.captcha pour l'affichage d'un CAPTCHA dans une page web est expliqué. Le chapitre 12 met l'accent sur AJAX et les solutions existantes qui tournent autour (Ajax4jsf, ICEfaces, GWT ...) Enfin, le chapitre 13 présente divers components Seam tel que <s:fileUpload> pour uploader des fichiers à partir d'un form JSF, <s:graphicImage> pour le rendu dynamique d'images , des UI components pour la génération de PDF à travers des templates de Facelets, mais aussi le module Seam de génération de graphique basé sur JFreeChart, l'envoi de mail avec un component mail Seam etc

Ce que j'ai aimé dans ce livre : Le ton de l'auteur. On a l'impression d'assister à une présentation en live de Seam, l'auteur passe beaucoup de temps à introduire les choses, à peser le pour et le contre des solutions existantes et ensuite à expliquer comment Seam peut être une solution possible. Le thème du golf, omniprésent et instructif ;-)

Ce que j'ai moins aimé dans ce livre : La prise en compte d'une version antérieure de JBoss AS : 4.2 au lieu de 5 (Java EE 5)

Le code source du livre est bien entendu disponible sur le site du livre, ainsi que deux chapitres "bonus" format PDF concernant l'intégration avec Spring d'une part et la gestion du business process (jBPM) d'autre part : http://www.manning.com/dallen/

Le site de l'auteur : http://www.mojavelinux.com/ Un errata est disponible à l'adresse http://www.manning.com/dallen/excerpt_errata.html

Enfin, le code source du livre est aussi disponible sur : http://code.google.com/p/seaminaction/

English version :

A seam is a joining of 2 things, like 2 fabrics for example. But for 3 years now, it has had another meaning for developers since it also refers to a framework. It is a rather new framework, the 1.0.0 Beta version was released in September 2005, the project leader was Gavin King (one of the creators of Hibernate), it uses JSF and EJB 3, and so it is with some big interest and curiosity that i read this book. The author, Dan Allen, knows what he is talking about since he is a committer on the project. We learn that the term Seam was chosen to refer to the work put on to facilitate the collaboration between JSF and EJB 3. JBoss Seam applications may run on Websphere, Weblogic, Tomcat. The book has a practical approach since it is based on an application centered on the game of golf (Open 18), to illustrate the features of Seam. The book is divided into 4 parts.

In the 1st part (chapters 1, 2), the seam-gen tool is explained and used from the beginning to set up the development environment, using a Hypersonic H2 database.

In the 2nd part (chapters 3, 4, 5, 6), the author explains what Seam brings to JSF, correcting some defects, such as a verbose XML file (faces-config.xml), by removing the <managed-bean> tags from the file. With Seam it is possible to define the backed beans in an XML file. The life cycle of JSF with Seam is also detailed to explain the advantages of Seam. Chapter 4 introduces the components, its related annotations (@Name, @Scope ...), the life cycle of components, etc. In chapter 5, the tags of the configuration file components.xml (the alternative to annotations) are explained in details. Chapter 6 is about interceptors and the concept of bijection (= injection + outjection, with annotations @In, @Out) by introducing the new term outjection which refers to the possibility of injecting the property of a component into a context variable, which can be re-used inside another component, a JSF view ... With bijection, the values are injected from context variables when the component is called and injected again into the context variables. A clear distinction is made between static injection (the value is injected when the component instance is created) and dynamic injection (the value is injected when a method on the component is executed).

In the 3rd part (chapters 7, 8, 9, 10), an entire chapter (chapter 7) is dedicated to the Conversation scope, one of the 2 scopes/contexts introduced by Seam (the other scope being business process, which is longer than the session), as an addition to the 4 classic scopes which are Request, Page, Session, Application. This scope ties together individual requests. So the 6 scopes ordered by ascending scope are : Request (event), Page, Conversation, Session, Business Process, Application. The term of conversation, page flows and related annotations (@Begin, @Conversational, @End, etc) are systematically and largely explained with code snippets around the Open 18 application. Chapter 8 is a necessary reminder of JPA and Hibernate. I have particularly liked the quick presentation on extended persistence context and the differences between these 2 APIs because it is well explained. The next chapter is about the persistence and the transactions with Seam, in particular within the conversation, and is largely illustrated with code snippets. Chapter 10 explains the Seam Application Framework with an exercise.

In the 4th part (chapters 11, 12, 13), we learn that Seam relies on JAAS for authentication (chapter 11). A sample with a JSF login page form is used. A clear distinction is made between role-based authorizations and rule-based authorisations. The rules engine Drools (the name Drools is derived from the term "dynamic rules") is explained and used to create the rules. A quick sample of use of the org.jboss.seam.captcha component to display CAPTCHA inside a web page is explained. AJAX and existing solutions (Ajax4jsf, ICEfaces, GWT ...) are empasized in chapter 12. Finally, chapter 13 introduces a few Seam components such as <s:fileUpload> to upload files from a JSF form, <s:graphicImage> for the dynamic rendering of images, UI components to generate PDF files using facelets templates, but also the Seam module for graphic generation based on JFreeChart, composing email with a Seam component mail etc

What I liked about this book : The author's tone. It makes you feel like you are attending a live presentation on Seam, the author spends a lot of time introducing things, weighs the pros and the cons of existing solutions and then explains how Seam can be a possible solution. I also liked the golf theme, omnipresent, and instructive ;-)

What I liked the least in this book : The referring to an older version of JBoss AS : 4.2 instead of 5 (Java EE 5)

The source code of the book is of course available on the book's website, along with 2 extra chapters in PDF format regarding the integration with Spring and the use of business process (jBPM) : http://www.manning.com/dallen/

The author's website : http://www.mojavelinux.com/ An errata is also available at http://www.manning.com/dallen/excerpt_errata.html

Finally, the code source of the book is also available at : http://code.google.com/p/seaminaction/

«Spring Recipes: A Problem-Solution Approach», ou un livre de plus couvrant le Framework Spring ? Oui, mais un excellent livre !
En tant que Springer, j'ai eu l'occasion de lire un certain nombre de livres sur Spring. Bien que tous couvrent très bien Spring, la manière de le présenter est souvent fort semblable. Selon se critère, ce livre est une exception.

En effet, «Spring Recipes: A Problem-Solution Approach» se base sur une approche Problème-Solution-Explication. Ainsi le problème (ce que l'on désire faire) est dans un premier temps exposé pour ensuite être résolu par une solution, qui sera expliquée en détail et critiquée.

Et le terme 'une solution' est important car le livre ne va pas proposer la solution optimale directement, mais plutôt proposer une solution simple mais qui résous le problème (et ce parfois sans Spring dans un premier temps). De cette solution, le livre va ensuite mettre en avant les lacunes et faiblesses de cette solution pour l'améliorer. Et dans le souci de cette amélioration, l'utilité de Spring apparait clairement
Et c'est ce cheminement qui est selon moi la valeur ajoutée de ce livre, car il va non seulement vous apprendre à utiliser, mais surtout vous permettre de comprendre en quoi il est utile ou intéressant de l'utiliser.

Concernant le contenu du livre, celui-ci est fort complet. Il couvre Spring Framework (Accès aux données, transactions, AOP, Testing, Scripting …) mais aussi le portfolio Spring (Spring WebFlow, Spring Security, ..).
Mon seul gros regret est le chapitre sur Spring MVC, qui détaille plus l'ancienne manière de faire que le nouveau Framework basé sur les annotations.

Ce livre, publié en août 2008 aux éditions Apress, est parfait pour le développeur Spring, qu'il soit débutant ou expérimenté. Il intimide par son épaisseur (890 pages) qui s'explique par les nombreux domaines pris en charge par Spring mais aussi par le nombre d'auteurs puisqu'il y en a quatre.
Il couvre bien sûr les nouveautés de la version 2.5 du framework léger Spring.
J'ai apprécié les nombreux exemples de code et de configuration qui accompagnent les 22 chapitres, ainsi que la diversité des sujets abordés : AOP, MVC, JDBC, Hibernate, Quartz, remoting, design patterns, gestion des transactions, JMX, les tests, tuning …
On y trouve même un exemple de configuration de JasperReports pour la génération de fichiers PDF !
Le livre est logiquement découpé en 4 parties composée chacune de plusieurs chapitres.
Le 1er chapitre fait un tour rapide des différents sujets abordés dans le livre.
Le 2ème chapitre présente avec le traditionnel exemple "Hello World" une première esquisse de l'implémentation du pattern "Injection de dépendance" (DI) via Spring.
Le 3ème chapitre aborde le pattern au coeur de Spring : Inversion of Control.
Les différentes types d'IoC sont décrit en détails :
- DI (avec 2 sous-types : constructor DI et setter DI)
- Dependency lookup (avec 2 sous-types : dependency pull et contextualized dependency lookup)
L'interface BeanFactory est introduite et expliquée avec de nombreux exemples.
Le chapitre sur les langages dynamiques décrit la création de beans managés par Spring avec BeanShell, JRuby et Groovy.
Le plus gros chapitre du livre consacre presque 100 pages à l'implémentation du pattern MVC dans Spring, en détaillant l'utilisation d'autres technologies Web telles que Velocity, Freemaker …
Et l'on trouve ensuite de façon logique une explication détaillée de Spring Web Flow..
On peut cependant regretter l'absence de chapitres consacrés aux web services, à la sécurité, aux EJBs ou encore JMS.
Le code source des exemples est disponible en ligne sur le site des éditions Apress.

Le livre en lui-même est bien présenté et agréable à lire. Les chapitres sont courts et bien découpés, ce qui facilite son usage comme référence pour plus tard.

Il a été écrit par deux des principaux Core Developers de Wicket depuis qu'il est OpenSource. On peut donc leur faire confiance quand ils donnent des conseils ;-) . Les parties de code sont assez claires même si j'ai eu un peu de mal à comprendre où rattacher quoi à certains moments.

Les auteurs détaillent le framework progressivement même si l'application est déjà bien lancée au chapitre 3. Chaque partie est expliquée en détail mais pas trop. Je ne me lancerai quand-même pas dans la publication d'un composant sans y regarder à deux fois mais les principes et les bases sont évoqués.

Le chapitre sur Spring est bien présenté, on voit différentes façons de l'intégrer, y compris par les annotations. La partie sur « Aller en production » est vraiment intéressante car on y apprend que Wicket peut exposer des Mbeans pour se reconfigurer à chaud. Il est aussi expliqué comment tester ses composants et ses pages.

J'aurais aimé un chapitre sur les projets annexes que l'on retrouve côté Wicket Stuff.

Par exemple, dans le chapitre sur la sécurité, Acegi n'est pas évoqué. Certes c'est un livre sur Wicket, mais quelques paragraphes pour montrer les extensions annexes auraient été les bienvenus.

De plus, le livre ne revient pas sur les changements qui ont eu lieu au fil des versions. Pourquoi ne pas parler de Wicket 2 qui est mort-né ? Et Wicket 1.4, quelles seront les nouveautés ? Allez, je demandais juste un bout d'introduction. Cette version est à peine évoquée au fil des pages.

Le livre a répondu à beaucoup des questions que je me posais. Son spectre n'est pas très large (pas de Wicket Stuff) mais largement suffisant pour démarrer rapidement. Je le recommande à ceux qui veulent tester Wicket et se lancer dans leur premier projet.
Mais d'ailleurs, vous devriez déjà être sur Amazon pour commander votre exemplaire.

Retrouvez la critique originale (et complète) ici

« Wicket In Action » ou comment mélanger la théorie et la pratique de façon agréable. Si vous souhaitez aborder le développement Web sous un nouvel angle, Wicket est la solution. Ce framework permet une réelle séparation de la partie HTML et de la partie JAVA. Cependant, l'approche étant fondamentalement différente, sur quel livre se baser pour réaliser l'apprentissage de ce framework ?

« Wicket in Action » livre publié chez Manning, sorti récemment, présente le framework avec beaucoup de pertinence, en ne sautant aucune étape, et en laissant encore un peu de travail au lecteur pour l'acquisition de certains composants.

Après une brève présentation du pourquoi, du comment, le livre s'attache à nous faire comprendre le fonctionnement intrinsèque du framework via une petite application Web (« Boutique de vente de Fromage ») mettant en ?uvre les concepts fondamentaux. Cette approche très pragmatique du sujet permet au lecteur de comprendre en douceur le raisonnement qu'il devra acquérir pour réaliser lui-même des services. La présentation pas à pas des différents composant de l'application, de la méthode de mise en ?uvre, et de la manière de séparer visualisation pour un graphiste et intégration pour un développeur, donne indéniablement envie d'en savoir plus.

Les chapitres suivant permettront d'approfondir les sujets, parfois abordés rapidement au cours de l'exemple (comme la notion de modèles), via une judicieuse montée en puissance, pour finir par l'intégration de composants Ajax dans les pages. Tous les composants de Wicket ne sont pas détaillés laissant au lecteur le plaisir de chercher pour voir plus loin.

Ce livre est écrit en autre par Martjin Dashorst, un collègue de Jonathan Locke (créateur de Wicket), qui connait très bien le sujet pour avoir travaillé sur les toutes premières versions du framework, et qui participé aux orientations sur les concepts et développements.

Comme l'explique la description du livre, sans Java côté serveur, eBay n'existerait pas...et donc pas possible d'acheter le poster de Farrah Fawcett qui vous plait tant. Voilà l'ambiance dans laquelle vous baignerez à la lecture de "Head First Servlets and JSP" : un contenu décalé (des images et dialogues amusants, etc.) par rapport aux ouvrages informatiques traditionnels, mais qui cache une pédagogie bien étudiée et qui fonctionne (je pense que tous les lecteurs de cette collection confirmeront).

Le but de ce livre est non seulement d'expliquer les techniques de développement orienté web avec Java (Servlets, JSP, taglibs...) mais surtout une préparation à la certification Sun Certified Web Component Developer Exam (SCWCD) dans sa version pour J2EE 1.5 : chaque chapitre est ainsi ponctué d'un mini examen, et à la fin du livre un dernier pour vous tester véritablement.

Les trois auteurs sont très qualifiés sur le sujet puisque Bryan Basham a participé à la conception de la SCWCD, Bert Bates quant à lui, a oeuvré pour la Sun Certified Business Component Developer et enfin Kathy Sierra est fondatrice de javaranch.com et a participé également à la conception de la SCJP. Que du beau monde donc !

Et les trois auteurs se focalisent uniquement sur les sujets de la certification, vous garantissant la réussite de la certification avec tous les conseils prodigués dans l'ouvrage.

Je ne vais pas trop m'étendre et juste résumer la qualité de l'ouvrage en donnant la note maximale pour un livre qui vous apprendra tous les rudiments du développement web en Java, ou vous aidera à réviser pour passer la SCWCD. Un livre à acheter les yeux fermés !

Ce livre est excellent, c'est grâce à lui que j'ai appris les bases de Spring. Bien qu'en anglais, il est très agréable et facile à lire.
Pour les novices, c'est effectivement un support de choix : il va introduire Spring en douceur par l'explication des raisons d'être de celui-ci, pour ensuite expliquer certaines notions sur lesquelles se base Spring (l'injection de dépendance, l'inversion de contrôle, la programmation orientée aspect) sans devenir pénible et difficile à lire.

Il présentera ensuite techniquement les différents services que Spring apporte dans le développement, allant des possibilités de simplification de la couche DAO, à la programmation distribuée ou encore le développement Web grâce à son module MVC.
Ces qualités font de lui un très bon guide pour apprendre Spring, mais aussi un aide mémoire lorsqu'un petit trou de mémoire survient. Il m'arrive encore régulièrement de le relire afin de rafraîchir certains points précis.

De plus, un des auteurs est aussi l'un des créateurs de Spring, Rod Johnson, qui n'en est pas à son premier livre populaire dans le monde Java/J2EE.
Il connait donc bien son sujet, et arrive sans peine à le vendre, et même à nous donner envie d'en savoir plus sur Spring.
Mon seul regret est qu'il n'a pas encore été réédité en prenant en compte les nouveautés de la version 2.0 de Spring, et est donc limité à la version précédente : 1.2

Il s'agit d'un très bon livre d'introduction à GWT.
Il est bien écrit et didactique.
Je dois avouer que la structure des chapitres m'a d'abord déconcerté, chacun de ces chapitres est scindé en quatre parties:

• Présentation
• "Time for action"
• "What's just happened"
• "There's more / summary"
  

Le fait de commencer par réaliser le code puis ensuite de donner l'explication du code réalisé, peut surprendre mais finalement cela permet de ne pas réserver ce livre à un public restreint. Pour le débutant, le fait que le code soit clairement séparé des explications permet de se concentrer sur les faits importants et de ne pas se disperser entre le code et les explications.
Pour un lecteur expérimenté, cela permet de retrouver rapidement l'information recherchée ou de passer rapidement sur les notions qu'il maitrise.
La section "There's more /summary" est très intéressante, elle permet de voir les petits plus existants, et de recentrer les notions déjà vu.

La qualité du code donné, ainsi que les méthodes de réalisation fournies sont de très bon niveau.

Pourquoi ne pas mettre 5 étoiles ?
C'est un très bon livre d'introduction et d'aide mémoire, mais il n'est pas totalement complet.
Il manque pour moi trois notions pour qu'il soit complet.
D'abord un peu d'information sur les conventions de nommage, nottament pour les styles CSS.
Ensuite, l'utilisation du protocole JSON n'est pas abordé, ce protocole peut-être utile pour permettre de mélanger un application GWT avec un autre langage PHP par exemple.
Enfin, un exemple d'utilisation du framework GWT, avec un autre framework de type Struts, pour l'intégration avec des applications existantes.

Ce livre est une merveille, il est à la fois précis et concis, détaillant chaque élément du framework sans se perdre dans de longues explications, tous les textes sont très courts et entrecoupés de code fonctionnel et réutilisable. Les codes et les erratas pourront être téléchargés sur le site du livre.

JSF est un framework qui a la réputation d'être complexe à appréhender au premier contact pour le novice. Vous pourrez grâce à ce livre prendre la main sereinement et developper rapidement des applications en profitant de la puissance et de la souplesse des JSF. Il est important de noter que l'on peut aborder ce livre sans avoir de connaissance particulière sur les JSP/Servlet, seule une connaissance de la programmation Java est nécessaire.

Tous les exemples de code sont complets, ce qui permet d'être opérationnel très rapidement. Et surtout ce livre sera une formidable référence à conserver sous le bras tout au long du développement. Je conseille la lecture de ce livre à toute personne aillant l'intention de développer des applications utilisant les JSF.

Kent Tong a une façon très didactique de présenter le framework Tapestry. Il explique les grands principes, montre leurs applications de façon générale puis donne des exemples précis et pertinents.

Dans son livre, il présente d'abord le fonctionnement intrinsèque de ce framework, puis montre des explications pertinentes d'intégration avec des framework tiers, tels Hibernate ou HtmlUnit. Cela permet donc vraiment d'aborder la conception de site web de façon globale. La pertinence est telle que j'ai réutilisé ces exemples d'intégration dans d'autres contextes. En effet, Kent Tong explique tant les détails de réalisation que la portée de ceux-ci avec clarté et précision.

A noter également que Kent Tong a régulièrement fait parvenir des corrections ou mises à jour de son pdf. Par exemple, la version que j'avais acquise l'année passée couvrait uniquement Tapestry 4.0. Puis Tapestry 4.1 est apparu, et peu de temps après Kent Tong a communiqué une version à jour de son livre couvrant Tapestry 4.1 (qui introduit des changements notables).

Au final, personnellement, c'est le meilleur livre d'introduction à un framework que j'ai vu jusqu'à présent.

NB : Je tiens toutefois à préciser que je n'ai pas retenu ce framework.

Kent Tong has a very didactic way of explaining the Tapestry framework. He explains the fundamental aspects behind the framework from a general point of view, and then provides very consistent and precise examples.

In his book, Kent Tong shows first the Tapestry framework and its way of doing things. Then he explains how to integrate the framework with others, like Hibernate or HtmlUnit. Thus, with this book, one can approach web design in all its aspects, which is fairly important. The interest of Kent Tong examples are such that I've used them in different contexts than Tapestry. Indeed, he explains both the details of the implementation as well as the impacts, all being done with clarity and precision.

Important to notice as well, Kent Tong has regularly provided updates or corrections of his book. For example, when I bought the book, only Tapestry 4.0 was covered. Then Tapestry 4.1 appeared. Short after, Kent Tong provided an updated version of his book covering Tapestry 4.1 (which introduces some fairly important changes).

Finally, personally, it's the best framework introduction book I've read until now.

NB : Just a last notice : eventually, I didn't retain Tapestry.

J'ai eu un coup de coeur pour ce livre concernant la certification SCWCD J2EE 1.4 (310-081).
Je pense que Charles Lyons a réussi quelque chose de magnifique avec ce livre.

J'ai beaucoup aimé son approche, très équilibrée, pour vous expliquer les choses. Il ne va pas vous expliquer le protocole HTTP dans tous les détails comme si vous deviez être un expert réseau, ni vous l'expliquer comme si vous aviez vécu dans le désert jusqu'à présent. Mais il va vous l'expliquer simplement, mettant l'accent sur les choses à retenir pour l'examen.
Les questions que l'on retrouve dans le livre (il y en a plus de 300) vous donnent une bonne idée de ce qui vous attends à l'examen.

Mais il y a également des bonus :

Ainsi, en plus du livre, vous avez également un "mock exam" en ligne, vous permettant de vous entraîner encore un peu plus.
Les deux derniers chapitre du livre vous expliquent également les modifications introduites avec Java EE 5 dans ce qui est Servlet 2.5, JSP 2.1, et EL 2.1.

Attention que ce n'est qu'un "Study Companion" pour ce qui est de la certification. Il n'est pas là pour remplacer les livres qui vous apprennent tout de A à Z. Il est là pour réviser quelque peu la matière et vous rafraîchir la mémoire sur les points importants pour l'examen.

Bien que ce livre tranche tout à fait, si on le compare avec l'approche choisie pas les auteurs de la série Head First de chez Oreilly, il a tout de même un style propre à lui qui le rend différent des autres livres que l'ont lit généralement sur les certifications.

Il m'a vraiment beaucoup plus.

Je lui donne 5 étoiles, car je pense qu'il le mérite vraiment. Et j'espère que vous partagerez également cet avis.