Les livres sur les frameworks Web Java MVC

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

English version :

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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é !

Le livre est divisé en 5 parties.

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

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

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

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

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

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

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

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

Commentez Donner une note à l'article (5)

English version :

The book is divided in 5 parts.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 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.

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.