Les livres Java Web pour les Débutants

24 livres et 27 critiques, dernière mise à jour le 21 juin 2019 , note moyenne : 4.8

  1. Programmation GWT 2
  2. Apache Maven - Maîtrisez l'infrastructure d'un projet Java EE
  3. Développements n-tiers avec Java EE
  4. Les EJB 3 (avec Struts 2, JSF 2, JasperReports 3, Flex 3) - Développez pour le web par l'exemple : 3 applications détaillées
  5. JSF 2.0 Cookbook
  6. Apache Struts 2 - Web Application Development
  7. GWT - Créer des applications web interactives avec Google Web Toolkit (versions 1.7 et 2.0)
  8. Struts 2 - Le framework de développement d'applications Java EE
  9. Beginning Java™ EE 6 Platform with GlassFish™ 3 - From Novice to Professional
  10. Spring par l'exemple
  11. Pro Spring Dynamic Modules for OSGi Service Platforms
  12. Spring par la pratique - Spring 2.5 et 3.0
  13. Developing with Ext GWT - Enterprise RIA Development
  14. Professional Apache Tomcat 6
  15. JBoss in Action
  16. Struts 2 in Action - Donald Brown, Chad Michael Davis, Scott Stanlick
  17. Java EE - Guide de développement d'applications web en Java
  18. Head First Servlets and JSP
  19. Professional Java Development with the Spring Framework
  20. Développement Java sous STRUTS : Version 1.2
  21. Core JavaServer Faces
  22. Enjoying Web Development with Tapestry - Put the fun back into J2EE application development
  23. Initiation à JSP - Avec 50 exercices corrigés
  24. Jakarta Struts - par la pratique
couverture du livre Programmation GWT 2

Note 5 drapeau
Détails du livre
Sommaire
Critiques (2)
 
 

Programmation GWT 2

de
Public visé : Débutant

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.

Édition : Eyrolles - 516 pages , 2eédition, 13 septembre 2012

ISBN10 : 2212134789 - ISBN13 : 9782212134780

Commandez sur www.amazon.fr :

38.00 € TTC (prix éditeur 38.00 € TTC) livraison gratuite !
  • Introduction à GWT
  • Chapitre 1 : L'environnement de développment
  • Chapitre 2 : Les contrôles
  • Chapitre 3 : Le modèle de placement CSS
  • Chapitre 4 : Les bibliothèques tierces
  • Chapitre 5 : L'intégration de code JavaScript
  • Chapitre 6 : La création de composants personnalisés
  • Chapitre 7 : Les services RPC
  • Chapitre 8 : L'intégration J2EE
  • Chapitre 9 : Le chargement à la demande
  • Chapitre 10 : La liaison différée
  • Chapitre 11 : La gestion des ressources
  • Chapitre 12 : Sous le capot de GWT
  • Chapitre 13 : L'internationalisation
  • Chapitre 14 : L'environnement de tests
  • Chapitre 15 : Les design patterns GWT
  • Chapitre 16 : La création d'interfaces avec UIBinder
  • Chapitre 17 : Le plug-in Eclipse pour GWT
  • Chapitre 18 : Les composants CellWidget
  • Chapitre 19 : Activités et places
  • Chapitre 20 : L'API Request Factory
  • Chapitre 21 : L'API Editors
Critique du livre par la rédaction prenom nom le 24 juin 2013


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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


couverture du livre Apache Maven

Note 5 drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Apache Maven

Maîtrisez l'infrastructure d'un projet Java EE

de
Public visé : Débutant

Édition : ENI - 406 pages , 1re édition, 1er juin 2011

ISBN10 : 2746065096 - ISBN13 : 9782746065093

Commandez sur www.amazon.fr :

54.00 € TTC (prix éditeur 54.00 € TTC) livraison gratuite !
  • Préface
  • Avant-propos
  • Chapitre 1 : Présentation d'Apache Maven
  • Chapitre 2 : Définition et cycle de vie d'un projet
  • Chapitre 3 : Organisation et dépendances des projets
  • Chapitre 4 : Les artefacts pour Java EE et les profils Maven
  • Chapitre 5 : Apache Maven dans un contexte professionnel
  • Chapitre 6 : Rapports Maven et mesure de la qualité
Critique du livre par la rédaction longbeach le 9 janvier 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.


couverture du livre Développements n-tiers avec Java EE

Note 5 drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Développements n-tiers avec Java EE

de
Public visé : Débutant

Résumé de l'éditeur

Ce 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 louvrage précédent du même auteur « Java EE - Guide de développement d'applications Web en Java » paru aux Editions ENI. Ce nouvel ouvrage a pour objectif de présenter en détail et de façon exhaustive, toutes les étapes de réalisation dapplications Internet avancées en Java EE, à partir dun 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 second 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érentes 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 type 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. Lauteur 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 dapplications Web...).

Édition : ENI - 902 pages , 1re édition, 1er mars 2011

ISBN10 : 2746062631 - ISBN13 : 9782746062634

Commandez sur www.amazon.fr :

51.03 € TTC (prix éditeur 51.03 € TTC) livraison gratuite !
  • Chapitre 1 : La plate-forme JAVA EE
  • Chapitre 2: Le serveur Java EE GlassFish
  • Chapitre 3: La couche ou tiers Web
  • Chapitre 4: Java persistence API (JPA)
  • Chapitre 5: La couche ou tiers Métier
Critique du livre par la rédaction longbeach le 6 janvier 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.


couverture du livre Les EJB 3 (avec Struts 2, JSF 2, JasperReports 3, Flex 3)

Note 5 drapeau
Détails du livre
Sommaire
Critiques (1)
0 commentaire
 
 

Les EJB 3 (avec Struts 2, JSF 2, JasperReports 3, Flex 3)

Développez pour le web par l'exemple : 3 applications détaillées

de
Public visé : Débutant

Résumé de l'éditeur

Ce livre sur les EJB 3 s'adresse aux développeurs Java d'applications web travaillant sur les frameworks Struts 2, JSF 2 ou Flex 3. Le débutant comme l'expert trouveront les informations qui leur conviennent sur l'utilisation des EJB (Enterprise JavaBeans) de manière générale et les gains de productivité apportés par la version 3.

L'auteur propose le développement avec les EJB de trois applications web de vente en ligne aux fonctionnalités quasi identiques et qui sont basées sur des couches métier et persistance communes. À l'aide de l'IDE Eclipse et du serveur d'application JBoss 6, il exploite les fonctionnalités d'un container EJB pour :

  • mettre en place une couche de persistance basée sur les Entity beans, le langage JPQL et la Java Persistence API ;
  • créer des objets métiers à l'aide des Session beans et des Message-driven beans ;
  • définir une politique de sécurité avec une gestion des rôles et des permissions définie dans un fichier de propriétés, une base ou un annuaire LDAP ;
  • exposer des EJB 3 en tant que web services ;
  • mettre en place des traitements différés et ponctuels à l'aide des EJB Timers ;
  • faire de la programmation par aspect grâce aux Interceptors.

Tout au long des chapitres, l'auteur :

  • décrit et met en place les nouveautés incluses dans les dernières versions des frameworks Struts 2 et JSF 2 ;
  • détaille l'utilisation du framework GraniteDS pour réaliser la communication entre les objets Java et Flex 3 et créer une interface RIA ;
  • met en avant le framework open-source de reporting JasperReports et montre son utilisation avec les EJB, Struts 2 et JSF 2 pour créer des rapports graphiques.


Enfin, l'auteur décrit les apports de la toute dernière version des EJB, la version 3.1, qui a été finalisée en décembre 2009.

Les sources des applications sont en téléchargement sur le site www.editions-eni.fr et l'auteur continuera de les faire évoluer sur son site.

Édition : ENI - 370 pages , 1re édition, 1er juillet 2010

ISBN10 : 2746055678 - ISBN13 : 9782746055674

Commandez sur www.amazon.fr :

37.05 € TTC (prix éditeur 39.00 € TTC) livraison gratuite !
  • 1. Introduction
  • 2. L'application VenteEnLigne
  • 3. Les entity beans et l'API de persistance (JPA)
  • 4. Les sessions Beans
  • 5. Traitements des commandes avec les Message-Driven Beans
  • 6. Utilisation des WebServices
  • 7. Les EJBs Timer
  • 8. Les Interceptors
  • 9. Securité
  • 10. Struts 2
  • 11. Développement d'un client avec JSF 2
  • 12. Génération de rapports avec JasperReports
  • 13. Développement d'un client avec Flex 3
  • 14. Mise en place de l'environnement
  • 15. EJB 3.1 : les nouveautés avec Java EE 6
  • 13. Développement d'un client avec Flex 3
Critique du livre par la rédaction Hikage le 1er septembre 2010
Si vous souhaitez découvrir rapidement les EJB 3, ce livre est un excellent moyen de commencer.
À l'aide de capture d'écran et d'extrait de code source, il présente clairements les différents aspect de ceux-ci : la couche métier avec les Session Bean, la persistance avec JPA, la securité, les fonctionnalités transverses avec les interceptors ou encore l'interopérabilité par le biais des WebServices.

Mais le point fort de ce livre est qu'il ne porte pas uniquement sur les EJBs, mais aussi leur utilisation dans des projets avec des outils et frameworks qui ne sont pas forcément liés à ceux-ci au départ.
J'ai fort apprécié la section d'intégration de Flex et des EJBs par exemple, qui est très bien expliquée, ou encore l'intégration avec JasperReport. Ces sujets sont très spécifiques et donc très rarement traités, ce qui en fait une plus-value importante (du moins pour ceux qui s'y intéresse).

Le chapitre concernant la spécification JEE 6 est appréciable également afin de survoler rapidement les nouveautés de celle-ci.

Au niveau de la forme, le livre est bien écrit et assez aisé à suivre. Mon seul regret est de devoir de temps en temps jongler entre les pages, du fait des extraits de code parfois trop verbeux.

Public
Grâce à ses codes source très bien expliqués, ses fonds d'écrans explicites et des explications très facile à comprendre, ce livre est particulièrement bien adapté à des profils neophytes désirant découvrir les EJBs 3.




 Poster une réponse Signaler un problème

Avatar de Hikage Hikage - Rédacteur https://www.developpez.com
le 14/09/2010 à 8:59
Bonjour,

J'ai eu l'occasion de lire le livre Les EJB 3 (avec Struts 2, JSF 2, JasperReports 3, Flex 3), de Celinio Fernandes.

C'est un excellent livre francophone pour découvrir les EJBs simplement, et dans des cas pratiques d'interaction avec des fronts Web (JSF et Struts 2) ou RIA (Flex).

 
couverture du livre JSF 2.0 Cookbook

Note 5 drapeau
Détails du livre
Sommaire
Critiques (1)
0 commentaire
 
 

JSF 2.0 Cookbook

de
Public visé : Débutant

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

Édition : PackT Publishing - 396 pages , 1re édition, 1er juin 2010

ISBN10 : 1847199526 - ISBN13 : 9781847199522

Commandez sur www.amazon.fr :

34.26 € TTC (prix éditeur 36.06 € TTC) livraison gratuite !
  • Chapter 1: Using Standard and Custom Converters in JSF
  • Chapter 2: Using Standard and Custom Validators in JSF
  • Chapter 3: File Management
  • Chapter 4: Security
  • Chapter 5: Custom Components
  • Chapter 6: AJAX in JSF
  • Chapter 7: Internationalization and Localization
  • Chapter 8: JSF, Images, CSS, and JS
  • Chapter 9: JSF-Managing and Testing
  • Chapter 10: Facelets
  • Chapter 11: JSF 2.0 Features
  • Chapter 12: Mixing JSF with Other Technologies
  • Appendix: Configuring JSF-related Technologies
Critique du livre par la rédaction longbeach le 1er août 2010
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.




 Poster une réponse Signaler un problème

Avatar de longbeach longbeach - Rédacteur https://www.developpez.com
le 23/08/2010 à 10:52
Bonjour à tous,

les livres sur JSF 2.0 commencent à arriver. En voici un autre : JSF 2.0 Cookbook.

Je l'ai lu et j'ai plutôt été satisfait du contenu. Ma critique est disponible à cette adresse :

http://javaweb.developpez.com/livres/?page=Anglais#L9781847199522

Bonne lecture.

 
couverture du livre Apache Struts 2

Note 5 drapeau
Détails du livre
Sommaire
Critiques (1)
0 commentaire
 
 

Apache Struts 2

Web Application Development

de
Public visé : Débutant

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.

Édition : PackT Publishing - 360 pages , 1re édition, 1er juin 2009

ISBN10 : 1847193390 - ISBN13 : 9781847193391

Commandez sur www.amazon.fr :

24.29 € TTC (prix éditeur 25.76 € TTC) livraison gratuite !
[list][*]Chapter 1: Struts and Agile Development[*]Chapter 2: Basic Configuration[*]Chapter 3: Actions and ActionSupport[*]Chapter 4: Results and Result Types[*]Chapter 5: OGNL, the Value Stack, and Custom Tags[*]Chapter 6: Form Tags[*]Chapter 7: Form Validation and Type Conversion[*]Chapter 8: Interceptors[*]Chapter 9: Exceptions and Logging[*]Chapter 10: Getting Started with JavaScript[*]Chapter 11: Advanced JavaScript, the DOM, and CSS[*]Chapter 12: Themes and Templates[*]Chapter 13: Rich Internet Applications[*]Chapter 14: Comprehensive Testing[*]Chapter 15: Documenting our Application
[list]
Critique du livre par la rédaction longbeach le 1er juin 2010
Ce livre est composé de 15 chapitres. On peut considérer que les 9 premiers chapitres (205 pages) présentent les nouveautés de Struts 2 et le reste du livre est un mélange d'apprentissage de JavaScript/Ajax et de bonnes pratiques pour documenter et tester une application web.
Il repose sur la version 2.1.6 de Struts.
Les exemples du livre sont téléchargeables à l'adresse : http://www.packtpub.com/sites/defaul.../3391_Code.zip

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

English version :

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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




 Poster une réponse Signaler un problème

Avatar de longbeach longbeach - Rédacteur https://www.developpez.com
le 28/06/2010 à 8:15
Bonjour à tous,

un livre sympa sur Struts 2 existe, il s'appelle Apache Struts 2 - Web Application Development.

Je l'ai lu et ma critique, plutôt positive, est disponible à cette adresse :

http://javaweb.developpez.com/livres/?page=Anglais#L9781847193391

Bonne lecture.

 
couverture du livre GWT

Note 5 drapeau
Détails du livre
Sommaire
Critiques (2)
13 commentaires
 
 

GWT

Créer des applications web interactives avec Google Web Toolkit (versions 1.7 et 2.0)

de
Public visé : Débutant

Résumé de l'éditeur

Cet ouvrage s'adresse à tous les développeurs Java qui souhaitent découvrir ce nouvel outil créé par Google pour le développement web. Il intéressera également tous ceux qui utilisent déjà AJAX et JavaScript et qui souhaitent enrichir leurs compétences. Le principe de GWT est simple : " coder en Java, compiler en JavaScript ", et cette simplicité c'est aussi sa force. Ce livre est construit en deux parties : la première expose les bases qui permettent de comprendre GWT et de réaliser une application complète. Vous y trouverez toutes les informations utiles sur des éléments tels que les widgets et les mécanismes RPC de communication avec les serveurs. la deuxième explore les concepts avancés qui vous permettront d'élaborer des applications GWT plus sophistiquées, grâce aux possibilités d'internationalisation (i18n), d'envoi direct de requêtes HTTP, d'emploi de XML et JSON. Ce livre vous présente également les nouveautés et atouts de la version 2.0 de GWT : code splitting, OOPHM, UiBinder...

Édition : Dunod - 205 pages , 1re édition, 1er novembre 2009

ISBN10 : 2100531824 - ISBN13 : 9782100531820

Commandez sur www.amazon.fr :

23.76 € TTC (prix éditeur 25.00 € TTC) livraison gratuite !
  • De HTML à GWT
  • Hello, GWT
  • Développer avec GWT
  • Widgets
  • Communiquer avec le serveur
  • Internationalisation
  • Mécanismes avancés du compilateur
  • Le mécanisme d'historique de GWT
  • Envoyer des requêtes HTTP
  • Créer ses propres Widgets
  • Bibliothèques Tierces
  • GWT 2.0
Critique du livre par la rédaction Petrus le 1er février 2010
Lorsque Olivier m'a proposé de lire son bouquin, j'ai sauté sur l'occasion, ne connaissant pas du tout GWT sinon par quelques Hello John Doe !. De zéro ou presque donc, j'ai suivi sa présentation pragmatique, qui introduit les concepts principaux de GWT, et que l'on peut considérer comme un premier guide pour le développeur (francophone) qui souhaite se familiariser avec cette plateforme de développement made in Google.

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

J'ai aimé lire ce livre synthétique (200 pages) et très accessible, démystifiant GWT et proposant une bonne introduction au développement GWT. Merci Olivier pour cette agréable lecture !
Critique du livre par la rédaction prenom nom le 1er novembre 2009
Pour disposer d'un livre sur GWT dans leur langue, les développeurs francophones auront dû patienter trois ans. Cela peut paraître long mais cette attente s'avère finalement bénéfique. D'une part, Olivier Gérardin, l'auteur, a pu acquérir durant cette période suffisamment d'expérience sur divers projets réels pour maîtriser son sujet. D'autre part, GWT a gagné en maturité et c'est maintenant qu'il faut des ressources pour diffuser cette technologie au delà des early adopters. Le livre "GWT" d'Olivier Gérardin est en bonne voie pour être une de ces ressources.

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

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

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

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

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

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

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

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

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

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

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

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

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

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




 Poster une réponse Signaler un problème

Avatar de Ricky81 Ricky81 - Expert éminent sénior https://www.developpez.com
le 07/11/2009 à 9:24
GWT - Cr&eacute;er des applications web interactives avec Google Web Toolkit versions 1.7 et 2.0: Amazon.fr: Olivier G&eacute;rardin, Didier Girard: Livres@@AMEPARAM@@http://ecx.images-amazon.com/images/I/41zKb979h8L.@@AMEPARAM@@41zKb979h8L

25/11/2009

Bonjour,

Nous avons le plaisir de publier la critique de l'ouvrage par benwit :

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

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

(...)
Retrouvez la critique complète

Et bien sur n'hésitez pas à nous laisser vos impressions à la suite.

07/11/2009

Bonjour,

Olivier Gérardin va publier un livre francophone sur GWT 1.7 et 2.0 qui devrait sortir aux éditions Dunod vers le 18 novembre.

Au programme de ce livre de 224 pages :
  • De HTML à Java.
  • La révolution GWT.
  • Créer un premier projet GWT (installation, modification de l'interface, déploiement en mode web).
  • Construire l'interface graphique (les widgets, les panels, les styles CSS, les bibiothèques de composants).
  • Communiquer avec le serveur (principes de GWT RPC, test et debug). Maîtriser les concepts avancés (internationalisation, optimiser les transferts d'images, contrôler la compilation, les tests avec JUnit...).
  • Découvrir quelques bibliothèques tierces (Google Charts, ExtJS, ExGXT, Gwittir...).


Des ressources en ligne compléteront l'édition papier.

Êtes-vous intéressés ?

N'hésitez pas à poster vos commentaires à la suite, notamment pour ceux qui se pencheront sur le livre lors de sa sortie.
Avatar de mvvvv mvvvv - Membre averti https://www.developpez.com
le 07/11/2009 à 10:50
Il est vrai que les ressources sur GWT sont majoritairement anglophones

Ceci dit la version 2.0 se cherche encore je pense

+1
Avatar de vintz72 vintz72 - Membre actif https://www.developpez.com
le 09/11/2009 à 9:30
Je ne suis pas sur des projets Web ces temps-ci, mais si pour le prochain, j'ai l'occasion d'utiliser GWT, je serais tenter par ce genre de bouquin. C'est toujours utile d'avoir une référence sans connexion...
couverture du livre Struts 2

Note 5 drapeau
Détails du livre
Sommaire
Critiques (1)
11 commentaires
 
 

Struts 2

Le framework de développement d'applications Java EE

de
Public visé : Débutant

Résumé de l'éditeur

Ce livre sur Struts 2 s'adresse aux développeurs Java qui souhaitent disposer d'un ouvrage de référence, pour mettre en application le framework Java EE le plus répandu. L'ouvrage est décomposé en vingt-trois chapitres qui expliquent le fonctionnement du framewok, sa mise en place, chaque couche du modèle de conception MVC, l'utilisation des formulaires en passant par les plug-ins et le développement de résultats sans oublier la notion d'intercepteurs. Chaque concept est abordé de façon théorique et technique afin de permettre aux concepteurs disposant de connaissances en Java EE d'utiliser une API facilitant les développements d'applications web. Les applications utilisées dans les chapitres sont issus d'exemples concrets et sont téléchargeables sur le site de l'éditeur et sur la plate-forme de l'auteur www.gdawj.com.

Édition : ENI - 450 pages , 1re édition, 7 septembre 2009

ISBN10 : 2746050544 - ISBN13 : 9782746050549

Commandez sur www.amazon.fr :

37.05 € TTC (prix éditeur 39.00 € TTC) livraison gratuite !
  • Présentation
  • Modèle de conception MVC et Java EE
  • Commencer avec Struts 2
  • Gestion des traces et débogage
  • Gestion des actions
  • Bibliothèque de tag Struts
  • Messages et internationalisation
  • Validation des entrées
  • Gestion des types et conversions
  • Couche modèle et accès aux données
  • Gestion de l'upload ou chargement de données
  • Gestion du téléchargement de données
  • Gestion du téléchargement de données
  • Gestion des chargements de pages
  • Développer des intercepteurs
  • Développer des résultats
  • Gérer le double clic ou double envoi
  • Struts et Ajax JQuery
  • Les moteurs de templates
  • XSLT
  • Plug-ins Struts
  • Struts sans configuration
  • Annexe
Critique du livre par la rédaction X-plode le 1er septembre 2009
Comme le nom de l'ouvrage l'indique, Jérôme Lafosse nous livre au travers de plus de 400 pages, toutes les notions à connaître pour développer avec la nouvelle évolution du framework web Java Struts.

Dès les premières pages, nous avons un descriptif succinct des notions essentielles et de l'architecture MVC I et MVC II.
Cette attention particulière pour toute personne novice en la matière, lui permettrait de comprendre les explications données par la suite et pouvoir ainsi dès la fin du livre, développer ses propres applications web.

Les chapitres suivants détaillent chaque partie du framework allant du filtre à l'ajout et l'utilisation de plug-ins complémentaire à/ou déjà intégré dans le framework.

Enfin, Jérôme Lafosse conclut par une annexe recensant les différents intercepteurs.

Un apprentissage par l'exemple continu qui nous permet de voir l'évolution d'un code avec les différents acquis reçus au cours du chapitre, et qui démontre la valeur ajoutée de chaque partie tant sur le code que dans les exemples via les copies d'écran des résultats. Des explications claires et détaillées, qui nous permettent d'avoir deux utilisations du livre. La première serait pour l'apprentissage du langage et la seconde comme livre de référence pour le développement d'applications.
Il est très complet et couvre toutes les notions pour développer une application professionnelle en Struts 2 avec différentes librairies complémentaire comme JQuery pour l'utilisation d'Ajax, Velocity en tant que générateur de template ...

Enfin, la police et la mise en page permettent une lecture aisée et fluide.

Les points négatifs que je pourrais apporter sont : Au niveau de l'édition, nous avons un caractère récurrent (qui est <+>) qui pourrait dérouter les plus novices.
Enfin, on aurait apprécié un surlignage des modifications ou des lignes du code qui étaient rajoutées dans les exemples suivant l'explication.




 Poster une réponse Signaler un problème

Avatar de Ricky81 Ricky81 - Expert éminent sénior https://www.developpez.com
le 01/07/2009 à 23:40
[ame="http://www.amazon.fr/Struts-framework-d%C3%A9veloppement-dapplications-Java/dp/2746050544/wwwdeveloppec-21"]Struts 2 - Le framework de d&eacute;veloppement d&#39;applications Java EE: Amazon.fr: J&eacute;r&ocirc;me LAFOSSE: Livres@@AMEPARAM@@http://ecx.images-amazon.com/images/I/51cygy8ssnL.@@AMEPARAM@@51cygy8ssnL[/ame]

22/09/2009

Sorti il y a quelques semaines, nous vous proposons un premier retour sur l'ouvrage.

21/07/2009

En avant-première, l'auteur vous offre un extrait gratuit de l'ouvrage.
Il s'agit du chapitre introductif du livre, chapitre intitulé "Présentation".

http://jlafosse.developpez.com/livre.../presentation/

L'ouvrage sortira aux éditions ENI en septembre et sera également disponible à la commande en format numérique (lequel sera offert pour l'achat du format papier).
Pour en savoir plus

01/07/2009

Bonsoir,

Ce livre sur Struts 2 s'adresse aux développeurs Java qui souhaitent disposer d'un ouvrage de référence, pour mettre en application le framework Java EE le plus répandu. L'ouvrage est décomposé en vingt-trois chapitres qui expliquent le fonctionnement du framework, sa mise en place, chaque couche du modèle de conception MVC, l'utilisation des formulaires en passant par les plug-ins et le développement de résultats sans oublier la notion d'intercepteurs. Chaque concept est abordé de façon théorique et technique afin de permettre aux concepteurs disposant de connaissances en Java EE d'utiliser une API facilitant les développements d'applications web. Les applications utilisées dans les chapitres sont issus d'exemples concrets et sont téléchargeables sur le site de l'éditeur et sur la plate-forme de l'auteur www.gdawj.com.
Table des matières :

Chapitre 1 : Présentation
Chapitre 2 : Modèle de conception MVC et Java EE
Chapitre 3 : Commencer avec Struts 2
Chapitre 4 : Gestion des traces et débogage
Chapitre 5 : Gestion des actions
Chapitre 6 : Bibliothèques de tags Struts
Chapitre 7 : Messages et internationalisation
Chapitre 8 : Validation des entrées
Chapitre 9 : Gestion des types et conversion
Chapitre 10 : Couche modèle et accès aux données
Chapitre 11 : Gestion de l'upload ou chargement des données
Chapitre 12 : Gestion du download ou téléchargement de données
Chapitre 13 : Gestion des chargements de pages
Chapitre 14 : Développer des intercepteurs
Chapitre 15 : Développer des résultats
Chapitre 16 : Gérer le double-clic ou double envoi
Chapitre 17 : Struts et Ajax JQuery
Chapitre 18 : Les moteurs de templates
Chapitre 19 : XSLT
Chapitre 20 : Plug-ins Struts
Chapitre 21 : Struts sans configuration
Chapitre 22 : Annexes
Qu'en pensez vous ? Certains vont-ils l'acheter ?

Voir aussi :
Mise à disposition gratuite du projet BetaBoutique Struts 2, par Jérôme Lafosse
[Livre] Extraits gratuits de "Java EE - Guide de développement d'applications web en Java" par Jérôme Lafosse !
Commandez chez ENI
Avatar de Bakann Bakann - Nouveau membre du Club https://www.developpez.com
le 02/07/2009 à 11:10
Il n'y a pas de sommaire consultable?
Avatar de ruscov ruscov - Membre confirmé https://www.developpez.com
le 02/07/2009 à 11:25
Pour ma part cela fait +-2 ans que je travaille avec Struts 2 et leur site m'a amplement suffit pour démarrer.
De plus il y a déjà pas mal de bouquin qui traite du sujet.
Le seul avantage que j'y vois c'est pour ceux qui sont nuls en anglais.
Mais c'est mon avis perso.
couverture du livre Beginning Java™ EE 6 Platform with GlassFish™ 3

Note 5 drapeau
Détails du livre
Sommaire
Critiques (1)
0 commentaire
 
 

Beginning Java™ EE 6 Platform with GlassFish™ 3

From Novice to Professional

de
Public visé : Débutant

Résumé de l'éditeur

Sun's enterprise Java? 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 GlassFish? 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.

Édition : Apress - 500 pages , 1re édition, 1er mai 2009

ISBN10 : 1430219548 - ISBN13 : 9781430219545

Commandez sur www.amazon.fr :

31.39 € TTC (prix éditeur 35.83 € TTC) livraison gratuite !
[list][*]Chapter 1 Java EE 6 at a Glance.[*]Chapter 2 Java Persistence.[*]Chapter 3 Object-Relational Mapping.[*]Chapter 4 Managing Persistent Objects.[*]Chapter 5 Callbacks and Listeners.[*]Chapter 6 Enterprise Java Beans.[*]Chapter 7 Session Beans and the Timer Service.[*]Chapter 8 Callbacks and Interceptors.[*]Chapter 9 Transactions and Security.[*]Chapter 10 JavaServer Faces.[*]Chapter 11 Pages and Components.[*]Chapter 12 Processing and Navigation.[*]Chapter 13 Sending Messages.[*]Chapter 14 SOAP Web Services.[*]Chapter 15 RESTful Web Services
[list]
Critique du livre par la rédaction longbeach le 1er août 2009
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.




 Poster une réponse Signaler un problème

Avatar de longbeach longbeach - Rédacteur https://www.developpez.com
le 16/08/2009 à 16:40
Bonjour,
le deuxième livre d'Antonio Goncalves, co-fondateur du JUG de Paris et récemment élu Java Champion, est sorti il y a environ
3 mois.
Le titre est Beginning Java EE 6 Platform with GlassFish 3, From novice to professional, aux editions Apress.

Comme le titre l'indique, le livre est consacré à Java EE 6 en général et aux EJB 3.1, JSF 2.0 et Web Services (SOAP et Restful) en particulier, avec
GlassFish 3 comme serveur d'application.
Vous pouvez lire ma critique ici :

http://java.developpez.com/livres/?page=Anglais#L9781430219545

 
couverture du livre Spring par l'exemple

Note 4.5 drapeau
Détails du livre
Sommaire
Critiques (1)
5 commentaires
 
 

Spring par l'exemple

de

Résumé de l'éditeur

Spring représente le framework applicatif Java EE le plus simple et le plus puissant que j'aie jamais utilisé. Depuis l'inversion de contrôle et la programmation orientée aspect à la persistance, les transactions, le design pattern MVC, les tests et autres, ce livre explique comment tirer profit de Spring au travers d'exemples de code détaillés. Ces exemples vont du scan de composants dans le chemin d'accès aux classes au test unitaire des contrôleurs Spring MVC. Spring propose des solutions simples à des problèmes difficiles. Cette simplicité a été également mon premier objectif dans la conception de cet ouvrage. J'ai souhaité trouver un équilibre entre l'étendue des sujets traités, le niveau de détail, la rapidité d'apprentissage et les connaissances requises. Chaque chapitre explore un sujet important au travers d'un exemple réel complet. Lors de la première lecture d'un chapitre, je vous recommande de suivre l'exemple de manière séquentielle. Ensuite, vous pouvez vous en servir comme référence en examinant la liste des problèmes-solutions. Si vous cherchez à résoudre un problème précis, vous pouvez aller directement aux solutions dont vous avez besoin en consultant la table des matières ou l'index.

Édition : Pearson Education - 510 pages , 1re édition, 1er mai 2009

ISBN10 : 2744023396 - ISBN13 : 9782744023392

Broché

Commandez sur www.amazon.fr :

39.09 € TTC (prix éditeur 42.00 € TTC)
  • A propos de l'auteur
  • Introduction
  • Inversion de contrôle et conteneur
  • Introduction au framework Spring
  • Configuration des beans
  • Fonction élaborées du conteneur Spring IoC
  • Proxy dynamique et Spring AOP classique
  • Spring 2.x AOP et prise en charge d'AspectJ
  • Prise en charge de JDBC
  • Gestion des transactions
  • Prise en charge de l'ORM
  • Framework Spring MVC
  • Intégration avec d'autres frameworks web
  • Prise en charge des tests unitaires
  • Index
Critique du livre par la rédaction Baptiste Wicht le 1er juillet 2009
Ce livre est une excellente introduction à Spring. En effet, il va explorer les différents concepts de Spring en allant chaque fois un peu plus loin. Après avoir lu ce livre, on maitrise les principales fonctionalités du framewok Spring. Chaque chapitre du livre traite d'un concept spécifique de Spring. Chacun des chapitres est découpé en sous-chapitres se basant sur une série de problèmes/solutions, ce qui se révèle très pratique pour retrouver des informations par la suite.

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

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

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

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

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

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




 Poster une réponse Signaler un problème

Avatar de Baptiste Wicht Baptiste Wicht - Expert éminent sénior https://www.developpez.com
le 31/07/2009 à 16:31
Je viens de terminer ma lecture de Spring par l'exemple.

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

[...]

En conclusion, ce livre vous permettra de commencer à développer des applications basées sur Spring et de découvrir la puissance de ce framework. La seule critique que je peux faire par rapport à ce livre est la longueur des chapitres Spring MVC et frameworks web. Pour moi qui suis plutôt orientés applications Desktop, j'aurais préféré aller plus loin dans certains chapitres ou explorer d'autres fonctionnalités de Spring telles que la validation, le scheduling/pooling de threads ou le support de langages dynamiques dans la configuration des beans.
Vous pouvez lire la critique complète sur notre page livres : http://java.developpez.com/livres/?p...L9782744023392

Voilà
Avatar de kmdkaci kmdkaci - Membre éprouvé https://www.developpez.com
le 03/08/2009 à 10:47
Bonjour,
Merci pour la critique. Juste une suggestion, ça aurait été mieux de mettre l'annonce dans la rubrique Accueil, afin de présenter l'aspect technique du site, autre que celui des news.
Avatar de Ricky81 Ricky81 - Expert éminent sénior https://www.developpez.com
le 03/08/2009 à 15:44
Citation Envoyé par kmdkaci Voir le message
Bonjour,
Merci pour la critique. Juste une suggestion, ça aurait été mieux de mettre l'annonce dans la rubrique Accueil, afin de présenter l'aspect technique du site, autre que celui des news.
Salut,

Les critiques de livres n'intéressent pas tout le monde (preuve en est le nombre de lus sur http://java.developpez.com/ ) et encore moins les non Javaïste lisant l'index général http://www.developpez.com/ Ceci explique cela

 
couverture du livre Pro Spring Dynamic Modules for OSGi Service Platforms

Note 3.5 drapeau
Détails du livre
Sommaire
Critiques (1)
4 commentaires
 
 

Pro Spring Dynamic Modules for OSGi Service Platforms

de

Résumé de l'éditeur

Spring and OSGi's features are a natural fit; they are orthogonal to each other: OSGi is about packaging, deployment, and versioning issues, while Spring is about providing the necessary foundation to wire up Java classes in their most basic form using dependency injection and aspect orientation to fulfill an application's purpose.

Pro Spring Dynamic Modules for OSGiT Service Platforms by Daniel Rubio is the first book to cover OSGi as practically implemented by the world's most popular, agile, and open source enterprise Java framework, Spring.

  • Author Daniel Rubio covers the ease at which OSGi is used with the Spring Framework in development, packaging, versioning, and deployment.
  • Enterprises are trusting Spring more and more, and this book leverages OSGi in a way that can "complete" the use of Spring in the enterprise, as OSGi is already being trusted and adopted by IBM, BEA, and others.
  • The text discusses how Spring OSGi makes your Spring applications trusted SOA applications.


What you'll learn?
  • Understand the fundamentals of OSGi and Spring, and combine the two.
  • Take your Spring applications and bundles, and incorporate OSGi for production-ready packaging, versioning practices, and deployment.
  • Create production-ready Spring Beans by packaging and versioning, and then deploy them.
  • Develop data access methods and means for your Spring OSGi projects.
  • Build and use GUIs for Spring OSGi.
  • Test, scale, and optimize your Spring OSGi applications for deployment and performance.

Édition : Apress - 392 pages , 1re édition, 1er février 2009

ISBN10 : 1430216123 - ISBN13 : 9781430216124

Broché

Commandez sur www.amazon.fr :

33.74 € TTC (prix éditeur 37.43 € TTC)
  • Introducing OSGi
  • Introducing Spring
  • Integrating Spring and OSGi
  • Spring Dynamic Modules for OSGi
  • SpringSource dm Server
  • Versioning with OSGi and Spring
  • Data Access and Bundle Management Without SpringSource dm Server
  • Web Applications Using Spring and OSGi
  • Testing with Spring and OSGi
Critique du livre par la rédaction Hikage le 1er juillet 2009
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.




 Poster une réponse Signaler un problème

Avatar de Hikage Hikage - Rédacteur https://www.developpez.com
le 05/07/2009 à 18:06
En début d'année, Apress a publié l'un des tout premiers livres concernant OSGi, et en particulier Spring Dm, le projet du porfolio Spring dédié à rendre OSGi accessible à tout le monde : Pro Spring Dynamic Modules for OSGi Service Platforms

Est-ce que certains d'entre vous l'ont lu ? Si oui, qu'en pensez-vous ?

Pour ma part, je le trouve excellent comme introduction à OSGi, Spring dm et tout ce qui tourne autour.

Cependant, des personnes plus expérimentées seront peut etre déçues. En effet, pour un livre de la collection "Pro", on reste un peu sur sa faim.
Du moins, c'est mon avis.

Et vous ?
Avatar de blacktitanium42 blacktitanium42 - Futur Membre du Club https://www.developpez.com
le 29/08/2009 à 1:39
Oui moi aussi je ai commencé à le lire ,pour le moment je suis un peu déçu par livre.

La lecture du livre n est pas facile , il faut être vraiment concentré pour ne pas décrocher au bout de 30 minutes.

De plus les exemples avec ant ,pas très pratique je trouve .il aurait pu trouver mieux

pour ceux qui ont testé les exemples du livre ,il y a des problèmes lors des chargements des bundles .

je vais continuer qu'en même pour voir ce que ça donne par la suite.
Avatar de ego ego - Rédacteur https://www.developpez.com
le 11/11/2009 à 15:20
j'ai lu ça dernièrement.
Le livre est pas trop mal mais en fait, OSGI ce n'est pas si compliqué que ça alors il n'y a pas trop de truc à dire sur les aspects techniques.
Ce qui est vraiment "chiant" c'est la gestion de dépendances à la fois dans le bundle et côté processus de fabrication (le build).
Le gars explique pas mal le fonctionnement de Ivy mais je pense qu'un chapitre plus théorique sur cet aspect "build" et gestion des numéros de version serait pas mal.
Ouhai, les numéros de version on en a dans plein de fichiers, comment optimiser tout ça !?!

Donc oui le livre vaut le coup d'être lu mais voilà, OSGI c'est pas compliqué alors on n'en ressort pas avec la même impression qu'en ayant lu "Pro Spring" par exemple.

 
couverture du livre Spring par la pratique

Note 4.5 drapeau
Détails du livre
Sommaire
Critiques (2)
11 commentaires
 
 

Spring par la pratique

Spring 2.5 et 3.0

de

Résumé de l'éditeur

Cet ouvrage montre comment développer des applications Java EE professionnelles performantes à l'aide du framework Spring. L'ouvrage présente les concepts sur lesquels reposent Spring (conteneur léger, injection de dépendances, programmation orienté aspect) avant de détailler les différentes facettes du développement d'applications d'entreprise avec Spring : couche présentation, persistance des données et gestion des transactions, intégration avec d'autres applications et sécurité applicative.

Cette seconde édition présente en détail les nouveautés majeures des versions 2.5 et 3.0 de Spring et de ses modules annexes : modèle de programmation basé sur les annotations, Spring Dynamic Modules for OSGi, Spring Batch, Spring Security, SpringSource dm Server, etc. L'accent est mis tout particulièrement sur les bonnes pratiques de conception et de développement, qui sont illustrées à travers une étude de cas détaillée, le projet Open Source Tudu Lists.

Édition : Eyrolles - 658 pages , 2eédition, 1er janvier 2009

ISBN10 : 221212421X - ISBN13 : 9782212124217

Broché

Commandez sur www.amazon.fr :

42.75 € TTC (prix éditeur 45.00 € TTC) livraison gratuite !
  • Avant-propos
  • Introduction à Spring
  • Partie 1 : Les fondations de Spring
    • Le conteneur léger de Spring
    • Concepts avancés du conteneur Spring
    • Les concepts de la POA
    • Spring AOP
    • Test des applications Spring
  • Partie 2 : Les frameworks de présentation
    • Spring MVC
    • Spring WebFlow
    • Utilisation d'Ajax avec Spring
  • Partie 3 : Gestion des données
    • Persistance des données
    • Gestion des transactions
    • Support des technologies JMS et JCA
  • Partie 4 : Technologies d'intégration
    • Spring Web Services
    • Spring Security
    • Spring Batch
  • Partie 5 : Spring en production
    • Spring Dynamic Modules
    • Spring DM Server
    • Supervision avec JMX
Critique du livre par la rédaction Eric REBOISSON le 1er janvier 2010
N'ayant pas eu la chance de critiquer la première édition de "Spring par la pratique", c'est avec joie et grand intérêt que j'ai accueilli le facteur m'apportant cette seconde édition. Pour la petite histoire, j'ai suivi la formation Spring Core en 2008, dispensée par Julien Dubois, co-auteur sur cet ouvrage et j'ai eu comme compère de formation Gildas Cuisinier, relecteur de ce second opus, 4 jours aussi intéressants que ce présent ouvrage.
Le livre commence donc par la pédagogie nécessaire autour des concepts Spring (conteneur léger, inversion de contrôle (IOC), injection de dépendance, AOP (Aspect Oriented Programmation, POA en français pour programmation orientée aspect)) puis la suite est un savant mélange de théorie permettant au lecteur de comprendre correctement les concepts de Spring (et pourquoi ceux-ci existent) et de pratique via la mise en ouvre de cas concrets extraits de l'application fil rouge Tudu List.
On appréciera au fil des chapitres suivants l'exhaustivité de la couverture du portofolio Spring : Spring AOP, Spring Batch, Spring MVC, Spring Web Flow… Il appartient ensuite au lecteur d'utiliser ce qui lui paraîtra nécessaire dans ses applications. A noter qu'il faut un minimum de connaissances sur les frameworks et concepts (où du moins en connaître les principes majeurs) auxquels s'adresse Spring (Hibernate, GWT, JMS, Webservices…) même ci ceux-ci sont très bien introduits dans le livre, ne serait-ce que pour comprendre ce qu'apporte Spring couplé à ces éléments.
Mon avis sur "Spring par la pratique" :

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


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


Nous avons donc là un excellent ouvrage en français sur Spring, clair et détaillé, pédagogique et très complet que je conseille aux curieux désireux de connaître Spring mais aussi aux confirmés qui trouveront dans ce livre les nouveautés du portofolio Spring.
Critique du livre par la rédaction Hikage le 1er juin 2009
Spring par la pratique, première édition, fut un excellent livre sur Spring et son portfolio. A sa sortie, il couvrait directement Spring 2.0, fraichement sorti à l'époque. Mais l'eau a coulé sous les ponts et le livre est devenu un peu désuet de par les nouveautés de Spring 2.5 et 3.0 ou encore l'arrivée de projet tels que Spring Dm ou Spring Batch.. C'est là qu'intervient la nouvelle édition, couvrant justement ceux-ci, alors que Spring 3.0 n'est pas encore officiellement sorti.
Sur la forme, le livre garde le même style que l'ancienne édition, chaque chapitre étant divisé en deux parties. La première étant une présentation théorique d'un sujet, la deuxième étant sa mise en pratique dans un exemple concret ( le même qu'auparavant : Tudu List ). Concernant le contenu par contre, les changements sont majeurs, allant de grosse mises à jour à de nouveaux chapitres complets.

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

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

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




 Poster une réponse Signaler un problème

Avatar de Hikage Hikage - Rédacteur https://www.developpez.com
le 23/06/2009 à 21:18
18/08/2009

Suite à la sortie de Spring 3.0 M4, Arnaud Cogoluègnes propose un complément au livre, concernant deux nouveautés de cette version :
  • le namespace jdbc
  • le namespace task


Pour plus d'information, je vous invite à visiter la page des compléments

23/06/2009

Trois ans après la première édition, le tout premier livre francophone sur Spring et son portfolio se voit être mis à jour.

Et comme pour la première fois, ce livre couvre des sujets inédits comme Spring Dm et la technologie OSGi, ou le nouveau serveur Spring Dm Server permettant de tirer parti de cette dernière.

Mais ce n'est pas tout, il est l'un des tout premiers livres à couvrir Spring 3.0 ( toute langues confondues, ce qui n'est pas rien ! ). Pour rappel, cette version n'est pas encore officiellement sortie.

D'autres sujets ont de leur coté été mis à jour, c'est le cas de Spring MVC, se basant maintenant sur le jeu d'annotations ou le nouvellement nommé Spring Security, successeur de Acegi.
Spring Batch fait aussi parti des sujets traités.

Bref, un pur bonheur pour ceux qui ne connaissent pas Spring, mais aussi un excellent livre pour ceux utilisant Spring 2.0 et voulant se remettre à niveau.

Quelques informations :

Sortie eBook : 23 Juin 2009, disponible sur izibook
Sortie papier : le 7 juillet 2009

Critique du livre, en avant première

Bonne lecture
Avatar de irnbru irnbru - Membre averti https://www.developpez.com
le 11/08/2009 à 10:08
J'ai pris le livre, il n'est pas mal surtout en termes d'explications. Par contre la présence du code est plutôt légère. Je préfère les explications au code mais un minimum de code complet serait cool. Remarque que je n'ai lu que deux chapitres. Mais plutôt okay comme livre. Je vous tiendrais au courant au fur à mesure de l'avancement de mon exploration.

Cheers,
IRNBRU
Avatar de Hikage Hikage - Rédacteur https://www.developpez.com
le 11/08/2009 à 11:18
En même temps, il y a une application complète diposnible sur
http://www.springparlapratique.org
couverture du livre Developing with Ext GWT

Note 5 drapeau
Détails du livre
Sommaire
Critiques (1)
6 commentaires
 
 

Developing with Ext GWT

Enterprise RIA Development

de
Public visé : Débutant

Résumé de l'éditeur

Developing in Ext GWT is a fast?paced, practical guide to quickly learning the tasks necessary in building enterprise?class Rich Internet Applications. Based around the exciting new UI library from Ajax leaders Ext JS and the latest GWT release, this book takes the reader through setup, the available widgets, and advanced custom widgets and templates, and concludes with a functional sample client?server application in less than 150 pages. Not your typical beginner's guide to programming, this book provides a rapid approach to becoming effective with leading commercial RIA tools and libraries.

[list][*]A practical approach to enterprise RIA development using industry-proven tools.[*]Full coverage of the new Ext GWT 2.0 widget library based on GWT 1.6[*]Designed for professional developers needing a quick, no-nonsense overview of the initial requirements to get started, ending with an example client-server application
[list]

Édition : Apress - 141 pages , 1re édition, 1er mai 2009

ISBN10 : 1430219408 - ISBN13 : 9781430219408

Commandez sur www.amazon.fr :

0.00 $ TTC (prix éditeur 19.99 $ TTC)
[list][*]Présentation de Ext GWT et GWT[*]Organisez votre environnement[*]Des composants, des composants, partout ![*]Composants avancés[*]Travailler avec des données[*]Un exemple concret
[list]
Critique du livre par la rédaction prenom nom le 1er juin 2009
Ce livre s'adresse aux développeurs Java qui veulent rapidement développer une application Web riche en utilisant la librairie Ext-GWT.

Le point fort des ouvrages de cette collection, c'est de suivre l'évolution technologique au plus près. Celui-ci ne déroge pas à la règle et utilise les librairies GWT et Ext-GWT dans leurs dernières versions. Pour GWT, c'est la 1.6 et pour Ext-GWT, c'est la 2.0 (encore au stade M2). Si vous envisagez de l'acheter, c'est donc le moment !

Ce livre a une approche didactique classique, il commence par une présentation générale, explique comment installer cette librairie, présente les composants simples et avancés et termine avec un exemple concret.

Le premier chapitre présente à la fois les librairies Ext-GWT et GWT. Comme le sujet de ce livre est Ext-GWT, c'est d'abord elle qui est présentée. On sent bien que cette librairie n'est qu'une sur couche de GWT car l'auteur a beaucoup plus de généralités à dire sur GWT. Si cette présentation de GWT ne remplace pas un livre dédié, elle en demeure néanmoins un bon résumé.

Le deuxième chapitre est un tutoriel très pratique qui vous explique comment configurer un environnement de développement Ext-GWT sous eclipse et comment commencer une première application. L'auteur a semble t'il préféré le côté didactique des batchs de GWT à la simplicité du plugin Eclipse-GWT.

Les troisième et quatrième chapitres présentent les composants de la librairie, des plus simples ou plus avancés. La présentation est progressive et la lecture facile. Quelques captures d'écran et exemples de code viennent compléter les explications.

Le cinquième chapitre présente les composants Ext-GWT qui font le lien entre les widgets graphiques et le serveur. Comme la librairie, l'auteur fait le choix du "full gwt" et ne traite donc que du mode RPC de GWT. Ne cherchez donc pas dans ce livre d'exemple d'échanges de données avec XML ou JSON, vous n'en trouverez pas !

Le sixième et dernier chapitre se veut être un exemple concret qui reprend un peu tout ce qui a été présenté dans les chapitres précédents. Bien que synthétique, il apporte également les quelques informations complémentaires nécessaires à la construction d'une application réelle.

Avant de lire ce livre, j'avais réalisé des applications Ext-GWT en utilisant tous les composants qu'elle propose. L'avantage pour vous, c'est que j'ai pu écrire une meilleure critique vis à vis de ce que dit ou ne dit pas l'auteur ! L'inconvénient pour moi, c'est que du coup, ce livre m'a un peu laissé sur ma faim ... Il faut croire que je ne suis pas la cible !

Ceci dit, ce qui est super dans ce livre, c'est toutes les remarques, trucs et astuces qu'il recèle. J'ai été agréablement surpris de voir qu'il dresse tous les pièges dans lesquels je suis tombé moi-même. Je le recommande donc principalement à ceux qui veulent écrire leur première application avec Ext-GWT.

English version :

This book is intended for Java developers who want to quickly develop a rich web application using GWT-Ext library.

The particularity of this collection is to follow technological developments as closely as possible. This book is not an exception to the rule and uses GWT and GWT-Ext in their latest versions (GWT is 1.6 and GWT-Ext is 2.0). If you plan to buy, so this is the moment !

This book has a didactic style, it begins with an overview, how to install this library, introduces the simple and advanced components and ends with a concrete example.

The first chapter describes both GWT-Ext and GWT. Since the topic of this book is Ext-GWT, author begins with it. We can see that this library is a layer of GWT because the author has much more to say about general GWT. If this presentation of GWT does not replace a book dedicated, it remains a good summary.

The second chapter is a useful tutorial that explains how to configure a development environment GWT-Ext in Eclipse and how to start a first application. The author seems to prefer the didactic GWT batches to the simplicity of the GWT Eclipse-plugin.

The third and fourth chapters gradually introduces the components of the library, from the simplest to the more advanced one. The presentation is progressive and easy reading. Some screenshots and code examples complement the explanations.

The fifth chapter describes the GWT-Ext components which link the graphical widgets to the server components. As the library does, the author decided to follow a "full GWT" way and therefore does only cover the GWT RPC mode. Do not try to find in this book an example of data exchange with XML or JSON, you won't find any !

The sixth and final section provides a concrete example which aims to sumamarize all the things presented in previous chapters. Although synthetic, it also provides some additional information needed to build a real application.

Before reading this book, I had built GWT-Ext applications, using all the Ext components. The benefit to you is that I could write a better review with respect to what is said or not by the author! The downside for me is that suddenly, I'm left wanting more ... Must believe that I am not the target !

What is great in this book is all the comments, tips and tricks it contains. I was pleasantly surprised to see that it gives all the traps in which I fall myself. I therefore recommend mainly to those who want to write their first application with GWT-Ext.




 Poster une réponse Signaler un problème

Avatar de Ricky81 Ricky81 - Expert éminent sénior https://www.developpez.com
le 21/06/2009 à 11:03
Bonjour,

Avez vous des retours d'expériences sur les livres GWT disponibles en librairies ?

Un petit inventaire (non nécessairement exhaustif) :


Ais-je bien cherché ? Pas encore de livre francophone sur le sujet ?
Avatar de benwit benwit - Rédacteur https://www.developpez.com
le 22/06/2009 à 7:44
Il faudrait distinguer les livres spécifiques à GWT (tous ceux cités sauf un) de ceux spécifiques à une surcouche de GWT (Le livre sur Ext-GWT).

Il pourrait être également intéressant de les trier par ordre de parution / version de GWT car GWT évoluant très vite, certains expliquent des trucs qui n'ont plus lieu d'être.

Eh non, rien en français pour l'instant ... Des éditeurs seraient partant ?
Avatar de Louhike Louhike - Membre habitué https://www.developpez.com
le 22/06/2009 à 21:47
J'ai acheté "GWT in action" sur Amazon et je suis très satisfait. Le livre n'est pas super récent donc c'est une ancienne version de GWT mais ça ne m'a pas gêné pour l'instant.
Par contre, le premier chapitre du livre est un peu confus pour un débutant et j'ai eu un peu de mal à tout suivre, mais dès le chapitre 2 ça allait mieux.
Donc j'aurais tendance à le recommander, d'autant que j'ai vu plusieurs critiques qui le considéraient comme un des plus intéressants parmi les livres sur GWT.
Il faut par contre avoir déjà des notions légères de Java évidemment, le but étant d'apprendre GWT, pas le langage qu'il utilise.

 
couverture du livre Professional Apache Tomcat 6

Note 5 drapeau
Détails du livre
Sommaire
Critiques (1)
3 commentaires
 
 

Professional Apache Tomcat 6

de
Public visé : Débutant

Résumé de l'éditeur

Tomcat is the official reference implementation of Sun's servlet and JSP specifications, and Java developers must test all Web applications on Tomcat to ensure they work as designed

Boasting more than 40 percent new and updated material, this book covers all the major new features affecting server administration and management

Explores the additional built-in tools of Tomcat, which help Java developers program more efficiently, and looks at how Apache's other open source servlet/JSP technologies are designed to work with Tomcat

Features full coverage of Release 6, which supports the latest JSP and servlet specifications: JSP 2.1 and Servlets 2.5

Addresses solving real-world problems encountered during all phases of server administration, including managing class loaders and connectors, security, shared hosting and clustering, and system testing

Édition : WRox Professional - 629 pages , 1re édition, 1er août 2007

ISBN10 : 0471753610 - ISBN13 : 9780471753612

Commandez sur www.amazon.fr :

30.48 € TTC (prix éditeur 31.46 € TTC) livraison gratuite !
[list][*]Apache Tomcat[*]Web Applications: Servelets, JSPs, and More.[*]Tomcat installation[*]Tomcat Architecture.[*]Basic Tomcat Configuration.[*]Advanced Tomcat Features (2)[*]Web Application Configuration.[*]Web Application Administration.[*]Class Loaders.[*]HTTP Connectors[*]Tomcat and Apache HTTP Server.[*]Tomcat and IIS.[*]JDBC Connectivity.[*]Tomcat Security.[*]Shared Tomcat Housing .[*]Monitoring and Managing Tomcat with JMX.[*]Clustering.[*]Embedded Tomcat.[*]Logging.[*]Performance Testing.[*]Performance Tuning.[*]Appendix A. Tomcat and IDEs.[*]Appendix B. Apache Ant.
[list]
Critique du livre par la rédaction Hikage le 1er juin 2009
Si vous cherchez un très bon livre sur Tomcat, Professional Apache Tomcat 6 est clairement un très bon choix.

Présenté par ses auteurs comme une réponse au manque cruel d'une documentation de qualité sur ce serveur de Servlet, ce livre couvre effectivement tout les points intéressants.
L'audience cible est aussi très vaste : le non initié trouvera ses marques dans les premiers chapitres où les origines de Tomcat, les bases de Servlet/JSP ou encore l'installation sont présentées.

Les chapitres suivants intéresseront un public beaucoup plus vaste : l'architecture de Tomcat, sa configuration et ses principales fonctionnalités sont détaillées et expliquées.
Dans ces chapitres, les fichiers server.xml et context.xml ou encore web.xml sont décryptés, balises par balises, attributs par attributs, le tout avec des explications complètes et claires.
Des fonctionnalités moins communes mais tout aussi intéressantes, telles que la gestion de Single Sign On ou la persistance des sessions, sont aussi au sommaire.

Mais le livre ne s'arrête pas à une vue développeur de Tomcat, des sujets plus orientés administrateurs complètent la portée de ce livre : présentation des différents connecteurs, intégration de Tomcat avec Apache Http Server ou Microsoft IIS, Monitoring avec JMX, mise en clusters et optimisation.

Bref, ce livre est un très bon investissement si vous vous intéressez à Tomcat : très bon support pour le découvrir, et excellente bible Tomcat par la suite.




 Poster une réponse Signaler un problème

Avatar de Ricky81 Ricky81 - Expert éminent sénior https://www.developpez.com
le 16/06/2009 à 21:01
Bonsoir,

La dernière version stable de Tomcat est la 6.0 (actuellement 6.0.20).

Il existe plusieurs livres sur le sujet, donc un en français :


En avez vous lus certains et si oui, qu'en avez vous pensé ?
Avatar de sal.gass sal.gass - Membre régulier https://www.developpez.com
le 17/06/2009 à 0:33
Bonsoir,
quand on veux savoir une nouvelle chose ou un nouveau sujet on cherche souvent un livre, on trouve plusieurs, et après on reste inquiet quel est le bon livre qui répond à nos besoin

Personnellement, je n'ai aucun livre de ce que vous avez cité.
J'ai le suivant : Pro Apache Tomcat 6
J'ai pas encore lu malgré qu'il était chez moi plus qu'un ans.

Je travail avec tomcat 6 depuis longtemps, quand je veux savoir un truc ou quand je rencontre un soucis je cherche dans les forums.

Je ne sait pas si lire un livre apporte le plus,
c'est par la pratique on maitrise les chose.

c'est mon propre avis .
Avatar de Ricky81 Ricky81 - Expert éminent sénior https://www.developpez.com
le 17/06/2009 à 6:59
Citation Envoyé par logarsalem Voir le message

Personnellement, je n'ai aucun livre de ce que vous avez cité.
J'ai le suivant : Pro Apache Tomcat 6
J'ai pas encore lu malgré qu'il était chez moi plus qu'un ans.
Ajouté

C'est un peu dommage de lui faire prendre la poussière : je pense que passé un certain niveau le livre n'est plus vu comme une bible de secours, mais comme un outil d'approfondissement. Or sur l'instant présent, on ressent rarement ce besoin d'approfondissement car on a tendance à attendre la rencontre d'une problématique qui nous est inconnue plutôt que d'exploiter le livre pour aller en profondeur dans des sujets qui pourraient nous intéresser.

 
couverture du livre JBoss in Action

Note 5 drapeau
Détails du livre
Sommaire
Critiques (1)
1 commentaire
 
 

JBoss in Action

de
Public visé : Débutant

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.

Édition : Manning - 464 pages , 1re édition, 1er janvier 2009

ISBN10 : 1933988029 - ISBN13 : 9781933988023

Commandez sur www.amazon.fr :

31.49 € TTC (prix éditeur 39.82 € TTC) livraison gratuite !
PART 1 THE JBOSS APPLICATION SERVER
  • 1 Vote for JBoss
  • 2 Managing the JBoss Application Server
  • 3 Deploying applications
  • 4 Securing applications

Part 2 APPLICATION SERVICES
  • 5 Configuring JBoss Web Server
  • 6 Securing web applications
  • 7 Configuring enterprise applications
  • 8 JBoss Messaging
  • 9 Configuring Web Services

Part 3 JBOSS PORTAL
  • 10 The JBoss Portal and portlets
  • 11 Configuring the JBoss Portal

Part 4 GOING TO PRODUCTION
  • 12 Understanding clustering
  • 13 Clustering JBoss AS services
  • 14 Tuning the JBoss Application Server
  • 15 Going to production

Critique du livre par la rédaction longbeach le 1er juin 2009
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.




 Poster une réponse Signaler un problème

Avatar de Ricky81 Ricky81 - Expert éminent sénior https://www.developpez.com
le 02/06/2009 à 8:51
Bonjour,

Manning a publié en janvier un ouvrage intitulé JBoss in Action: Configuring the JBoss Application Server écrit par Javid Jamae et Peter Johnson.

Etant donné la rareté d'ouvrages récents sur JBoss (mis à part le récent JBoss - Développement, déploiement et sécurisation d'applications JEE) certains d'entre vous ont sans doute envisagé de se retourner vers les livres anglais ?

L'avez vous lu, et si oui qu'en pensez vous ?

Eric
Avatar de longbeach longbeach - Rédacteur https://www.developpez.com
le 04/06/2009 à 7:22
Je vous invite à lire ma critique du livre JBoss in Action à cette adresse :
http://java.developpez.com/livres/?page=Anglais#L9781933988023

 
couverture du livre Struts 2 in Action

Note 5 drapeau
Détails du livre
Sommaire
Critiques (1)
0 commentaire
 
 

Struts 2 in Action

Donald Brown, Chad Michael Davis, Scott Stanlick

de
Public visé : Débutant

Édition : Manning - 401 pages , 1re édition, 1er janvier 2008

ISBN10 : 193398807x - ISBN13 : 9781933988078

Commandez sur www.amazon.fr :

32.26 € TTC (prix éditeur 44.99 € TTC) livraison gratuite !
Part 1 Struts 2: a brand new framework
  • 1 Struts 2: the modern web application framework
  • 2 Saying hello to Struts 2

Part 2 Core concepts: actions, interceptors, and type conversion
  • 3 Working with Struts 2 actions
  • 4 Adding workflow with interceptors
  • 5 Data transfer: OGNL and type conversion

Part 3 Building the view: tags and results
  • 6 Building a view: tags
  • 7 UI component tags
  • 8 Results in detail

Part 4 Improving your application
  • 9 Integrating with Spring and Hibernate/JPA
  • 10 Exploring the validation framework
  • 11 Understanding internationalization

Part 5 Advanced topics and best practices
  • 12 Extending Struts 2 with plug-ins
  • 13 Best practices
  • 14 Migration from Struts Classic
  • 15 Advanced topics
Critique du livre par la rédaction longbeach le 1er avril 2009
Le livre est divisé en 5 parties.

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

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

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

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

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

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

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

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

Commentez Donner une note à l'article (5)

English version :

The book is divided in 5 parts.

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

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

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

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

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

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

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

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




 Poster une réponse Signaler un problème

Avatar de Ricky81 Ricky81 - Expert éminent sénior https://www.developpez.com
le 18/04/2009 à 9:43
Bonjour,

Celinio Fernandes a publié une critique de Struts 2 in Action

Petits extraits :

Ce que j'ai aimé dans ce livre : le code source de chaque chapitre est packagé de façon appropriée dans l'archive (fichier war) de l'application finale, sauf les derniers chapitres.
Ce que j'ai moins aimé dans ce livre : J'ai trouvé le livre peut-être un peu trop verbeux à mon goût, dans certains passages. (...) L'absence de chapitre au sujet de l'intégration de librairies Javascript et de composants Ajax dans Struts 2.
D'autres membres ont une opinion sur ce livre ?

 
couverture du livre Java EE

Note 5 drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Java EE

Guide de développement d'applications web en Java

de
Public visé : Débutant

Édition : ENI - 610 pages , 1re édition, 1er février 2009

ISBN10 : 2746047152 - ISBN13 : 9782746047150

Commandez sur www.amazon.fr :

51.03 € TTC (prix éditeur 54.00 € TTC) livraison gratuite !
Chapitre 1 : Objectifs et spécifications de Java EE
  • Les conventions
  • Définitions de J2EE/Java EE
  • Encodage des applications Java
  • Les architectures Web
  • Mise en place de l'environnement
  • Installation du serveur d'applications Java EE (Tomcat)
  • Installation de l'environnement de développement (IDE) Eclipse

Chapitre 2 Le serveur d'applications Apache-Tomcat
  • Qu'est-ce que Tomcat ?
  • Installation de Tomcat
  • Coupler Tomcat et le serveur Web Apache
  • Architecture et configuration de Tomcat
  • Rappels XML
  • Les fichiers de configuration Tomcat
  • Le fichier de configuration des applications
  • Le fichier de configuration des utilisateurs
  • Le fichier de configuration de la sécurité
  • Arborescence d'un projet Tomcat
  • Analyse, monitoring et supervision
  • Apache-Tomcat et SSL/HTTPS

Chapitre 3 Les JavaServer Page
  • Qu'est-ce qu'une JavaServer Page ?
  • Déclarations, commentaires et scriptlets
  • Les objets implicites
  • Premières JSP simples
  • Gérer les exceptions et erreurs en JSP
  • Bibliothèque de tags JSTL
  • Bibliothèque de balises personnalisées
  • Les JavaBeans ou Beans
  • Transfert de contrôle
  • Travailler avec des fichiers et répertoires

Chapitre 4 Les Servlets
  • Qu'est-ce qu'une Servlet ?
  • Le projet BetaBoutique
  • Première Servlet
  • Servlet authentification
  • Interface ServletConfig
  • Interface ServletContext
  • Traitement des requêtes
  • Traitement des réponses
  • Synchronisation des traitements
  • État des clients
  • Les filtres
  • Interface RequestDispatcher
  • Introduction au modèle MVC
  • Gestion des exceptions, erreurs et page d'accueil
  • En résumé

Chapitre 5 Java et les bases de données
  • Travailler avec une base de données
  • Partage de connexions
  • Écouteurs/listeners et cycle de vie
  • Sources de données et pools de connexion
  • Bases de données et MVC
  • Classe modèle
  • Modèle et JavaBean
  • Les transactions
  • Multilingue et JDBC
  • Authentification et Realms

Chapitre 6 Framework Java EE
  • Framework
  • Apache-Struts
  • Projet Web
  • Formulaires Struts
  • Vues et Struts
  • Les validations et vérifications de données
  • Le contrôleur Struts
  • Développement du module d'administration
  • Web 2.0
  • En résumé

Chapitre 7 Techniques avancées
  • Gestion des traces et des logs
  • Ant : Another Neat Tool
  • Déployer un projet Java EE
  • Optimisation de la mémoire
  • En résumé
Critique du livre par la rédaction longbeach le 1er février 2009
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/


couverture du livre Head First Servlets and JSP

Note 5 drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Head First Servlets and JSP

de
Public visé : Débutant

Résumé de l'éditeur

Looking to study up for the new J2EE 1.5 Sun Certified Web Component Developer (SCWCD) exam?

This book will get you way up to speed on the technology you'll know it so well, in fact, that you can pass the brand new J2EE 1.5 exam. If that's what you want to do, that is. Maybe you don't care about the exam, but need to use servlets and JSPs in your next project. You're working on a deadline. You're over the legal limit for caffeine. You can't waste your time with a book that makes sense only AFTER you're an expert (or worse, one that puts you to sleep).

Learn how to write servlets and JSPs, what makes a web container tick (and what ticks it off), how to use JSP's Expression Language (EL for short), and how to write deployment descriptors for your web applications. Master the c:out tag, and get a handle on exactly what's changed since the older J2EE 1.4 exam. You don't just pass the new J2EE 1.5 SCWCD exam, you'll understand this stuff and put it to work immediately.

Head First Servlets and JSP doesn't just give you a bunch of facts to memorize; it drives knowledge straight into your brain. You'll interact with servlets and JSPs in ways that help you learn quickly and deeply. And when you're through with the book, you can take a brand-new mock exam, created specifically to simulate the real test-taking experience.

Édition : O'Reilly - 911 pages , 2eédition, 25 mars 2008

ISBN10 : 0596516681 - ISBN13 : 9780596516680

Commandez sur www.amazon.fr :

35.15 € TTC (prix éditeur 37.99 € TTC) livraison gratuite !
  • Chapter 1. intro and overview
  • Chapter 2. high-level overview
  • Chapter 3. hands-on MVC
  • Chapter 4. request AND response
  • Chapter 5. attributes and listeners
  • Chapter 6. session management
  • Chapter 7. using JSP
  • Chapter 8. scriptless JSP
  • Chapter 9. using JSTL
  • Chapter 10. custom tag development
  • Chapter 11. web app deployment
  • Chapter 12. Web app security
  • Chapter 13. filters and wrappers
  • Chapter 14. patterns and struts
  • Appendix A. Final Mock Exam
Critique du livre par la rédaction Eric REBOISSON le 1er septembre 2008
Comme l'explique la description du livre, sans Java côté serveur, eBay n'existerait pas...et donc pas possible d'acheter le poster de Farrah Fawcett qui vous plait tant. Voilà l'ambiance dans laquelle vous baignerez à la lecture de "Head First Servlets and JSP" : un contenu décalé (des images et dialogues amusants, etc.) par rapport aux ouvrages informatiques traditionnels, mais qui cache une pédagogie bien étudiée et qui fonctionne (je pense que tous les lecteurs de cette collection confirmeront).

Le but de ce livre est non seulement d'expliquer les techniques de développement orienté web avec Java (Servlets, JSP, taglibs...) mais surtout une préparation à la certification Sun Certified Web Component Developer Exam (SCWCD) dans sa version pour J2EE 1.5 : chaque chapitre est ainsi ponctué d'un mini examen, et à la fin du livre un dernier pour vous tester véritablement.

Les trois auteurs sont très qualifiés sur le sujet puisque Bryan Basham a participé à la conception de la SCWCD, Bert Bates quant à lui, a oeuvré pour la Sun Certified Business Component Developer et enfin Kathy Sierra est fondatrice de javaranch.com et a participé également à la conception de la SCJP. Que du beau monde donc !

Et les trois auteurs se focalisent uniquement sur les sujets de la certification, vous garantissant la réussite de la certification avec tous les conseils prodigués dans l'ouvrage.

Je ne vais pas trop m'étendre et juste résumer la qualité de l'ouvrage en donnant la note maximale pour un livre qui vous apprendra tous les rudiments du développement web en Java, ou vous aidera à réviser pour passer la SCWCD. Un livre à acheter les yeux fermés !


couverture du livre Professional Java Development with the Spring Framework

Note 3.5 drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Professional Java Development with the Spring Framework

de

Résumé de l'éditeur

The Spring Framework is a major open source application development framework that makes Java/J2EE(TM) development easier and more productive. This book shows you not only what Spring can do but why, explaining its functionality and motivation to help you use all parts of the framework to develop successful applications.

You will be guided through all the Spring features and see how they form a coherent whole. In turn, this will help you understand the rationale for Spring's approach, when to use Spring, and how to follow best practices. All this is illustrated with a complete sample application. When you finish the book, you will be well equipped to use Spring effectively in everything from simple Web applications to complex enterprise applications.

What you will learn from this book
  • The core Inversion of Control container and the concept of Dependency Injection
  • Spring's Aspect Oriented Programming (AOP) framework and why AOP is important in J2EE development
  • How to use Spring's programmatic and declarative transaction management services effectively
  • Ways to access data using Spring's JDBC functionality, iBATIS SQL Maps, Hibernate, and other O/R mapping frameworks
  • Spring services for accessing and implementing EJBs
  • Spring's remoting framework


Who this book is for
This book is for Java/J2EE architects and developers who want to gain a deeper knowledge of the Spring Framework and use it effectively.

Wrox Professional guides are planned and written by working programmers to meet the real-world needs of programmers, developers, and IT professionals. Focused and relevant, they address the issues technology professionals face every day. They provide examples, practical solutions, and expert education in new technologies, all designed to help programmers do a better job.

Édition : Wrox, Wiley Publishing - 643 pages , 1re édition, 1er juillet 2005

ISBN10 : 0764574833 - ISBN13 : 9780764574832

Broché

Commandez sur www.amazon.fr :

25.13 € TTC (prix éditeur 29.57 € TTC)
  • Introducing the Spring Framework
  • The Bean Factory and Application Context
  • Advanced Container Concepts
  • Spring and AOP
  • DAO Support and JDBC Framework
  • Transaction and Resource Management
  • Object/Relational Mapping
  • Lightweight Remoting
  • Supporting Services
  • Acegi Security System for Spring
  • Spring and EJB
  • Web MVC Framework
  • Web View Technologies
  • Integrating with Other Web Frameworks
  • The Sample Application
  • Conclusion
  • Appendix A : Requirements for the Sample Application
Critique du livre par la rédaction Hikage le 1er octobre 2007
Ce livre est excellent, c'est grâce à lui que j'ai appris les bases de Spring. Bien qu'en anglais, il est très agréable et facile à lire.
Pour les novices, c'est effectivement un support de choix : il va introduire Spring en douceur par l'explication des raisons d'être de celui-ci, pour ensuite expliquer certaines notions sur lesquelles se base Spring (l'injection de dépendance, l'inversion de contrôle, la programmation orientée aspect) sans devenir pénible et difficile à lire.

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

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


couverture du livre Développement Java sous STRUTS : Version 1.2

Note 5 drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Développement Java sous STRUTS : Version 1.2

de
Public visé : Débutant

Résumé de l'éditeur

Cet ouvrage s'adresse à toute personne désireuse de perfectionner ses connaissances sur le développement Web avec Java. Il décrit les différents constituants de Struts ainsi que les méthodes pour développer des applications utilisant ce framework.
Le chapitre 1 permet de découvrir le développement Web avec Java.
Le chapitre 2 présente le framework Struts d'un point de vue théorique puis d'un point de vue pratique en développant une première application Struts.
La Vue du modèle MVC 2 Struts est présentée dans le chapitre 3, les ActionForms et les formulaires JSP y sont détaillés.
Le chapitre 4 présente les validations en utilisant des méthodes de la classe ActionForm et/ou les validators. Il présente également différentes méthodes de validation utilisant des formulaires constitués de plusieurs pages JSP.
Le chapitre 5 présente le contrôleur représenté par la classe ActionServlet et les classes Action.
Les balises Struts sont détaillées dans le chapitre 6.
Le chapitre 7 montre comment implémenter le modèle dans une application Struts. Différentes méthodes sont proposées, la première en utilisant des classes Java simples, la deuxième détaille l'utilisation du Design Pattern DAO, la troisième utilise le framework objet/relationnel Hibernate, la dernière les EJB et les services web.
Le chapitre 8 présente des outils open source qu'il est possible d'utiliser avec Struts : ANT, Maven, Log4J, JUnit. Il présente également la future version de Struts 1.3 ainsi que quelques technologies concurrentes présentes ou futures (JSF, Shale, MyFaces).

Édition : ENI - 415 pages , 1re édition, 4 janvier 2006

ISBN10 : 2746031051 - ISBN13 : 9782746031050

Commandez sur www.amazon.fr :

25.78 € TTC (prix éditeur 27.14 € TTC) livraison gratuite !
  • Le développement Web avec Java
  • Struts : MVC 2
  • La Vue
  • Les validations d'entrées
  • Le Contrôleur
  • Les balises Struts
  • Le Modèle
  • Outils open-source et évolution
  • Installation et configuration des outils
  • Utilisation d'Eclipse
  • DTD Struts-config.xml
Critique du livre par la rédaction Edouard Kaiser le 1er juin 2007
En reprenant les bases de la programmation web (HTML, Servlet, JSP) et les infrastructures que cela met en jeu (serveurs Web, serveur d'application et de base de données), l'auteur nous entraîne petit à petit vers la programmation web structurée par le modèle MVC sous le framework Struts. Si vous ne savez pas ce qu'est le modèle MVC, aucun souci car une partie d'un chapitre lui est consacrée afin de bien assimiler ce qu'apporte ce modèle et en quoi Struts réponds à sa mise en place.
Tout les concepts du framework sont ici clairement abordées (ActionForm, taglibs Struts, Validators, etc.) à travers des exemples concis et facilement compréhensibles.
Mais ce livre ne se contente pas simplement de décrire l'utilisation du framework et ce qui le compose, l'auteur élargit le sujet en montrant comment ce framework peut être utilisé, couplé à d'autres technologies telles que les WebServices ou les EJBs. De plus des patterns tels que le pattern DAO sont également décrits (appuyé sur Hibernate). De ce fait, cet ouvrage permet à n'importe quelle personne souhaitant se lancer dans le développement web d'obtenir une vue générale concernant les différentes couches composant une application. On appréciera également une partie d'un chapitre dédiée à des outils tels que Log4j ou ANT par exemple.
Cependant j'aurais une remarque à faire concernant les exemples en eux-mêmes du livre. Même s'il est très pratique d'avoir plusieurs petits exemples pour comprendre différents concepts, je pense qu'il aurait été bon également que le livre s'appuie sur la réalisation d'une et une seule application afin de mieux assimiler en quoi justement ce modèle permet de séparer clairement les différentes couches applicatives afin d'obtenir un résultat modulaire.


couverture du livre Core JavaServer Faces

Note 5 drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Core JavaServer Faces

de
Public visé : Débutant

Résumé de l'éditeur

JavaServer Faces is a Web application framework -- similar to Jakarta Struts -- that gives application developers access to custom components that facilitate the creation of rich user interfaces. JSF also provides Integrated Development Environment (IDE) vendors with a standard upon which to base their IDEs. In the Core tradition, this new book aims to be THE tutorial and reference for experienced programmers who need to learn this exciting new technology. Although J2EE is still the most popular platform for developing Web applications, Microsoft's .NET has gained market share over the past two years. J2EE is arguably more powerful, but .NET, is generally regarded as easier to use. J2EE currently lacks- a rich component model that makes it easy to develop custom components and an IDE (like Visual Studio) that facilitates Web application development. That's where JSF enters the equation, and this book aims to be the most authoritative treatment of the topic -- a must-have for any serious J2EE programmer.

Édition : Prentice Hall - 656 pages , 1re édition, 1er juin 2004

ISBN10 : 0131463055 - ISBN13 : 9780131463059

Commandez sur www.amazon.fr :

42.62 € TTC (prix éditeur 42.62 € TTC) livraison gratuite !
  • Preface
  • Getting Started
  • Managed Beans
  • Navigation (on the Prentice Hall site)
  • Basic Standard Components
  • Data Tables
  • Conversion and Validation
  • Event Handlers
  • Subviews and Tiles
  • Custom Components
  • Accessing External Services
  • Wireless Clients
  • How Do I...
Critique du livre par la rédaction Michel Blavin le 1er mai 2007
Ce livre est une merveille, il est à la fois précis et concis, détaillant chaque élément du framework sans se perdre dans de longues explications, tous les textes sont très courts et entrecoupés de code fonctionnel et réutilisable. Les codes et les erratas pourront être téléchargés sur le site du livre.

JSF est un framework qui a la réputation d'être complexe à appréhender au premier contact pour le novice. Vous pourrez grâce à ce livre prendre la main sereinement et developper rapidement des applications en profitant de la puissance et de la souplesse des JSF. Il est important de noter que l'on peut aborder ce livre sans avoir de connaissance particulière sur les JSP/Servlet, seule une connaissance de la programmation Java est nécessaire.

Tous les exemples de code sont complets, ce qui permet d'être opérationnel très rapidement. Et surtout ce livre sera une formidable référence à conserver sous le bras tout au long du développement. Je conseille la lecture de ce livre à toute personne aillant l'intention de développer des applications utilisant les JSF.


couverture du livre Enjoying Web Development with Tapestry

Note 5 drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Enjoying Web Development with Tapestry

Put the fun back into J2EE application development

de
Public visé : Débutant

Résumé de l'éditeur

If you'd like to create web-based applications easily, then this book is for you. More importantly, it shows you how to do that with joy and feel good about your own work! You don't need to know servlet or JSP while your productivity will be much higher than using servlet or JSP directly. This is possible because we're going to use a library called "Tapestry" that makes complicated stuff simple and elegant.

How does it do that? First, it allows the web designer to work on the static contents and design of a page while allowing the developer to work on the dynamic contents of that page without stepping on each other's toes; Second, it allows developers to work with high level concepts such as objects and properties instead of HTTP URLs, query parameters or HTML string values; Third, it comes with powerful components such as calendar, tree and data grid and it allows you to create your own components for reuse in your own project.

How this book can help you learn Tapestry? 1. It has a tutorial style that walks you through in a step-by-step manner. 2. It is concise. There is no lengthy, abstract description. 3. Many diagrams are used to show the flow of processing and high level concepts so that you get a whole picture of what's happening. 4. Free sample chapters are available (online). You can judge it yourself.

It includes the following chapters: Getting Started with Tapestry, Using Forms, Validating Inputs, Creating an e-Shop, Creating Custom Components, Supporting Other Languages, Using the Table Component, Handling File Downloads and Uploads, Providing a Common Layout, Using Javascript, Building Dynamic Forms, Test Driven Development with HtmlUnit, Database and Concurrency Issues, Using Hibernate, Integrating with Struts.

Édition : Lulu Press - 495 pages , 1re édition, 1er avril 2006

ISBN10 : 1411649133 - ISBN13 : 9781411649132

Commandez sur www.amazon.fr :

31.06 € TTC (prix éditeur 31.06 € TTC) livraison gratuite !
  • Getting Started with Tapestry
  • Using Forms
  • Validating Input
  • Creating an e-Shop
  • Creating Custom Components
  • Supporting Other Languages
  • Using the Table Component
  • Handling File Downloads and Uploads
  • Providing a Common Layout
  • Using Javascript
  • Building Interactive Forms with AJAX
  • Test Driven Development with HtmlUnit
  • Database and Concurrency Issues
  • Using Hibernate
  • Integrating with Struts
Critique du livre par la rédaction joseph_p le 1er mai 2007
Kent Tong a une façon très didactique de présenter le framework Tapestry. Il explique les grands principes, montre leurs applications de façon générale puis donne des exemples précis et pertinents.

Dans son livre, il présente d'abord le fonctionnement intrinsèque de ce framework, puis montre des explications pertinentes d'intégration avec des framework tiers, tels Hibernate ou HtmlUnit. Cela permet donc vraiment d'aborder la conception de site web de façon globale. La pertinence est telle que j'ai réutilisé ces exemples d'intégration dans d'autres contextes. En effet, Kent Tong explique tant les détails de réalisation que la portée de ceux-ci avec clarté et précision.

A noter également que Kent Tong a régulièrement fait parvenir des corrections ou mises à jour de son pdf. Par exemple, la version que j'avais acquise l'année passée couvrait uniquement Tapestry 4.0. Puis Tapestry 4.1 est apparu, et peu de temps après Kent Tong a communiqué une version à jour de son livre couvrant Tapestry 4.1 (qui introduit des changements notables).

Au final, personnellement, c'est le meilleur livre d'introduction à un framework que j'ai vu jusqu'à présent.

NB : Je tiens toutefois à préciser que je n'ai pas retenu ce framework.

Kent Tong has a very didactic way of explaining the Tapestry framework. He explains the fundamental aspects behind the framework from a general point of view, and then provides very consistent and precise examples.

In his book, Kent Tong shows first the Tapestry framework and its way of doing things. Then he explains how to integrate the framework with others, like Hibernate or HtmlUnit. Thus, with this book, one can approach web design in all its aspects, which is fairly important. The interest of Kent Tong examples are such that I've used them in different contexts than Tapestry. Indeed, he explains both the details of the implementation as well as the impacts, all being done with clarity and precision.

Important to notice as well, Kent Tong has regularly provided updates or corrections of his book. For example, when I bought the book, only Tapestry 4.0 was covered. Then Tapestry 4.1 appeared. Short after, Kent Tong provided an updated version of his book covering Tapestry 4.1 (which introduces some fairly important changes).

Finally, personally, it's the best framework introduction book I've read until now.

NB : Just a last notice : eventually, I didn't retain Tapestry.


couverture du livre Initiation à JSP

Note 5 drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Initiation à JSP

Avec 50 exercices corrigés

de
Public visé : Débutant

Résumé de l'éditeur

Apprendre JSP par la pratique. Particulièrement adapté aux étudiants, ce livre décrit de manière concrète et illustrée tous les concepts de JSP (JavaServer Pages), langage de script permettant de développer des sites Web dynamiques associés à des bases de données. Avec une approche très pédagogique, héritée de l'expèrience de formateur des auteurs, cet ouvrage explique à l'aide de termes clairs et d'exemples simples toutes les notions relatives à la programmation JSP : les bases du langage Java, JavaBeans, cookies, sessions, connexion aux bases de données, servlets... Pour permettre au lecteur d'appliquer directement ses connaissances, chaque chapitre se clôt par une série d'exercices, dont les fichiers sources et les corrigés figurent sur le CD-Rom d'accompagnement.

Édition : Eyrolles - 353 pages , 1re édition, 1er septembre 2004

ISBN10 : 2212115326 - ISBN13 : 9782212115321

Commandez sur www.amazon.fr :

27.55 € TTC (prix éditeur 29.00 € TTC) livraison gratuite !
  • Avant-propos - Organisation de l'ouvrage
  • Introduction - Le comment ça marche du Web
    • Etude d'un premier script JSP
    • Internet et le modèle client-serveur
    • Qu'est ce qu'une base de données ?
    • Exploitation des exemples et exercices du livre
    • Résumé
  • Concepts fondamentaux
    • Radiographie d'un script JSP
    • Déclarer une variable
    • L'instruction d'affectation
    • Les opérateurs arithmètiques
    • Résumé
    • Exercices
  • Communiquer avec l'internaute
    • Les différentes façons d'afficher une information
    • Transmettre une information à un site
    • Résumé
    • Exercices
  • Les structures de la programmation Java
    • Les tests
    • Les boucles
    • Les fonctions
    • Résumé
    • Exercices
  • Utiliser un objet Java dans un script
    • La notion de composants métier
    • Ecrire un JavaBean
    • Appeler un bean depuis un JSP
    • Résumé
    • Exercices
  • Interroger une base de donn?es
    • Mettre en place une base de données
    • Enrichir une base de données avec JSP
    • Résumé
    • Exercices
  • Connaître l'internaute
    • Les cookies
    • La session
    • Résumé
    • Exercices
  • Les servlets ou les dessous cachés de JSP
    • Du JSP à la servlet
    • Construire ses propres servlets
    • Résumé
    • Exercices
  • Annexe - Contenu et exploitation du CD-Rom
Critique du livre par la rédaction Xoux le 1er janvier 2005


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

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

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

Retrouvez la critique complète ici.


couverture du livre Jakarta Struts

Note 5 drapeau
Détails du livre
Sommaire
Critiques (1)
 
 

Jakarta Struts

par la pratique

de
Traducteurs : Sylvie Gréco
Public visé : Débutant

Résumé de l'éditeur

Le framework Struts : le standard de fait pour le développement d'applications Web en Java. Parce qu'ils permettent d'assurer l'évolutivité des applications Web, de diminuer les coûts et les délais de développement, et d'accroître la fiabilité des applications, les frameworks se sont imposés comme une alternative très avantageuse aux servies et aux JSP en matière de développement d'applications Web en Java. Standard de fait parmi les frameworks Open Source, Struts gère de façon simple la plupart des tâches inhérentes au développement d'applications Web ; il est entièrement compatible avec les standards en vigueur (JSP, EJB, servlets, etc.). Struts en action Cet ouvrage est conçu comme un tutoriel dont l'objectif est de vous faire acquérir une connaissance concrète et immédiatement exploitable de Struts : design pattern MVC, vues, contrôleur, traitement des erreurs, internationalisation des applications, etc. Le code des nombreux exemples et de l'application complète proposés est directement réutilisable.

Édition : Eyrolles - 331 pages , 1re édition, 1er janvier 2003

ISBN10 : 2212112319 - ISBN13 : 9782212112313

Commandez sur www.amazon.fr :

37.05 € TTC (prix éditeur 39.00 € TTC) livraison gratuite !
  • Présentation du projet Jakarta Struts et de ses composants annexes
    • Le projet Jakarta Struts
    • Les applications Web
    • Le conteneur de servlets/JSP Tomcat
  • Présentation des servlets et des JavaServer Pages
    • L'architecture servlet Java
    • Que sont les JavaServer Pages ?
  • Présentation de Struts
    • Télécharger et installer Struts
    • Créer une première application Struts
  • Le contrôleur
    • La classe ActionServlet
    • La classe Action
    • Les plug-ins Struts
    • La classe RequestProcessor
  • Les vues
  • L'internationalisation des applications Struts
    • Les composants i18n d'une application Struts
    • Internationalisation de l'application eyrollesapp
  • Le traitement des erreurs
    • Les composants de traitement d'erreurs Struts
    • Ajouter le traitement d'erreurs à l'application eyrollesstruts
  • Création d'ActionMapping personnalisés
    • Qu'est ce qu'un ActionMapping ?
    • Création d'un ActionMapping personnalisé
  • Le pool de connexions JDBC
    • Qu'est ce qu'une DataSource ?
    • Utilisation d'une DataSource dans une application Struts
  • Débogage des applications Struts
    • Intégrer Tomcat dans une application Java
    • Débogage d'une application Struts
  • Développement d'une application Struts
    • Description de l'application Employes
  • Le fichier struts-config.xml
    • Les sous-éléments Struts
    • Ajouter une DataSource Struts
    • Ajouter des définitions de FormBean
    • Ajouter des redirections globales
    • Ajouter des actions
    • Ajouter un RequestProcessor
    • Ajouter des ressources de messages
    • Ajouter un Plug-in
  • La bibliothèque de balises Bean
  • La bibliothèque de balises HTML
  • La bibliothèque de balises Logic
  • La bibliothèque de balises Template
Critique du livre par la rédaction Xoux le 1er décembre 2004
Cet ouvrage se destine essentiellement aux débutants désirant apprendre à utiliser le framework Struts.
Très facile et agréable à lire, il fait le tour des prérequis nécessaires à la compréhension et l'utilisation de Struts pour se focaliser par la suite sur la version 1.1 du framework.

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

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

Retrouvez la critique complète ici.