Conception d'applications en Java / JEE

Cet ouvrage traite de la conception d’applications à travers le prisme du langage Java.

Partant du principe que la littérature traitant de la conception logicielle est souvent anti-pédagogique, l’auteur revisite les patterns et les principes de conception logicielle en les illustrant d’exemples concrets. J’ai d’ailleurs trouvé l’idée d’illustrer les patterns du GOF suivant l’organisation du JDK aussi originale que passionnante mais surtout très empreinte de réalisme.

L’auteur consacre la première partie de son ouvrage à dispenser quelques rappels de cours sur le monde Java et sur la notation UML. Ces rappels, qui peuvent au premier abord sembler synthétiques, sont en réalité extrêmement bien ciblés sur les notions abordées dans le reste de l’ouvrage. Ces rappels sont également l’occasion pour l’auteur de nous imprégner de la méthodologie de pensée propre à la conception logicielle. On peut également apprécier que les technologies présentées soient très contemporaines concernant JEE (EJB – JPA –JSF…). Le seul reproche que je pourrais faire à ce tour d’horizon technologique JEE serait l’absence de mention des WS REST. Je me suis d’ailleurs demandé, à cet égard si cet oubli était volontaire dans la mesure où REST se permet de prendre des libertés vis-à-vis du génie logiciel ou si cela fera l’objet d’un complément dans la prochaine édition.

La seconde partie détaille les Design patterns de conception ainsi que les principes d’architecture. La description de ces modèles de conception efface, pour le plus grand plaisir du lecteur, la dimension aussi théorique qu’indigeste de ces monuments du GOF. Pour réussir cette prouesse pédagogique, il réussit à illustrer le concept abstrait d’un trait d’UML et nous replonger dans le concret avec le code source en Java. J’ai d’ailleurs pu mesurer à quel point cette méthode était vertueuse lorsque j’ai abordé le chapitre 7. En effet, ce chapitre ne propose aucun exemple en Java et je dois reconnaitre que ma compréhension de ce qui y est exposé fut très superficielle.

La troisième et dernière partie du livre nous offre deux études, la première en Java SE (moteur générique de jeux d'arcades 2D) et la seconde en JEE (une application de commerce électronique), qui clôturent sur le même ton ce livre : un savant mélange des principes généraux et des détails du langage. C’est indéniable, la mayonnaise pédagogique prend !!!

Je recommande cet ouvrage à ceux qui développent déjà Java et JEE et qui souhaiteraient rebondir sur leur connaissance de ce langage pour apprendre les principes de la conception logicielle.

Rédigé par un professionnel du développement d'applications J2EE ( certification Sun et JBoss ), cet ouvrage séduira par un style trés facile à lire, et une méthode d'apprentissage assez pragmatique, quoique nécessitant beaucoup de curiosité et d'autodidactie.

L'auteur présente la conception d'une application J2EE simple (au travers le projet "BlueWeb"), ainsi que son déploiement, en présentant tous les artefacts, API et outils utilisables de nos jours. Une petite revue technologique (logiciels libres / GNU essentiellement) forte interessante en soit pour les débutants. Les technologies comme Ant, JUnit, SWT, Regex et autre Log4j sont ainsi étalées et démystifiées de façon assez habile. De nombreuses analogies et exemples satisferont pleinement le lecteur qui ne se sentira par "décroché", et pourra acquérir assez rapidement de bonnes notions sur le monde J2EE et les méthodes de développement préconisées. On notera également que l'auteur s'est attaché à présenter des outils issus du monde libre dans la plupart des cas, plus accessibles pour les apprentis architectes J2EE...

Sont particulièrement appréciables :

• l'organisation du livre, les larges marges définissant clairement les nouveaux termes abordés, des anecdotes et retours d'expérience ;
• le style d'écriture en général ;
• la revue panoramique assez complète initiée par l'auteur, la présentation technologique générale.
  

Vous aborderez donc dans cet ouvrage: une étude de cas J2EE, les EJB, Ant, JBoss, les architectures J2EE ( MVC ) et autres patterns, HTTP, JWS, Checkstyle, XDoclet...

Trois ans et demi après la première version, je viens de lire la seconde version de l'ouvrage « Programmation GWT 2 » de Sami Jaber. Je vais me concentrer sur les nouveautés de cette version et je vous renvoie à ma première critique pour plus de précision.

L'auteur fait un peu de ménage. Le chapitre qui a été le plus réduit est celui sur les bibliothèques tierces. Par exemple, la partie sur l'incubateur GWT est passée de quatre pages à un paragraphe; cela se comprend bien quand on sait que ce projet d'incubateur a été abandonné. De même, les références aux bibliothèques de data-binding perdent de leur intérêt maintenant que GWT inclut son propre mécanisme.

L'auteur actualise par-ci par-là les chapitres existants. Parfois, ce sont de simples reformulations pour employer des buzzwords (HTML 5); parfois, c'est parce que certaines des hypothèses qu'il faisait à l'époque se sont confirmées depuis. Quoi qu'il en soit, même s'il essaye de faire de la place pour accueillir de nouvelles pages, cela ne se fait pas au détriment de son optique d'ouvrage de référence sur GWT. Ainsi, malgré la réduction du chapitre sur les bibliothèques tierces, Sami trouve la place de dire un mot sur le framework Web GWT qui monte: Vaadin.

L'auteur a ajouté quatre nouveaux chapitres sur les ajouts de la version 2.5:

Le premier concerne les CellWidgets, une nouvelle approche de séparation modèle/vue pour créer des composants plus performants lorsqu'ils sont utilisés dans des grilles de données. L'idée est d'injecter directement de l'HTML au lieu de réaliser de coûteuses opérations sur le DOM. C'est le chapitre qui m'a le plus intéressé car la nouvelle version du framework Sencha GXT 3 utilise les «Appareance» et les «SafeHtmlTemplate» qui y sont décrits.

Le second concerne le framework MVP dénommé Activities & Places et c'est le seul livre GWT qui en parle aujourd'hui.

Les troisième et quatrième nouveaux chapitres traitent de RequestFactory, un nouveau protocole d'échange et de l'API Editors qui proposent un mécanisme de liaison de données plus souple (AutoBean).

Si je peux émettre un petit regret, c'est que le livre soit sorti avant l'annonce de la nouvelle gouvernance de GWT; j'aurai bien vu l'opinion de l'auteur sur ce sujet en guise de conclusion. Que les lecteurs se rassurent, elle est disponible sur son blog.

Cette deuxième édition fait 21 chapitres (516 pages) alors que la première édition fait 17 chapitres (461 pages). Soit environ 50 pages supplémentaires.
Elle prend en compte les nouveautés introduites depuis la version 2.0 jusqu'à la version 2.5.
Les développeurs francophones peuvent certainement remercier l'auteur d'avoir mis à leur disposition un livre en français qui soit aussi complet et à jour sur GWT.

Chapitre 1 :
Le premier chapitre présente clairement la structure d'un projet GWT mais aussi les différents modes : mode développement et mode production. Avec une petite introduction à une nouveauté de la version 2.5 : le super DevMode.

Chapitres 2 et 3:
Dans le chapitre 2, j'ai apprécié l'honnêteté de l'auteur qui souligne dès le début "la simplicité et la sobriété" des widgets disponibles en standard dans le framework. Les principaux widgets sont passés en revue, avec exemples d'utilisation à l'appui (code Java et CSS, ainsi que des captures d'écrans).

Chapitre 4 :
Je pense que ce chapitre dresse un bon tour d'horizon des bibliothèques tierces (Sencha Ext-GWT, SmartGWT, GWT-DnD, GChart, GWT HighCharts) et des frameworks complémentaires (Vaadin entre autres).

Chapitre 5 :
L'utilisation de JavaScript dans du code Java est étudiée de façon minutieuse dans ce chapitre : insertion de code JavaScript dans une méthode Java, intégration d'un fichier JavaScript externe, correspondance des types entre Java et JavaScript etc. L'auteur fournit également des explications sur les types Overlay, plutôt méconnus.

Chapitre 6 :
La création de composants personnalisés est souvent nécessaire dans un projet et ce livre ne manque pas d'y consacrer un chapitre entier. On y voit de façon détaillée la mécanique événementielle de GWT et le modèle de widget.

Chapitre 7 :
Ce chapitre décrit les services RPC et dévoile les bonnes pratiques à mettre en place lors de leurs utilisations.

Chapitre 8 :
Ce chapitre met l'accent sur l'intégration J2EE avec un exemple d'utilisation des EBJ 3 et de JPA. J'ai trouvé l'exemple pertinent et suffisamment illustré par du code.

Chapitres 9, 10 et 11 :
Ces chapitres expliquent et décrivent amplement le chargement à la demande (code splitting), la liaison différée (deferred binding) et la gestion des ressources (API ClientBundle) à grand renfort de code, de rapports de compilations, de captures d'écrans de navigateurs, etc.

Chapitre 12 :
Ce chapitre rentre dans les entrailles de GWT : différentes facettes du compilateur, fichiers créés, réduction de code (pruning) et optimisations.

Chapitre 13 :
Le mmécanisme de l'internationalisation avec GWT est traité dans ce chapitre. L'auteur aborde et montre bien l'utilisation de l'API i18n, les dictionnaires, les messages, les conversions de types ainsi que l'outillage.

Chapitre 14 :
Les tests ne sont pas délaissés puisque un chapitre entier y est dédié. On y voit l'utilisation de GWTTestCase, HTMLUnit et Selenium. Ce dernier framework est pas mal utilisé dans le chapitre, notamment pour l'écriture des tests fonctionnels (decription de Selenium IDE et du module WebDriver). Enfin la notion de mocking n'est pas oubliée puisqu'elle est illustrée avec un exemple utilisant JMock et EasyMock.

Chapitre 15 :
Ce chapitre sur les design patterns est à mon avis un des plus importants car il liste les les bonnes pratiques d'architecture et de conception. Et à mon avis l'auteur a fait un très bon travail en fournissant pas mal de conseils : comment gérer la session, l'historique du navigateur, les traitements longs avec les classes Timer et Scheduler, les patterns Commande, MVC et MVP etc.

Chapitre 16 :
J'ai trouvé le chapitre dédié à UIBinder très exhaustif. On y voit la gestion des styles et ressources, l'incorporation des images, la gestion des évènements, le référencement de widgets composites à l'intérieur d'un widget composite ...

Chapitre 17 :
Un très court chapitre qui prend la peine de faire un tour d'horizon du plug-in Eclipse pour GWT. Je pense qu'il montre bien ses possibilités.

Chapitre 18 :
Ce chapitre est consacré aux composants CellWidget. J'ai bien apprécié la description et l'utilisation (nombreux extraits de code) du widget CellTable, très utilisé pour la création de tableaux. La documentation officielle de Google est très bonne sur le sujet mais des explications supplémentaires et de surcroît en français ne sont jamais de trop !

Chapitre 19 :
Enfin un chapitre dédié à l'API Activities and Places. A l'heure actuelle il existe encore peu d'ouvrages qui abordent en détails cette API et c'est un gros manque. Dans ce chapitre l'auteur explique longuement cette API complexe et l'illustre à l'aide d'un exemple et d'un schéma décrivant toute la chaîne d'exécution de l'API Activities and Places.

Chapitres 20 et 21 :
Ces deux derniers chapitres concernent les API RequestFactory, AutoBean et Editors. Tous les deux sont bien riches en code et explications, conseils et avertissements !

De manière générale j'ai beaucoup apprécié l'exhaustivité des explications fournit dans la plupart des chapitres. Mais aussi les conseils et avertissements sur certains sujets complexes.
J'ai aussi beaucoup apprécié l'apparition d'un chapitre entièrement dédié à Activities and Places. L'importance de ce framework dans le développement d'une application GWT mérite en effet un chapitre à lui tout seul et l'auteur a bien veillé à en inclure un mais a également produit un bel effort d'explications détaillées de cette API difficile pour la rendre plus compréhensible et plus assimilable.
Je n'ai a priori noté qu'un seul manque dans ce livre : une présentation un peu plus détaillée du super dev mode, qu'on avait annoncé comme une nouveauté très intéressante de la version 2.5. Mais cette fonctionnalité est relativement neuve, notamment au moment de l'écriture de cette deuxième édition du livre.

Le coffret "Maîtrisez et optimisez le développement n-tiers" contient deux livres de Jérôme Lafosse. Le premier s'intitule "Guide de développement d'applications Web en Java" et le second "Développements n-tiers avec Java EE". Si les deux livres sont disponibles séparément, je pense que c'est une bonne idée de proposer les deux ensembles tant ils sont complémentaires. On a ainsi à travers 1500 pages une présentation globale de la plateforme JEE.

Pour les débutants, le premier livre est idéal pour commencer.

L'auteur présente dans un premier chapitre les objectifs de JEE et les avantages à utiliser cette plateforme. J'ai apprécié qu'il indique d'entrée les conventions qu'il faut respecter pour tirer la quintessence de cette plateforme.

Puis, dès le second chapitre, il indique comment installer Tomcat. Je trouve ce choix très juste, car les développeurs ont besoin de démarrer rapidement lorsqu'ils apprennent une nouvelle technologie.

Au troisième chapitre, il présente les JSP et là encore, je trouve son choix judicieux dans la mesure où il est probable que le développeur Web souhaitant se mettre à Java ait déjà commencé par du HTML et du PHP. La transition n'en sera que plus douce.

Puisque les JSP sont compilées, il est naturel qu'au chapitre suivant, il traite des servlets. Une introduction au pattern MVC permet alors de situer les JSP par rapport aux servlets et nous conduit naturellement au dernier tiers qui est l'accès aux données.

Le cinquième chapitre présente donc l'API JDBC qui permet d'interagir avec des bases de données relationnelles.

Les deux derniers chapitres présentent le premier framework JEE Struts, le système de logging Log4J et le système de build ANT. Il existe des ouvrages spécialisés pour chacun de ces derniers sujets, mais pour débuter, il est pertinent d'avoir regroupé tout ce dont on a besoin dans un unique ouvrage. Certes, Struts n'est plus le framework JEE à la mode mais il est encore suffisamment utilisé en entreprise pour mériter un chapitre.

Le second livre est une suite logique du premier dans la mesure où il présente les nouvelles fonctionnalités de la plateforme. Il est intéressant de constater que l'auteur a suivi la même trame que pour son précédent ouvrage tout en progressant d'un niveau :

• le chapitre d'introduction présente l'évolution de la plateforme JEE et la pléthore d'API, ainsi que les outils du développeur expérimenté : Subversion, Hudson, JUnit, Selenium ;
• le serveur JEE Glassfish succède au conteneur de servlet Tomcat ;
• le framework JSF orienté composants remplace les simples JSP ou le framework Struts orienté actions ;
• l'API de persistance JPA remplace ici l'accès direct aux données via JDBC ;
• on termine avec les couches métiers (EJB) et services (SOAP, REST).
  

Dans les deux livres, j'ai apprécié le fait que l'auteur utilise une application Web comme fil conducteur. Je lui suis également reconnaissant pour les petits détails pratiques qu'il distille tout au long des chapitres. Il a vraiment utilisé la plateforme et cela se voit.

En conclusion, si vous êtes familier des JSP, de Struts et de JDBC, et que vous souhaitez découvrir les nouveautés de JEE 6, c'est ce second livre qui vous intéressera le plus. En revanche, si vous souhaitez vous mettre au développement Web en Java, l'acquisition de ce coffret est recommandée. Il vous offre un guide progressif qui correspond à l'évolution naturelle qu'ont suivi de nombreux développeurs JEE expérimentés.

Chapitre 1 :
Ce livre sur Maven est constitué de 6 grands chapitres. Le premier chapitre est consacré à la présentation d'Apache Maven.
L'auteur explique l'historique de l'outil. Il en profite pour donner des ressources de références utiles telles que les sites des plugins, des listes de diffusion, des blogs ...
L'installation de Maven sur un poste de travail est expliquée de façon très précise. Puis viennent les explications sur les fichiers pom.xml, settings.xml etc. Pour mettre en application les fonctionnalités majeures de Maven, l'auteur développe un projet appelé mvnbook-entry-plugins qui est une sorte de point d'entrée pour les plugins. Ce projet utilise des API et frameworks tels que JAX-WS 2.0, JAXB, Guice, JPA 2 et Struts 2.

Chapitre 2 :
Ce chapitre commence le développement du projet en mettant en application les archétypes pour initialiser le projet.
Le cycle de vie du projet est vu, à l'aide de plusieurs schémas, les tests unitaires sont décrits, les artefacts générés sont listés, les premiers plugins présentés (maven-compiler-plugin, maven-jar-plugin). L'auteur s'est bien attardé sur l'encodage des fichiers d'un projet et je trouve cela bien utile, l'encodage des caractères étant un problème récurrent.

Chapitre 3 :
Ce chapitre aborde les dépendances entre classes. Les différents champs d'application de ces dépendances sont bien expliqués et avec l'aide de schémas. Ensuite, l'auteur poursuit la construction du projet du livre avec l'implémentation de JPA 2.0 dans le module mvnbook-persistence. Les résolutions de conflits liés aux dépendances sont expliquées.
Le projet du livre est un projet multi-modules, ce qui permet bien sûr de décrire la construction d'un projet multi-modules. L'auteur explique bien l'importance de la construction de ce type de projets, au niveau de l'organisation, qui peut se baser sur l'héritage ou l'aggrégation ou les deux à la fois, et l'impact qu'elle a sur la suite des développements, y compris la livraison. Enfin le concept de propriétés dans les fichiers POM est mis en avant.

Chapitre 4 :
Dans le quatrième chapitre, l'auteur décrit l'installation de Tomcat et de JBoss, pour les besoins de l'application mais surtout pour montrer l'utilisation des plugins Maven pour le déploiement.
Il utilise JAX-B pour le développement des Web Services.
Ensuite, les profils sont expliqués, ainsi que les artefacts (WAR, EAR) générés par les modules de l'application (mvnbook-webapp, mvnbook-webservice, mvnbok-ear-webservice, ...).

Chapitre 5 :
Ce chapitre, comme le titre l'indique, traite de Maven dans un contexte professionnel c'est-à-dire l'utilisation de Maven combiné avec les divers outils faisant partie du cycle de développement : SVN, l'IDE Eclipse, le plugin m2eclipse, les tests, le déploiement avec le protocole WebDAV, la mise en place de Nexus et l'intégration continue.
J'ai trouvé ce dernier point particulièrement bien traité dans la mesure où l'installation et la configuration de Jenkins sont bien détaillées mais aussi parce que le plugin maven-release-plugin, pour la gestion des releases et des versions, est lui aussi bien décrit.

Chapitre 6 :
Ce chapitre s'intéresse à la génération de la documentation et aux outils offerts par Maven pour faire de la qualimétrie sur un projet.
Les outils passés en revue sont Checkstyle, PMD, Sonar. J'ai bien apprécié la desciption suffisamment détaillée de Sonar (installation, configuration) avec son plugin Maven.

Ce que j'ai aimé :
J'ai apprécié les explications bien fournies sur plusieurs idées-clés de Maven telles que les profils et les scopes. J'ai aussi trouvé fort utiles les explications sur plusieurs plugins comme maven-release-plugin mais aussi d'autres thèmes comme l'intégration continue avec Jenkins.

Ce que j'ai moins aimé :
On peut éventuellement regretter le sujet de l'application développée pour le livre. En effet, je pense qu'une application de gestion des plugins peut apporter de la confusion aux débutants qui découvrent Maven, et plus particulèrement les plugins. Une confusion entre la notion de plugin géré par l'application et la notion de plugin Maven peut se produire.

J'utilise Tomcat en développement depuis quelques années et j'avais envie d'en savoir un peu plus sur cet outil. J'aurai pu explorer la documentation technique en anglais sur le Web mais je me suis dit que ça serait plus confortable de lire un livre, l'idéal étant qu'il soit écrit en français et qu'il concerne la dernière version. Avec ces exigences, je n'en ai trouvé qu'un seul, celui d'Etienne Langlet intitulé sobrement "Apache Tomcat 7".

Ce livre s'adresse à un large public. Après les rappels sur le contexte technique (Java, JEE), les débutants pourront suivre étape par étape les différentes procédures avec captures d'écrans (installation, configuration). Les utilisateurs intermédiaires apprécieront que l'auteur considère aussi bien les environnements Windows que Linux. Les plus experts découvriront des conseils pour améliorer la sécurité (paramètres à positionner, activation du gestionnaire de sécurité de la JVM) et des fonctionnalités moins connues (interface texte du manager).

Ce livre couvre tous les aspects : utilisation avec les outils de développement (eclipse, netbeans, ant), configuration avec les serveurs web en frontal (Apache, IIS), déploiement d'applications sur une seule ou plusieurs JVM en répartition horizontale ou verticale, sécurisation des applications (HTTPS, SSO, JAAS), analyse et supervision (logging, tests de montée en charge, JMX).

Je n'ai pas vraiment de reproches sinon sur la forme. Je ne suis pas un grand fan de la mise en page mais c'est plus une contrainte de la collection. En revanche, j'ai trouvé certains schémas très bien réalisés.

En conclusion, c'est un ouvrage très intéressant que je recommande à tous ceux qui veulent en savoir plus sur Tomcat.

N'ayant plus développé en Java depuis 2002, il m'est soudain venu l'envie de jeter un oeil sur l'évolution de J2EE (oui, à l'époque, on ne disait pas encore JEE), au moins pour voir ce qu'il était devenu en mon absence. Voyant le titre et les informations sur ce livre sur le site de l'éditeur, je m'attendais à "encore un" autre livre sur le développement, présentant en vitesse quelques concepts avant de plonger dans le code, sans forcément creuser les concepts sous-jacents.
Grave erreur.
Sous des aspects pas forcément de bon augure (couverture flashy, liste à la Prévert des sujets abordés), ce livre est en fait un vrai plaisir à lire, qui présente (selon moi) les choses au juste niveau de détail pour un développeur un peu expérimenté.
Non content de donner une bonne vision de la plate-forme Java (ce qui commence à être un exploit, vu la quantité d'informations), le livre propose une approche résolument orientée vers un architecte ou un développeur expert, et passe beaucoup plus de temps à détailler la conception que l'implémentation, le code étant téléchargeable depuis le site de l'auteur.
Chacun des chapitres commence par une présentation du contexte et de l'historique de la brique étudiée (persistance, communication, etc.), avant de montrer un certain nombre d'exemples d'implémentation, tout en parsemant la marge de notes vers des références plus exhaustives, que ce soit d'autres livres ou des sites Web.
Finalement, si ce que vous attendez d'un livre est d'avoir une vue de toute la plate-forme, et tous les pointeurs nécessaires pour construire sur des bases solides, ce livre est pour vous. Si, au contraire, vous cherchez un cours de développement, ou un annuaire contenant toutes les API de J2EE, passez votre chemin.

Ce livre, paru en mars 2011 et préfacé par Roberto Chinnici, le leader de la plate-forme Java EE chez Oracle, couvre en profondeur (902 pages !) la plate-forme Java EE 6, sortie en 2009.
L'auteur n'en est pas à son premier livre et il en avait déjà écrit un sur Java EE (paru en février 2009).
Son dernier ouvrage est un véritable guide destiné à toute personne impliquée dans la conception et le développement d'une application Java EE. Et il s'adresse du coup à tous les profils : l'expérimenté y trouvera des rappels utiles et le débutant les explications et les conseils dont il a besoin.
D'ailleurs, quand on parcourt le sommaire, on s'aperçoit d'emblée que l'ouvrage se veut exhaustif :
divisé en six principaux chapitres (chaque chapitre étant composé de 15 à 30 sous-chapitres), il aborde de très nombreuses technologies autour de Java EE.

Le premier chapitre présente la liste des spécifications Java EE 6. Il permet non seulement de connaître les nouveautés apportées par Java EE 6 mais aussi d'apprendre le développement d'une application (un projet de gestion d'une école) de A à Z : modélisation UML, mise en place de l'architecture (développement en couches), de l'environnement de développement, d'un outil de build (Ant), d'un gestionnaire de configuration (Subversion), d'un serveur (GlassFish), des tests (JUnit et SeleniumHQ), des logs (Log4j), de l'intégration continue (Hudson), d'une base de données (MySQL), etc.

Si vous cherchez un livre sur le serveur d'application GlassFish, alors ne cherchez plus, ce livre est le livre qu'il vous faut. En effet un chapitre de près de 160 pages est entièrement dédié à ce serveur dans sa version 3. Et de nombreux aspects sont couverts là encore : installation, administration, monitoring, clustering, optimisation, load balancing... De plus l'auteur a pu bénéficier de l'expertise d'Alexis Moussine-Pouchkine, membre de l'équipe GlassFish chez Oracle, lors de la relecture.
C'est également dans ce deuxième chapitre que l'auteur montre l'interopérabilité possible entre Java et PHP avec un exemple intéressant d'utilisation des EJB depuis une page PHP !

Le troisième chapitre aborde le développement de la couche web avec les servlets 3.0, les JSP et le framework JSF 2.0 qui représente en fait les trois quarts de ce chapitre. Si vous souhaitez créer une application Web à partir de la dernière version de JSF alors ce livre peut vous apporter une aide précieuse. L'auteur passe en revue l'essentiel des nouveautés du framework concernant la création des managed beans, l'ajout d'Ajax, l'internationalisation, la navigation, le cycle de vie, la création d'un composant composite, la conversion et la validation des données, etc.

Le quatrième chapitre est entièrement dédié, et à juste titre tellement le sujet est vaste, à l'API JPA.
EclipseLink est l'implémentation open source de référence de JPA 2.0 et est aussi l'implémentation de JPA choisie dans cet ouvrage, avec une base MySql. L'auteur adopte une approche top-down : il crée d'abord les classes des entités puis génère les tables de la base à partir des entités. L'approche bottom-up est également décrite plus loin dans le chapitre.
Les annotations et les relations sont expliquées de façon très détaillée. Des diagrammes UML et Merise viennent illustrer les relations entre les entités.
Dans la suite on retrouve les principales fonctionnalités qui constituent l'API JPA : gestion de l'optimisation, des accès concurrents, des entités avec l'Entity Manager, des transactions, cycle de vie d'une entité, différences Java SE et Java EE, le langage JPQL... Mais aussi des exemples d'utilisation de l'API Criteria, nouveauté de JPA 2.0.

Le cinquième chapitre traite de la couche métier de l'application. L'auteur apporte des explications pour l'utilisation des EJB (versions 3.0 et 3.1) avec Struts 2 et JSF 2. Les différents types d'EJB (Session Bean, MDB, Entity Bean) sont utilisés pour le développement de l'application.
Le framework de log LOG4J est longuement détaillé et JMS est aussi mis en pratique, avec OpenMQ.
Je pense qu'il y a une très bonne répartition explications "théoriques" des EJB et mise en pratique de ces explications pour continuer le développement de l'application.
Si vous cherchez un livre pour bien démarrer avec les EJB 3.0 et 3.1, alors ce livre peut répondre à vos attentes.

Le sixième et dernier chapitre est dédié aux services Web. Dans la première moitié du chapitre, après une introduction exhaustive aux schémas XML et aux concepts des services Web, l'auteur détaille la création et l'utilisation d'un service Web (avec notamment l'API JAX-WS) à partir de composants variés tels que les EJB, les servlets et JSF.
Dans la deuxième moitié du chapitre, l'architecture REST est mise en avant avec l'utilisation de Jersey, l'implémentation de référence de JAX-RS.

En conclusion, ce livre est très complet, contient beaucoup d'explications qui aident à développer une application de bout en bout.
Un petit regret que j'ai tout de même est l'absence de Maven. L'auteur a privilégié Ant pour builder le projet et c'est un peu dommage dans la mesure où Maven est désormais assez systématiquement utilisé pour développer une application.
Le code source est disponible en téléchargement sur le site des éditions ENI : http://www.editions-eni.fr
Enfin, pour continuer à se faire une idée du livre, si cette critique ne vous a pas convaincu, je vous invite à lire l'interview de l'auteur, réalisée à l'occasion de la sortie du livre.

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.

Lorsque Olivier m'a proposé de lire son bouquin, j'ai sauté sur l'occasion, ne connaissant pas du tout GWT sinon par quelques Hello John Doe !. De zéro ou presque donc, j'ai suivi sa présentation pragmatique, qui introduit les concepts principaux de GWT, et que l'on peut considérer comme un premier guide pour le développeur (francophone) qui souhaite se familiariser avec cette plateforme de développement made in Google.

Le plan est simple et efficace, on enchaîne relativement rapidement et naturellement les chapitres, largement illustrés. Olivier Gérardin a choisi d'aborder le contexte d'apparition de GWT sur le marché, puis détaille l'architecture (arborescence, installation) d'un projet GWT. Le livre aborde ensuite les différentes APIs disponibles (widgets et UI, Events, I18N, JSNI, DON XML, Ext-GWT, SmartGWT), et les différentes méthodes de communication (GWT RPC, HTTP/JSON, WS) offertes. Enfin un dernier chapitre s'attarde sur les nouveautés de GWT 2.0, comme UIBinder, le Code Splitting et SOYC, OOPHM, etc.

J'ai aimé lire ce livre synthétique (200 pages) et très accessible, démystifiant GWT et proposant une bonne introduction au développement GWT. Merci Olivier pour cette agréable lecture !

Pour disposer d'un livre sur GWT dans leur langue, les développeurs francophones auront dû patienter trois ans. Cela peut paraître long mais cette attente s'avère finalement bénéfique. D'une part, Olivier Gérardin, l'auteur, a pu acquérir durant cette période suffisamment d'expérience sur divers projets réels pour maîtriser son sujet. D'autre part, GWT a gagné en maturité et c'est maintenant qu'il faut des ressources pour diffuser cette technologie au delà des early adopters. Le livre "GWT" d'Olivier Gérardin est en bonne voie pour être une de ces ressources.

Dans sa préface, Didier Girard note qu'il n'est jamais aisé de présenter une technologie car soit on va trop loin, soit pas assez. L'exercice est donc difficile et c'est vrai qu'Olivier a trouvé le bon équilibre.

Chapitre 1 : De HTML à GWT En exagérant à peine, Google fait croire que GWT va permettre à quiconque de développer une superbe application web 2.0. Il faut, avouons le, de bonnes bases et trop souvent, je me rend bien compte dans les forums GWT, qu'elles font parfois défaut. Pour m'être essayé à l'exercice, il faut dire qu'il n'est pas facile de présenter toutes les notions indispensables sans craindre de perdre son lecteur. En choisissant l'approche historique, Olivier Gérardin y parvient brillamment.

Chapitre 2 : Hello, GWT Contrairement aux livres anglo-saxons qui souvent paraphrasent la doc d'installation de GWT par scripts de commande, celui-ci s'est mis au goût du jour pour l'installation de GWT en utilisant le plugin de Google. Ce qui lui permet de passer plus de temps sur les différents fichiers d'un projet GWT et les liens qu'ils entretiennent entre eux. J'ai également bien aimé sa manière de créer un nouveau projet en privilégiant le standard "dynamic web project".

Chapitre 3 : Développer avec GWT Les différences entre le mode de développement et le mode de production sont bien expliquées ainsi que les contraintes sur le code Java. A recommander à tous ceux qui demandent pourquoi leur projet GWT ne compile pas !!!

Chapitre 4 : Widgets Une présentation des différents widgets GWT avec des exemples. J'ai bien aimé l'indication des styles css impliqué dans le rendu des composants; le débutant pourra regretter qu'il l'ait réservé aux widgets les plus complexes.

Chapitre 5 : Communiquer avec le serveur Un exemple concret avec toutes les étapes nécessaires. Un bon point également pour les chapitres sur la sérialisation et les exceptions.

Chapitre 6 : Internationalisation L'internationalisation "statique" n'aura plus de secret pour vous. On ressent bien la pratique de l'auteur car il y a pleins de trucs et astuces. Pour ma part, je regrette que les solutions alternatives n'aient pas été développées (même si elles sont considérées comme moins propres par Google lui-même).

Chapitre 7 : Mécanismes avancés du compilateur Il est question ici de JSNI et de Deferred Binding, sujets très intéressants mais un peu court à mon goût. Ceci dit, il faut reconnaître que ces techniques ne concerneront qu'une minorité des cas d'utilisations de GWT.

Chapitre 8 : Le mécanisme d'historique de GWT Une fois ce chapitre lu, cela paraît tellement simple que j'aurai eu envie de l'utiliser un maximum si sa remarque de prudence (oh combien juste) n'était venu freiner mon enthousiasme.

Chapitre 9 : Envoyer des requêtes HTTP Un chapitre bien sympathique pour parler d'XML, de JSON et de la contrainte de sécurité "Same Origin Policy" et de son contournement.

Chapitre 10 : Créer ses propres Widgets Un panorama des différentes possibilités.

Chapitre 11 : Bibliothèques Tierces Ce chapitre a l'intérêt de montrer qu'il existe également tout un écosystème GWT. Parce que pendant une période, elle fût le seul complément crédible et parce qu'elle met en perspective les deux autres librairies concurrentes, EXT-GWT et SmartGWT, il est compréhensible que GWT-EXT ait été abordée. Cependant, selon moi, l'auteur aurait du en rester là et ne pas aborder son utilisation concrète à l'heure où elle est abandonnée et où des alternatives plus pérennes existent. C'est mon plus gros reproche, espérant que les débutants ne l'utiliseront pas. En revanche, j'ai apprécié le paragraphe sur les Google API en général et sur Google Gears en particulier. Maintenant que Chrome OS a été présenté, cette librairie gagne en intérêt.

Chapitre 12 : GWT 2.0 L'auteur n'oublie pas les principales modifications apportées par la dernière version, ce qui en fait à l'heure de cette critique le livre le plus à jour sur GWT ! Il se paye même le luxe d'expliquer comment récupérer la version 2.0 ... ... mais il y a plus simple puisque la Release Candidate est sortie le jour de publication du livre.

En conclusion, si vous voulez découvrir GWT ou si certains des points précédents ont éveillé votre curiosité, je vous recommande ce livre.

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.

Ce livre est une excellente introduction à Spring. En effet, il va explorer les différents concepts de Spring en allant chaque fois un peu plus loin. Après avoir lu ce livre, on maitrise les principales fonctionalités du framewok Spring. Chaque chapitre du livre traite d'un concept spécifique de Spring. Chacun des chapitres est découpé en sous-chapitres se basant sur une série de problèmes/solutions, ce qui se révèle très pratique pour retrouver des informations par la suite.

Le premier chapitre traite de l'inversion de contrôle en général. Les différents types d'IoC y sont décrits et mis en oeuvre à l'aide de la création d'un petit exemple de container IoC développé au long du chapitre.

Le deuxième chapitre présente le framework Spring et son impressionnant portfolio. Vous y apprendrez à installer le framework et ses dépendances ainsi que Spring IDE.

Avec les deux chapitres suivants, on explore les fonctionnalités d'inversion de contrôle de Spring. Après ce chapitre, vous saurez tout ce qu'il faut savoir sur l'utilisation de Spring pour injecter vos dépendances dans vos objets. L'injection de beans, de collections ou de constantes n'auront plus de secret pour vous. Des fonctionnalités plus élaborées, telles que les beans et méthodes de fabrique, les postprocesseurs, l'internationalisation ou les éditeurs de propriété, sont également explorées.

Avec les deux prochains chapitres, vous apprendrez à modulariser les préoccupations transversales en utilisation la programmation orientée aspect. Ces chapitres commencent en utilisant les proxies dynamiques de Java pour coder ces préoccupations transversales, ensuite de quoi, il nous apprend à utiliser Spring AOP classique (Spring 1.x) et enfin, on apprend à utiliser Spring AOP (Spring 2.x). Le support d'AspectJ est également traité en profondeur, du tissage au chargement en passant par la configuration d'aspects AspectJ en tant que beans Spring.
Le chapitre 7 explore la prise en charge de JDBC (appelée Spring JDBC). On y apprendra à utiliser des templates JDBC pour faciliter le développement d'applications basées sur JDBC. On y verra également comment profiter des generics et des varargs de Java 5.0 pour JDBC.
On passe ensuite à la gestion des transactions avec Spring. Les différentes méthodes pour implémenter les transactions avec Spring, API du gestionnaire de transactions, template de transaction, Spring AOP, greffons transactionnels ou encore annotation @Transactional, y sont traités en détail. On verra également comment configurer finement les différentes transactions, via leurs attributs de propagation, isolation, temporisation ou encore annulation.
Le chapitre suivant traite de la prise en charge de l'ORM dans Spring. On y voit comment configurer un framework ORM dans Spring et on développe également un exemple complet avec JPA et Hibernate.

L'antépénultième chapitre traite du framework Spring MVC qui permet de développer facilement des applications web sur la base du design pattern MVC. Les différents concepts de Spring MVC y sont traitées et bien que ce ne soit pas exhaustif, après la lecture de ce chapitre, vous serez capable de développer une première application web basique avec Spring MVC. On enchaîne directement avec le chapitre suivant qui traite de l'intégration avec d'autres frameworks Web tels que Struts, JSF ou DWR.

Le dernier chapitre traite de l'intégration des tests unitaires. Ce chapitre explique comment simplifier le test d'une application basé sur le Spring Framework avec JUnit ou TestNG. On y apprendra à créer des tests unitaires ainsi que des tests d'intégration.
En conclusion, ce livre vous permettra de commencer à développer des applications basées sur Spring et de découvrir la puissance de ce framework. La seule critique que je peux faire par rapport à ce livre est la longueur des chapitres Spring MVC et frameworks web. Pour moi qui suis plutôt orientés applications Desktop, j'aurais préféré aller plus loin dans certains chapitres ou explorer d'autres fonctionnalités de Spring telles que la validation, le scheduling/pooling de threads ou le support de langages dynamiques dans la configuration des beans.

N'ayant pas eu la chance de critiquer la première édition de "Spring par la pratique", c'est avec joie et grand intérêt que j'ai accueilli le facteur m'apportant cette seconde édition. Pour la petite histoire, j'ai suivi la formation Spring Core en 2008, dispensée par Julien Dubois, co-auteur sur cet ouvrage et j'ai eu comme compère de formation Gildas Cuisinier, relecteur de ce second opus, 4 jours aussi intéressants que ce présent ouvrage.
Le livre commence donc par la pédagogie nécessaire autour des concepts Spring (conteneur léger, inversion de contrôle (IOC), injection de dépendance, AOP (Aspect Oriented Programmation, POA en français pour programmation orientée aspect)) puis la suite est un savant mélange de théorie permettant au lecteur de comprendre correctement les concepts de Spring (et pourquoi ceux-ci existent) et de pratique via la mise en ouvre de cas concrets extraits de l'application fil rouge Tudu List.
On appréciera au fil des chapitres suivants l'exhaustivité de la couverture du portofolio Spring : Spring AOP, Spring Batch, Spring MVC, Spring Web Flow… Il appartient ensuite au lecteur d'utiliser ce qui lui paraîtra nécessaire dans ses applications. A noter qu'il faut un minimum de connaissances sur les frameworks et concepts (où du moins en connaître les principes majeurs) auxquels s'adresse Spring (Hibernate, GWT, JMS, Webservices…) même ci ceux-ci sont très bien introduits dans le livre, ne serait-ce que pour comprendre ce qu'apporte Spring couplé à ces éléments.
Mon avis sur "Spring par la pratique" :

J'ai aimé

• Un très bon livre sur Spring en français
• La pédagogie idéale pour la découverte des débutants au travers d'une lecture assez facile
• L'introduction TRES intéressante montre en quoi Spring peut aider à une bonne conception projet, par la séparation des couches et les abstractions proposées par les modules de Spring
• Le cas d'étude réel avec l'application Tudu List, une application complète (qui évolue au fil des améliorations de Spring) illustrant les nombreuses caractéristiques de Spring (téléchargeable sur http://www.springparlapratique.org)

Et un peu moins

• Les termes traduits en français, car je pense que vous utilisez, comme moi, au quotidien la terminologie anglaise (aspect, AOP…), mais comme c'est un livre en français…
• Les mises en ouvre sont assez génériques donc pour les détails il faudra creuser les ressources du Web par soi-même (mais sinon, nous n'aurions plus de travail…)
• Les exemples sont un peu parachutés par moment et il n'est pas toujours évident de les comprendre dans le tout d'une application

Nous avons donc là un excellent ouvrage en français sur Spring, clair et détaillé, pédagogique et très complet que je conseille aux curieux désireux de connaître Spring mais aussi aux confirmés qui trouveront dans ce livre les nouveautés du portofolio Spring.

Spring par la pratique, première édition, fut un excellent livre sur Spring et son portfolio. A sa sortie, il couvrait directement Spring 2.0, fraichement sorti à l'époque. Mais l'eau a coulé sous les ponts et le livre est devenu un peu désuet de par les nouveautés de Spring 2.5 et 3.0 ou encore l'arrivée de projet tels que Spring Dm ou Spring Batch.. C'est là qu'intervient la nouvelle édition, couvrant justement ceux-ci, alors que Spring 3.0 n'est pas encore officiellement sorti.
Sur la forme, le livre garde le même style que l'ancienne édition, chaque chapitre étant divisé en deux parties. La première étant une présentation théorique d'un sujet, la deuxième étant sa mise en pratique dans un exemple concret ( le même qu'auparavant : Tudu List ). Concernant le contenu par contre, les changements sont majeurs, allant de grosse mises à jour à de nouveaux chapitres complets.

Ce qui change ?
Les chapitre concernant les bases de Spring ( Inversion du controle, injection de dépendances, AOP ) ont été complètement revus afin de prendre en compte les nouvelles possiblités de configuration apportées par Spring 2.5 et Spring 3.0 : annotations, expression language, nouveaux schéma XML.
La chapitre sur la partie Web à aussi ré-écrit afin de présenter le nouveau framework @MVC et ses annotations ainsi que le support de REST. C'est aussi le cas du chapitre Spring WebFlow, qui se base sur la version 2.0, ou sur la sécurité basé sur Spring Security et non plus sur Acegi.

Quoi de neuf ?
Parmi les nouveautés, plusieurs chapitres sont dédiés à OSGi et les solutions apportées par SpringSource : Spring Dynamic Modules qui rend le développement OSGi des plus simples, et Spring Dm Server qui propose une alternative à JEE en permettant le déploiement d'application OSGi.
Spring Batch, une solution de traitements de lots de fichiers en Java, se voit aussi consacrer un chapitre.

Une autre nouveauté est le nouveau site (http://www.springparlapratique.org) qui accompagne le livre qui permet de discuter avec les auteurs ou récupérer le code source.
Je conseille donc vivement la lecture de ce livre, aussi bien au débutant voulant apprendre à utiliser Spring en se basant sur la dernière version qu'a des personnes souhaitant simplement se mettre à jour et découvrir les nouveautés du portfolio. Le contenu est des plus complet et très bien expliqué !

Vous ne vous êtes jamais demandé comment une application comme Google Maps est si réactive ? Ou comment certains sites vous suggèrent des informations en fonction de ce que vous êtes en train de saisir dans les champs des formulaires ? Si vous n'avez pas encore de réponse, vous trouverez des réponses dans le livre "Ajax on Java" de Steve Olson, traduit en français par Denis Priou.

Ce livre est destiné aux développeurs souhaitant réaliser des applications web dotées du concept Ajax. Le premier chapitre décrit les étapes nécessaires à l'installation de l'environnement Java, suivi d'un exemple d'interaction entre un client et un serveur via Ajax, dont on trouve la description coté client au chapitre 2 et l'utilisation côté serveur au chapitre 3. Même si on associe souvent XML à Ajax, l'auteur nous montre que cette structure de données n'est pas toujours nécessaire quand il s'agit d'une simple application ou quand il n'y a qu'une donnée à échanger entre le serveur et le client à un instant donné. En revanche si l'application nécessite des transferts de données nombreux et complexes, recourir à une structure comme XML ou JSON est primordial. C'est ce qui est décrit au chapitre 4. Dans ce dernier, l'auteur présente différentes API de parsing XML, notamment JDOM, DOM4J et SAX. Il y décrit aussi la façon de recevoir les données et surtout comment JavaScript exploite le code XML. Dans le même chapitre l'auteur présente une "alternative" à XML. Il s'agit de JSON, un moyen simple et moins gourmand en ressources, mais qui présente aussi l'avantage de pouvoir effectuer des analyses avec la fonction eval() de JavaScript.

Au chapitre 5, l'auteur décrit les méthodes qui permettent d'atteindre des informations stockées dans une base de données et de les afficher intuitivement grâce à Ajax. Chaque jour qui passe apporte son lot de nouvelles applications web. Pour accélérer les développements, de nombreuses librairies ont vu le jour pour aider les développeurs à créer des sites web utilisant Ajax.

Le chapitre 6 présente ces différentes boîtes à outils, entre autres Dojo Toolkit, Rico Toolkit et DWR (Direct WebRemoting) lesquelles offrent de nombreuses fonctionnalités très utiles. A la fin du chapitre, un exemple de Glisser-Déposer a été détaillé avec la librairie Scriptaculous et Prototype. Cet exemple complet décrit la création d'un panier pour un site e-Commerce.

Si vous êtes amené à réécrire plusieurs fois le même code pour Ajax, sachez que le chapitre 7 vous explique comment développer des fonctionnalités personnelles que vous allez réemployer dans vos applications en créant vos propres étiquettes et utiliser dans les pages JSP.

Le chapitre 8 et 9 présentent les techniques t'intégration d'Ajax dans des applications développées avec les Framework Struts et JSF (Java Server Faces). Le chapitre 10 est un tutoriel présentant l'outil GWT (Google Web Toolkit).

Cet ouvrage est destiné aux développeurs web en Java. Les cours sont présentés d'une manière progressive. Toutefois, les développeurs familiarisés avec les Servlets, JavaScript, HTML et l'analyse syntaxique sous XML n'auront pas de mal à suivre les exemples et les codes sources décrits dans ce livre. Grâce à Ajax vos applications deviendront plus intuitives et réactives. L'auteur l'a dit : "Développeurs Swing, soyez prévenus : Ajax hausse le ton et le niveau de jeu !"

Ce livre s'adresse à des débutants mais aussi à des personnes experimentées car il contient de nombreux rappels et aussi des astuces.

Le chapitre 1 couvre des choses qui doivent être connues lorsque l'on veut faire du développment Java EE. Cela va de l'installation du JDK à la présentation du modèle MVC, en passant par l'installation et la configuration d'un serveur Tomcat dans Eclipse et sous Windows.

Le chapitre 2 présente l'installation de Tomcat 6.0.X sous Linux, ainsi que l'installation et la configuration du serveur Web Apache en frontal du serveur Tomcat. Les fichiers XML de configuration des 2 serveurs (server.xml, web.ml, tomcat-users.xml, etc) sont expliqués, avec en prime des rappels sur XML. La sécurité, la gestion des utilisateurs, le connecteur HTTPS sont également détaillés. Ce chapitre se veut pratique puisqu'il détaille la création et le déploiement d'un projet dans Tomcat. Le monitoring et les tests de montée en charge sont abondamment expliqués. J'ai particulièrement apprécié le cas de tests s'appuyant sur JMeter.

Le chapitre 3 présente les JSP. Elles sont utilisées dans l'élaboration de l'application BetaBoutique. C'est en toute logique que les tags JSTL sont ensuite présentés, et sont suivis d'un sous-chapitre consacré à la création de taglibs personnalisées. En fait, ce chapitre fait le tour complet du développement avec des JSP (avec des servlets, des JavaBeans, etc ...). J'ai apprécié l'utilisation de la librairie commons-beanutils pour la manipulation des JavaBeans ainsi que du parser XStream pour la sérialisation/déserialisation d'objets Java.

Le chapitre 4 est consacré aux servlets. Une maquette de l'application BetaBoutique est insérée dans ce chapitre. L'application commence à prendre forme avec l'utilisation des servlets (sessions, filtres, cookies, interface RequestDispacter, etc ...).

Le chapitre 5 présente l'API JDBC. La base de données de l'application est construite à partir de MySQL. Le partage d'une connexion est bien illustré par du code. L'interface DataSource est ensuite utilisée et ses avantages expliqués. Un pool de connexion est créé dans Tomcat. De nouvelles astuces sont introduites (JavaScript, Ajax, la librairie DbUtils). Ce chapitre sur les bases de données serait incomplet s'il ne traitait pas des transactions, ce qui est chose faite juste après. Finalement l'authentification est étudiée, via la base de données et via les fichiers de configuration.

Le chapitre 6 décrit le framework Struts dans sa version 1.X, à travers le développement de l'application chatbetaboutique. Les caractéristiques les plus connues de ce framework sont mises en exergue : action, form, dynaform, internationalisation, validations avec validators et javascript. J'ai apprécié l'illustration par du code des actions les moins connues mais pourtant bien utiles : DispatchAction, LookUpDispatchAction, MappingDispatchAction, SwitchAction. Le module administration de cette application est par la suite bien décrit et implémenté.

Enfin le dernier chapitre détaille la très utilisée librairie log4J, la construction de tâches avec ANT, l'optimisation de la mémoire dans Tomcat 6.X.

En résumé, j'ai trouvé le livre très riche, surtout pour les débutants, et j'avoue que personnellement j'aurais souhaité avoir un tel livre dans mes étagères il y a quelques années. Il représente également une source importante de rappels pour les plus experimentés.

Le code source du livre est bien entendu disponible sur le site des éditions ENI, ainsi que sur http://www.gdawj.com/

Depuis maintenant plusieurs années (je n'ose pas compter) que je développe sous Eclipse, j'ai toujours eu des difficultés à comprendre le fonctionnement de ces différents modules, leurs couvertures et leurs interactions. Dans ce contexte ce livre me semblait convenir et je n'ai pas été déçu. J'ai toujours eu l'habitude d'utiliser Eclipse en anglais et si la plupart des impressions d'écran sont en anglais, certaines demeurent "étrangement" en français. On sent tout de même qu'un effort particulier a été fait sur ce point. Ce livre est vraiment idéal pour celui qui veut connaître les différentes briques logicielles qui composent Eclipse Europa avec un niveau de détail la plupart du temps suffisant (idéal pour des experts techniques ou des responsables techniques).

Le chapitre RPC détaille un exemple simple d'implémentation d'une application RCP. Ce chapitre est très intéressant mais je suis resté un peu frustré de ne pas pouvoir faire un test directement avec les corrigés car les sources ne sont pas disponibles sur le site Eyrolles.

Le chapitre sur la gestion de configuration avec CVS ou SVN est par contre presque trop détaillé et l'on aurait pu se passer de l'installation de Tortoise, mais cela montre un côté que l'on a moins l'habitude de voir : l'installation d'un serveur CVS et SVN. Cette étape fait souvent perdre du temps dans le démarrage amont d'un projet. Le chapitre sur le profiling montre un outil relativement inconnu qui peut être très important pour limiter les risques de fuite mémoire sur un projet. Il couvre de manière générale le spectre des outils intégrés dans TPTP. Ces modules sont relativement poussés et pourraient permettre l'économie de licence d'outils onéreux tel que JProbe.

La présentation des sous-projets JST et WST nous explique de manière exhaustive les composants qu'ils contiennent. Cela reste superficiel bien entendu (il faudrait presque un livre pour chaque module) mais j'aurais bien aimé avoir quelques précisions sur le fonctionnement des modules web services, monitor TCP (quelques lignes, voir un paragraphe aurait suffi). De plus le fait de découper par incubateur (JST d'un côté et WST de l'autre) fait que l'on retrouve les modules pêle-mêles ce qui nuit un peu à la lisibilité. La partie Data Tools Platform reste assez superficielle mais couvre les points indispensables à connaître. Par contre, tout le déroulement du chapitre parle d'Apache Derby alors que les scripts fournis ainsi que les exemples des chapitres suivants utilisent tous Mysql 5. Du coup, impossible d'intégrer les scripts à la base Derby.

Cette partie fait malheureusement sombrer le lecteur que je suis dans une impuissance dûe au fait qu'il m'est impossible d'intégrer les projets des chapitres suivants. Du coup, lire les exemples d'implémentation sans pouvoir les tester réellement est vraiment frustrant. Le format et la distance dans les explications est très bien trouvé de mon point de vue, mais cela aurait dû être appuyé par des projets téléchargeables "impeccables" et une démarche pour suivre sur ces projets. Les chapitres suivants sont bien entendu intéressants même si la partie Seam est à mon sens en trop car non intégrée dans la plate forme standard Europa.

Il est évident que des outils comme Eclipse évoluent très rapidement (depuis Europa sont sortis Ganymede et Galileo) et les supports papiers ne sont donc pas forcément les plus adaptés. Il y manque d'ailleurs le projet Mylyn (arrivé depuis Galileo) concernant les aspects de gestion des tâches et automatisations des process. Mais ce livre montre les principales fonctionnalités d'Eclipse ce qui est déjà conséquent. De plus cet outil devenant le centre des processus de développement il est actuellement indispensable de connaître les domaines techniques qu'il couvre et comment les utiliser. En attendant une version Galileo du bouquin, il reste donc la référence en son genre.

Eclipse étant de plus en plus utilisé par les entreprises, nous sommes tous un jour confrontés à celui-ci. Et si vous désirez maîtriser rapidement l'IDE, ce livre pourrait être une solution.

Le livre va présenter les différents modules et plugins disponibles pour vous aider dans le développement Java allant du module WTP pour le développement Web, au plugin TPTP pour le profiling de code ou le projet Dali pour le support JPA.
Pour chacun des modules, l'installation sera décrite si elle est nécessaire et l'utilisation du module sera expliquée clairement. Le tout est accompagné de nombreuses copies d'écran.

Un rappel général des différentes technologies JEE est fait comme c'est le cas pour JSF ou les EJB par exemple. Mais même si le titre du livre spécifie JEE, celui-ci ne s'y arrête pas rigoureusement en présentant JBoss Seam (un projet basé sur JSF), la programmation de client riche ou encore la conception MDA avec EclipseUML et AndroMDA.

Bref, ce livre est très bien fait et permet de vite prendre en main les différents plugins nécessaires au développement de projet Java.

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.

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.

Ce livre s'adresse essentiellement à des débutants qui disposent d'un minimum de culture informatique et sont intéressés par le développement Web et la création de pages dynamiques.
Avant d'aborder les JSP, les auteurs s'attachent à poser les fondements du développement Web en insistant sur des points essentiels tels que HTTP, HTML et les bases de données.
Très facile et agréable à lire, il propose également une excellente pédagogie reposant sur un résumé ainsi que des exercices en fin de chapitres. Les termes sont clairs et les exemples nombreux, un précieux CD-ROM accompagne l'ouvrage, et le lecteur apprendra les bases de l'écriture de scriptlets, l'utilisation de JavaBeans, et sera capable de décrire les liens intimes entre JSP et Servlet.

L'ouvrage étant rendu accessible à un public de débutants non initiés aux technologies Web et Java, le propos ne se limite donc pas à JSP et cela a tout naturellement pour conséquence d'en réduire la portée sur ce thème.
Si les choix et orientations des auteurs sont discutables, il n'en reste pas moins que les explications et la progression sont pertinentes. Les débutants y trouveront ainsi tout ce qu'il leur faut pour bien débuter avec JSP et en connaître les caractéristiques de base.
Cependant, le livre atteint ses limites lorsqu'on souhaite aller plus loin et notamment vers un développement plus structuré où les facteurs temps et maintenabilité ont entre autre leur importance. En effet, cet ouvrage ne traite pas des bibliothèques de tags (il se limite à ceux utilisés dans le cadre de JavaBeans) et se cantonne à des pages JSP écrites entièrement en scriptlets. C'est dommage car la notion de bibliothèques de tags reste l'un des fondements de JSP et illustre toute sa puissance, mais il faut bien faire des choix et organiser le livre en fonction du public visé, ce qu'ont bien fait les auteurs.

En conclusion, ce livre, écrit d'une fort belle manière et sans grandes fautes, peut être suggéré aux débutants aussi bien en développement Web que pour les seules JSP. Ceux-ci devront néanmoins réfléchir à leurs attentes : si le désir d'approfondir est présent, ce livre n'y répondra que partiellement.

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 !

Cet ouvrage se destine essentiellement aux débutants désirant apprendre à utiliser le framework Struts.
Très facile et agréable à lire, il fait le tour des prérequis nécessaires à la compréhension et l'utilisation de Struts pour se focaliser par la suite sur la version 1.1 du framework.

L'auteur se repose sur l'utilisation de Tomcat 4.1 et de MySQL pour illustrer son propos et construire ses exemples.
Les explications des concepts de base (MVC, ActionForm, Action, fichier de configuration, internationalisation, ...), tout comme leur mise en oeuvre à travers des exemples, sont conformes à ce que propose Struts 1.1, mais l'auteur omet de nombreuses nouveautés introduites à partir de cette version.
Il ne faut donc pas se fier au titre original de cet ouvrage (à savoir Mastering Jakarta Struts) sous peine d'être déçu.

Malgré tout, ce livre reste l'une des rares ressources françaises sur Struts et, même s'il ne permet pas d'être directement opérationnel sur la version courante, permettra à un public de débutants de se familiariser rapidement avec le framework. De plus, ses annexes sur les librairies de tags pourront servir d'aide mémoire.
Si vous recherchez un ouvrage couvrant une version plus récente de Struts pour vous former rapidement ou tout simplement avoir une référence, vous n'aurez malheureusement pas d'autre choix de vous orienter vers des publications en langue anglaise.

Retrouvez la critique complète ici.