Les livres Java Web pour les Expérimentés

Si vous souhaitez découvrir rapidement les EJB 3, ce livre est un excellent moyen de commencer.
À l'aide de capture d'écran et d'extrait de code source, il présente clairements les différents aspect de ceux-ci : la couche métier avec les Session Bean, la persistance avec JPA, la securité, les fonctionnalités transverses avec les interceptors ou encore l'interopérabilité par le biais des WebServices.

Mais le point fort de ce livre est qu'il ne porte pas uniquement sur les EJBs, mais aussi leur utilisation dans des projets avec des outils et frameworks qui ne sont pas forcément liés à ceux-ci au départ.
J'ai fort apprécié la section d'intégration de Flex et des EJBs par exemple, qui est très bien expliquée, ou encore l'intégration avec JasperReport. Ces sujets sont très spécifiques et donc très rarement traités, ce qui en fait une plus-value importante (du moins pour ceux qui s'y intéresse).

Le chapitre concernant la spécification JEE 6 est appréciable également afin de survoler rapidement les nouveautés de celle-ci.

Au niveau de la forme, le livre est bien écrit et assez aisé à suivre. Mon seul regret est de devoir de temps en temps jongler entre les pages, du fait des extraits de code parfois trop verbeux.

Public
Grâce à ses codes source très bien expliqués, ses fonds d'écrans explicites et des explications très facile à comprendre, ce livre est particulièrement bien adapté à des profils neophytes désirant découvrir les EJBs 3.

Programmation GWT 2 est un livre écrit par Sami Jaber, consultant indépendant, qui s'est immergé dans le projet GWT 2 pendant son élaboration. Ceci lui a permis d'écrire cet ouvrage en avant première.

Il ne faut pas considérer ce livre comme un tutoriel évolué qui décrit comment développer une application GWT. L'auteur met plutôt l'accent sur les nouveautés du framework et décortique les prouesses technologiques de GWT.

La première partie du livre est une présentation rapide de GWT et de l'environnement de développement. On assiste ensuite à un tour très rapide des widgets disponibles dans GWT ainsi que les divers conteneurs. Ici, un développeur débutant désireux de prendre en main la technologie regrettera que l'auteur passe un peu rapidement sur ces points. Pour bien apprécier le livre, il faut à mon avis avoir déjà bricolé un peu la version 1.X de GWT.

On appréciera le chapitre 4 qui présente les bibliothèques tierces, comme GXT ou SmartGWT. Même s'il est assez succinct, cela donne un aperçu global des possibilités du marché.

Avec le chapitre 5, on entre dans les arcanes de GWT avec la présentation de JSO et des Overlay. Ce chapitre est un peu complexe à suivre mais on voit que l'auteur est impressionné par l'inventivité des créateurs du framework et a cherché à bien comprendre la magie qu'il y a dessous.

On lira avec intérêt le chapitre 7 sur les services RPC, éléments incontournables pour créer une vraie application.

Ensuite l'auteur décrit les nouveautés de GWT 2, comme les optimisations du chargement à la demande, la liaison différée ou la gestion des ressources et l'internationalisation.

On découvrira aussi ce qui se passe "sous le capot de GWT" avec notamment la génération de JS et les optimisations.

En fin de livre, on appréciera les chapitres qui parlent de comment créer des tests dans une application GWT 2 et qui présentent des designs patterns et bonnes pratiques pour le développement d'application GWT. Et, cerise sur le gâteau, l'avant dernier chapitre est consacré à UIBinder, une des grandes nouveautés de la version 2 et nous met l'eau à la bouche avec cet outil qui va grandement simplifier la création des interfaces graphiques.

Globalement, le livre est plutôt bien écrit et clair. Certains chapitres sont assez difficiles à comprendre et pas toujours indispensables à l'apprentissage de GWT. Par contre, ils sont très intéressant pour la culture ou pour maitriser complètement les arcanes de GWT.

Je recommanderai cet ouvrage dans un premier temps aux personnes ayant eu une première expérience dans le développement GWT et qui cherchent à utiliser avec profit les nouveautés de GWT 2. Les développeurs ne connaissant pas du tout GWT auront à mon avis besoin de beaucoup de travail personnel pour commencer à appréhender les subtilités de ce framework.

Pour diffuser des ressources sur une technologie, on peut soit traduire une ressource existante dans une autre langue, soit créer une nouvelle ressource de toute pièce. Sami Jaber a choisi, pour notre plus grand bonheur, la seconde solution. L'originalité de son ouvrage consiste à apporter des informations complètement inédites sur GWT 1.0 et 2.0.

Sur la forme, c'est un ouvrage technique qui se picore davantage qu'il ne se lit de bout en bout.

Sur le fond, c'est assez riche. Jugez plutôt :

1) Des chapitres "classiques" qu'on retrouve plus ou moins dans les autres livres GWT.

L'introduction intéressera particulièrement les décideurs puisqu'elle brosse une vue d'ensemble de GWT et le situe face aux autres frameworks Ajax.

Les chapitres "L'environnement de développement", "Les contrôles", "Le plug-in Eclipse pour Gwt" s'adresseront davantage aux développeurs débutants qui n'auraient pas préalablement lu de livre sur le sujet.

Le chapitre "Les bibliothèques tierces" est un peu tiède à mon goût, à la fois pas assez exhaustif (comment pourrait'il l'être ?) et trop détaillé pour un simple survol (Qu'est ce qu'apporte un seul exemple ?). Notez bien mon questionnement car à la place de l'auteur, je ne sais pas comment j'aurai fait ? Il ne pouvait pas passer dessus et il ne pouvait pas trop détailler non plus pour des contraintes éditoriales évidentes; il a donc opté pour une solution intermédiaire. Une fois le livre terminé, ma perplexité subsiste. Les librairies présentées sont intéressantes aujourd'hui mais comparé au potentiel de GWT 2, elles paraissent bien fades.

• Smart GWT étant un wrapper de code JS, on perd des avantages de GWT (comme le debug pas à pas, la prévention contre les fuites mémoires, ...)
• GXT quand à elle est une librairie full GWT mais tous ceux qui ont regardé son code vous diront qu'elle est loin déjà d'avoir intégré toute la puissance de GWT 1.0 (deferred binding). On a donc hâte qu'elle soit réécrite en tirant toutes les spécificités supplémentaires introduites par GWT 2.0.
• Gears est aujourd'hui abandonnée au profit d'une solution plus standard du W3C.
• Quand aux autres plus particulières, on a qu'un souhait : que leur intégration future à GWT se fasse le plus tôt possible.
  

Le chapitre "Les services RPC" ressemble pour l'essentiel à ce qu'on trouve ailleurs. Certes, l'auteur parle de deRPC, la nouvelle version du RPC, du mode hybride compatible RPC 1.X et RPC 2.X, de bonnes pratiques et du contournement de la règle SOP (Exemple du proxying) mais il m'a un peu laissé sur ma faim. J'aurai aimé dans ce chapitre une section "sous le capot" telle qu'on les trouve dans d'autres chapitres. J'aurai également aimé qu'il détaille la connexion d'un client RPC à un serveur non RPC.

2) Des chapitres qui détaillent des aspects de GWT comme aucun ouvrage ne l'a fait jusqu'à présent.

Le chapitre "L'intégration de code Javascript" est passionnant. En suivant la problématique, l'approche historique et les débats de l'équipe de développement GWT, on a l'impression d'être avec eux dans les coulisses.

Le chapitre "La création de composants personnalisés" est assez étoffée. On y apprend surtout pourquoi Javascript a des fuites mémoires et comment GWT s'y prend pour les éviter. A conseiller aux développeurs Javascript !!!

Le chapitre "L'intégration J2EE" fournit des pistes à ceux qui doivent s'interfacer avec du Spring et des EJB. Certains reprocheront que la liaison avec leur librairie préférée n'est pas abordée mais vu la richesse de J2EE, le choix de l'auteur se limitant aux deux principales est pertinent.

Les chapitres "La liaison différee" et "Sous le capot de GWT" détaillent les mécanismes utilisés par GWT pour générer du code multi navigateur et optimisé. Très intéressant !!!

Le chapitre "L'internationalisation" est très complet. Je note particulièrement la question des formes plurielles et des outils pour en écrire le moins possible (Feignant ? Non, productif !).

Dans le chapitre "Les design Pattern GWT", il est question à la fois des patterns MVC, MVP pour séparer les responsabilités et de bonnes pratiques concernant l'historique, les traitements longs et la sécurité. Cette dernière étant détaillée (injection sql, XSS, CSRF, authentification), elle pourrait peut être faire l'objet d'un chapitre séparé ?

3) Et "must have", des chapitres complètements inédits sur la version 2.0 qui est sortie en même temps que l'ouvrage.

Le chapitre "Les modèles de placement CSS" intéressera tous ceux qui ont galéré pour faire la mise en page de leur application GWT. La nouvelle solution est beaucoup plus propre et est donc à essayer d'urgence !

Le chapitre "Le chargement à la demande" décrit la nouvelle fonctionnalité qui permet de partitionner le code javascript généré. Sur le papier, elle semble intéressante mais reste à voir en pratique si elle n'apporte pas davantage de complexité. Mais bon, l'ami Sami vous aura prévenu !

Le chapitre "La gestion des ressources" répond également à une problématique d'optimisation des temps de chargements. On y apprend comment mettre en cache tout types de ressources et même comment faire de l'injection de styles CSS (Il faut dire que l'extension du mécanisme ImageBundle a permis d'introduire des directives dans les fichier CSS)

Le chapitre "L'environnement de tests" présente les styles de test introduits dans la nouvelle version. A se demander comment on faisait avant ?

Le chapitre "La création d'interface avec UIBinder" sera utile à tous ceux qui préfèrent coder leur vues en XML.

Comme je vous le disais dans ma critique du livre d'Olivier Gérardin, les francophones ont dû attendre plus de 3 ans les livres en français sur GWT mais une fois de plus, cela valait le coup d'attendre. Le hasard faisant bien les choses, je suis ravi de l'ordre de parution puisque après le premier livre en français sur GWT (plus didactique), les développeurs pourront continuer avec celui-ci (plus technique), le premier livre mondial sur GWT 2.0.

Comme le nom de l'ouvrage l'indique, Jérôme Lafosse nous livre au travers de plus de 400 pages, toutes les notions à connaître pour développer avec la nouvelle évolution du framework web Java Struts.

Dès les premières pages, nous avons un descriptif succinct des notions essentielles et de l'architecture MVC I et MVC II.
Cette attention particulière pour toute personne novice en la matière, lui permettrait de comprendre les explications données par la suite et pouvoir ainsi dès la fin du livre, développer ses propres applications web.

Les chapitres suivants détaillent chaque partie du framework allant du filtre à l'ajout et l'utilisation de plug-ins complémentaire à/ou déjà intégré dans le framework.

Enfin, Jérôme Lafosse conclut par une annexe recensant les différents intercepteurs.

Un apprentissage par l'exemple continu qui nous permet de voir l'évolution d'un code avec les différents acquis reçus au cours du chapitre, et qui démontre la valeur ajoutée de chaque partie tant sur le code que dans les exemples via les copies d'écran des résultats. Des explications claires et détaillées, qui nous permettent d'avoir deux utilisations du livre. La première serait pour l'apprentissage du langage et la seconde comme livre de référence pour le développement d'applications.
Il est très complet et couvre toutes les notions pour développer une application professionnelle en Struts 2 avec différentes librairies complémentaire comme JQuery pour l'utilisation d'Ajax, Velocity en tant que générateur de template ...

Enfin, la police et la mise en page permettent une lecture aisée et fluide.

Les points négatifs que je pourrais apporter sont : Au niveau de l'édition, nous avons un caractère récurrent (qui est <+>) qui pourrait dérouter les plus novices.
Enfin, on aurait apprécié un surlignage des modifications ou des lignes du code qui étaient rajoutées dans les exemples suivant l'explication.

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.

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/

Ce livre est une réussite dans la mesure où il atteint les objectifs qu'il s'était fixé, à savoir faire découvrir Java EE 5 aux architectes et développeurs confirmés. L'ouvrage s'articule autour de la réalisation d'un site de commerce électronique ce qui a pour avantage d'éclairer à chaque chapitre les concepts théoriques vus précédemment, et permet de mesurer d'une manière précise les apports de Java EE 5 dans la pratique, sans pour autant rentrer dans les détails de chaque spécification abordée. Pour cela l'auteur a pris soin de mettre des références fort pertinentes.

La progression du livre est très pédagogique ce qui est un tour de force compte tenu de l'étendue du sujet : l'auteur parvient à expliquer au fur et à mesure différents concepts et leur imbrication sans sauter les étapes.

Autre point positif, le site de l'auteur est doté d'un forum et permet ainsi de discuter de tel ou tel aspect du livre.

Si je devais relever des points négatifs, je dirais que la présence systèmatique du code des annotations peut paraître inutile compte tenu d'une certaine redondance, mais bon ça reste anécdotique.

Pour conclure, c'est un livre très abouti, à commander donc et à recommander.

Bien que des notions élémentaires de la plateforme Java EE soient suffisantes pour aborder ce livre, il requiert toutefois d'avoir de solides connaissances de la plateforme Java SE ainsi que de bons acquis en UML et XML.

Cet ouvrage tient toutes ses promesses. Il réussit le tour de force d'aborder un nombre impressionant d'APIs de la plateforme Java EE de façon claire et concise. Celles-ci ne sont donc pas abordées dans leur intégralité (un livre ne suffirait pas) mais elles le sont suffisamment pour commencer à savoir s'en servir et nous donner l'envie d'aller plus loin. Ces APIs font toutes partie des spécifications constituant Java EE 5 (EJB3, JPA, JSP, JSF, JSTL, JMS, JAX-WS, JAXB, JavaMail, ...). Pour les personnes voulant approfondir ces notions, l'auteur a eu la très bonne idée de donner, tout au long de son ouvrage, des références sur les sujets qu'il aborde.

Le livre est construit autour du développement d'une application web complète (de type site marchand). C'est cette approche qui permet de couvrir de façon concrète le large panel d'APIs abordées.

Autre point intéressant, la première partie est consacrée à la conception de l'application où l'auteur partage son expérience et son savoir faire en expliquant ses choix (attitude qu'il adopte tout au long du livre).

Agréable à lire et au contenu d'une grande qualité, cet ouvrage m'apparaît être un indispensable pour tout développeur Java EE désireux de connaître la plateforme Java EE 5.

Vous trouverez également sur le site de l'auteur les sources complètes du livre ainsi qu'un espace de discussion autour du livre et du code de l'application.

En reprenant les bases de la programmation web (HTML, Servlet, JSP) et les infrastructures que cela met en jeu (serveurs Web, serveur d'application et de base de données), l'auteur nous entraîne petit à petit vers la programmation web structurée par le modèle MVC sous le framework Struts. Si vous ne savez pas ce qu'est le modèle MVC, aucun souci car une partie d'un chapitre lui est consacrée afin de bien assimiler ce qu'apporte ce modèle et en quoi Struts réponds à sa mise en place.
Tout les concepts du framework sont ici clairement abordées (ActionForm, taglibs Struts, Validators, etc.) à travers des exemples concis et facilement compréhensibles.
Mais ce livre ne se contente pas simplement de décrire l'utilisation du framework et ce qui le compose, l'auteur élargit le sujet en montrant comment ce framework peut être utilisé, couplé à d'autres technologies telles que les WebServices ou les EJBs. De plus des patterns tels que le pattern DAO sont également décrits (appuyé sur Hibernate). De ce fait, cet ouvrage permet à n'importe quelle personne souhaitant se lancer dans le développement web d'obtenir une vue générale concernant les différentes couches composant une application. On appréciera également une partie d'un chapitre dédiée à des outils tels que Log4j ou ANT par exemple.
Cependant j'aurais une remarque à faire concernant les exemples en eux-mêmes du livre. Même s'il est très pratique d'avoir plusieurs petits exemples pour comprendre différents concepts, je pense qu'il aurait été bon également que le livre s'appuie sur la réalisation d'une et une seule application afin de mieux assimiler en quoi justement ce modèle permet de séparer clairement les différentes couches applicatives afin d'obtenir un résultat modulaire.

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.

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.

Cet ouvrage débute par le constat alarmant que la technologie Java est arrivée à une croisée des chemins, et que les frameworks et outils employés en entreprise ont atteint une taille critique et une complexité telles qu'elles mettent en péril les évolutions et les investissements. Beaucoup trop de développeurs cèdent encore à la fascination du "marteau en or", et cet ouvrage se propose de leur montrer la voie du pragmatisme et de l'efficience. Pour cela, les auteurs mèlent considérations techniques concrètes liées au codage et réflexions portées sur le design des applications, tout en ne négligeant pas les aspects psychologiques qui ont un impact sur la conception et le déroulement des projets, tout cela constituant un panorama complet, à ma connaissance inédit, de l'activité du développeur Java en entreprise. A toutes les étapes de la construction de l'application, les auteurs mettent en garde contre la tentation d'introduire de la lourdeur et de la sophistication là où ce n'est pas nécessaire, et proposent des alternatives plus légères et plus "agiles".

La lecture de ce livre a pour effet bénéfique de décomplexer le développeur rebuté par la complexité des conteneurs d'EJB et autres frameworks d'entreprise "indigestes". Pour les problématiques - majoritaires - pour lesquelles les mécanismes sophistiqués mis en oeuvre dans ces frameworks ne sont pas une nécessité vitale ou n'apportent pas de plus-value, cet ouvrage conseille l'emploi de frameworks plus légers, plus simples et plus spécialisés, tels que Spring & Hibernate, et l'illustre par une étude de cas. Les dernières évolutions de la plateforme entreprise de Sun, J2EE 5, qui montrent un réel effort en direction de la simplicité, laissent à penser que les auteurs ont vu juste et visé là où cela faisait mal... D'autres préconisations, tel que le développement dirigé par les tests, sont elles en passe d'entrer dans les moeurs, et la lecture des arguments en sa faveur développés dans ce livre devrait achever de convaincre les réticents.

L'intérêt que représente ce petit livre atypique pour le développeur Java professionnel est inversement proportionnel à son nombre de pages. J'ai particulièrement apprécié le portrait qui est fait du développeur soumis quotidiennement à des tiraillements entre volonté de bien faire et volonté demieux faire, et dans lequel nous nous reconnaissons tous. Ce livre, plutôt destiné aux développeurs expérimentés, sera le compagnon idéal de vos autres ouvrages d'ingénierie logicielle, afin de ne jamais perdre de vue la plus grande vertu à laquelle doivent aspirer tous les développeurs : la simplicité.

C'est un livre sur le développement J2EE avec Eclipse. L'intérêt de l'ouvrage est de présenter les très nombreux outils à interfacer avec Eclipse qui ne se suffit plus à lui-même. Qu'il s'agisse du déploiement avec Ant, des tests unitaires avec JUnit, de l'analyse des performances avec JUnitPerf, de la génération de fichiers de configuration ou de code avec XDoclet, de la gestion collaborative de sources avec CVS, de la génération de code à partir de diagrammes UML avec EclipseUML... nombreux sont les outils qui permettent d'accélerer et de rationnaliser le développement d'applications J2EE. L'auteur nous présente avec simplicité les multiples outils ainsi que les méthodes (design pattern) à disposition des développeurs pour un travail de qualité, réutilisable et maintenable.

Cet ouvrage se destine à des développeurs, experts techniques ou architectes, disposant de bases concernant Struts et étant à la recherche de bonnes pratiques.
Les pistes de réflexions suggérées par les auteurs sont nombreuses, dispersées tout au long d'un ouvrage qui manque de cohérence d'ensemble et qui s'éloigne par moment de Struts. Ainsi, le lecteur y trouvera une multitude de conseils pour ses développements Web en Java, mais ne devra pas se reposer sur cet ouvrage pour apprendre à utiliser Struts.

Malgré une certaine désorganisation, les sujets abordés par les auteurs sont intéressants mais par moment assez peu explorés en profondeur. Charge au lecteur d'aller plus loin en partant à la recherche de lectures complémentaires sur les sujets qui auront retenu son attention.
Agrémenté de quelques chapitres plutôt orientés "Gestion de projet", le propos de cet ouvrage repose entièrement sur la suite de développement Jasic (éditée par les sociétés respectives des auteurs) qui rassemble un certain nombre d'outils/framework tels que Struts ou encore iBatis.

On regrettera néanmoins l'absence de certaines thématiques comme les traitements côté serveur, Struts-Layout, les bibliothèques de tags bean et logic, ou encore davantage d'éléments concernant les Tiles. Le lecteur appréciera l'abondance d'illustrations par le code, code dont le style n'est malheureusement pas très agréable à la lecture.

En conclusion, ce livre, véritable mine d'informations et de conseils, malgré une organisation une peu fouillie, vous sera de bon conseil pour approndir l'utilisation de Struts ou de manière générale la construction d'applications Web basées autour de Struts ou un framework équivalent.
Par contre, il ne vous formera pas à Struts, et un minimum de connaissances sur ce framework semble nécessaire pour bien aborder le contenu du livre.

Retrouvez la critique complète ici.

Voilà un gros ouvrage (plus de 1000 pages) traitant des Services Web : une première partie définit les concepts autour des Services Web, une seconde plus technique couvre les technologies et spécifications, et le livre s'achève avec l'utilisation des Services Web sur les plateformes Java et .Net.
Le livre "Services Web avec J2EE et .Net" est très complet pour comprendre les nombreux intervenants des Services Web, on y trouvera une explication à de nombreux acronymes satellites (SOAP, WSDL, UDDI...la liste est longue), comme un dictionnaire en somme, c'est d'ailleurs je pense son optique d'utilisation première. La majeure partie de ce livre est donc théorique, le reste laisse place aux cas pratiques J2EE et .Net, avec des exemples que j'ai trouvé légers pour ces deux plateformes, donc à vos claviers pour allez plus loin.
La mise en page est claire, de nombreux schémas et échantillons de codes viennent agrémenter la théorie dispensée. Donc, un livre bien utile pour se rappeller l'utilisation et la mise en oeuvre de Service Web, mais également un bon point de départ pour comprendre la technologie. Je le conseille finalement à ceux qui débutent dans les Web Services, aux décideurs pour acquérir une vue d'ensemble tout en gardant à l'idée qu'à posteriori une exploration technique sera nécessaire.
Bonne lecture !

Si vous souhaitez tout savoir des Web Services, alors ce livre est pour vous !
Très complet, il vous permettra d'apprendre tout d'abord les bases, puis vous vous tournerez ensuite vers des notions plus complexes.
L'étude de cas est un vrai régal: en effet, dans beaucoup de livres, on vous explique ce que vous devez faire, mais il arrive très souvent que cela manque... d'exemples. Cette étude comble cette lacune et on ne peut que l'apprécier.
Bref, encore un livre que ne je peux que conseiller !