Les livres Java pour les DébutantsConsultez tous les livres

Ayant lu les deux précédents ouvrages français sur GWT, je n'avais pas d'attente particulière envers celui-ci. Si j'ai décidé de le lire, ce n'est pas pour apprendre sur le sujet mais pour voir comment l'auteur allait le traiter.

Tout d'abord, l'auteur a fait le choix de ne pas parler du positionnement de GWT, de son historique, des généralités. Cela pourra déranger un novice mais j'ai personnellement apprécié : les ouvrages précédents ayant brillamment traité cet aspect, il n'aurait pas été d'un grand intérêt de le refaire, surtout que cela permet d'alléger le livre et d'aborder des points autrement plus intéressants.

L'auteur commence donc son premier chapitre "Développer avec GWT" en allant à l'essentiel. Pas besoin d'installer GWT en ligne de commande, on l'installe vite fait bien fait dans Eclipse. Il faut dire que l'intégration à cet IDE a bien progressé au fil des versions et que la documentation en ligne existante est suffisante. L'espace libéré lui permet d'expliquer chaque partie de la structure d'un projet GWT, tant au niveau développement qu'au niveau déploiement une fois compilé.

Dans le deuxième chapitre "Créer une interface graphique", inutile de décrire chaque widget, les livres précédents et la documentation en ligne y pourvoient amplement. A la place, il préfère se concentrer sur les widgets de positionnement qui posent le plus de problèmes (comme on le voit sur le forum). De plus, il est question principalement des nouveaux widgets de positionnement, ceux de la version 2.0, les XXXLayouts qui sont à utiliser de préférence.

Ensuite, qu'il s'agisse des exemples à la fin du chapitre 2 (FormPanel, Widgets personnalisés) ou de ceux du chapitre 3 relatifs aux événements, ils sont toujours concrets et utiles. Jugez plutôt : composant d'upload de fichier ou composant qui permet d'opacifier une zone de l'écran.

Au chapitre 4 sur la communication client/serveur, il sera question du classique RPC, de son futur remplaçant deRPC mais aussi de l'accès bas niveau (RequestBuilder) nécessaire pour uploader un fichier ou récupérer des flux XML/JSON (traités côté client au chapitre 5).

Le sixième chapitre "Concevoir l'architecture" présente un exemple concret d'application du pattern MVP! Vous comprendrez les différences par rapport à MVC et les bénéfices d'un outil comme GIN.

Bien qu'introduisant les GWTTestCase ou les bancs d'essai GWT, le septième chapitre sur les tests aurait probablement mérité d'être plus développé.

En lisant le chapitre 8 sur l'internationalisation, on voit immédiatement que l'auteur y a été confronté et l'a mis en ouvre personnellement dans des exemples réels, de même qu'au dernier chapitre sur les techniques avancées (JSNI, CLient Bundle).

Je dois avouer que ce livre m'a plu davantage que ce que j'imaginais à priori; principalement pour le contenu inédit qu'il apporte. Je le conseille également aux développeurs qui cherchent un ouvrage pratique qui soit davantage un complément aux documentations officielles qu'un substitut.

Étant débutant sur cette plateforme GWT, j'ai commencé par de l'autoformation afin d'acquérir les bases, les principes et les notions-clés de cette technologie. Ensuite, j'ai voulu approfondir et surtout cadrer un peu tout ce que j'avais appris pour voir les bonnes pratiques, les bonnes façons de faire ainsi qu'avoir des critiques sur les méthodologies que j'utilisais.

C'est pourquoi j'ai décidé de me procurer ce livre qui avait l'air de survoler l'ensemble des notions à maitriser en GWT. En effet on y retrouve de nombreux points-clés tels que : le récapitulatif de la technologie, la gestion des interfaces graphiques, le modèle d'évènement utilisé par GWT ainsi que la communication client / serveur. Parmi les chapitres du livre, on retrouve des cas pratiques détaillés auxquels chaque développeur pourra être confronté : l'internationalisation de son application, le parsing des fichiers (XML, JSON), etc.

D'autres chapitres m'ont paru un peu plus obscurs (par exemple le chapitre sur les tests) mais c'est surtout parce que je n'ai pas encore eu le temps de les mettre en pratique. Mais, si je me réfère à la qualité des autres, je pense ne pas avoir de surprises le jour où je devrai m'y mettre.

Pour conclure, je dirai que ce livre est maintenant sur mon bureau et me sert de gros pense-bête. Je m'y réfère assez souvent pour voir si je suis toujours dans le vrai et valider mes choix techniques. C'est une ressource intéressante, complète, mais qui fait peut-être l'impasse sur des thématiques plus basiques (installation de l'environnement, utilisation du langage Java, etc.). Les exercices reflètent bien des cas concrets, qu'on retrouve habituellement dans nos métiers de développeur d'applications, mais il permet également d'avoir une bonne approche lors de la phase de conception et de qualification.

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.

Comme son titre l'indique ce livre traite de l'intégration des EJB avec divers Framework : Struts2, JSF2, JasperReports3 et Flex3 au travers d'une application de vente en ligne développée tout au long des chapitres. L'auteur commence donc par une description des EJB et des apports de la version courante (3.1). Il décrit ensuite l'utilisation des EJB au sein d'une application déployée sur Jboss6 et balaye l'ensemble de la spécification au travers d'exemples variés : JPA, Session Beans, Message Driven Beans, EJB Timers et interceptors. Les exemples vont tour à tour utiliser du WebServices, une couche de présentation réalisée avec Struts2 puis JSF2 et enfin Flex3. Une utilisation des EJB comme source de données pour JasperReports est aussi discutée dans l'un des chapitres.

On pourra reprocher quelques choix discutables sur les implémentations (mélange de Junit3 et 4, confusion entre tests unitaires et tests d'intégration, la gestion des exceptions etc...) ou des raccourcis un peu rapides (non, Struts2 n'est pas juste comme Struts1 avec des extensions différentes sur les URL) qui ternissent un peu le propos.

Mais au final, cet ouvrage se lit comme un tutoriel autour des EJB et non comme un ouvrage de référence. Son gros intérêt c'est son côté didactique qui permet d'explorer les EJB3 sous toutes leurs coutures. La contrepartie en abordant autant de sujets c'est de perdre le débutant, pourtant une des cibles du livre. A vouloir traiter tant de sujets on passe parfois de façon superficielle et on demande donc beaucoup de connaissances préalables au lecteur. Mais on appréciera grandement les exemples fournis et les tutoriels permettant de mettre en place l'environnement ou de manipuler certains outils. D'un point de vue personnel, c'est l'intégration avec Flex3 qui m'a le plus intéressé ne connaissant pas Flex. J'ai ainsi découvert qu'il existait une passerelle entre JAVA avec Flex par l'intermédiaire de BlazeDS et Granite et rien que pour ça, j'ai apprécié la lecture de ce livre.

En conclusion, un bon ouvrage pour découvrir en un seul livre plusieurs technologies d'un seul coup et les EJB en particulier mais qui devra se compléter par des livres plus spécialisés si l'on désire approfondir les frameworks abordés.

Dans ce livre constitué de 12 chapitres, l'auteur Shamsuddin Ahammad présente iReport, l'outil indispensable pour concevoir des rapports basés sur la librairie JasperReports, écrite en Java.
Une base MySQL est créée et son modèle décrit dans l'annexe.

Les trois premiers chapitres font un tour rapide de l'outil avec :
- une présentation des fonctionnalités de iReport,
- l'utilisation du générateur de rapports pour la création d'un premier rapport depuis une connexion à une base MySQL,
- le formatage du rapport et de ses éléments

A partir du quatrième chapitre, l'auteur aborde le traitement des données dans iReport avec les créations de variables (pour des calculs de sommes par exemple) et de paramètres (pour créer des requêtes ou des titres dynamiques par exemple).
Ensuite les groupes et les variables de groupes sont expliqués.

Un chapitre entier est dédié aux rapports contenant des sous-rapports, avec les relations maitre-enfant.
Un autre chapitre détaille la création de tableaux croisés, très utilisés dans les rapports.
Trois types de rapports graphiques sont créés : diagramme en camembert, diagramme en camembert 3D et diagramme en bâtons.
L'auteur montre également comment afficher des images qui sont stockées sur le disque ou bien en base de données.

Un exemple montre l'utilisation de l'API JasperReports pour créer un projet qui affiche un rapport dans une application Swing. L'affichage d'un rapport dans une application Web n'est pas détaillé mais l'auteur mentionne néanmoins les méthodes à utiliser.
NetBeans est l'IDE choisi par l'auteur pour développer, avec l'intégration du plugin Report Designer.

Ce que j'ai aimé : Les nombreuses copies d'écrans qui facilitent la compréhension, notamment pour la mise en place de sous-rapports.

Ce que j'ai moins aimé : j'aurais souhaité voir l'utilisation d'autres sources de données telles que des requêtes EJB-QL (EJB avec JPA) ou MDX pour des cubes de données.

Le site de l'auteur est : http://ireport-tutorial.blogspot.com/

English version :

In this book made of 12 chapters, the author Shamsuddin Ahammad shows how to use iReport, the indispensable tool to conceive reports based on the JasperReports library, written with Java.
A MySQL database is created and its model is described in the appendix.

The first three chapters give us a quick overview of the tool :
- a presentation of the functionalities of iReport,
- the use of the Report Wizard to create a first report with a connexion to a MySQL database,
- formatting the report and its elements.

Starting from the fourth chapter, the author explains the processing of data in iReport with the creation of variables (to calculate sums for instance) and parameters (to create dynamic queries or titles for instance).
Then groups and group variables are explained.

An entire chapter is dedicated to reports and their sub-reports, with master-child relations.
Another chapter details the creation of crosstabs, which are very used in reports.
Three types of graphic charts are created : a pie chart, a 3D pie chart and a bar chart.
The author also shows how to display pictures which are stored in a disk or in a database .

An example shows the use of the JasperReports API to create a project which displays a report in a Swing application.
The display of a report in a web application is not detailed but the author still mentions the methods to use.
NetBeans is the IDE chosen by the author to develop, with the integration of the Report Designer plugin.

What I liked the most : the numerous screen shots to facilitate the comprehension, especially the use of sub-reports.

What I liked the least : I would have wanted to read about the use of other types of datasource such as EJB-QL queries (EJB with JPA) or MDX for cubes of data.

The site of the author is http://ireport-tutorial.blogspot.com/

Avant de lire ce livre, je connaissais déjà l'auteur, Francesco Marchioni, grâce à son site - http://www.mastertheboss.com/ - qui est dédié à JBoss. C'est donc avec enthousiasme que j'ai souhaité me procurer ce livre et je n'ai pas été déçu. En effet le livre est à l'image du site : pratique, riche en exemples et en informations utiles.
Concernant la version traitée de JBoss, il s'agit de la version 5. Le livre a été publié en décembre 2009, en même temps que la sortie de la version 6 de JBoss, qui s'aligne petit à petit avec Java EE 6. Mais le livre reste totalement à jour, dans la mesure où il traite principalement de fonctionnalités de JBoss qui sont plus ou moins indépendantes des versions de Java EE.

Le livre est constitué de 14 chapitres. On peut trouver, comme à l'accoutumé dans les livres de la collection Packt Publishing, un résumé à la fin de chaque chapitre qui récapitule les principales notions qui ont été vues.

Les 3ers chapitres décrivent l'installation de JBoss, ses nouveautés et la configuration des services (logs, connexion à la base, les transactions, utilisation de la console JMX, de la console d'administration basée sur Jopr).

Le chapitre 4 met en avant le container EJB de JBoss puisqu'il est consacré au développement des session beans (EJB 3). Il y a du code, des explications théoriques (par exemple sur le cycle de vie des session beans) et pratiques (par exemple configurer la taille du pool de stateless session beans dans JBoss).

Le chapitre 5 aborde la persistance et crée un projet dans Eclipse en utilisant les entity beans et la Java Persistence API (JPA).

Le chapitre 6 utilise JSF 1.2 pour la création d'une application Web. L'auteur décrit le serveur Web contenu dans JBoss et qui utilise Apache Tomcat.

Le chapitre 7 utilise JMS avec les Message-Driven Beans et JBoss Messaging qui remplace JBoss MQ. Là encore on trouve une partie théorique et une partie pratique.

Le chapitre 8 montre l'utilisation d'Hibernate avec JBoss Tools / Hibernate Tools.

Les chapitres 9 à 12 rentrent dans le coeur de JBoss AS avec des explications sur JMX et les MBeans, ainsi que la gestion des ressources depuis la console d'administration. Des Web Services sont développés et déployés avec JBoss WS.
Le clustering de serveurs JBoss AS n'est pas oublié avec des explications sur la configuration nécessaire pour le load balancing et l'utilisation de JBoss Cache pour synchroniser les données dans un cluster.

Enfin j'ai trouvé les chapitres 13 et 14 sur la sécurité très complets. Tout est abordé : JAAS, JBossSX, certificats, sécurisation des EJB, encryption des Web Services.

Ce que j'ai aimé : Les nombreuses illustrations (de la console et de la structure des fichiers dans JBoss, des captures d'écrans d'Eclipse ...), les exemples concrets, le côté simple des explications.

Ce que j'ai moins aimé : Certains points ne sont pas abordés en détails mais ce n'est pas quelque chose de négatif dans la mesure où l'auteur fournit les explications de base nécessaires pour aller plus loin dans les détails si nécessaire.

English version :

Before reading this book, I already knew the author, Francesco Marchioni, because of his web site - http://www.mastertheboss.com/ - which is dedicated to JBoss. So it was with enthusiasm that I wished to get a copy of the book and I was not disappointed. Indeed the book is like the web site : practical, rich in samples and useful information.
The book uses JBoss 5. It was published in december 2009, when the first version of JBoss 6 was becoming available and starting to implement Java EE 6. But the book is still up to date since it describes functionalities of JBoss that are more or less independant of the versions of Java EE.

The book is made of 14 chapters. As usual with the books from the Packt Publishing collection, there is a resume at the end of each chapter which recapitulates the main subjects.

The first 3 chapters describe the installation of JBoss, the new features and the configuration of services (logs, database connection, transactions, use of the JMX console and the administration console based on Jopr).

Chapter 4 is dedicated to the EJB container in JBoss since the session beans (EJB 3) are being developed. There is coding, theoretical explanations (for instance the session beans life cycle) and practical explanations (for instance how to configure the size of the pool of stateless session beans in JBoss).

Chapter 5 is about the persistence and a project is developed in Eclipse, using entity beans and the Java Persistence API (JPA).

Chapter 6 uses JSF 1.2 for the creation of a web application. The author describes the Web server inside JBoss and which uses Apache Tomcat.

Chapter 7 uses JMS with Message-Driven Beans and JBoss Messaging which replaces JBoss MQ. Again, there are nice explanations : theoretical and practical.

Chapter 8 shows the use of Hibernate with JBoss Tools / Hibernate Tools.

Chapters 9 to 12 go into the heart of JBoss AS with explanations of JMX, the MBeans and the management of resources from the administration console. Web Services are developed and deployed in JBoss WS.
Clustering of JBoss AS servers is not forgotten : there are explanations on the configuration needed for load balancing and the use of JBoss Cache to synchronise data in a cluster, among many other explanations.

Finally I found chapters 13 and 14 on security very complete. The author writes about everything : JAAS, JBossSX, certificates, securing EJB, Web Services encryption ...

What I liked the most : The many illustrations (of the console, the file system structure in JBoss, the screenshots of Eclipse ...), the concrete samples, the simple explanations.

What I liked the least : one might have liked to read more details about certains subjects but that is not a negative thing because the author gives the basic explanations needed to investigate further if necessary.

Maven est aujourd'hui un outil incontournable pour assurer la gestion d'un projet informatique (même s'il n'est pas le seul et loin de faire l'unanimité), notamment pour le monde Java.

Je connais Maven pour l'avoir utilisé sur quelques projets, par le maintien de la FAQ Maven sur le site Developpez.com et également par la lecture de quelques ouvrages sur l'outil.
C'est donc avec grande curiosité que je souhaitais lire "Apache Maven" d'Arnaud Héritier et Nicolas De Loof, un ouvrage en français et atypique selon les dires.

Je dois dire tout de suite que je n'ai pas été déçu car voilà un ouvrage informatique que j'ai dévoré comme un roman, par petits bouts tous les jours, vraiment !

Ce livre raconte donc l'histoire d'un projet, petit et désordonné au départ (sauvegardé sur une disquette), qui deviendra par la suite le produit phare de la multinationale Geegol :) au travers des bonnes pratiques que le projet distille avec son utilisation de Maven.
On apprendra alors tout au long de l'histoire comment utiliser Maven pour répondre aux incontournables des projets en entreprise, depuis la création du projet jusqu'à sa livraison.
On prendra alors connaissance des nombreuses fonctionnalités de Maven, comme sa gestion des dépendances, la convention plutôt que la configuration, les profils, etc. Mais également sa possibilité d'intégration avec d'autres produits, comme les IDE, les serveurs d'intégration continue, etc.
Très pragmatique, le livre fournit des exemples de configuration directement utilisables dans vos projets.

J'ai aimé également l'ouverture des auteurs sur le produit, on trouvera bien sûr les avantages de Maven mais aussi ses points faibles, les alternatives (ex : Graddle, Ant) ainsi qu'un avant goût du futur, avec Maven 3.
Vous l'aviez peut être deviné : j'ai énormément apprécié ce livre et j'y retrouve l'esprit pédagogique présent également dans la collection "Tête la première" (pour moi une référence en matière de pédagogie informatique).
Les grands intérêts du livre passent par le style employé, très jovial, jamais ennuyant. On y retrouve les grandes lignes principales permettant de mener à bien un projet Java mais également de nombreuses astuces qui pourront parfaire vos réalisations.

Nous avons donc au final un très bon livre en français sur Maven, que je conseille à tous ceux qui auront à travailler avec cet outil formidable.

Ce livre est une vraie merveille au niveau de la présentation. Il se démarque clairement de la plupart des livres d'informatique que j'ai pu lire. Contrairement à ceux-ci (qui sont beaucoup plus formels, présentant de manière tout à fait neutre leur sujet) Apache Maven est beaucoup plus vivant et dynamique. Ici, le livre est écrit comme une retranscription de la vie d'une équipe qui a choisi Maven. Nous avons droit à une dose d'humour, mais aussi à des débats où chacun défend son point de vue. Et le résultat est étonnant, car il nous donne l'impression de vivre cette aventure avec eux, nous donnant envie de continuer d'avancer dans le livre sans attendre.

Du point de vue du contenu, Apache Maven couvre les fonctionnalités les plus importantes et/ou les plus intéressantes de Maven, le tout réparti en trois parties :

Premiers pas avec Maven
Dans cette partie, c'est tout d'abord le choix de Maven face à d'autres outils similaires qui est introduit. Sa force principale est les conventions apportées car elles permettent à n'importe quel développeur connaissant Maven de retrouver ses repères rapidement sur n'importe quel projet basé sur Maven. Dans cette partie on découvre également la gestion de dépendances, les premiers plug-ins et comment générer des livrables.

Maven en entreprise
Dans cette seconde partie, l'intégration de Maven dans les trois plus importants IDE (Eclipse, Netbeans et Idea) est présentée, le tout sous la forme d'un débat, dont la conclusion est particulièrement intéressante ! La notion de dépôt d'entreprise est également introduite, permettant de réduire considérablement la bande passante vers Internet, mais également d'avoir une gestion plus fine de ce qui est permis ou non au sein des projets. Et pour finir, les auteurs présentent un plug-in permettant de simplifier considérablement la livraison d'un livrable (deux commandes !)

Encore plus loin avec Maven
Maven, c'est aussi tous ses plug-ins. Mais comment faire quand il n'en existe aucun qui correspond à nos besoins ? Les auteurs nous montrent qu'il n'est pas sorcier de créer nos propres plug-ins Maven. C'est ensuite la notion d'archétype qui est présentée : ceux-ci sont une espèce de template de projet préconfiguré. Exit le copier-coller d'un projet et de renommer à la main les fichiers qui vont bien. Les archétypes proposent une solution beaucoup plus élégante !
Les auteurs terminent finalement par le chapitre certainement le plus intéressant : des best practices basées sur leurs propres expériences

Conclusion
Au final, j'ai réellement dévoré ce livre. Je connaissais et utilisais déjà Maven mais sans avoir pris le temps de regarder toutes ses possibilités. À la fin de ce livre, j'avais qu'une seule envie : tester par moi-même ! Je conseille donc vivement ce livre à toute personne ne connaissant pas (ou mal) Maven. Par contre pour les très bons connaisseurs, je doute que ce livre soit très intéressant, sauf pour convaincre leur management d'utiliser Maven.

On peut s'en douter en lisant le titre, cet ouvrage va nous faire découvrir Maven, l'outil de construction de projets Java d'Apache.
Il ne faut pas s'attendre ici à trouver LA bible sur Maven, mais plutôt d'apprendre à utiliser cet outil au sein d'une organisation.

Pour ce faire, Nicolas de Loof et Arnaud Héritier nous racontent l'histoire d'une équipe de développeurs, qui va être confrontée à différentes situations - qui ne manqueront pas de nous rappeler nos propres expériences.

Le livre se divise en trois grandes parties.
La première se destine à nous familiariser avec Maven et ses principaux concepts.
La seconde aborde des concepts plus poussés, en particulier concernant l'utilisation de Maven au sein d'une entreprise.
Enfin la dernière partie regroupe différents sujets, par exemple des cas atypiques d'utilisation de Maven.

1e partie : Premiers pas avec Maven

Cette première partie se destine à nous familiariser avec Maven et ses principaux concepts.
Les auteurs en profitent pour poser le décor de leur histoire. Nous suivrons donc l'équipe de développement d'un petit projet nommé noubliepaslalistedescourses !
Autrefois construit par un simple fichier .bat, cette application va rajeunir en étant migré vers Maven.
C'est ici que l'on constate les premiers bénéfices de l'outil d'Apache : gestion simplifiée des dépendances, cycle de vie de construction d'un projet, création des livrables (fichier JAR final par exemple), etc.
Les auteurs s'attaquent à d'autres problématiques, telles que la gestion des versions du JDK, l'intégration d'autres langages (Groovy par exemple).
Un chapitre est également consacré à la politique de tests, en mettant en lumière les différents types de tests (unitaires, fonctionnels, d'intégration, etc.) et même l'intégration continue.

On le voit dès cette première partie : ce livre n'est pas là uniquement pour nous parler de Maven, mais bien de tout ce qui a trait à l'environnement de développement.

2e partie : Maven en entreprise

Cette seconde partie aborde des questions plus poussées, des aspects de Maven qui prennent tout leur sens dans un environnement d'entreprise.
Ainsi, la première problématique abordée est la gestion avancée des dépendances, et en particulier l'introduction des dépôts d'entreprises (les repositories).
Par la suite, on s'attaque aux concepts des projets multi-modules et de l'héritage, très utiles dès que les projets prennent de l'importance !
Il est également question de la construction de livrables plus complexes, en particulier les WAR, les EJB ou les EAR.

Un chapitre est dédié à l'intégration de tout ceci au sein du principal outil du développeur : l'IDE (l'environnement de développement).
Qu'il s'agisse d'Eclipse, de NetBeans ou encore d'IntelliJ, ils sont tous étudiés par les auteurs du livre, qui nous montrent aussi bien la facilité d'utilisation de Maven directement dans l'IDE, que les petits plus qu'ils ont à offrir au développeur pour faciliter son travail quotidien.

Cette seconde partie s'achève sur un point crucial de la vie d'un projet : la livraison !
Cette étape, trop souvent bâclée, peut faire échouer un projet. Les auteurs nous donnent donc les moyens proposés par Maven pour simplifier, automatiser et fiabiliser ce processus.

3e partie : Encore plus loin avec Maven

Cette dernière partie aborde différents sujets qui n'ont pas encore été vus dans les chapitres précédents.
Tout d'abord, les auteurs nous expliquent comment il est possible de lancer des tâches par Maven alors qu'aucun plugin spécifique n'existe pour cela.
Il est ainsi question de développement de plugin Maven, mais aussi de l'intégration d'Ant au sein de Maven.

Un autre sujet connexe est abordé ici : la surveillance de la qualité du code.
Là aussi, Maven peut apporter des solutions - essentiellement grâce à des plugins ou à Sonar - et les auteurs ne manquent pas de nous le montrer.
C'est également le bon moment pour introduire la fonctionnalité de génération de site - et de rapports techniques - offerte par Maven !

Par la suite, un chapitre est entièrement consacré au démarrage d'un nouveau projet.
C'est ici l'occasion de voir les recommandations que l'on peut faire sur de nouveaux projets, et non plus de parler de migration de projets existants vers Maven.
On passe ainsi en revue certaines bonnes pratiques à mettre en place dès le début d'un projet, on apprend également à utiliser les archetypes de Maven, ces plugins qui nous permettent de créer le squelette d'un projet en fonction de son type.

Maintenant que nous avons fait le tour des principales fonctionnalités de Maven, les auteurs se posent une question un peu déroutante, mais tout de même intéressante : "Avons-nous fait le bon choix ?".
C'est ici que l'on fait une sorte de bilan, de savoir si finalement Maven est véritablement l'outil à utiliser au sein de nos projets, d'en définir les limitations et les problèmes.
Les auteurs nous parlent ensuite de l'écosystème autour de Maven : ses concurrents (Ant, Ivy et Gradle en première ligne), les sociétés qui gravitent autour de l'outil (en particulier Sonatype), etc.
Enfin, on termine avec quelques pages nous montrant les nouveautés de Maven 3.

Avant de conclure cet ouvrage, les auteurs décident de nous offrir leurs précieuses recommandations vis-à-vis de l'utilisation de Maven, leurs 10 commandements.

Mon avis

Apache Maven est un livre plutôt atypique.
Il s'apparente plus à un roman qu'à un livre technique traditionnel, et ne doit pas être pris pour une sorte de "bible" sur l'outil d'Apache.
Le fait que Nicolas de Loof et Arnaud Héritier aient abordé le sujet de Maven en racontant la vie et l'évolution d'une équipe de développement est une excellente idée, car cela nous montre un usage très réel et concret de cet outil.
Cela nous permet également de voir tous les à-côtés qui ne sont habituellement pas traités par des ouvrages informatiques sur un outil.
Ici, au-delà de Maven, les auteurs évoquent le TDD (Test Driven Development ou Développement piloté par les tests), les différentes façons de tester son application, le suivi de qualité, l'intégration continue, l'aspect livraison, les bonnes et mauvaises pratiques en général, etc.
C'est forcément un autre bon point pour ce livre !

Alors certes mon niveau en Maven, qui est plutôt bon, ne m'a pas permis de sortir de cette lecture avec beaucoup de nouvelles informations.
Toutefois, cela m'a conforté dans mes idées, m'a rassuré sur mes bonnes pratiques, et m'a appris quelques astuces plutôt sympathiques.
Le fait que ce livre aborde vraiment tous les aspects de la vie d'un projet est un énorme plus, et pourra, à mon avis, intéresser des personnes n'ayant pas un profil de développeur !

Selon moi, ce livre doit être vu comme un indispensable complément à une "bible" Maven, par exemple Maven: The Definitive Guide, d'autant que ce dernier vient tout juste d'être traduit en français.

Vous trouverez une critique complète de cet ouvrage, ainsi que tous les détails relatif à ce livre à cette adresse : http://linsolas.developpez.com/critiques/apache-maven/

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.

Critique en français

Vous avez entendu parler d'OSGi mais vous ne savez pas ce que c'est ? Ou vous pensez que cela est trop compliqué ? Alors le livre de Daniel Rubio est surement un moyen d'appréhender OSGi de manière simple grâce à Spring Dm.

Ce livre est bien écrit et permet d'avoir une première approche sur le sujet. Dès les premiers chapitres, OSGi est expliqué très simplement et vous apprendrez quels sont les avantages de cette technologie face à JEE.
Ensuite, Spring Dm sera présenté. Celui-ci apporte la simplicité POJOs dans le monde OSGi, à la manière des projets Spring.

Vous ne connaissez pas du tout Spring ? Pas de soucis ! Une introduction succincte mais suffisante du Framework sera faite, ce qui vous permettra de suivre correctement le reste du livre sans problème.

D'autres sujets, toujours gravitant autour de OSGi et Spring seront abordés. C'est le cas du serveur de SpringSource par exemple. C'est ainsi que vous apprendrez les extensions d'OSGi qu'il apporte pour faciliter le développement, en particulier avec JPA. L'utilitaire bnd sera lui aussi au sommaire, afin de vous expliquer comment rendre un JAR compatible OSGi sans trop d'effort.

Bref, c'est un excellent livre pour débuter avec OSGi et Spring Dm, mais pour moi il ne va pas assez en profondeur pour un livre de la collection "Pro".

English review

You've heard about OSGi but do not know what it is? Or do you think this is too complicated? Then the Daniel Rubio's book is probably a simple way to learn OSGi thanks to Spring Dm.
This book is well written and gives a first approach on the subject. In the first chapters, OSGi is explained very simply and you will learn what are the benefits of this technology face to JEE.

Then Dm Spring will be presented. This brings the simplicity of POJOs in the OSGi world, like all the Spring projects.
You do not know anything of Spring? No worries! A brief but sufficient introduction of the Framework will be made, allowing you to follow the book without difficulty.

Other subjects, always revolving around OSGi and Spring, will be covered. This is the case SpringSource server for example. Thus you will learn the extensions it provides to OSGi to facilitate development, especially for JPA.
The tool 'bnd' is also introduced in summary, to explain you how to make a OSGi-compatible JARs without too much effort.

In short, it is an excellent book to start with OSGi and Spring Dm, but for me it does not go deep enough for a book of the "Pro" collection.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

English version :

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Le livre est divisé en 4 parties.

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

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

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

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

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

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

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

English version :

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

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

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

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

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

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

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

"Maven : the definitive guide" est un livre adoptant une pédagogie très progressive sur l'outil Maven. Commençant par une présentation en surface de l'outil (son orientation déclarative, quelques commandes de base, les plugins connexes) pour continuer sur un descriptif de ses possibilités plus étendues (extension par l'écriture de plugin, intégration dans Eclipse, etc.).

Les plus

• Un guide très complet
• Deux échantillons de projet Maven utilisables immédiatement : une première structure simple et une autre découpée en modules comme dans le monde réel de l'entreprise (web, modèle, services, etc.)
• La découverte de nombreux outils en dehors de Maven (Spring, Hibernate, Geronimo...)
• Le plaisir de la découverte de l'outil, l'écriture agréable et jamais ennuyante (voire même amusante)
• On trouvera aussi de nombreuses astuces et des conseils qui trouveront je suis sûr une place dans vos projets existants

Les moins

• Comme Eric le soulignait précédemment, il est parfois étrange de se voir référer un schéma qui se trouve 2 ou 3 pages plus loin, mais ça c'est du détail sur la mise en page
• Je ne trouve pas d'autres points négatifs...juste peut être que j'aurais voulu en avoir plus encore (par exemple une ouverture à d'autres systèmes de gestion de repositories d'entreprise, mais seul Nexus est retenu, compréhensible car développé par Sonatype)

A qui s'adresse ce livre ?

• A tous ceux qui ne connaissent pas Maven, car cet ouvrage est une très bonne introduction pour ce fabuleux outil, mais aussi aux intéressés qui chercheraient à aller plus loin encore (pour ce qui concerne l'optimisation par exemple)
• Mais également aux autres qui chercheraient à convaincre des équipes de développement réfractaires (beaucoup pensent encore que seul l'outil Ant existe) ou à trouver l'argumentaire pour convaincre des décideurs hésitants sur cette option technologique pouvant apporter bien des indicateurs au niveau d'un projet.

Voilà donc un ouvrage que j'ai vraiment apprécié et dont je conseille vivement la lecture ! A noter au final aussi la sympathique (ou pas) métaphore du fourmilier en couverture...

Ce livre porte bien son nom. Non seulement il est destiné à tout public, mais en plus il constitue vraiment un guide complet sur Maven 2.
En effet, il aborde tous les aspects de Maven 2 (cycle de vie, gestion de dépendances, outils, extensions, etc.) en fournissant au lecteur suffisamment d'éléments pour que celui-ci puisse approfondir s'il le souhaite.

Le découpage de l'ouvrage est bien fait et permettra à ceux qui ont déjà un peu d'expérience avec Maven de se focaliser sur l'un ou l'autre chapitre de la partie Maven by Example avant d'aller parcourir la partie Maven Reference qui se propose d'approfondir les connaissances de base.
Les premiers chapitres sont vraiment écrits dans une approche progressive et illustrent les possibilités de Maven 2 via des applications exemples représentatives.

J'ai été impressionné par le nombre d'astuces et de conseils prodigués, permettant d'utiliser Maven 2 de manière intelligente et non en suivant une simple mécanique de déclaration pure et dure de dépendances.
Si j'ai trouvé le chapitre sur les assemblies un peu plus indigeste que les autres, celui sur m2eclipse devrait ravir ceux qui sont lassés par l'édition de fichier XML et ne se sentent pas assez productifs dans leur utilisation de Maven 2 (on regrettera juste que les illustrations soient parfois à 1 ou 2 pages de la description, la faute au nombre important de visuels nécessaires à ce chapitre).
Les chapitres plus avancés sur Nexus et la création de plugins sont également intéressants, même si sans doute moins utiles à la majorité des lecteurs. On a notamment droit à un éventail complet de l'utilisation et configuration de Nexus, excellent point de départ pour vous aider à initier un proxy/repository d'entreprise.

Enfin, on appréciera la présence des 2 annexes permettant respectivement d'avoir un aperçu des éléments de configuration pouvant être déclarés dans le fichier de configuration global (settings.xml), ainsi que les artefacts du serveur Geronimo qui vous permettrons de pallier à l'indisponibilité (via les repositories) de ceux correspondants à la spécification Java EE (vous évitant de devoir installer ces derniers à la main).

En conclusion, Maven: The Definitive Guide est un livre bien écrit, assez complet, et dans lequel tout lecteur devrait s'y retrouver.
Ce qui est vraiment appréciable, c'est que les auteurs ne masquent en aucun cas les défauts et problématiques courantes survenant avec Maven 2, mais surtout qu'ils fournissent au lecteur les outils et pratiques pour traiter ces derniers.
Un livre à recommander.

Habitué à d'autres formes de persistence et ORM avec le langage Java, Harnessing Hibernate est ma première lecture sur Hibernate. Les chapitres de ce livre gravitent autour d'un projet central (le traditionnel outil de gestion de collection de musique), enrichi au fur et à mesure par les fonctionnalités d'Hibernate. Installation des outils (Maven, Ant), mappings et requêtes simples, requêtes Criteria, annotations, intégration avec d'autres bases de données (HSQLDB, MySQL) et outils (Spring, Stripes, IDE Eclipse) : une vision assez globale est donnée et vous serez en mesure de construire vos premiers projets avec une couche de persistence reposant sur Hibernate, et en exploitant les primitives simples.

Néanmoins je trouve que l'auteur consacre beaucoup trop de temps aux outils annexes comme Maven (le chapitre 12!), qui nécessite à lui seul un livre, et j'aurais préféré qu'il passe davantage de temps sur des mappings plus complexes, ou encore à la gestion de cache, la gestion des sessions Hibernate. Il demeure bien construit pour un lecteur débutant, mais aura du mal à satisfaire celui-ci dés l'apparition des premiers besoins atypiques et plus complexes. Utile, mais loin d'être indispensable.

Ce livre est vraiment instructif car il explique vraiment bien ce que peut être le langage Java. Le débutant y trouvera un très bon cours pour le Java, la POO, les graphiques avec SWING, et même pour le développement web avec JSP et d'autres outils / techniques / ... .

Ce livre sera aussi une très bonne référence pour les initiés à Java car il contient une annexe très bien fournie et des exemples de code tout faits qui peuvent beaucoup servir.

Une chose très constructive aussi : beaucoup de remarques sur certains points communs avec le langage C++, pour que l'on puisse bien voir les différences ou similitudes avec ce langage. J'ai également beaucoup apprécié le chapitre sur la programmation générique qui est vraiment bien construit. Sinon, mon seul regret est qu'il manque un chapitre sur JDBC qui est très utile et aurait pu introduire une partie BDD.

Conclusion : Ce livre est pour moi LA référence en français du langage Java pour ceux qui voudraient l'apprendre.
C'est également un très bon aide mémoire pour les initiés car il donne tout ce qu'il faut pour être totalement autonome afin de développer ses propres applications et appréhender en toute sérénité la volumineuse documentation Java.

Étant développeur C / C++ de base et désirant migrer vers le langage Java, je me suis intéressé à l'ouvrage « Programmer en Java » de Jean-Claude Delannoy dans sa 5e Édition. La première approche de ce livre est plutôt bonne, il regroupe la plupart des bases du langage comme les class, les threads, les boucles et même l'interface graphique de type Swing sur plusieurs chapitres. On peut noter également la présence d'un chapitre dédié à Java EE qui donne des idées sur la programmation orientée Web avec les pages dynamiques JSP ou les servlets.

Avec plus de détail, ce livre montre une approche très pratique et scolaire sur les divers points du langage Java avec des exemples de code expliqués. J'ai également apprécié les diverses comparaisons entre le Java et le langage C++ qui permette de voir comment le Java est assez proche du C++ et permet également aux développeurs C++ de ne pas être dépaysé par le Java.

Mon avis sur cet ouvrage est très positif, cependant, il est vraiment réservé pour apprendre les bases et ce limite uniquement aux aspects les plus importants du langage Java, ce qui signifie que si vous cherchez des informations sur des techniques de programmation avancés, ce livre ne sera pas fait pour vous. Par contre pour apprendre ou migrer sur le Java, ce livre est un réel plus à avoir à côté de soi.

Un ouvrage très instructif pour tous ceux qui voudraient se lancer dans Java. Ce livre traite de tous les points essentiels du langage : les origines de Java, les types, mots clés, POO, threads, IHM, programmation Web, etc. Claude Delannoy, l'auteur de "Programmer en Java" publie là une 5ème édition de ce qu'on peut appeler maintenant un best-seller. Je vous livre maintenant mes impressions :

• Un sommaire très détaillé qui pour moi est un bon indicateur sur le contenu
• La rédaction et le style simple facilitant la bonne compréhension
• Un contenu de qualité et fiable et les parallèles avec C/C++
• Plus de 250 000 ouvrages vendus, ce n'est pas un hasard

• La mise en page trop sobre (mais les goûts et les couleurs, vous connaissez la suite...)
• Certains chapitres ne sont vraiment que des petites introductions (mais on comprendra que l'ouvrage n'a pas non plus vocation à l'exhaustivité)

Au final, sans être LE livre indispensable au développeur Java qui se respecte, il est je pense un très bon livre en français sur le développement Java pour ceux que l'anglais rebuterait.
Le petit bonus : pour chaque plate-forme (Mac, Windows et Linux/Unix) un CD contenant Eclipse Europa, le JDK en version 6, et les codes sources du livre, ainsi les malheureux de la connexion internet ne seront pas en reste.

Je conseille donc vivement la lecture de "Programmer en Java" de Claude Delannoy, non seulement au débutant Java, mais aussi aux initiés qui chercheraient un référent documentaire.

Tout d'abord, ce livre ne se veut pas un livre complet sur les programmes cités ici. C'est une introduction à l'analyse de programmes. Ce livre est donc destiné aux programmeurs qui n'ont pas encore testés leurs propres outils d'analyse et qui aimeraient en savoir plus sur les possibilités existantes dans ce domaine.

L'auteur va tout d'abord nous parler des warnings du compilateur Java (javac) et de la manière dont on peut les configurer pour n'avoir que ceux qu'on désire vraiment traiter. Il va ensuite nous montrer comment les configurer dans Eclipse. L'auteur utilisera Eclipse pour tous les exemples concernant l'intégration avec un IDE.

Après avoir vu les possibilités du compilateur Java, on va passer dans le vif du sujet avec la présentation de trois outils pour trois besoins différents. Tout d'abord, on va découvrir un outil d'analyse de code source, PMD. L'auteur va nous montrer comment faire marcher PMD de manière standalone, ensuite dans Ant, puis dans Eclipse et enfin, il va nous montrer comment étendre PMD avec de nouvelles règles. On va également découvrir CPD qui est un utilitaire de PMD permettant de détecter des portions de code copiées-collées.

L'auteur va suivre cette structure pour les 3 programmes présentés dans l'article, ce qui permet de s'y retrouver facilement. A la fin de chaque chapitre sur un outil, on va retrouver un résumé avec les points importants de chaque partie de la présentation. Ce résumé permet très succinctement de placer l'outil dans son contexte et de découvrir les principaux avantages du produit. Ce qui peut se révéler très intéressant si on revient sur le livre un moment après l'avoir lu.

Ensuite, l'auteur va nous présenter un outil d'analyse statique, FindBugs. Il va nous montrer l'utilisation en ligne de commande ou avec l'interface graphique de cet outil et nous montrer ce qu'on peut faire avec. Une courte partie est consacrée à une partie peu connue de FindBugs, le datamining. Cela permet de faire des comparaisons entre plusieurs analyses FindBugs pour vérifier l'avancement des erreurs, le nombre d'erreurs résolues et le nombre d'erreurs supplémentaires. On peut également suivre l'avancement du projet avec cet utilitaire étant donné qu'il nous donne par exemple le nombre de classes du projet.

Enfin, l'auteur nous présente le dernier outil, un outil d'analyse dynamique, Java PathFinder développé par la NASA. Cet outil permet de tester tous les chemins d'exécution possible de votre programme et permet de détecter certains problèmes comme des DeadLocks ou des exceptions non gérées. Il se révèle très utile dans un programme multi-threadé pour trouver des problèmes de concurrence.

En conclusion, ce livre est une très bonne introduction à l'analyse de programmes Java et vous permettra de découvrir trois excellents programmes d'analyse. Les programmes présentés ne sont qu'une sélection, il en existe d'autres, mais ils sont choisis parmi les meilleurs et dans un tel article, il n'aurait servi à rien de présenter plusieurs programmes de même catégorie. L'article se lit bien, mais certains passages sont plus difficiles à suivre. Il m'a fallu revenir plusieurs fois sur le même paragraphe pour bien le comprendre, mais en général, la lecture se révèle fluide et agréable. Je le conseille donc à tous les programmeurs Java qui aimeraient se lancer dans l'analyse de leurs programmes mais ne savent pas par où commencer.

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

Une excellente FAQ de poche

Ce livre de poche, complément idéal de l'Aide-Mémoire Java publié chez Dunod, se présente comme un guide de survie. C'est en fait une bonne petite FAQ couvrant les API de bases de Java. Que ce soit les entrées/sortie, la manipulation des chaines de caractères, des dates, des nombres. Mais cela couvre également d'autres domaines comme l'écriture/lecture de fichiers ZIP, l'envoi/réception de mails via JAVAMail, la transformation XML par XSLT, ....

Je vous laisse découvrir par vous-même la table des matières pour que vous sachiez exactement ce qu'il couvre.

La façon dont le livre est découpé, et dont les exemples de code sont présentés, permet de trouver rapidement ce que l'on cherche.
En effet, quasi chaque sous-chapitre d'un chapitre commence par un bout de code, en blanc sous fond noir. Ce qui fait que lorsqu'on feuillete ou parcourt rapidement le livre ou un chapitre à la recherche d'une solution à notre problème, notre regard est directement attiré sur le code, ce qui en facilite grandement sa recherche.

Chaque code est accompagné d'un texte explicatif, lorsque c'est nécessaire, mais surtout d'autres détails et/ou astuces supplémentaires y sont donnés.

Les bouts de code sont toujours très courts mais toujours utilisables.

J'ai noté quelques exemples pour lesquels je ne suis personellement pas toujours d'accord. Ainsi, pour voir si une chaîne de caractères contient un nombre, il utilise le parseInt() de la classe Integer enrobé dans un try-catch avec NumberFormatException. Sachant qu'une exception coute cher, je préfère utiliser d'autres techniques que cela pour vérifier que c'est bien un nombre.
Aussi, lorsqu'il s'agit d'additionner et de soustraire des dates, ou de calculer la différence entre deux dates, son auteur propose à chaque fois d'additionner/soustraire des millisecondes ou de convertir en millisecondes.
J'aurais préféré qu'il propose des exemples de code où il utilise JodaTime, tout comme il propose des exemples de code avec JavaMail pour la gestion des mails.
JodaTime est vraiment l'API qu'il vous faut si vous devez manipuler des dates et des intervalles de dates. D'ailleurs, une JSR a été créée récemment pour introduire JodaTime dans une prochaine version du JDK

A part cela, je n'ai trop rien à dire. Une vraie petite FAQ de poche.

Ce livre est destiné à toutes les personnes utilisant Swing. Il va vous expliquer les principaux concepts de Swing. Vous allez les apprendre via une série d'exemples ludiques. A la fin de chaque chapitre, vous allez pouvoir appliquer les différentes notions à une petite application.

On va commencer par voir les concepts fondamentaux de Swing. C'est-à-dire la notion de composants, de container, les fenêtres ainsi que les looks and feels. On va continuer ensuite avec la gestion des événements. Puis on va partir sur les composants plus complexes comme la JList, la JTable et le JTree. On va ainsi voir la notion de modèles, de renderers ainsi que d'editors. Sans oublier l'architecture MVC de Swing. Après avoir découvert toutes ces notions, un chapitre entier sera consacré aux composants texte avec notamment la gestion des Document, des Action ainsi que de l'undo-redo. Puis un autre chapitre pour le drag and drop. Vous y découvrirez 2 manières de faire du drag-and-drop, la deuxième étant seulement disponible depuis le JDK 4.

Après nous avoir parlé de tous les concepts de "base" de Swing, l'auteur va nous expliquer le concept de threading avec Swing. Un concept très important mais souvent mal compris par les débutants et même par les utilisateurs plus expérimentés. Ce concept sera expliqué avec une série de tests pour montrer la différence de performances de Swing avec ou sans respect de l'Event Dispatching Thread. On va également apprendre quels sont les nouveautés qui ont vu le jour dans les dernières versions de Java (1.4 et 5.0 pour ce livre). Puis vient le dernier chapitre sur le formalisme UML, mais je ne trouve pas que ce chapitre apporte grand-chose au livre vu la faible complexité des diagrammes UML utilisés.

En conclusion, ce livre va vous apprendre les principaux concepts de Swing et d'une très bonne manière. Après la lecture de ce livre, vous devriez parfaitement maîtriser les bases de Swing et vous devriez pouvoir vous lancer dans le développement d'interfaces graphiques en Swing. Néanmoins, ce livre n'est pas un catalogue Swing montrant tous les composants et leurs fonctions, la Javadoc et les tutoriaux de Sun étant nettement suffisants à ce niveau-là. On peut néanmoins regretter le manque de clarté de certains chapitres, comme celui sur les Javabeans ou encore la brièveté du chapitre sur l'undo-redo ou celui sur la deuxième manière de faire du drag-and-drop. Mais mis à part ces petits défauts, ce livre reste une excellente introduction au framework Swing et je ne peux que vous le conseiller.

J'ai trouvé ce livre tout simplement excellent. Les auteurs de ce livre abordent Java d'une manière très originale qui consiste à combiner images, textes et jeux, ce qui permet de démystifier bon nombre de sujets délicats, ainsi on peut y trouver, par exemple, un dialogue entre une variable locale et une variable d'instance !

Chaque chapitre est clôturé par une série d'exercices très bien faits et ordonnés par difficulté croissante. Vous pouvez donc vous retrouver à jouer le rôle du compilateur ou bien de la JVM ce qui peut être très instructif.

J'ajouterais que pour tirer pleinement parti de ce livre, il vaut mieux connaître déjà un langage de programmation et qu'il soit de préférence orienté objet (mais ce n'est pas obligatoire). Si vous faites partie de cette catégorie de gens alors ce livre constitue un très bon investissement. Dans le cas contraire, passez votre chemin.

Je viens de terminer la lecture du livre SWING dans la collection "Les cahiers du programmeur", un ouvrage sur l' APISwing qui permet de concevoir des interfaces graphiques avec le langage de programmation Java. Place maintenant à une petite présentation du contenu et à mes impressions sur cette publication dont le fil rouge est une application pour la modélisation 3D d'un logement.

Un bon point pour commencer, le sommaire complet et les titres de chapitres détaillés permettent d' accéder rapidement à l'information. Ensuite pour chaque chapitre, les grands thèmes couverts sont annoncés, on sait donc d'avance ce que l'on va découvrir, c'est structuré et ça suscite l'envie de lire. Pour la matière, toutes les phases de création du projet Sweet Home 3D sont présentées : on débute par l'idée et les phases inhérentes au démarrage d'un projet (cahier des charges, conception...), puis l'installation des outils de développement, la programmation proprement dite et les cycles de tests associés pour finir avec le déploiement de l'applicatif. Le comparatif avec d'autres API graphiques (AWT, SWT, JFace) est le bienvenu pour expliquer les choix qui peuvent conduire à l'utilisation ou non d'un des outils. On pourra lire également sur chaque page des petits encarts pour agrémenter les explications du livre (B.A.-BA, A retenir, Astuces, Pour aller plus loin, Attention...)

Ce livre ne traite donc pas uniquement de Swing et on puisera énormément d'informations sur (entre autres) :

• Les fondations d'un projet informatique (cahier des charges, référentiel des sources)
• Les nouveautés de Java 5 (annotations, généricité,)
• Les designs patterns (MVC, Singleton, Décorateur, Proxy...)
• Le déploiement avec Java Veb Start
• ANT

Le livre expose des extraits de code commentés sur l'implémentation de l'application, des scénarios fonctionnels, des diagrammes de classes UML et des copies d'écrans pour illustrer les différentes étapes. J'ai cherché ce qui pouvait manquer dans le contenu mais tout est là.

C'était une découverte de la collection "Les cahiers du programmeur", et je dois dire que j'ai été enchanté tant par la qualité du contenu technique que par la pédagogie adoptée pour tenir le lecteur en haleine, mais aussi par la mise en page très riche et lisible à la fois. Je donne donc la note maximale et je ferai simple pour la conclusion : tous les livres devraient être comme ça, vous pouvez donc l'acheter les yeux fermés !

Tout d'abord, je dois vous signaler, avant que vous n'alliez plus loin dans la critique, que j'ai été relecteur technique de ce livre.
Mon avis aurait donc pu être faussé.
C'est la raison pour laquelle j'ai attendu que quelqu'un d'autre fasse une critique de ce livre, avant de publier la mienne :-).

Ce livre est le seul que j'ai lu jusqu'à ce jour qui explique aussi clairement comment développer une application Swing en utilisant le modèle MVC tout en faisant bien la distinction entre le modèle MVC de votre application et le modèle MVC (ou plutôt M-VC) des composants Swing.
Attention que ce livre n'est pas là pour vous faire découvrir tous les composants Swing qui sont à votre disposition, mais plutôt pour vous faire découvrir comment bien découper/structurer votre application Swing.
Malgré cela, on y apprend l'utilisation des JTable, JTree, ..., à afficher le même modèle sous des vues différentes (on visualise la même pièce en 3D, en 2D et sous forme de table), implémenter l'Undo/Redo, le Drag and Drop, l'internationalisation d'une application, ...
On y apprend de plus comment découper un projet, comment les personnes ont raisonné pour finalement arriver au design de cette application.
Tout au long de l'ouvrage, l'auteur compare également Swing et AWT avec SWT et JFace, nous fait découvrir des modules Eclipse intéressants.
L'étude de cas que l'auteur a choisi pour ce livre est certainement pour beaucoup dans la qualité de l'ouvrage.
Dès le premier chapitre, on a envie d'en savoir plus, de connaitre comment l'auteur s'y est pris pour réaliser son étude de cas.
Sachez également que l'auteur a aussi mis son étude de cas à la disposition de tous, sous licence open source, et qu'elle est totalement opérationelle.

En conclusion, je ne peux que conseiller ce livre à tous ceux qui programment ou désirent programmer en Swing.
Ce livre me semble assez unique dans sa façon d'aborder Swing.
Pourquoi je ne donne que 4.5/5 à ce livre ? C'est la question que l'auteur m'a posée.
Je lui ai répondu que je mettrais 5/5 au livre qui m'expliquerait Swing à la façon "Head First/Tête première". Et le système des étoiles ne me permet pas de lui donner 4.9/5.

Ce livre est tout simplement génial. C'est la première fois que je lis un livre d'informatique aussi prenant, on a à chaque fois envie d'aller plus loin et d'avancer dans les chapitres.

Ceci est surtout du à la structure qu'a utilisée l'auteur pour écrire ce livre. Il n'en a pas fait un simple catalogue Swing montrant toutes les méthodes et classes de Swing et leur utilisation; il crée plutôt un projet qu'on va faire avancer tout au long du livre en lui ajoutant de nouvelles fonctionnalités. En plus de toutes les informations techniques que l'on obtient durant la lecture des différents chapitres, l'auteur nous fait aussi part de son expérience dans le travail en groupe et le développement de projet. En effet, on va voir comment découper le projet en plusieurs scénarios bien distincts, comment appliquer la méthode XP, comme utiliser CVS pour archiver et partager les fichiers du projet, etc. L'auteur va aussi traiter de la différence SWT/SWING/AWT.

Les domaines techniques abordés par cette application sont très vastes. On va voir comment créer des nouveaux composants Swing en respectant l'architecture MVC et comment faire une application respectant elle aussi le principe MVC. On va aussi voir comment utiliser les composants complexes que sont le JTable et le JTree. On va aussi apprendre à gérer des actions annulables dans l'application et la façon d'utiliser le glisser-déposer dans votre application. On passera aussi sur l'enregistrement de préférences utilisateurs et des données de l'application. En plus, on verra aussi comment visualiser une vue en 2D et en 3D !

En conclusion, je conseille ce livre non seulement à toutes personnes développant une application Swing mais aussi à toute personne développant une application graphique en Java, car ce livre dans ses métiers sait se montrer très général, de sorte que la plupart des informations sont utilisables pour une application graphique non Swing.

Ce livre présente 68 méthodes d'optimisation pour du code Java. Néanmoins, il faut bien faire attention au mot optimisation : pour ceux qui s'attendent à n'avoir que des astuces pour avoir un code plus rapide, ce n'est pas le cas. Seules 18 astuces permettent d'optimiser les performances de votre application. Les autres astuces permettent de produire un code plus sûr et plus stable.

Ces astuces sont parfois plus des explications sur comment faire quelque chose qu'une réelle astuce. Mais elles sont néanmoins très intéressantes. Avec ces astuces, vous apprendrez à faire correctement des tests d'égalité, à avoir un code multithread sécurisé ou encore à gérer correctement vos exceptions. Vous apprendrez aussi à implémenter des classes constantes et à redéfinir la méthode equals.

La partie sur les performances se révèle à mon goût un peu faible. Une astuce sur l'optimisation manuelle du code s'avère très intéressante. Les autres étant plus basiques, avec par exemple l'utilisation de StringBuffer à la place de String dans une boucle. Mais cette partie traite aussi de concepts plus avancés tels que l'inlining, l'évaluation différée ou encore l'utilisation de variables de pile plutôt que de variables globales. De plus, les comparaisons entre les différentes techniques sont expliquées directement en bytecode ce qui permet de voir directement ce que ça donne.

Une chose que je trouve dommage est que ce livre n'a pas été mis à jour depuis sa première édition. Il utilise donc Java 1.2, mais la plupart des astuces présentées ici sont toujours valables avec les dernières versions de Java.

En conclusion, ce livre vous montrera différentes manières de mieux coder en Java et d'optimiser les performances de vos programmes. Mais ce livre n'est pas la solution miracle à vos problèmes de performances.

Tout d'abord, je dois vous dire que c'est la première fois que j'ai un livre de Claude Delannoy dans mes mains. Et je suis parti du principe que ce livre doit m'offrir des exercices pour programmer en Java (mais aussi en Java 5, vu que c'est le pourquoi de la 2ième édition).

• Rien trouvé sur les collections
• Rien trouvé sur la nouvelle boucle for each (for : )
• Explications quelques fois trop succinctes, voire même complètement absentes

• Bien structuré
• Respect des conventions (une classe commence par un Majuscule, une méthode par une minuscule, CamelAnnotation, ...)
• La généricité y est bien abordée
• Les énumérations y sont bien expliquées
• Les exercices permettent de vous entraîner pour la certification (mais attention, ce livre ne suffit pas à vous préparer à la certification !!!)

• Les nouveautés contenues dans Java 5 sont vraiment traitées de façon inégale.
• Il n'y a pas vraiment d'exercices concernant les collections, et leur gestion, et je n'en ai pas vu non plus concernant les Threads.
• Les solutions des exercices sont quelques peu légères voire même absentes, et il n'y a aucun exercice sur l'api JDBC et la manipulation des fichiers XML.

Conclusion : un bon livre d'exercices, mais décevant un peu pour ce qui est des exercices concernant Java 5. En fait, ce livre fait très bien la paire avec le livre desTP informatiques d'Alexandre Brillant, couvrant Java 5. Mais le fait de devoir acheter les 2 livres fait que cela revient assez cher l'exercice. Je conseillerais alors, pour la somme des 2 livres, d'acheter un autre livre (mais en anglais, malheureusement, Comment Programmez en Java, de chez Deitel et Deitel).

Un bon ouvrage pour aborder Spring, et les différents concepts fondateurs de son architecture (IoP, AOP). J'ai apprécié les chapitres de démystification de la notion de conteneur léger et de POA, trés accessibles pour les débutants, même si (et c'est normal) ils demeurent incomplets. Sans être rentré dans le détail, j'ai également apprécié la parallèle réalisé avec l'étude de cas "Tudu List", projet OpenSource disponible surSourceForge. Les différentes méthodes d'injection (modificateur, constructeur, propriétés, collaborateurs) , les notions d'aspects (join point, crosscut, code advice, aspect weaver) sont donc abordés, et vous serez capable d'appréhender l'intégration de Spring avec Struts, ou encore avec le propre modèle de pattern MVC de Spring (Spring MVC) et AJAX (DWR, script.aculo.us).

Ce livre conviendra donc aux débutants, qui y trouveront de nombreux exemples sur la manipulation des différents connecteurs de Spring, mais l'expert y trouvera peu d'intérêt, le plan choisi étant volontairement trés général.

Lorsque j'ai acheté ce livre, j'avais une appréhension sur ce que j'allais découvrir. Etant très intéressé par le framework Spring, j'avais eu l'occasion de lire plusieurs livres anglophones sur le sujet.
C'est donc avec sceptiscime que j'ai accueilli le premier livre francophone sur ce framework : Serait-ce une simple traduction/adaptation des versions anglaises? Possèdera-t-il une valeur ajoutée ?

Au final, j'ai été séduit ! Ce livre est très bien écrit, agréable à lire et aborde les sujets les plus fréquents dans le développement J2EE. De plus, il décrit non seulement des fonctionnalités propres à Spring 2.0 mais aussi l'intégration avec un framework Ajax (DWR). C'est le premier livre que j'ai pu lire à avoir traité ces derniers points.

Le livre se base sur une application réelle,Tudu List, qui est proposée sous différents frameworks de présentation : Struts, Spring MVC, Spring WebFlow, Portlet.
Cela permet de voir comment Spring est mis en pratique sur un projet complet. C'est, à mon avis, parfois plus intéressant que d'essayer de comprendre une portion de code dénuée de contexte.

Je conseille donc ce livre à toute personne qui désire découvrir Spring Framework, le livre introduisant la notion de conteneur légers, la programmation orientée aspect pour ensuite présenter de manière plus technique les possibilités de Spring.

Ma réaction face à ce livre tient en quelques mots : il aurait dû s'appeler Spring pour la pratique.

En effet, il passe rapidement sur les considérations de modélisation ou de structuration d'une application pour directement aborder les multiples façons d'utiliser Spring, notamment du fait de ses nombreux connecteurs. Il en couvre d'ailleurs la plupart je pense, ce qui est une bonne chose.

Aussi, l'ensemble du livre est très orienté technique, allant même jusqu'à détailler les balises xml. Cela peut s'avérer très utile si vous êtes non anglophone, un peu moins sinon, vu que la doc Spring est très bien foutue.

Au final, je suis resté sur ma faim concernant la modélisation et la façon de travailler. Certes, plein de solutions techniques sont abordées, mais le "comment construire son application" autour de Spring n'est pas assez approfondi je trouve. Ce qui est dommage, je trouve, vu que Spring apporte une vraie révolution en termes de conception (à mes yeux du moins). D'où mon 4.

Vous avez sans doute entendu parler de Spring, mais vous vous demandez ce que c'est, ce que cela peut faire pour vous? Alors ce livre est pour vous.

Ce livre présente un tour d'horizon du framework Spring. Mais il fait plus que de vous donner une idée, il vous montre comment l'utiliser. Si ce livre s'appelle "Spring par la pratique" c'est qu'il s'appuie entièrement sur une application écrite à l'occasion : TUDU List. Vous pouvez voir cette application sur le site : http://app.ess.ch/tudu/welcome.action . Différentes versions de cette application ont aussi été créées correspondant aux différentes technologies présentées dans le livre.

La première partie du livre commence par présenter les problématiques de la programmation Java et Java EE (séparation de préoccupation, test, indépendance de la plateforme et du serveur...). Ensuite il présente brièvement les réponses qu'apporte Spring avec la notion de conteneur léger et de POA. Enfin il présente brièvement l'application TUDU List qui sert de fil rouge au livre.

On trouve ensuite 4 chapitres très denses en informations. Le premier revient en détail sur les conteneurs léger et les notions d'inversion de control et d'injection de dépendance. Le second présente Spring en tant que conteneur léger et son utilisation. Le troisième présente la POA et enfin le quatrième l'intégration de la POA dans Spring.

Ensuite le livre aborde les différentes technologies et frameworks utilisés en Java EE et reprend la même structure tout du long :

• Présentation sommaire de la technologie
• Intégration dans Spring
• Intégration dans TUDU List

Par exemple dans le cas de Struts, les auteurs commencent par présenter le framework en définissant MVC2, les actions et les FormBeans, ensuite ils présentent les trois possibilités d'intégration de Struts dans Spring, enfin ils présentent la solution utilisée dans TUDU List avec des morceaux de code et de fichiers de configuration.

Le livre aborde donc successivement tous les aspects : framework de présentation (Struts, Spring MVC, Spring WebFlow, Ajax et Portlets), gestion des données (persistance, transactions), l'intégration (JMS, JCA, XML, Acegy Security) et enfin les outils connexes (supervision avec JMX et test).

Même si certains points mériteraient d'être plus détaillés, ce livre est indispensable pour qui veut un aperçu complet de ce que peut lui apporter Spring et de ce que va lui coûter sa mise en oeuvre. On peut déplorer que parfois les extraits de code soient trop courts pour permettre de bien comprendre où ils se situent et nécessitent de se reporter aux codes sources de l'application. Cela rend obligatoire le fait d'avoir un ordinateur sous la main, ou de laisser des commentaires si l'on est coincé dans un train.

Voila le livre idéal pour découvrir ou redécouvrir la plate-forme Java.
Clair et concis (malgré la taille), il vous servira également de guide de référence lorsque vous aurez le malheur de ne pas pouvoir accéder facilement à des ressources en ligne ou à la Javadoc.

Cette nouvelle édition introduit les nouveautés de Java 5 en se concentrant sur l'essentiel (logique, puisque l'ouvrage anciennement "Java in a Nutshell" s'appelle désormais "Java enconcentré").
Bien entendu, vous ne trouverez pas tous le détail d'une API comme les Generics, mais suffisamment pour ensuite vous débrouiller et fouiller la partie "Guide de référence".

Ce livre en impose, tant par le nombre de pages (dont les 400 premières constituent la matière grise) que par la densité des informations.
Certains passages auraient certes pu être adaptés à Java 5, mais le travail serait considérable et certains passages risqueraient de devenir trop complexes et risqueraient de mettre en arrière plan les concepts illustrés.

Mention spéciale aux traducteurs Anne et Alexandre Gachet qui ont réalisé un travail de grande qualité. On ne leur reprochera pas les quelques coquilles relevées compte tenu du nombre impressionnant de pages.

Bref, vous l'aurez compris, cet ouvrage est plus qu'un livre de chevet, une vraie bible comme on aimerait en voir plus souvent.

Cette 3ème édition du cahier des programmeurs Java d'Emmanuel Puybaret est un remaniement total comparé à la 1ère édition :

• une centaine de pages en plus
• 1 CD-ROM est maintenant joint avec
• 2 nouveaux chapitres, couvrant java.io et XML
• dernier chapitre fortement enrichi d'une partie dédiée à la synchronisation et au multi-threading, superbement bien expliqué
• rajout d'appartés (notes marginales) à l'intention des développeurs C, C++ et C#
• rajout d'appartés concernant les principales nouveautés du JDK 5.0

J'avais déjà lu la 1ère édition de ce livre, et la façon dont Emmanuel Puybaret explique les choses ma plue énormément. Les illustrations apportent beaucoup à la compréhension. Le code vous est expliqué, décortiqué. Vous n'avez presque plus l'impression de lire, mais de l'entendre vous parler. Ce livre est captivant. J'ai eu des difficultés à m'en détacher contrairement à d'autres livres, pour lesquels il m'a fallu me faire violence pour les lire jusqu'au bout (Le livre d'Anne Tassot en est un exemple).

Ce livre est AMHA le meilleur de la collection "Cahiers du programmeur", du point de vue approche pédagogique, illustration des propos, ... Emmanuel Puybaret a une approche pédagogique qui fait merveille.

Deux bémols :

• Le chapitre XML m'a paru très pauvre. Mais XML est tellement vaste, et ses librairies Java également, qu'un livre dédié qu'à cela ne suffirait pas.
• Le prix est passé de 23 à 29

A conseiller à tous les débutants Java.

Un livre indispensable pour tout débutant en Java et souvent nécessaire pour développeur confirmé devant aborder des sujets dont il n'a pas l'habitude.

Ce petit livre couvre succinctement l'essentiel de la programmation Java, avec à la fois les explications sur le fonctionnement fondamental de chaque fonctionnalité et des exemples pertinents.

Bien sûr, si vous voulez aborder un aspect bien spécifique, ce livre ne vous sera pas suffisant, mais il offrira sans doute déjà assez d'informations pour bien débuter. De toutes façons, jamais un livre généraliste sur Java ne donnera jamais assez d'éléments sur un point précis des très vastes bibliothèques disponibles.

Au final : un must have.

Un livre à avoir dans votre poche

Cet aide-mémoire, de petit format, devrait être tout le temps dans votre poche.

Dès les premières pages de cet aide-mémoire, je fus surpris par sa qualité tant du point de vue du texte, que du point de vue des bouts de code Java donnés.

Ainsi, d'entrée de jeu (chapitre 1 et 2), on vous apprend comment afficher la date du jour dans un format donné, la nouvelle boucle ForEach, la classe StringBuilder, la classe Collator (Est-ce que Éléonor précède Fabian ou pas ?), les énumérations (enum).

J'aime également beaucoup la façon dont les auteurs vous expliquent les mécanismes de la programmation par objet, la généricité (nouveauté du JDK 5.0) et le contrôle d'exécution.

Le chapitre 8, dédié aux API Java, aborde les collections, les tables, les URL et Sockets, AWT, Swing et les applets. Cela ne couvre évidemment pas tout ce qu'un livré dédié à Swing pourrait couvrir, bien évidemment, mais vous y avez vraiment l'essentiel (composants, événements, conteneurs et systèmes d'agencement (layout))

Dans le dernier chapitre (le 9), ils y ont même consacré une petite partie sur la sécurité, et l'utilitaire policytool.

J'oubliais également la partie consacrée aux entrées-sorties, ainsi que celle consacrée aux threads.

Quand je vous dis que malgré sa petite taille, il couvre une multitude de choses, je n'exagère pas. Ce n'est pas un ouvrage de référence, qui passe en revue toutes les API du JDK. Mais un excellent aide-mémoire, illustré abondamment d'extraits de code, très bien pensés.

Un excellent rapport qualité/prix

Ant est devenu un outil indispensable au développeur Java, quel que soit son domaine de prédilection : J2SE, J2EE, etc. Sa portabilité, sa facilité d'utilisation et son intégration à de nombreux EDI/RAD du marché (grâce à des plugins, voir même par défaut avec NetBeans), en font un outil incontournable. Voici quelques liens grâce auquels vous pourrez en apprendre un peu plus :

Présentation de Ant par Ludovic Fernàndez

Forum d'entraide Ant

Autres outils pour le développeur Java