Les livres Java en AnglaisConsultez tous les livres

"Real World Java EE Night Hacks" raconte comment Adam Bien a créé une application afin d'avoir des statistiques sur son blog dont la fréquentation a explosé suite à la sortie de son premier livre.

On commence par quelques pages sur les critères pour son application (performances, inter portabilité avec différents serveurs d'applications, robustesse et aucune dépendance).

Une fois le contexte mis en place, le développement de l'application commence. Toute sa démarche (choix des API, utilisation de design pattern...) est expliquée, ce qui est fort intéressant car l'auteur est Java champion et a beaucoup d'expérience en Java.

Lors des chapitres, on aura droit à plusieurs technologies comme les tests unitaires, la couverture de test, le refactoring, Mockito, EJB 3.1, CDI, JPA, JAX-RS, JMX, Maven 3, Mercurial/Git, Hudson...

Le tout très bien amené et toujours argumenté.

De plus l'auteur n'hésite pas à donner son avis comme par exemple sur le fait que :

• Avoir une couverture de test de 100% n'est pas obligatoire ;
• Les annotations sont beaucoup plus pratiques que les XML alors que sur le papier les XML sont très intéressants ;
• ...

On comprendra aussi la puissance des Design Pattern et du refactoring.

Le livre se conclut par trois chapitres sur le processus de développement, les tests de stress et l'architecture logicielle.

Ce dernier chapitre peut être complété par la lecture de son premier livre.

Donc si je résume, je conseille sa lecture car c'est un livre très bon et pragmatique. En espérant qu'il fasse d'autres livres car je l'ai trouvé un peu court.

Ce livre de 312 pages a pour but de nous apprendre le tuning de JBoss AS 5. Pour cela l'auteur commence par nous expliquer sa méthodologie et les outils qu'il va utiliser. JBoss étant gratuit et opensource, les outils utilisés (VisualVM, JMeter, Eclipse TPTP) le seront aussi.

Puis commence la partie technique du tuning avec la JVM. Le tout avec des tests chiffrés, des conseils, de la théorie et de la pratique.

On verra comment choisir la taille maximum de la JVM, comment compartimenter la mémoire de la JVM, comment choisir le meilleur comportement du Garbage Collector... Puis chacun des modules (Pool JDBC, thread pool, provider JMS, EJB, Hibernate, Tomcat Web Server...) de JBoss seront traités.

Là encore l'auteur nous explique comment choisir la taille des pools, détecter les fuites de connexions à la base de données, paramétrer les logs...

Un chapitre entier présente le clustering avec JBoss et le cache distribué "JBoss Cache". En derniers chapitres, on a droit à comment programmer une application Web rapide avec une comparaison entre JSP/Servlet et JSF et RichFaces. Le tout en expliquant bien que la productivité du développeur est aussi très importante. Puis les Web services seront traités.

L'auteur ne se contente pas seulement de nous expliquer le tuning de JBoss mais aussi tout ce qui est autour comme le tuning de l'OS, le tuning du réseau, le tuning de Hibernate... Tout ça afin d'avoir l'application la plus performante possible.

En résumé on se retrouve avec un livre facile à lire et à comprendre, très complet et avec un retour d'expérience de l'auteur qui maîtrise le sujet, ce qui permet d'avoir un certain nombre de conseils qui sont parfois difficiles à obtenir.

Un livre que j'aurais bien aimé avoir lorsque j'ai commencé à m'intéresser au tuning de serveur d'application.

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.

Ce livre est une très bonne introduction à la création d'applications modulaires en Java. Ce livre présente tous les principaux concepts de la technologie OSGi, de Spring Dynamic Modules ainsi que des outils permettant de faciliter le développement d'applications OSGi.

Le premier chapitre présente la problématique de modularité et présente comment OSGi tente de résoudre ce problème. Les concepts principaux de la technologie y sont également décrits.

Le second chapitre présente différents conteneurs OSGi. Dans ce chapitre, on crée un premier programme Hello World en utilisant OSGi. On améliore ensuite ce programme en utilisant la publication et la consommation de services OSGI.

Le troisième chapitre introduit l'application "Dude, Where's my Jar ?" qui nous suivra tout au long du livre. Cette application est une application web permettant d'effectuer des recherches de fichier Jar dans des repository Maven. En plus de cela, le chapitre présente la série d'outils Pax qui permettent de faciliter le développement d'applications OSGi.

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

Le chapitre cinq développe le bundle suivant. Ce chapitre se focalise sur la publication et la consommation de services OSGi. En plus de cela, on apprend également à tester une application et des services OSGi.

Il est maintenant temps de passer à Spring Dynamic Modules avec le chapitre suivant. On y voit comment faciliter la consommation et la déclaration de services sous forme de beans Spring.

Avec le chapitre 7, on commence à développer le bundle web. Pour cela, on va inclure Tomcat ou Jetty sous forme de bundles OSGi. On va ensuite voir les différences qu'il y a entre déclarer un bundle simple (JAR) et un bundle web (WAR).

Le chapitre suivant traite de l'extension de bundle OSGI au moyen de fragment. On va notamment voir comment découpler la partie JSP et design de la partie applicative.

L'avant dernier chapitre permet de voir comment déployer une application OSGi en production. Il présente l'ajout d'une console web à l'application pour administer directement les modules.

Le dernier chapitre présente les services de journalisation et d'administration qui font partie de la norme OSGi.

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

English version :

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Français

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

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

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

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

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

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

English

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

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

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

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

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

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

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.

Ce livre présente plusieurs particularités du langage Java ainsi que beaucoup de trucs et astuces permettant d'utiliser au mieux ce language.

Le premier chapitre passe en revue les particularités du langage Java. Il met en avant quelques spécialités du langage et démontre quelques erreurs qui sont communes aux programmeurs Java. Le chapitre suivant est complètement dedié au mot clé final. Il parle de l'utilité du mot clé final pour les champs, les méthodes et les classes. Ce chapitre traite aussi de la compilation conditionelle. Le chapitre suivant est dediée aux objets immuables, de leur conception à leur utilité.

Le quatrième chapitre est entièrement dedié aux collections du langage Java. Il présente les différents types de Collection que propose l'API standard et les différents concepts qu'il est utile de connaître pour choisir une collection. Ce chapitre ne se contente pas de lister les différentes collections, il va décrire en détails les mécanismes de chacune de ces dernières. Il va également traiter de la performance des collections et des arguments pouvant conduire au choix de l'une ou de l'autre collection.

Le chapitre 5 décrit le mécanisme des exceptions dans Java. Il présente également les bonnes manières de gérer les exceptions dans un programme Java. Le chapitre suivant décrit en profondeur le système des classes internes. Il va décrire tous les types de classes internes, leur utilité et leur utilisation. Il donne aussi un résumé de ce que peut faire et ne peut pas faire chaque type de classe interne.

Le chapitre 7 traite des constantes. Il parle des constantes de substition, des objets constants et des options constantes. Il traite également des "bit fields" qui sont des variables combinant plusieurs états vrais-faux. Avec le chapitre suivant, on passe dans la modélisation des données. Ce chapitre indique tous les points auxquels il faut faire attention quand on modélise un modèle de données. Il traite des contraintes sur le modèle, du langage de modélisation naturel et du choix entre une base de données orientée objet ou relationnelle.

Le chapitre suivant traite de la réflection et son utilité dans un programme Java. Un premier exemple utilise la reflection pour faciliter le logging des classes et un autre pour les tests unitaires. Le chapitre 10 décrit les proxies. Il va décrire le proxy statique et le proxy dynamique généré directement par Java. L'avant-dernier chapitre décrit les références et présente les différentes utilités de chacun des types de référence présente dans le langage Java. Enfin le dernier chapitre repasse sur les nouveautés de Tiger. Ce chapitre n'est utile qu'aux personnes ne connaissant pas encore ces nouveautés.

En conclusion, ce livre est très bon pour compléter ses connaissances sur le Java. En effet, ce livre traite de sujets qui ne sont habituellement pas traités dans les autres livres que j'ai pu lire sur Java. Néanmoins, j'ai trouvé que certains chapitres n'allaient pas assez en profondeur dans leur sujet. Cependant, ce livre m'a permis d'appréhender des sujets encore quasi-inconnus et d'en approfondir d'autres. Je conseille ce livre à tous les utilisateurs du langage Java qui n'ont pas forcément encore poussé à fond dans le langage.