Mes critiques de livres
Dernière mise à jour : - 10 livres - 10 critiques
- Apache Maven - Maîtrisez l'infrastructure d'un projet Java EE
- Développements n-tiers avec Java EE
- iReport 3.7
- Pro Spring 2.5
- JBoss in Action
- JSF 2.0 Cookbook
- Java EE : Guide de développement d'applications web en Java
- Beginning Java EE 6 Platform with GlassFish 3: From Novice to Professional
- Apache Struts 2 - Web Application Development
- JBoss AS 5 Development
- Business Intelligence avec SQL Server 2008 R2
- Programmation GWT 2 (2ème édition)
 |
Public visé : débutants et avancés Résumé de l'éditeurCe livre sur Apache Maven (en version 3 au moment de l’écriture), s’adresse à tout développeur amené à travailler sur des projets Java de taille conséquente. Il sert également de guide pour les architectes qui souhaitent mettre en œuvre Apache Maven sur un nouveau projet ou sur un projet existant. Apache Maven, créé il y a tout juste 10 ans, tient aujourd’hui une place centrale dans l’écosystème du développement logiciel sur la plate-forme Java EE. La dernière version est le fruit d’un travail conséquent de la communauté, riche de nombreux retours d’expérience. Du développeur Java débutant à l’architecte technique, chaque lecteur trouvera dans cet ouvrage des informations claires et précises, illustrées par de nombreux schémas, pour aborder avec sérénité la découverte d’Apache Maven, jusqu’à sa gestion au sein d’une infrastructure projet. L’auteur propose régulièrement au lecteur de réaliser des travaux pratiques pour se forger une première expérience significative sur le produit. L’explication des origines d’Apache Maven dans le premier chapitre permet de mieux appréhender l’importance stratégique de sa mise en œuvre sur des projets Java EE. Le deuxième chapitre permet une première approche de la philosophie générale autour de la notion de cycle de vie des projets Maven. Le troisième chapitre se focalise sur l’organisation et les relations entre projets grâce à la gestion des graphes de dépendances, c’est dans le quatrième chapitre que le lecteur trouvera les informations sur l’étendue des possibilités qu’offre Apache Maven grâce à la mise en œuvre de plugins associés à des profils. Tout au long du cinquième chapitre, la mise en place complète d'une infrastructure autour d'Apache Maven sur un projet professionnel Java est détaillée : l’environnement de développement, la mise en place de tests, la gestion des référentiels, l’intégration continue et le processus de releases pour la livraison du projet. Le sixième et dernier chapitre de cet ouvrage traite de la génération de rapports Web complets pour la mesure de la qualité des projets Java. Tout au long du livre l’auteur s’appuie sur une application concrète pour illustrer ses propos, le code source est en téléchargement sur www.editions-eni.fr. D’autre part, l’auteur a mis en place un site dédié au livre et à cette application à l’adresse http://mvnbook.mgreau.com. Critique du livre par la rédaction (Celinio FERNANDES) - Septembre 2011
Chapitre 1 : Ce livre sur Maven est constitué de 6 grands chapitres. Le premier chapitre est consacré à la présentation d'Apache Maven. L'auteur explique l'historique de l'outil. Il en profite pour donner des ressources de références utiles telles que les sites des plugins, des listes de diffusion, des blogs ... L'installation de Maven sur un poste de travail est expliquée de façon très précise. Puis viennent les explications sur les fichiers pom.xml, settings.xml etc. Pour mettre en application les fonctionnalités majeures de Maven, l'auteur développe un projet appelé mvnbook-entry-plugins qui est une sorte de point d'entrée pour les plugins. Ce projet utilise des API et frameworks tels que JAX-WS 2.0, JAXB, Guice, JPA 2 et Struts 2.
Chapitre 2 : Ce chapitre commence le développement du projet en mettant en application les archétypes pour initialiser le projet. Le cycle de vie du projet est vu, à l'aide de plusieurs schémas, les tests unitaires sont décrits, les artefacts générés sont listés, les premiers plugins présentés (maven-compiler-plugin, maven-jar-plugin). L'auteur s'est bien attardé sur l'encodage des fichiers d'un projet et je trouve cela bien utile, l'encodage des caractères étant un problème récurrent.
Chapitre 3 : Ce chapitre aborde les dépendances entre classes. Les différents champs d'application de ces dépendances sont bien expliqués et avec l'aide de schémas. Ensuite, l'auteur poursuit la construction du projet du livre avec l'implémentation de JPA 2.0 dans le module mvnbook-persistence. Les résolutions de conflits liés aux dépendances sont expliquées. Le projet du livre est un projet multi-modules, ce qui permet bien sûr de décrire la construction d'un projet multi-modules. L'auteur explique bien l'importance de la construction de ce type de projets, au niveau de l'organisation, qui peut se baser sur l'héritage ou l'aggrégation ou les deux à la fois, et l'impact qu'elle a sur la suite des développements, y compris la livraison. Enfin le concept de propriétés dans les fichiers POM est mis en avant.
Chapitre 4 : Dans le quatrième chapitre, l'auteur décrit l'installation de Tomcat et de JBoss, pour les besoins de l'application mais surtout pour montrer l'utilisation des plugins Maven pour le déploiement. Il utilise JAX-B pour le développement des Web Services. Ensuite, les profils sont expliqués, ainsi que les artefacts (WAR, EAR) générés par les modules de l'application (mvnbook-webapp, mvnbook-webservice, mvnbok-ear-webservice, ...).
Chapitre 5 : Ce chapitre, comme le titre l'indique, traite de Maven dans un contexte professionnel c'est-à-dire l'utilisation de Maven combiné avec les divers outils faisant partie du cycle de développement : SVN, l'IDE Eclipse, le plugin m2eclipse, les tests, le déploiement avec le protocole WebDAV, la mise en place de Nexus et l'intégration continue. J'ai trouvé ce dernier point particulièrement bien traité dans la mesure où l'installation et la configuration de Jenkins sont bien détaillées mais aussi parce que le plugin maven-release-plugin, pour la gestion des releases et des versions, est lui aussi bien décrit.
Chapitre 6 : Ce chapitre s'intéresse à la génération de la documentation et aux outils offerts par Maven pour faire de la qualimétrie sur un projet. Les outils passés en revue sont Checkstyle, PMD, Sonar. J'ai bien apprécié la desciption suffisamment détaillée de Sonar (installation, configuration) avec son plugin Maven.
Ce que j'ai aimé : J'ai apprécié les explications bien fournies sur plusieurs idées-clés de Maven telles que les profils et les scopes. J'ai aussi trouvé fort utiles les explications sur plusieurs plugins comme maven-release-plugin mais aussi d'autres thèmes comme l'intégration continue avec Jenkins.
Ce que j'ai moins aimé : On peut éventuellement regretter le sujet de l'application développée pour le livre. En effet, je pense qu'une application de gestion des plugins peut apporter de la confusion aux débutants qui découvrent Maven, et plus particulèrement les plugins. Une confusion entre la notion de plugin géré par l'application et la notion de plugin Maven peut se produire. Sommaire
406 pages,
1ère édition,
Juin 2011,
Editions ENI,
ISBN10 : 9782746065093,
Broché Commandez sur http://www.editions-eni.fr : 54 EUR TTC (prix éditeur 54 EUR TTC) - Livraison Gratuite ! |
|
Public visé : débutants et avancés Résumé de l'éditeurCe livre consacré à la plate-forme Java EE s'adresse aux architectes logiciels et développeurs d'applications Java EE souhaitant mettre en place des projets avancés avec des techniques optimisées. La lecture de ce livre requiert des connaissances de base dans le développement d'applications Web en Java. Ces connaissances sont largement détaillées dans l'ouvrage précédent du même auteur « Java EE - Guide de développement d'applications Web en Java » paru aux Éditions ENI. Ce nouvel ouvrage a pour objectif de présenter en détail et de façon exhaustive, toutes les étapes de réalisation d'applications Internet avancées en Java EE, à partir d'un projet concret et facilement portable. Il détaille dans un premier chapitre la plate-forme Java EE, ses différentes architectures et API ainsi que les outils utilisés par les professionnels (Eclipse, NetBeans, Subversion, Ant, Hudson, JUnit...) au travers de l'étude de cas. Le deuxième chapitre est consacré à la mise en place détaillée du serveur Java EE de référence : GlassFish. Il détaille les concepts et l'architecture de GlassFish, l'installation et la configuration optimisée du serveur, en passant par la mise en production dans un environnement professionnel (clustering, load balancing, versioning...) et la liaison avec des composants annexes (SGBD, serveur mails...). Le chapitre trois aborde la programmation Web Java EE au travers des Servlets 3.0, JavaServer Pages 2.2 et le framework Java EE de référence : JavaServer Faces 2.0, ainsi que les concepts associés comme les feuilles de style CSS, le langage JavaScript ou encore XHTML. Le quatrième chapitre explore en détail la couche de persistance standardisée en Java . Les fonctionnalités de l'API de référence (Java Persistence API) sont détaillées et mises en application à partir d'exemples, en analogie avec les méthodologies UML et MERISE. Le chapitre cinq présente le tiers métier au travers de la dernière spécification des Enterprises JavaBeans. Les différents concepts, clients et types d'Enterprises JavaBeans sont explicités à partir de clients Java SE et Java EE, ainsi que les API Java Message Service et Message-Driven Bean. Le dernier chapitre est consacré à l'étude des services Web et traitements asynchrones en Java EE. Les technologies et services SOAP sont présentés en détail avec les différents types de clients (Java SE, Java EE et autres) tout comme les méthodes de packaging et déploiement (JAR, EAR, WAR). Enfin, la dernière partie explore de façon exhaustive l'architecture REST et la mise en place de services RESTful. Le code lié à l'étude de cas traitée dans le livre est en téléchargement sur le site www.editions-eni.fr. L'auteur propose également à ses lecteurs un lieu d'échanges via le site www.gdawj.com qui apporte également un certain nombre d'éléments complémentaires (exemples déployés, directement utilisables, des outils complémentaires pour le développement d'applications Web...) Critique du livre par la rédaction (Celinio FERNANDES) - Juin 2011
Ce livre, paru en mars 2011 et préfacé par Roberto Chinnici, le leader de la plate-forme Java EE chez Oracle,
couvre en profondeur (902 pages !) la plate-forme Java EE 6, sortie en 2009. L'auteur n'en est pas à son premier livre et il en avait déjà écrit un sur Java EE (paru en février 2009). Son dernier ouvrage est un véritable guide destiné à toute personne impliquée dans la conception et le développement d'une application Java EE. Et il s'adresse du coup à tous les profils : l'expérimenté y trouvera des rappels utiles et le débutant les explications et les conseils dont il a besoin. D'ailleurs, quand on parcourt le sommaire, on s'aperçoit d'emblée que l'ouvrage se veut exhaustif : divisé en six principaux chapitres (chaque chapitre étant composé de 15 à 30 sous-chapitres), il aborde de très nombreuses technologies autour de Java EE.
Le premier chapitre présente la liste des spécifications Java EE 6. Il permet non seulement de connaître les nouveautés apportées par Java EE 6 mais aussi d'apprendre
le développement d'une application (un projet de gestion d'une école) de A à Z : modélisation UML, mise en place de l'architecture (développement en couches),
de l'environnement de développement, d'un outil de build (Ant), d'un gestionnaire de configuration (Subversion), d'un serveur (GlassFish), des tests (JUnit et SeleniumHQ),
des logs (Log4j), de l'intégration continue (Hudson), d'une base de données (MySQL), etc.
Si vous cherchez un livre sur le serveur d'application GlassFish, alors ne cherchez plus, ce livre est le livre qu'il vous faut. En effet un chapitre de près de
160 pages est entièrement dédié à ce serveur dans sa version 3. Et de nombreux aspects sont couverts là encore : installation, administration, monitoring,
clustering, optimisation, load balancing... De plus l'auteur a pu bénéficier de l'expertise d'Alexis Moussine-Pouchkine, membre de l'équipe GlassFish chez Oracle,
lors de la relecture. C'est également dans ce deuxième chapitre que l'auteur montre l'interopérabilité possible entre Java et PHP avec un exemple intéressant d'utilisation des EJB depuis une page PHP !
Le troisième chapitre aborde le développement de la couche web avec les servlets 3.0, les JSP et le framework JSF 2.0 qui représente en fait
les trois quarts de ce chapitre. Si vous souhaitez créer une application Web à partir de la dernière version de JSF alors ce livre peut vous apporter
une aide précieuse. L'auteur passe en revue l'essentiel des nouveautés du framework concernant la création des managed beans, l'ajout d'Ajax, l'internationalisation, la navigation, le cycle de vie, la création d'un composant composite, la conversion et la validation des données, etc.
Le quatrième chapitre est entièrement dédié, et à juste titre tellement le sujet est vaste, à l'API JPA. EclipseLink est l'implémentation open source de référence de JPA 2.0 et est aussi l'implémentation de JPA choisie dans cet ouvrage, avec une base MySql. L'auteur adopte une approche top-down : il crée d'abord les classes des entités puis génère les tables de la base à partir des entités. L'approche bottom-up est également décrite plus loin dans le chapitre. Les annotations et les relations sont expliquées de façon très détaillée. Des diagrammes UML et Merise viennent illustrer les relations entre les entités. Dans la suite on retrouve les principales fonctionnalités qui constituent l'API JPA : gestion de l'optimisation, des accès concurrents, des entités avec l'Entity Manager, des transactions, cycle de vie d'une entité, différences Java SE et Java EE, le langage JPQL... Mais aussi des exemples d'utilisation de l'API Criteria, nouveauté de JPA 2.0.
Le cinquième chapitre traite de la couche métier de l'application. L'auteur apporte des explications pour l'utilisation des EJB (versions 3.0 et 3.1)
avec Struts 2 et JSF 2. Les différents types d'EJB (Session Bean, MDB, Entity Bean) sont utilisés pour le développement de l'application. Le framework de log LOG4J est longuement détaillé et JMS est aussi mis en pratique, avec OpenMQ. Je pense qu'il y a une très bonne répartition explications "théoriques" des EJB et mise en pratique de ces explications pour continuer le développement de l'application. Si vous cherchez un livre pour bien démarrer avec les EJB 3.0 et 3.1, alors ce livre peut répondre à vos attentes.
Le sixième et dernier chapitre est dédié aux services Web.
Dans la première moitié du chapitre, après une introduction exhaustive aux schémas XML et aux concepts des services Web, l'auteur détaille la création et l'utilisation
d'un service Web (avec notamment l'API JAX-WS) à partir de composants variés tels que les EJB, les servlets et JSF. Dans la deuxième moitié du chapitre, l'architecture REST est mise en avant avec l'utilisation de Jersey, l'implémentation de référence de JAX-RS.
En conclusion, ce livre est très complet, contient beaucoup d'explications qui aident à développer une application de bout en bout. Un petit regret que j'ai tout de même est l'absence de Maven. L'auteur a privilégié Ant pour builder le projet et c'est un peu dommage dans la mesure où Maven est désormais assez systématiquement utilisé pour développer une application. Le code source est disponible en téléchargement sur le site des éditions ENI : http://www.editions-eni.fr Enfin, pour continuer à se faire une idée du livre, si cette critique ne vous a pas convaincu, je vous invite à lire l'interview de l'auteur, réalisée à l'occasion de la sortie du livre. Sommaire
902 pages,
1ère édition,
Mars 2011,
Editions ENI,
ISBN10 : 9782746062634,
Broché Commandez sur http://www.editions-eni.fr : 51.30 EUR TTC (prix éditeur 51.30 EUR TTC) - Livraison Gratuite ! |
  |
Public visé : Débutants,Intermédiaires Résumé de l'éditeur
Although JasperReports is the world's most popular open source Java reporting library, it has always lacked one thing: It doesn't provide a tool to visually design reports. iReport is a visual report designer built on JasperReports that fills that lack. It is an intuitive and easy-to-use visual report builder/designer for JasperReports, written in 100% pure Java.
This beginner's tutorial book is a straightforward introduction to the iReport environment taking an example-oriented approach in developing your skills from scratch. It shows you how to use iReport for creating reports in PDF, RTF, and other formats, which can be delivered over the Web for immediate access.
This book will guide you through using iReport to develop various types of reports from a simple report through to dynamic enterprise-level reports based on realistic examples based on a sample Inventory Management System. It takes you through the main types of report available in iReport, and shows you exactly how to create them. It shows you how to use different report templates, how to use special kinds of data operations to generate more powerful reports, combine data to produce master-detail reports, add images, control the layout and formatting of your report and many more.
It will also show you how to use the NetBeans IDE to create Java projects with reporting facilities. You will learn how to vary report format and layout according to business requirements.
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/
Sommaire
222 pages,
1ère édition,
Mars 2010
Éditions PackT Publishing,
ISBN10 : 1847198805,
ISBN13 : 978-1-847198-80-8 |
 |
Public visé : Intermediaires,Experimentes Résumé de l'éditeurThe move from so-called heavyweight architectures, such as Enterprise JavaBeans, toward lightweight frameworks, like
Spring, has not stopped since Pro Spring was published by Rob Harrop and Jan Machacek in 2005; in fact, it's picked up pace. The
Spring Framework remains the leader in this move and provides a platform on which you can build your own applications and
services.
Pro Spring 2.5 covers the new features of Spring 2.5, but moreover, it is focused on the best practices and core standards
of contemporary Spring development. As members of the Spring development team at Cake Solutions, the author team brings extensive
practical experience gained from working with Spring since version 1.0 and delivering successful systems on top of it.
Learn the approaches that really matter in a professional, enterprise-level environment, so you can apply them to your
projects today, safe in the knowledge that they just work.
Ce livre, publié en août 2008 aux éditions Apress, est parfait pour le développeur Spring, qu'il soit débutant ou
expérimenté.
Il intimide par son épaisseur (890 pages) qui s'explique par les nombreux domaines
pris en charge par Spring mais aussi par le nombre d'auteurs puisqu'il y en a quatre.
Il couvre bien sûr les nouveautés de la version 2.5 du framework léger Spring. J'ai apprécié les nombreux exemples de code et de configuration qui accompagnent les 22 chapitres,
ainsi que la diversité des sujets abordés : AOP, MVC, JDBC, Hibernate, Quartz, remoting, design patterns,
gestion des transactions, JMX, les tests, tuning ...
On y trouve même un exemple de configuration de JasperReports pour la génération de fichiers PDF !
Le livre est logiquement découpé en 4 parties composée chacune de plusieurs chapitres. Le 1er chapitre fait un tour rapide des différents sujets abordés dans le livre.
Le 2ème chapitre présente avec le traditionnel exemple "Hello World" une première esquisse de l'implémentation du pattern "Injection de dépendance" (DI) via Spring. Le 3ème chapitre aborde le pattern au coeur de Spring : Inversion of Control.
Les différentes types d'IoC sont décrit en détails : - DI (avec 2 sous-types : constructor DI et setter DI) - Dependency lookup (avec 2 sous-types : dependency pull et contextualized dependency lookup) L'interface BeanFactory est introduite et expliquée avec de nombreux exemples. Le chapitre sur les langages dynamiques décrit la création de beans managés par Spring avec BeanShell, JRuby et Groovy.
Le plus gros chapitre du livre consacre presque 100 pages à l'implémentation du pattern MVC dans Spring,
en détaillant l'utilisation d'autres technologies Web telles que Velocity, Freemaker ...
Et l'on trouve ensuite de façon logique une explication détaillée de Spring Web Flow.. On peut cependant regretter l'absence de chapitres consacrés aux web services, à la sécurité, aux EJBs ou encore JMS.
Le code source des exemples est disponible en ligne sur le site des éditions Apress. Sommaire
890 pages,
1ère édition,
Août 2008
Éditions Apress,
ISBN10 : 1590599217,
ISBN13 : 978-1590599211 |
 |
Public visé : Débutants,Intermédiaires Résumé de l'éditeur
JBoss in Action teaches readers how to use the JBoss application server, digging into the things that separate JBoss from other
Java EE servers. This book goes deeply into the advanced features and configuration of the server. In particular, it focuses on
enterprise-class topics, such as high availability, security, and performance.
The book walks you through the JBoss 5 Application Server, from installation and configuration to production deployment. It guides
you through configuring the server's component containers, such as the JBoss Web Server, the EJB3 server, and JBoss Messaging. It
also gives you detailed insight into configuring the services, such as security, performance, and clustering. Beyond coverage of
the core application server, the book also teaches you how to use some of the "hot" technologies that run on top of the
application server, such as JBoss Seam and JBoss Portal.
The authors, both seasoned professional experts at developing and administering JBoss, provide meaningful explanations and
background on many topics, all tied together with practical, real-world advice from their collective experience. The uniquely
comprehensive explanations and the overall wide coverage provided in this book surpass any other content currently available.
This book is perfect for developers writing Java EE applications, as well as administrators responsible for maintaining the JBoss
Application Server.
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.
SommairePART 1 THE JBOSS APPLICATION SERVER
Part 2 APPLICATION SERVICES
Part 3 JBOSS PORTAL
Part 4 GOING TO PRODUCTION
464 pages,
1ère édition,
2009
Éditions Manning,
ISBN10 : 1933988029,
ISBN13 : 978-1933988023 Commandez sur www.amazon.fr : 31.49 EUR TTC seulement (au lieu de 39.82 EUR TTC : prix éditeur) - Livraison Gratuite ! |
 |
Public visé : Débutants, Intermédiaires Résumé de l'éditeur
JavaServer Faces is a Java-based Web application framework intended to simplify development of user interfaces for Java EE applications. You may already be aware of the laborious search through reference guides and documentation to develop your JSF applications. With the JSF Cookbook, you can find solutions to the most common JSF problems in a quick and easy way.
This book will cover all the important aspects involved in developing JSF applications. It provides clear instructions for getting the most out of JSF and offers many exercises to build impressive desktop-style interfaces for your web applications. Develop JSF applications starting with simple recipes and gradually moving on to complex recipes.
We discuss all of the fundamental aspects of JSF applications. Once you locate your desired topic, you can try to find a recipe that corresponds to your problem.
We start off with the simple concepts of Converters, validators and file management. We then work our way with various resources such as CSS, JavaScript, and images to improve your web applications. You will learn to build simple and complex custom components to suit your needs. Next, you get to exploit AJAX as well as implement internationalization and localization for your JSF applications. We then look into ensuring security for your applications and perform testing of your applications. You also get to learn all about Facelets and explore the newest JSF 2.0 features. Finally you get learn a few integrations such as JSTL with JSF, Spring with JSF, and Hibernate with JSF. All these concepts are presented in the form of easy-to-follow recipes.
Each chapter discusses separate types of recipes and they are presented with an increasing level of complexity from simple to advanced. All of these recipes can be used with JSF 1.2 as well.
This book helps you to find solutions to the most common aspects regarding JSF development with clear and easy-to-follow recipes
Ce livre couvre les nouveautés de JSF 2 à travers environ 100 recetttes.
A mon avis ces recettes fournissent un bon aperçu des nouvelles possibilités de la dernière version
de JSF. Les chapitres apportent des solutions immédiates à des problèmes et des pré-requis très courants dans le développement web. Bien sûr il est nécessaire de lire plus de documentation sur JSF 2 (telle que la référence complète) pour être capable de complètement comprendre et connaître les différentes options. Le principal IDE et le serveur utilisés dans le livre sont NetBeans 6.8 et GlassFish 3, respectivement. L'IDE Eclipse Ganymede est utilisé dans une recette (utilisation de JSF ID generator).
Les deux premiers chapitres donnent une bonne idée des validators et des converters, personnalisés et standards.
Apache MyFaces Trinidad et RichFaces sont utilisés. La validation est également mise en oeuvre à travers l'intégration de la JSR-303
(Bean validation) dans JSF 2.
Le chapitre 3 concerne la gestion des fichiers (envoi, téléchargement, extraction, export) avec l'aide des librairies
Mojarra Scales et de composants dans RichFaces et PrimeFaces.
Le chapitre 4 est un autre chapitre intéressant qui explore les différents moyens de protéger un site. Il met en oeuvre
l'utilisation des expressions EL qui font partie du projet JSF Security et qui utilisent une portée séparée et appelée securityscope.
Les rôles sont basés sur JAAS, stockés dans une base ou ajoutés à la HttpSession. La dernière recette utilise Spring Security
pour gérer une page de login.
Le chapitre 5 fournit des recettes pour la création de divers composants personnalisés (hello world,
un visualiseur d'images avec des fonctionnalités Ajax en utilisant le projet Dynamic Faces project, etc) et également
des composants composites personnalisés.
Le chapitre 6 concerne Ajax. Il couvre le nouveau tag <f:ajax> et utilise de nouveau plusieurs autres librairies de composants pour
ajouter des fonctionnalités Ajax (Dynamic Faces, Tomahawk, ajax4jsf, PrimeFaces ...).
Le chapitre 7 traite des besoins fréquents en matière de site que sont l'internationalisation et la localisation. Il utilise le tag core
f:loadBundle, les fichiers de messages properties, l'encoding ...
Le chapitre 8 montre comment ajouter des styles CSS à des tags JSF, peupler des grids avec des styles CSS, intégrer JavaScript
dans JSF avec divers exemples, récupérer des images d'une base et les envoyer de façon dynamique à une page JSF.
Il y a même une recette qui montre comment utiliser la librairie de tag rss4jsf pour montrer du contenu RSS dans des pages JSF.
Le chapitre 9 introduit diverses applications :
- l'outil Faces Console pour éditer de façon visuelle les fichiers de configuration JSF - JSFUnit (un framework JBoss pour tester des applications JSF) - JMeter pour mesurer la performance - JSF Chart Creator pour afficher des graphes
Le chapitre 10 est un chapitre important puisqu'il traite des Facelets qui, à partir de la version 2.0 de JSF,
font partie de la spécification JSF et sont la technologie de présentation recommandée avec JSF.
Le templating et les composants de composition sont les sujets les plus traités dans ce chapitre.
Le chapitre 11 est un ensemble de sept recettes autour des nouveautés de JSF 2.0 qui n'ont pas été abordées
dans les précédents chapitres.
Enfin le chapitre 12 est un autre chapitre utile puisqu'il montre l'intégration de JSF avec d'autres technologies
telles que Spring et les EJB.
L'appendix contient des listings des fichiers de configuration pour les frameworks basés sur JSF.
Ce que j'ai le plus aimé : les recettes sont basées sur des besoins et des problèmes fréquemment rencontrés lors
du développement. Elles sont donc très utiles.
Ce que j'ai moins aimé : je n'ai rien de particulièrement négatif à signaler. Ce livre de recettes correspond à l'idée et
aux attentes que j'avais avant de le lire.
English version :
This book covers the new features of JSF 2 in the form of about 1OO hundred recipes.
In my opinion these recipes give a good overview of the new capabilities of the latest
version of JSF. The chapters get right to the point with very common problems/requirements in web development and their solutions. Of course you still need to read more documentation about JSF 2 (such as the complete reference) to be able to completely understand and know the different options. The main IDE and the server used in the book are NetBeans 6.8 and GlassFish 3, respectively. The IDE Eclipse Ganymede is used in one recipe (Using JSF ID generator).
The first two chapters give a good idea of the custom and standard validators and converters.
Apache MyFaces Trinidad and RichFaces are used. Validation is also demonstrated through the built-in integration of
JSR-303 (Bean validation) in JSF 2.
Chapter 3 is about file management (uploading, downloading, extraction, export) with the help of
Mojarra Scales libraries, RichFaces and PrimeFaces components.
Chapter 4 is another interesting chapter that explores various ways to protect a site. It demonstrates
the use of EL expressions part of the JSF Security project which uses a separate scope called securityscope.
Roles are based on JAAS, stored in a database or added to the HttpSession. The last recipe makes use
of Spring Security to manage a login page.
Chapter 5 provides recipes to demonstrate the creation of various custom components (hello world,
image slide viewer with Ajax functionality using the Dynamic Faces project etc) and also
composite custom components.
Chapter 6 is about Ajax. It covers the new tag <f:ajax> and again uses several other component libraries
to add Ajax features (Dynamic Faces, Tomahawk, ajax4jsf, PrimeFaces ...).
Chapter 7 is about the frequent site requirements that are internationalization and localization.
It uses the core tag f:loadBundle, messages properties files, encoding ...
Chapter 8 shows how to add CSS styles to JSF tags, populate grids with CSS styles, integrate JavaScript
to JSF with various examples, retrieve images from a database and provide them dynamically to a JSF page.
There is even a recipe that shows how to use the tag libary rss4jsf to show RSS content in JSF pages.
Chapter 9 introduces various applications :
- the Faces Console tool to visually edit JSF configuration files - JSFUnit (JBoss framework for testing JSF applications) - JMeter to measure performance - JSF Chart Creator to diplay charts
Chapter 10 is an important one since it is about Facelets which, starting with JSF 2.0, is a part
of the JSF specification and the recommended presentation technology to use in conjunction with JSF.
Templating and composition components are the topics most discussed in this chapter.
Chapter 11 is a set of seven recipes about new features in JSF 2.0 that were not seen in the previous
chapters.
Finally chapter 12 is another useful chapter since it shows how to integrate JSF with other technologies
such as Spring and EJB
The appendix contains listings of the configuration files for JSF-related frameworks.
What i liked most : the recipes are based on frequent requirements and problems encountered
when developing. So they are really useful.
What i liked the least : nothing really negative to report. This book of recipes meets the idea
and expectations I had of it before reading it.
Sommaire
396 pages,
1ère édition,
Juin 2010
Editions PackT Publishing,
ISBN10 : 1847199526,
ISBN13 : 978-1-847199-52-2 Commandez sur www.amazon.fr : 34.26 EUR TTC seulement (au lieu de 36.06 EUR TTC : prix éditeur) - Livraison Gratuite ! |
 |
Public visé : Débutants Ce livre s'adresse à des débutants mais aussi à des personnes experimentées car il contient de nombreux rappels et aussi
des astuces.
Le chapitre 1 couvre des choses qui doivent être connues lorsque l'on veut faire du développment Java EE. Cela va de
l'installation du JDK à la présentation du modèle MVC, en passant par l'installation et la configuration d'un serveur Tomcat dans
Eclipse et sous Windows.
Le chapitre 2 présente l'installation de Tomcat 6.0.X sous Linux, ainsi que l'installation et la configuration du serveur Web
Apache en frontal
du serveur Tomcat. Les fichiers XML de configuration des 2 serveurs (server.xml, web.ml, tomcat-users.xml, etc) sont expliqués,
avec en prime des rappels sur XML. La sécurité, la gestion des utilisateurs, le connecteur HTTPS sont également détaillés. Ce
chapitre se veut pratique puisqu'il détaille la création et le déploiement d'un projet dans Tomcat. Le monitoring et les tests de
montée en charge sont abondamment expliqués. J'ai particulièrement apprécié le cas de tests s'appuyant sur JMeter.
Le chapitre 3 présente les JSP. Elles sont utilisées dans l'élaboration de l'application BetaBoutique. C'est en toute logique que
les tags JSTL sont ensuite présentés, et sont suivis d'un sous-chapitre consacré à la création de taglibs personnalisées. En fait,
ce chapitre fait le tour complet du développement avec des JSP (avec des servlets, des JavaBeans, etc ...). J'ai apprécié
l'utilisation de la librairie commons-beanutils pour la manipulation des JavaBeans ainsi que du parser XStream pour la
sérialisation/déserialisation d'objets Java.
Le chapitre 4 est consacré aux servlets. Une maquette de l'application BetaBoutique est insérée dans ce chapitre. L'application
commence à prendre forme avec l'utilisation des servlets (sessions, filtres, cookies, interface RequestDispacter, etc ...).
Le chapitre 5 présente l'API JDBC. La base de données de l'application est construite à partir de MySQL. Le partage d'une
connexion est bien illustré par du code. L'interface DataSource est ensuite utilisée et ses avantages expliqués. Un pool de
connexion est créé dans Tomcat. De nouvelles astuces sont introduites (JavaScript, Ajax, la librairie DbUtils). Ce chapitre sur
les bases de données serait incomplet s'il ne traitait pas des transactions, ce qui est chose faite juste après. Finalement
l'authentification est étudiée, via la base de données et via les fichiers de configuration.
Le chapitre 6 décrit le framework Struts dans sa version 1.X, à travers le développement de l'application chatbetaboutique. Les
caractéristiques les plus connues de ce framework sont mises en exergue : action, form, dynaform, internationalisation,
validations avec validators et javascript. J'ai apprécié l'illustration par du code des actions les moins connues mais pourtant
bien utiles : DispatchAction, LookUpDispatchAction, MappingDispatchAction, SwitchAction. Le module administration de cette
application est par la suite bien décrit et implémenté.
Enfin le dernier chapitre détaille la très utilisée librairie log4J, la construction de tâches avec ANT, l'optimisation de la
mémoire dans Tomcat 6.X.
En résumé, j'ai trouvé le livre très riche, surtout pour les débutants, et j'avoue que personnellement j'aurais souhaité avoir un
tel livre dans mes étagères il y a quelques années.
Il représente également une source importante de rappels pour les plus experimentés.
Le code source du livre est bien entendu disponible sur le site des éditions ENI, ainsi que sur
http://www.gdawj.com/
SommaireChapitre 1 : Objectifs et spécifications de Java EE
Chapitre 2 Le serveur d'applications Apache-Tomcat
Chapitre 3 Les JavaServer Page
Chapitre 4 Les Servlets
Chapitre 5 Java et les bases de données
Chapitre 6 Framework Java EE
Chapitre 7 Techniques avancées
610 pages,
1ère édition,
02 2009
Editions ENI,
ISBN10 : 2746047152,
ISBN13 : 978-2746047150 Commandez sur www.amazon.fr : 51.30 EUR TTC seulement (au lieu de 54 EUR TTC : prix éditeur) - Livraison Gratuite ! |
 |
Public visé : Débutants,Avancés Résumé de l'éditeur
Sun's enterprise JavaT platform, Java EE (Enterprise Edition), is getting a facelift! Beginning Java EE 6 Platform with GlassFish 3 is one of the first tutorial books on the forthcoming Java EE 6 Platform.
Step-by-step and easy to follow, this book describes many of the Java EE 6 specifications and reference implementations and shows them in action using practical examples.
This book uses the new version of GlassFishT 3 to deploy and administer the code examples.
Written by an expert member of the Java EE 6 specification request and review board in the Java Community Process (JCP), this book contains the best information possible, from an expert's perspective in enterprise Java technologies and platform.
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. Sommaire
500 pages,
1ère édition,
Mai 2009
Éditions Apress,
ISBN10 : 1-4302-1954-8,
ISBN13 : 978-1-4302-1954-5 |
 |
Public visé : Débutants, Intermédiaires Résumé de l'éditeur
Struts 2.1 is a modern, extensible, agile web application framework suitable for both small- and large-scale web applications.
The book begins with a comprehensive look at Struts 2.1 basics, interspersed with detours into more advanced development topics. You'll learn about configuring Struts 2.1 actions, results, and interceptors via both XML and Java annotations. You'll get an introduction to most of the Struts 2.1 custom tags and learn how they can assist in rapid application prototyping and development.
From there you'll make your way into Struts 2.1's strong support for form validation and type conversion, which allows you to treat your form values as domain objects without cluttering your code. A look at Struts 2.1's interceptors is the final piece of the Struts 2.1 puzzle, allowing you to leverage the standard Struts 2 interceptors as well as implement your own custom behavior.
After covering Struts 2.1 you'll journey into the world of JavaScript, a surprisingly capable language, the Document Object Model (DOM), and CSS, and learn how to create clean and concise client-side behavior. You'll leverage that knowledge as you move on to Struts 2 themes and templates, which give you a powerful way to encapsulate site-wide user interface behavior.
The book closes with a look at some tools that make the application development life cycle easier to manage, particularly in a team environment, and more automatic.
Ce livre est composé de 15 chapitres. On peut considérer que les 9 premiers chapitres (205 pages) présentent les nouveautés
de Struts 2 et le reste du livre est un mélange d'apprentissage de JavaScript/Ajax et de bonnes pratiques pour documenter
et tester une application web. Il repose sur la version 2.1.6 de Struts. Les exemples du livre sont téléchargeables à l'adresse : http://www.packtpub.com/files/code/3391_Code.zip
Chapitre 1 : Le chapitre 1 est une première introduction à Struts 2 avec une liste des principales nouveautés. Le lecteur est également introduit aux pratiques agiles .
Chapitre 2 : Ce chapitre continue sur les nouveautés de Struts 2. L'auteur commence à développer l'application RecipeBox, un site d'échanges de recettes de cuisine, en suivant les pratiques agiles avec des user stories. Les plug-ins Configuration Browser et Convention sont utilisés.
Chapitre 3 : Ce chapitre fait le tour de la classe ActionSupport (validation, internationalisation ...). L'auteur fournit également des conseils pour le développement avec l'utilisation de Cygwin et d'Eclipse.
Chapitre 4 : Ce chapitre se concentre sur les Results qui sont les retours des actions. Différents types de Results sont examinés, notamment FreeMarker. Le plug-in Convention est largement utilisé dans les exemples (annotations @Result, @Action ...).
Chapitre 5 : Dans ce chapitre, l'auteur examine OGNL, la value stack et plusieurs tags (<s:include>, <s:sort>, <s:append>, <s:merge>, <s:action>, <s:generator>, <s:url>, ...). Ces tags génériques sont richement expliqués, même ceux qui ne sont pas fréquemment utilisés.
Chapitre 6 : Ce chapitre examine les tags UI qui font partie du formulaire. Chaque tag UI (<s:form>, <s:textfield>, <s:checkbox>, ...) est bien expliqué, avec des exemples. L'auteur apporte une petite introduction aux thèmes et templates (ils sont abordés en détails dans le chapitre 12). Il apporte également des explications pour l'upload de fichiers et le traitement des soumissions en double (tag <s:token>).
Chapitre 7 : Ce chapitre fait le tour de la validation et de la conversion des données. Les différentes méthodes de validation sont abordées (fichier XML, validation manuelle, annotations), que ce soit côté serveur ou côté client (JavaScript). J'ai trouvé les explications suffisantes et les remarques pertinentes.
Chapitre 8 : Ce chapitre présente les intercepteurs, examine ceux disponible dans la pile par défaut et décrit comment écrire ses propres intercepteurs à partir d'un exemple (interceptor trim) bien fourni en explications (tant dans le code que dans la configuration).
Chapitre 9 : Les différentes techniques de gestion des exceptions et la gestion des logs sont examinées dans ce chapitre. L'auteur explique la configuration des logs avec Log4J.
Chapitre 10 : Dans ce chapitre entièrement consacré à JavaScript, l'auteur explique la syntaxe de ce langage très utilisé dans la construction d'applications Web.
Chapitre 11 : Ce chapitre aborde encore JavaScript mais aussi CSS et la librairie jQuery. J'ai bien aimé l'exemple donné à la fin du chapitre pour l'ajout d'une ligne, de façon dynamique, dans un formulaire, ce qui est un besoin courant.
Chapitre 12 : Lors de mes précédentes recherches, j'avais trouvé peu d'informations sur la création de thèmes. C'est pourquoi je trouve que ce court chapitre, consacré aux thèmes et aux templates, fournit une aide précieuse.
Chapitre 13 : Ce chapitre présente la librairie JavaScript Dojo et jette un regard sur les tags Dojo dans Struts 2 pour faire de l'AJAX. Le plug-in REST est également présenté, avec ses différents types de réponse (JSON, XML, XHTML).
Chapitre 14 : Ce chapitre est dédié aux tests et examine le développement dirigé par les tests. Pour cela les frameworks JUnit et TestNG sont utilisés. L'injection de dépendance est également expliquée et utilisée pour les tests. L'auteur en profite alors pour introduire le plug-in Spring pour Struts 2. Enfin d'autres formes de tests sont présentées : les tests fonctionnels à l'aide de Selenium, les tests de montée en charge avec JMeter.
Chapitre 15 : Ce chapitre s'écarte un peu du sujet principal du livre (Struts 2) pour aborder la documentation dans un projet. C'est donc l'occasion pour l'auteur de présenter l'AOP, l'outil Javadoc, la modélisation UML, la gestion des sources ...
Ce que j'ai aimé :
Les références données à la fin de chaque chapitre. Ce sont des liens qui permettent d'approfondir des notions.
Ce que j'ai moins aimé :
Je n'ai pas vraiment de critique négative à faire sur le contenu de ce livre, je pense en effet qu'il représente un bel effort pour présenter les nouveautés de Struts 2 et donc faciliter l'apprentissage de la nouvelle version de ce framework auquel on a souvent reproché son manque de documentation.
English version :
This book is made of 15 chapters. One might consider that the first nine chapters (205 pages) explain what's new with Struts 2 and that the rest of the book
is a mix of JavaScript/Ajax learning and good practices to document and test a web application. It is based on the 2.1.6 version of Struts. The book samples can be downloaded at the following address : http://www.packtpub.com/files/code/3391_Code.zip
Chapter 1 : This chapter 1 is a first introduction to Struts 2 with a list of the main new features. The reader is also introduced to the Agile method.
Chapter 2 : This chapter is still about the new features in Struts 2. The author begins the development of a RecipeBox application, a recipe swapping website, following the Agile method with user stories. The Configuration Browser and Convention plug-ins are used.
Chapter 3 : This chapter is about the ActionSupport class (validation, internationalization ...). The author also provides tips for development with the use of Cygwin and Eclipse.
Chapter 4 : This chapter focuses on Results which are the actions' responses. Different Result types are examined, in particular FreeMarker. The Convention plug-in is widely used in the samples (annotations @Result, @Action ...).
Chapter 5 : In this chapter, the autheur examines OGNL, the value stach and several tags (<s:include>, <s:sort>, <s:append>, <s:merge>, <s:action>, <s:generator>, <s:url>, ...). These generic tags are richly explained, even those that are not frequently used.
Chapter 6 : This chapter examines the UI tags that are part of the "form". Each UI tag(<s:form>, <s:textfield>, <s:checkbox>, ...) is well explained, with samples. The author gives a small introduction to themes and templates (they are detailed in chapter 12). He also gives explanations to upload files and to handle double submits (<s:token> tag).
Chapter 7 : This chapter looks at the validation and the conversion of data. The different methods of validation are explained (XML file, manual validation, annotations), whether it is server-side or client-side (JavaScript). I found the explanations sufficient and the remarks pertinent.
Chapter 8 : This chapter is about interceptors and examines those that are available in the default stack. It explains how to write your own interceptors with a sample (trim interceptor) that i found well documented with code and configuration explanations.
Chapter 9 : The different mecanisms to handle exceptions and logs are examined in this chapter. The author explains the logs configuration with Log4J.
Chapter 10 : In this chapter entirely dedicated to JavaScript, the author explains the syntax of this widely used language for the development of Web applications.
Chapter 11 : This chapter is still about JavaScript but also CSS and the jQuery library. I liked the example, at the end of the chapter, to add a line, in a dynamic way, in a form and which is a frequent requirement.
Chapter 12 : During my previous researches, I found very little information for the creation of themes. That is why I think this short chapter, dedicated to themes and templates, provides a precious help.
Chapter 13 : This chapter describes the Dojo JavaScript library and takes a look at the Dojo tags in Struts 2 to create Ajax applications. The REST plug-in is also introduced, with its different return types (JSON, XML, XHTML).
Chapter 14 : This chapter is dedicated to tests and examines test-driven development. For this purpose the JUnit and TestNG frameworks are used. Dependency injection is also explained and used in tests. The author takes this opportunity to introduce the Spring plug-in for Struts 2. Finally, other forms of testing are introduced : functional testing with the help of Selenium, load testing with JMeter.
Chapter 15 : This chapter diverges a bit from the main topic of the book (Struts 2) to look at ways to document a project. It is then an opportunity for the author to introduce AOP, the Javadoc tool, UML modeling, source code control systems ...
What I liked the most :
The references that are given at the end of each chapter. They are links for the reader to check if he wants to take a deeper look into topics of the current chapter.
What I liked the least :
I do not really have any negative critic to make on the content of the book. I think it represents a real nice effort to explain the new features of Struts 2 and that it will help developers who want to learn the framework in this latest version, which has often been criticized for its lack of documentation. Sommaire
360 pages,
1ère édition,
Juin 2009
Editions PackT Publishing,
ISBN10 : 1847193390,
ISBN13 : 9781847193391 |
 |
Public visé : Débutants, Intermédiaires, Expérimentés Résumé de l'éditeur
Develop, deploy, and secure Java applications on this robust, open source application server
A complete guide for JBoss developers covering everything from basic installation to creating, debugging, and securing Java EE applications on this popular, award-winning JBoss application server Master the most important areas of Java Enterprise programming including EJB 3.0, web services, the security framework, and more Starts with the basics of JBoss AS and moves on to cover important advanced topics with the help of easy-to-understand practical examples Written in a very simple and readable style, this book includes essential tips and tricks that will help you master JBoss AS development
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.
Sommaire
396 pages,
1ère édition,
Décembre 2009
Éditions PackT Publishing,
ISBN10 : 1847196829,
ISBN13 : 978-1-847196-82-8 Commandez sur www.amazon.fr : 35.16 EUR TTC seulement (au lieu de 37.48 EUR TTC : prix éditeur) - Livraison Gratuite ! |
 |
Public visé : Débutants, Intermédiaires Résumé de l'éditeur
Ce livre sur la Business Intelligence (BI) avec SQL Server 2008 R2, s'adresse à tous les membres d'une équipe décisionnelle : chef de projet, architecte, développeur ETL, développeur de rapports, service Aide à la Maîtrise d'Ouvrage (AMO). Du débutant au technicien expérimenté, le lecteur bénéficiera d'une approche métier du décisionnel. Tout au long du livre, et très progressivement, l'auteur détaille les concepts clés du décisionnel puis les met concrètement en application. Ainsi, au cours des différents chapitres, le lecteur va utiliser les différents outils de la suite SQL Server pour bâtir progressivement un système décisionnel complet et professionnel. A chaque chapitre, le livre regorge de solutions concrètes et professionnelles et de bonnes pratiques. Le lecteur bénéficie des retours d'expérience de l'auteur pour finalement gagner en expertise sur les différentes étapes d'un projet décisionnel. Plus précisément, l'auteur propose de créer le système décisionnel d'une société virtuelle, Distrisys. Ce sera l'occasion pour le lecteur d'aborder les sujets suivants : - L'architecture des serveurs et le choix des licences - La modélisation de l'entrepôt de données - La conception du cube Analysis Services - La réalisation des différents types de flux d'alimentation ETL avec Integration Services - L'utilisation d'Excel et de PowerPivot pour exploiter les données décisionnelles - La réalisation de rapports opérationnels et décisionnels avec Reporting Services Les différentes solutions réalisées au cours du livre sont en téléchargement sur le site www.editions-eni.fr et sont directement exploitables dans des projets. Les chapitres du livre : Avant-propos - Introduction - Installation et découverte des outils SQL Server - Réaliser son premier système décisionnel - La modélisation dimensionnelle - Alimenter l'entrepôt de données avec SSIS - Restituer les données décisionnelles - Conclusion et perspectives
Cet ouvrage se décompose en sept chapitres et, comme le dit son auteur dans l'introduction, il s'adresse à "tous les membres d'une équipe".
Cela va donc du chef de projet aux développeurs en passant par l'architecte. Concernant les prérequis, une connaissance de SQL Server est nécessaire. SQL Server 2008 R2 et Office 2010 doivent être installés. Ce livre apporte une bonne première expérience dans la réalisation d'un système décisionnel, avec l'offre BI de Microsoft.
Le 1er chapitre présente rapidement les solutions qui composent l'offre BI de Microsoft : - SSIS (ETL) ; - SSMDS (MDM) ; - SSAS (OLAP) ; - SSRS (rapports) ; - Excel 2010 avec PowerPivot. Il présente également la société virtuelle Distrisys qui va servir de cas d'étude pour la réalisation d'un système décisionnel. L'auteur va au-delà du développement technique de la solution puisqu'il décrit le déroulement du projet, avec notamment la notion de mode itératif (avec des lots).
Le 2e chapitre détaille les différents environnements (développement, recette, intégration, production) qui constituent l'architecture d'un projet
et présente les outils SQL Server Management Studio et Business Intelligence Developpement Studio.
Le 3e chapitre aborde la création d'un entrepôt de données (une table de faits et plusieurs tables de dimensions associées), ainsi
que celle d'un cube à l'aide d'un projet Analysis Services sous BIDS.
Le 4e chapitre continue la mise en place de l'entrepôt de données suivant les domaines fonctionnels vente, stock et achat,
à l'aide d'Analysis Services. L'auteur propose ensuite de faire des requêtes sur le cube. C'est l'occasion de se familiariser
avec le langage MDX.
Le 5e chapitre concerne l'ETL, donc l'extraction et la transformation des données, depuis SSIS (SQL Server Integration Services).
Des fichiers Excel sont utilisés pour charger les budgets de vente dans l'entrepôt de données. Des flux de données sont développés
pour charger un sas de données, une dimension et une table de faits. L'audit des flux ETL est expliqué et mis en place avec la création
de plusieurs TABLES d'audit.
Le 6e chapitre, consacré à la restitution des données, utilise Excel 2010, PowerPivot et SQL Server Reporting Services pour manipuler
les données du cube : création de tableaux croisés dynamique depuis Excel et mise en forme, génération de rapports (paramétrés, avec graphiques, etc.)
avec SSRS mais aussi Report Builder, qui ne nécessite pas BIDS.
Le 7e et dernier chapitre est un très court chapitre (trois pages) dans lequel l'auteur récapitule rapidement ce qui a été vu dans les précédents
chapitres. Les capacités décisionnelles du serveur Sharepoint sont également évoquées.
Ce que j'ai le plus aimé : la possibilité de parcourir les chapitres de façon non chronologique puisque l'ON peut charger les données en base
à tout moment grâce aux scripts disponibles en téléchargement. Les exemples pertinents.
Ce que j'ai moins aimé : Rien à signaler.
Sommaire
422 pages,
1ère édition,
Juillet 2010
Editions ENI,
ISBN10 : 274605566X,
ISBN13 : 978-2746055667 |
 |
Public visé : Débutants, Intermédiaires Résumé de l'éditeur
Pour peu qu'on en maîtrise les pré-requis d'architecture, le framework GWT 2 met à la portée de tous les développeurs web la possibilité de créer des applications web interactives et robustes avec une productivité hors pair. Publié en licence libre Apache, Google Web Toolkit génère depuis Java du code JavaScript et HTML5/CSS optimisé à l'extrême. La référence sur GWT 2 : une autre façon de développer pour le Web La version 2 de GWT est une révolution en termes de productivité, de simplicité et de robustesse. C'est ce que montre cet ouvrage de référence sur GWT 2, qui fournit au développeur une méthodologie de conception et des bonnes pratiques d'architecture. Il détaille les concepts qui sous-tendent le framework pour en donner les clés d'une utilisation pertinente et optimisée : performances, séparation en couches, intégration avec l'existant, design patterns, sécurité... De la conception à l'optimisation et aux tests, toutes les étapes du développement sont déroulées, exemples de code à l'appui. S'adressant tant au développeur qu'à l'architecte, l'ouvrage dévoile les coulisses de chaque API au fil d'un cas d'utilisation simple et décortique les nouveautés de GWT 2.5 que sont MVP avec Activity & Places, RequestFactory, CellWidgets et Editor. A qui s'adresse cet ouvrage ? A tous les développeurs web (Java, PHP, Ruby, Python...) qui souhaitent industrialiser la création d'applications complexes ; Aux architectes logiciels, chefs de projets ou testeurs qui doivent comprendre l'intérêt de GWT ; A tous ceux qui voient en HTML5 et JavaScript un socle idéal pour l'exécution d'applications web.
Cette deuxième édition fait 21 chapitres (516 pages) alors que la première édition comptait 17 chapitres (461 pages).
Soit environ 50 pages supplémentaires. Elle prend en compte les nouveautés introduites depuis la version 2.0 jusqu'à la version 2.5. Les développeurs francophones peuvent certainement remercier l'auteur d'avoir mis à leur disposition un livre en français qui est aussi complet et à jour sur GWT. Chapitre 1 Le premier chapitre présente clairement la structure d'un projet GWT mais aussi les différents modes : mode développement et mode production. Avec une petite introduction à une nouveauté de la version 2.5 : le super DevMode. Chapitres 2 et 3 Dans le chapitre 2, j'ai apprécié l'honnêteté de l'auteur qui souligne dès le début "la simplicité et la sobriété" des widgets disponibles en standard dans le framework. Les principaux widgets sont passés en revue, avec exemples d'utilisation à l'appui (code Java et CSS, ainsi que des captures d'écran). Chapitre 4 Je pense que ce chapitre dresse un bon tour d'horizon des bibliothèques tierces (Sencha Ext-GWT, SmartGWT, GWT-DnD, GChart, GWT HighCharts) et des frameworks complémentaires (Vaadin entre autres). Chapitre 5 L'utilisation de JavaScript dans du code Java est étudiée de façon minutieuse dans ce chapitre : insertion de code JavaScript dans une méthode Java, intégration d'un fichier JavaScript externe, correspondance des types entre Java et JavaScript, etc. L'auteur fournit également des explications sur les types Overlay, plutôt méconnus. Chapitre 6 La création de composants personnalisés est souvent nécessaire dans un projet et ce livre ne manque pas d'y consacrer un chapitre entier. On y voit de façon détaillée la mécanique événementielle de GWT et le modèle de widget. Chapitre 7 Ce chapitre décrit les services RPC et dévoile les bonnes pratiques à mettre en place lors de leurs utilisations. Chapitre 8 Ce chapitre met l'accent sur l'intégration J2EE avec un exemple d'utilisation des EBJ 3 et de JPA. J'ai trouvé l'exemple pertinent et suffisamment illustré par du code. Chapitres 9, 10 et 11 Ces chapitres expliquent et décrivent amplement le chargement à la demande (code splitting), la liaison différée (deferred binding) et la gestion des ressources (API ClientBundle) à grand renfort de code, de rapports de compilation, de captures d'écran de navigateurs, etc. Chapitre 12 Ce chapitre rentre dans les entrailles de GWT : différentes facettes du compilateur, fichiers créés, réduction de code (pruning) et optimisations. Chapitre 13 Le mécanisme de l'internationalisation avec GWT est traité dans ce chapitre. L'auteur aborde et montre bien l'utilisation de l'API i18n, les dictionnaires, les messages, les conversions de types ainsi que l'outillage. Chapitre 14 Les tests ne sont pas délaissés puisqu'un chapitre entier y est dédié. On y voit l'utilisation de GWTTestCase, HTMLUnit et Selenium. Ce dernier framework est pas mal utilisé dans le chapitre, notamment pour l'écriture des tests fonctionnels (description de Selenium IDE et du module WebDriver). Enfin la notion de mocking n'est pas oubliée puisqu'elle est illustrée avec un exemple utilisant JMock et EasyMock. Chapitre 15 Ce chapitre sur les design patterns est à mon avis un des plus importants car il liste les bonnes pratiques d'architecture et de conception. Et à mon avis l'auteur a fait un très bon travail en fournissant pas mal de conseils : comment gérer la session, l'historique du navigateur, les traitements longs avec les classes Timer et Scheduler, les patterns Commande, MVC et MVP, etc. Chapitre 16 J'ai trouvé le chapitre dédié à UIBinder très exhaustif. On y voit la gestion des styles et ressources, l'incorporation des images, la gestion des évènements, le référencement de widgets composites à l'intérieur d'un widget composite... Chapitre 17 Un très court chapitre qui prend la peine de faire un tour d'horizon du plug-in Eclipse pour GWT. Je pense qu'il montre bien ses possibilités. Chapitre 18 Un chapitre est consacré aux composants CellWidget. J'ai bien apprécié la description et l'utilisation (nombreux extraits de code) du widget CellTable, très utilisé pour la création de tableaux. La documentation officielle de Google est très bonne sur le sujet mais des explications supplémentaires et de surcroît en français ne sont jamais de trop ! Chapitre 19 Enfin un chapitre dédié à l'API Activities and Places. À l'heure actuelle il existe encore peu d'ouvrages qui abordent en détail cette API et c'est un gros manque. Dans ce chapitre l'auteur explique longuement cette API complexe et l'illustre à l'aide d'un exemple et d'un schéma décrivant toute la chaîne d'exécution de l'API Activities and Places. Chapitres 20 et 21 Ces deux derniers chapitres concernent les API RequestFactory, AutoBean et Editors. Tous les deux sont bien riches en code, explications, conseils et avertissements ! J'ai aussi beaucoup apprécié l'apparition d'un chapitre entièrement dédié à Activities and Places. L'importance de ce framework dans le développement d'une application GWT mérite en effet un chapitre à lui tout seul et l'auteur a bien veillé à en inclure un mais a également produit un bel effort d'explications détaillées de cette API difficile pour la rendre plus compréhensible et plus assimilable. Je n'ai a posteriori noté qu'un seul manque dans ce livre : une présentation un peu plus détaillée du super dev mode, qu'on avait annoncé comme une nouveauté très intéressante de la version 2.5. Mais cette fonctionnalité est relativement neuve, notamment au moment de l'écriture de cette deuxième édition du livre. Sommaire
422 pages,
2ème édition,
Septembre 2012
Editions Eyrolles,
ISBN10 : 9782212134780,
ISBN13 : 978-2212134780 |
Voir également :
Tous les livres de DVP
Vos questions techniques : forum d'entraide Accueil - Publiez vos articles, tutoriels et cours
et rejoignez-nous dans l'équipe de rédaction du club d'entraide des développeurs francophones
Nous contacter - Hébergement - Participez - Copyright © 2000-2011 www.developpez.com - Legal informations.
et rejoignez-nous dans l'équipe de rédaction du club d'entraide des développeurs francophones
Nous contacter - Hébergement - Participez - Copyright © 2000-2011 www.developpez.com - Legal informations.