Conception d'applications en Java / JEE

26 livres et 32 critiques, dernière mise à jour le 21 juin 2019 , note moyenne : 4.9

  1. Spring Boot par la pratique - Développer les services Rest avec Spring-Boot et Spring-RestTemplate
  2. Conception d'applications en Java/JEE - principes, patterns et architectures
  3. Les cahiers du programmeur: Java, conception et déploiement J2EE
  4. Programmation GWT 2
  5. Coffret de 2 livres : Maîtrisez et optimisez le développement n-tiers
  6. Apache Maven - Maîtrisez l'infrastructure d'un projet Java EE
  7. Apache Tomcat 7 - Guide d'administration du serveur Java EE 6 sous Windows et Linux
  8. Java EE 5 - EJB 3.0 - JPA - JSP - JSF - Web services - JMS - GlassFish 3 - Maven 3
  9. Développements n-tiers avec Java EE
  10. 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
  11. Programmation GWT 2 - Développer des applications RIA et Ajax avec Google Web Toolkit
  12. GWT - Créer des applications web interactives avec Google Web Toolkit (versions 1.7 et 2.0)
  13. Struts 2 - Le framework de développement d'applications Java EE
  14. Spring par l'exemple
  15. Spring par la pratique - Spring 2.5 et 3.0
  16. Ajax pour Java - L'art de la programmation XML et XMLHttpRequest
  17. Java EE - Guide de développement d'applications web en Java
  18. Développement JEE 5 avec Eclipse Europa
  19. Les Cahiers du programmeur Java EE 5
  20. Développement Java sous STRUTS : Version 1.2
  21. Java - Plus rapide, plus léger
  22. Eclipse et JBoss
  23. Struts - Les bonnes pratiques pour des développements web réussis
  24. Initiation à JSP - Avec 50 exercices corrigés
  25. Services Web avec J2EE et .NET : Conception et implémentations
  26. Jakarta Struts - par la pratique
couverture du livre Spring Boot par la pratique

drapeau
Détails du livre
Critiques (0)
0 commentaire
 
 

Spring Boot par la pratique

Développer les services Rest avec Spring-Boot et Spring-RestTemplate

de
Public visé : Intermédiaire

Résumé de l'éditeur

Ce livre présente par la pratique le développement des services REST en utilisant Spring-Boot et Spring-RestTemplate. L’objectif est de mettre en évidence la facilité de développement d’une application web à travers le framework Spring-Boot. Un accent est également mis sur les tests unitaires et les tests d'intégration en utilisant le framework Mockito.

Édition : Les Editions du Net - 110 pages , 1re édition, 20 juin 2018

ISBN10 : 2312059223 - ISBN13 : 9782312059228

Commandez sur www.amazon.fr :

20.00 € TTC (prix éditeur 20.00 € TTC)
Aucune critique n'a été faite pour l'instant



 Poster une réponse Signaler un problème

Avatar de Mickael Baron Mickael Baron - Responsable Java https://www.developpez.com
le 23/08/2018 à 18:20
Spring Boot par la pratique
Développer les services Rest avec Spring-Boot et Spring-RestTemplate
Ce livre présente par la pratique le développement des services REST en utilisant Spring-Boot et Spring-RestTemplate. L’objectif est de mettre en évidence la facilité de développement d’une application web à travers le framework Spring-Boot. Un accent est également mis sur les tests unitaires et les tests d'intégration en utilisant le framework Mockito.

[Lire la suite]




 
couverture du livre Conception d'applications en Java/JEE

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

Conception d'applications en Java/JEE

principes, patterns et architectures

de
Public visé : Intermédiaire

Résumé de l'éditeur

Cet ouvrage s’adresse principalement aux étudiants des cycles informatiques (IUT, LP, licence deuxième et troisième années) ainsi qu’aux élèves-ingénieurs en écoles d’informatique.
La phase de conception logicielle répond aux questions « comment résout-on le problème ? comment satisfait-on les besoins ? ». Elle fait suite à la phase d’analyse antérieure qui, elle, avait posé les questions « quel est le problème ? quels sont les besoins ? ».
Ce manuel explique les méthodes de la conception orientée objets. Il détaille les patrons de conception (design patterns), les principes de conception qui les sous-tendent et les principales architectures logicielles, en particulier les architectures web. Il s’appuie sur le langage Java.
Il présente pour chaque thème abordé plusieurs exemples et rassemble 58 exercices tous corrigés, ainsi que deux études de cas : JSE (Java Standard Edition) et JEE (Java Enterprise Edition) détaillées jusqu’au code complet.

Édition : Dunod - 416 pages , 1re édition, 3 septembre 2014

ISBN10 : 2100716867 - ISBN13 : 9782100716869

Commandez sur www.amazon.fr :

29.09 € TTC (prix éditeur 29.09 € TTC)
LES RAPPELS DE COURS.
LES PATRONS.
LES PRINCIPES.
LES ARCHITECTURES.
LES ETUDES DE CAS
Critique du livre par la rédaction marc autran le 5 février 2016
Cet ouvrage traite de la conception d’applications à travers le prisme du langage Java.

Partant du principe que la littérature traitant de la conception logicielle est souvent anti-pédagogique, l’auteur revisite les patterns et les principes de conception logicielle en les illustrant d’exemples concrets. J’ai d’ailleurs trouvé l’idée d’illustrer les patterns du GOF suivant l’organisation du JDK aussi originale que passionnante mais surtout très empreinte de réalisme.

L’auteur consacre la première partie de son ouvrage à dispenser quelques rappels de cours sur le monde Java et sur la notation UML. Ces rappels, qui peuvent au premier abord sembler synthétiques, sont en réalité extrêmement bien ciblés sur les notions abordées dans le reste de l’ouvrage. Ces rappels sont également l’occasion pour l’auteur de nous imprégner de la méthodologie de pensée propre à la conception logicielle. On peut également apprécier que les technologies présentées soient très contemporaines concernant JEE (EJB – JPA –JSF…). Le seul reproche que je pourrais faire à ce tour d’horizon technologique JEE serait l’absence de mention des WS REST. Je me suis d’ailleurs demandé, à cet égard si cet oubli était volontaire dans la mesure où REST se permet de prendre des libertés vis-à-vis du génie logiciel ou si cela fera l’objet d’un complément dans la prochaine édition.

La seconde partie détaille les Design patterns de conception ainsi que les principes d’architecture. La description de ces modèles de conception efface, pour le plus grand plaisir du lecteur, la dimension aussi théorique qu’indigeste de ces monuments du GOF. Pour réussir cette prouesse pédagogique, il réussit à illustrer le concept abstrait d’un trait d’UML et nous replonger dans le concret avec le code source en Java. J’ai d’ailleurs pu mesurer à quel point cette méthode était vertueuse lorsque j’ai abordé le chapitre 7. En effet, ce chapitre ne propose aucun exemple en Java et je dois reconnaitre que ma compréhension de ce qui y est exposé fut très superficielle.

La troisième et dernière partie du livre nous offre deux études, la première en Java SE (moteur générique de jeux d'arcades 2D) et la seconde en JEE (une application de commerce électronique), qui clôturent sur le même ton ce livre : un savant mélange des principes généraux et des détails du langage. C’est indéniable, la mayonnaise pédagogique prend !!!

Je recommande cet ouvrage à ceux qui développent déjà Java et JEE et qui souhaiteraient rebondir sur leur connaissance de ce langage pour apprendre les principes de la conception logicielle.




 Poster une réponse Signaler un problème

Avatar de Mickael Baron Mickael Baron - Responsable Java https://www.developpez.com
le 05/02/2016 à 17:06
Conception d'applications en Java/JEE
principes, patterns et architectures
Cet ouvrage s’adresse principalement aux étudiants des cycles informatiques (IUT, LP, licence deuxième et troisième années) ainsi qu’aux élèves-ingénieurs en écoles d’informatique.
La phase de conception logicielle répond aux questions « comment résout-on le problème ? comment satisfait-on les besoins ? ». Elle fait suite à la phase d’analyse antérieure qui, elle, avait posé les questions « quel est le problème ? quels sont les besoins ? ».
Ce manuel explique les méthodes de la conception orientée objets. Il détaille les patrons de conception (design patterns), les principes de conception qui les sous-tendent et les principales architectures logicielles, en particulier les architectures web. Il s’appuie sur le langage Java.
Il présente pour chaque thème abordé plusieurs exemples et rassemble 58 exercices tous corrigés, ainsi que deux études de cas : JSE (Java Standard Edition) et JEE (Java Enterprise Edition) détaillées jusqu’au code complet.

[Lire la suite]




 
couverture du livre Les cahiers du programmeur: Java, conception et déploiement J2EE

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

Les cahiers du programmeur: Java, conception et déploiement J2EE

de
Public visé : Débutant

Édition : Eyrolles - 192 pages , 1re édition, 23 octobre 2003

ISBN10 : 2212111940 - ISBN13 : 9782212111941

Commandez sur www.amazon.fr :

23.75 € TTC (prix éditeur 23.75 € TTC) livraison gratuite !
  • Avant-propos
  • Introduction au projet BlueWeb
  • Une architecture à 5 couches pour BlueWeb
  • Environnement de développement CVS et Ant
  • Interfaces graphiques pour la couche cliente
  • Couche de présentation des données - servlets HTTP
  • Couche métier avec les EJB
  • Déploiement de l'application et gestion des versions avec Ant et Java Web Start
  • Audit du code et qualité logicielle
  • Implémentation de la logique métier BlueWeb avec XDoclet
  • Index
Critique du livre par la rédaction Petrus le 16 septembre 2004


Rédigé par un professionnel du développement d'applications J2EE ( certification Sun et JBoss ), cet ouvrage séduira par un style trés facile à lire, et une méthode d'apprentissage assez pragmatique, quoique nécessitant beaucoup de curiosité et d'autodidactie.

L'auteur présente la conception d'une application J2EE simple (au travers le projet "BlueWeb"), ainsi que son déploiement, en présentant tous les artefacts, API et outils utilisables de nos jours. Une petite revue technologique (logiciels libres / GNU essentiellement) forte interessante en soit pour les débutants. Les technologies comme Ant, JUnit, SWT, Regex et autre Log4j sont ainsi étalées et démystifiées de façon assez habile. De nombreuses analogies et exemples satisferont pleinement le lecteur qui ne se sentira par "décroché", et pourra acquérir assez rapidement de bonnes notions sur le monde J2EE et les méthodes de développement préconisées. On notera également que l'auteur s'est attaché à présenter des outils issus du monde libre dans la plupart des cas, plus accessibles pour les apprentis architectes J2EE...

Sont particulièrement appréciables :

  • l'organisation du livre, les larges marges définissant clairement les nouveaux termes abordés, des anecdotes et retours d'expérience ;
  • le style d'écriture en général ;
  • la revue panoramique assez complète initiée par l'auteur, la présentation technologique générale.


Vous aborderez donc dans cet ouvrage: une étude de cas J2EE, les EJB, Ant, JBoss, les architectures J2EE ( MVC ) et autres patterns, HTTP, JWS, Checkstyle, XDoclet...


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 Coffret de 2 livres : Maîtrisez et optimisez le développement n-tiers

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

Coffret de 2 livres : Maîtrisez et optimisez le développement n-tiers

de
Public visé : Débutant

Résumé de l'éditeur

Ces deux livres de la collection Epsilon offrent au lecteur un maximum d'informations sur le développement d'applications n-tiers avec Java EE : 1512 pages pour devenir Expert. Le code lié aux études de cas traitées dans les 2 livres est en téléchargement sur le site www.editions-eni.fr. L'auteur propose également à ses lecteurs un lieu d'échanges via le site www.gdawj.com qui apporte également un certain nombre d'éléments complémentaires.

Java EE - Guide de développement d'applications web en Java Ce livre sur le développement d'applications web en Java s'adresse à tout développeur qui souhaite disposer de tous les détails des différentes étapes de réalisation d'une application web : l'analyse, la modélisation, le codage, la mise en production, les tests et la maintenance. Le livre suit une démarche progressive et s'appuie sur une étude de cas d'un développement d'une boutique de vente en ligne. Il est découpé en sept chapitres progressifs qui peuvent également être étudiés de manière autonome. Le premier chapitre présente le langage Java, explique les règles de nommage et les bonnes pratiques à adopter lors des développements de projets Java EE. Le chapitre 2 est consacré à la mise en place du serveur Java EE de référence, Tomcat, sous Windows et Linux. Les chapitres 3 et 4 explorent en détail les servlets et les JavaServer Page (JSP), en application avec l'étude de cas et le modèle MVC. Le chapitre 5 présente les bases de données en Java EE et détaille la mise en place de JDBC et des technologies associées. Le chapitre 6 concerne le développement Java EE à l'aide du framework Struts.[…]. Enfin, le dernier chapitre est consacré aux techniques avancées Java EE et permet de déployer un véritable projet sur un serveur en production à partir d'un nom de domaine.

Développements n-tiers avec Java EE - Architectures, GlassFish, JSF, JPA, JWS, EJB, JMS, SOAP, REST 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 […]. 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 […].Le second chapitre est consacré à la mise en place détaillée du serveur Java EE de référence : GlassFish […] 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 […]. Le quatrième chapitre explore en détail la couche de persistance standardisée en Java […]. Le chapitre cinq présente le tiers métier au travers de la dernière spécification des Enterprises JavaBeans […]. Le dernier chapitre est consacré à l'étude des services Web et traitements asynchrones en Java EE. Les technologies et services SOAP sont présentés en détail avec les différents types de clients (Java SE, Java EE et autres) tout comme les méthodes de packaging et déploiement (JAR, EAR, WAR). Enfin, la dernière partie explore de façon exhaustive l'architecture REST et la mise en place de services RESTful.

Édition : ENI - 1500 pages , 1re édition, 12 septembre 2011

ISBN10 : 274606751X - ISBN13 : 9782746067516

Commandez sur www.amazon.fr :

104.06 € TTC (prix éditeur 104.06 € TTC) livraison gratuite !
  • Guide de développement d'applications web en Java
    • Objectifs et spécifications de Java EE
    • Le serveur d'applications Apache-Tomcat
    • Les JavaServer Page
    • Les Servlets
    • Java et les bases de données
    • Framework Java EE
    • Techniques avancées
  • Développements n-tiers avec Java EE
    • La plate-forme JAVA EE
    • Le serveur Java EE GlassFish
    • La couche ou tiers Web
    • Java persistence API (JPA)
    • La couche ou tiers Métier
    • La couche ou tiers Service

Critique du livre par la rédaction prenom nom le 1er mai 2012


Le coffret "Maîtrisez et optimisez le développement n-tiers" contient deux livres de Jérôme Lafosse. Le premier s'intitule "Guide de développement d'applications Web en Java" et le second "Développements n-tiers avec Java EE". Si les deux livres sont disponibles séparément, je pense que c'est une bonne idée de proposer les deux ensembles tant ils sont complémentaires. On a ainsi à travers 1500 pages une présentation globale de la plateforme JEE.

Pour les débutants, le premier livre est idéal pour commencer.

L'auteur présente dans un premier chapitre les objectifs de JEE et les avantages à utiliser cette plateforme. J'ai apprécié qu'il indique d'entrée les conventions qu'il faut respecter pour tirer la quintessence de cette plateforme.

Puis, dès le second chapitre, il indique comment installer Tomcat. Je trouve ce choix très juste, car les développeurs ont besoin de démarrer rapidement lorsqu'ils apprennent une nouvelle technologie.

Au troisième chapitre, il présente les JSP et là encore, je trouve son choix judicieux dans la mesure où il est probable que le développeur Web souhaitant se mettre à Java ait déjà commencé par du HTML et du PHP. La transition n'en sera que plus douce.

Puisque les JSP sont compilées, il est naturel qu'au chapitre suivant, il traite des servlets. Une introduction au pattern MVC permet alors de situer les JSP par rapport aux servlets et nous conduit naturellement au dernier tiers qui est l'accès aux données.

Le cinquième chapitre présente donc l'API JDBC qui permet d'interagir avec des bases de données relationnelles.

Les deux derniers chapitres présentent le premier framework JEE Struts, le système de logging Log4J et le système de build ANT. Il existe des ouvrages spécialisés pour chacun de ces derniers sujets, mais pour débuter, il est pertinent d'avoir regroupé tout ce dont on a besoin dans un unique ouvrage. Certes, Struts n'est plus le framework JEE à la mode mais il est encore suffisamment utilisé en entreprise pour mériter un chapitre.

Le second livre est une suite logique du premier dans la mesure où il présente les nouvelles fonctionnalités de la plateforme. Il est intéressant de constater que l'auteur a suivi la même trame que pour son précédent ouvrage tout en progressant d'un niveau :

  • le chapitre d'introduction présente l'évolution de la plateforme JEE et la pléthore d'API, ainsi que les outils du développeur expérimenté : Subversion, Hudson, JUnit, Selenium ;
  • le serveur JEE Glassfish succède au conteneur de servlet Tomcat ;
  • le framework JSF orienté composants remplace les simples JSP ou le framework Struts orienté actions ;
  • l'API de persistance JPA remplace ici l'accès direct aux données via JDBC ;
  • on termine avec les couches métiers (EJB) et services (SOAP, REST).

Dans les deux livres, j'ai apprécié le fait que l'auteur utilise une application Web comme fil conducteur. Je lui suis également reconnaissant pour les petits détails pratiques qu'il distille tout au long des chapitres. Il a vraiment utilisé la plateforme et cela se voit.

En conclusion, si vous êtes familier des JSP, de Struts et de JDBC, et que vous souhaitez découvrir les nouveautés de JEE 6, c'est ce second livre qui vous intéressera le plus. En revanche, si vous souhaitez vous mettre au développement Web en Java, l'acquisition de ce coffret est recommandée. Il vous offre un guide progressif qui correspond à l'évolution naturelle qu'ont suivi de nombreux développeurs JEE expérimentés.


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 Apache Tomcat 7

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

Apache Tomcat 7

Guide d'administration du serveur Java EE 6 sous Windows et Linux

de

Résumé de l'éditeur

Ce livre sur Apache Tomcat 7 s'adresse à toute personne appelée à mettre en oeuvre ce serveur d'applications sous Windows ou Linux, que ce soit pour des besoins de test, de développement, ou des besoins de production dans un environnement d'entreprise.
Les deux premiers chapitres permettent de faire quelques rappels essentiels sur les technologies Internet et Java/Java EE, massivement utilisées par Tomcat.
Les chapitres suivants se concentrent sur les aspects fondamentaux de l'administration d'un serveur d'applications tels que l'installation, en tenant compte des contraintes d'entreprise, la gestion des applications ou encore la configuration de Tomcat 7.
Enfin les derniers chapitres présentent les points un peu plus avancés que sont la sécurité, la supervision du serveur et l'optimisation des performances, pour conclure sur l'utilisation de Tomcat 7 lors des phases de développement d'applications.
Avec un tel livre, le lecteur possède toutes les clés pour mettre en place une véritable infrastructure d'entreprise sécurisée et performante.
Si le lecteur est familier d'une version précédente de Tomcat, il pourra approfondir ses connaissances en trouvant dans ces pages une information précise pour une mise en application immédiate.

Édition : ENI - 430 pages , 1re édition, 6 juin 2011

ISBN10 : 2746062399 - ISBN13 : 9782746062399

Commandez sur www.amazon.fr :

28.04 € TTC (prix éditeur 39.00 € TTC) livraison gratuite !
  • Avant-propos
  • Préambule
  • La plate-forme Java EE 6
  • Le serveur Apache Tomcat 7 : installation et configuration
  • Administration du serveur
  • Déploiement et gestion des applications
  • La sécurité du serveur et des applications
  • Analyse et supervision
  • Clustering avec Tomcat 7
  • Utiliser Tomcat pour le développement
  • Annexe A : Installation et configuration de MySQL 5
  • Annexe B : Installation et configuration d'OpenLDAP
Critique du livre par la rédaction prenom nom le 1er août 2011
J'utilise Tomcat en développement depuis quelques années et j'avais envie d'en savoir un peu plus sur cet outil. J'aurai pu explorer la documentation technique en anglais sur le Web mais je me suis dit que ça serait plus confortable de lire un livre, l'idéal étant qu'il soit écrit en français et qu'il concerne la dernière version. Avec ces exigences, je n'en ai trouvé qu'un seul, celui d'Etienne Langlet intitulé sobrement "Apache Tomcat 7".

Ce livre s'adresse à un large public. Après les rappels sur le contexte technique (Java, JEE), les débutants pourront suivre étape par étape les différentes procédures avec captures d'écrans (installation, configuration). Les utilisateurs intermédiaires apprécieront que l'auteur considère aussi bien les environnements Windows que Linux. Les plus experts découvriront des conseils pour améliorer la sécurité (paramètres à positionner, activation du gestionnaire de sécurité de la JVM) et des fonctionnalités moins connues (interface texte du manager).

Ce livre couvre tous les aspects : utilisation avec les outils de développement (eclipse, netbeans, ant), configuration avec les serveurs web en frontal (Apache, IIS), déploiement d'applications sur une seule ou plusieurs JVM en répartition horizontale ou verticale, sécurisation des applications (HTTPS, SSO, JAAS), analyse et supervision (logging, tests de montée en charge, JMX).

Je n'ai pas vraiment de reproches sinon sur la forme. Je ne suis pas un grand fan de la mise en page mais c'est plus une contrainte de la collection. En revanche, j'ai trouvé certains schémas très bien réalisés.

En conclusion, c'est un ouvrage très intéressant que je recommande à tous ceux qui veulent en savoir plus sur Tomcat.




 Poster une réponse Signaler un problème

Avatar de Djug Djug - Expert éminent sénior https://www.developpez.com
le 24/08/2011 à 13:06
La rédaction de DVP a lu pour vous l'ouvrage suivant:

Apache Tomcat 7 - Guide d'administration du serveur Java EE 6 sous Windows et Linux, de Etienne LANGLET



RÉSUMÉ DE L'ÉDITEUR
Ce livre sur Apache Tomcat 7 s'adresse à toute personne appelée à mettre en oeuvre ce serveur d'applications sous Windows ou Linux, que ce soit pour des besoins de test, de développement, ou des besoins de production dans un environnement d'entreprise.
Les deux premiers chapitres permettent de faire quelques rappels essentiels sur les technologies Internet et Java/Java EE, massivement utilisées par Tomcat.
Les chapitres suivants se concentrent sur les aspects fondamentaux de l'administration d'un serveur d'applications tels que l'installation, en tenant compte des contraintes d'entreprise, la gestion des applications ou encore la configuration de Tomcat 7.
Enfin les derniers chapitres présentent les points un peu plus avancés que sont la sécurité, la supervision du serveur et l'optimisation des performances, pour conclure sur l'utilisation de Tomcat 7 lors des phases de développement d'applications.
Avec un tel livre, le lecteur possède toutes les clés pour mettre en place une véritable infrastructure d'entreprise sécurisée et performante.
Si le lecteur est familier d'une version précédente de Tomcat, il pourra approfondir ses connaissances en trouvant dans ces pages une information précise pour une mise en application immédiate.

L'avez-vous lu? Comptez-vous le lire ?

Quel est votre avis?

 
couverture du livre Java EE 5

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

Java EE 5

EJB 3.0 - JPA - JSP - JSF - Web services - JMS - GlassFish 3 - Maven 3

de
Public visé : Intermédiaire

Résumé de l'éditeur

Ce cahier détaille la conception d'un site de e-commerce avec UML et Java Enterprise Edition 5. Inspirée du Java Petstore, l'étude de cas se construit au fil des chapitres en appliquant les spécifications Java EE 5 : EJB 3.0, JPA 1.0, Servlet 2.5, JSP 2.1, JSF 1.2, Web Services 1.2, JAXB 2.0, JAX-WS 2.0, JavaMail 1.4, JMS 1.1. L'application est déployée dans le serveur GlassFish 3.0.1 et utilise la base de données Derby. Cet ouvrage s'adresse aux architectes et développeurs confirmés qui veulent découvrir Java EE 5 ou migrer leurs applications J2EE 1.4 existantes. Il montre comment s'imbriquent les différentes API de Java EE 5 dans une application internet-intranet et introduit Maven, le nouvel outil d'automatisation de développements d'Apache.

Édition : Eyrolles - 340 pages , 3eédition, 1er mars 2011

ISBN10 : 2212126581 - ISBN13 : 9782212126587

Commandez sur www.amazon.fr :

34.02 € TTC (prix éditeur 36.00 € TTC) livraison gratuite !
  • Présentation de l'étude de cas
  • Architecture de l'application
  • Outils et installation
  • Objets persistants
  • Traitements métier
  • Exécution de l'application
  • Interface web
  • Gestion du panier électronique
  • Échanges B2B
  • Traitements asynchrones
  • Annexe
Critique du livre par la rédaction Philippe Vialatte le 1er juin 2011
N'ayant plus développé en Java depuis 2002, il m'est soudain venu l'envie de jeter un oeil sur l'évolution de J2EE (oui, à l'époque, on ne disait pas encore JEE), au moins pour voir ce qu'il était devenu en mon absence. Voyant le titre et les informations sur ce livre sur le site de l'éditeur, je m'attendais à "encore un" autre livre sur le développement, présentant en vitesse quelques concepts avant de plonger dans le code, sans forcément creuser les concepts sous-jacents.
Grave erreur.
Sous des aspects pas forcément de bon augure (couverture flashy, liste à la Prévert des sujets abordés), ce livre est en fait un vrai plaisir à lire, qui présente (selon moi) les choses au juste niveau de détail pour un développeur un peu expérimenté.
Non content de donner une bonne vision de la plate-forme Java (ce qui commence à être un exploit, vu la quantité d'informations), le livre propose une approche résolument orientée vers un architecte ou un développeur expert, et passe beaucoup plus de temps à détailler la conception que l'implémentation, le code étant téléchargeable depuis le site de l'auteur.
Chacun des chapitres commence par une présentation du contexte et de l'historique de la brique étudiée (persistance, communication, etc.), avant de montrer un certain nombre d'exemples d'implémentation, tout en parsemant la marge de notes vers des références plus exhaustives, que ce soit d'autres livres ou des sites Web.
Finalement, si ce que vous attendez d'un livre est d'avoir une vue de toute la plate-forme, et tous les pointeurs nécessaires pour construire sur des bases solides, ce livre est pour vous. Si, au contraire, vous cherchez un cours de développement, ou un annuaire contenant toutes les API de J2EE, passez votre chemin.


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 Programmation GWT 2

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

Programmation GWT 2

Développer des applications RIA et Ajax avec Google Web Toolkit

de
Public visé : Intermédiaire

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 2.0 interactives et robustes avec autant d'aisance qu'en Flex ou Silverlight. Publié en licence libre Apache, le Google Web Toolkit génère depuis Java du code Ajax (JavaScript et XHTML/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 bibliothèques tierces principales telles que GWT-DnD, les API Google Calendar, Google Maps, SmartGWT et Ext-GWT...

Édition : Eyrolles - 461 pages , 1re édition, 5 janvier 2010

ISBN10 : 2212125690 - ISBN13 : 9782212125696

Commandez sur www.amazon.fr :

33.25 € TTC (prix éditeur 35.00 € TTC) livraison gratuite !
  • Introduction à GWT
  • L'environnement de développement
  • Les contrôles
  • Le modèle de placement
  • Bibliothèques tierces
  • Intégration de code JavaScript
  • Créer ses propres composants
  • Les services RPC
  • Intégration J2EE
  • Chargement à la demande
  • Liaison différée
  • Gestion des ressources
  • Sous le capot de GWT
  • Internationalisation
  • Gestion des tests
  • Design patterns GWT
  • Gérer la sécurité
  • UiBinder
  • Plugin Eclipse
Critique du livre par la rédaction nico-pyright(c) le 1er mai 2010
Programmation GWT 2 est un livre écrit par Sami Jaber, consultant indépendant, qui s'est immergé dans le projet GWT 2 pendant son élaboration. Ceci lui a permis d'écrire cet ouvrage en avant première.

Il ne faut pas considérer ce livre comme un tutoriel évolué qui décrit comment développer une application GWT. L'auteur met plutôt l'accent sur les nouveautés du framework et décortique les prouesses technologiques de GWT.

La première partie du livre est une présentation rapide de GWT et de l'environnement de développement. On assiste ensuite à un tour très rapide des widgets disponibles dans GWT ainsi que les divers conteneurs. Ici, un développeur débutant désireux de prendre en main la technologie regrettera que l'auteur passe un peu rapidement sur ces points. Pour bien apprécier le livre, il faut à mon avis avoir déjà bricolé un peu la version 1.X de GWT.

On appréciera le chapitre 4 qui présente les bibliothèques tierces, comme GXT ou SmartGWT. Même s'il est assez succinct, cela donne un aperçu global des possibilités du marché.

Avec le chapitre 5, on entre dans les arcanes de GWT avec la présentation de JSO et des Overlay. Ce chapitre est un peu complexe à suivre mais on voit que l'auteur est impressionné par l'inventivité des créateurs du framework et a cherché à bien comprendre la magie qu'il y a dessous.

On lira avec intérêt le chapitre 7 sur les services RPC, éléments incontournables pour créer une vraie application.

Ensuite l'auteur décrit les nouveautés de GWT 2, comme les optimisations du chargement à la demande, la liaison différée ou la gestion des ressources et l'internationalisation.

On découvrira aussi ce qui se passe "sous le capot de GWT" avec notamment la génération de JS et les optimisations.

En fin de livre, on appréciera les chapitres qui parlent de comment créer des tests dans une application GWT 2 et qui présentent des designs patterns et bonnes pratiques pour le développement d'application GWT. Et, cerise sur le gâteau, l'avant dernier chapitre est consacré à UIBinder, une des grandes nouveautés de la version 2 et nous met l'eau à la bouche avec cet outil qui va grandement simplifier la création des interfaces graphiques.

Globalement, le livre est plutôt bien écrit et clair. Certains chapitres sont assez difficiles à comprendre et pas toujours indispensables à l'apprentissage de GWT. Par contre, ils sont très intéressant pour la culture ou pour maitriser complètement les arcanes de GWT.

Je recommanderai cet ouvrage dans un premier temps aux personnes ayant eu une première expérience dans le développement GWT et qui cherchent à utiliser avec profit les nouveautés de GWT 2. Les développeurs ne connaissant pas du tout GWT auront à mon avis besoin de beaucoup de travail personnel pour commencer à appréhender les subtilités de ce framework.
Critique du livre par la rédaction prenom nom le 1er janvier 2010
Pour diffuser des ressources sur une technologie, on peut soit traduire une ressource existante dans une autre langue, soit créer une nouvelle ressource de toute pièce. Sami Jaber a choisi, pour notre plus grand bonheur, la seconde solution. L'originalité de son ouvrage consiste à apporter des informations complètement inédites sur GWT 1.0 et 2.0.

Sur la forme, c'est un ouvrage technique qui se picore davantage qu'il ne se lit de bout en bout.

Sur le fond, c'est assez riche. Jugez plutôt :

1) Des chapitres "classiques" qu'on retrouve plus ou moins dans les autres livres GWT.

L'introduction intéressera particulièrement les décideurs puisqu'elle brosse une vue d'ensemble de GWT et le situe face aux autres frameworks Ajax.

Les chapitres "L'environnement de développement", "Les contrôles", "Le plug-in Eclipse pour Gwt" s'adresseront davantage aux développeurs débutants qui n'auraient pas préalablement lu de livre sur le sujet.

Le chapitre "Les bibliothèques tierces" est un peu tiède à mon goût, à la fois pas assez exhaustif (comment pourrait'il l'être ?) et trop détaillé pour un simple survol (Qu'est ce qu'apporte un seul exemple ?). Notez bien mon questionnement car à la place de l'auteur, je ne sais pas comment j'aurai fait ? Il ne pouvait pas passer dessus et il ne pouvait pas trop détailler non plus pour des contraintes éditoriales évidentes; il a donc opté pour une solution intermédiaire. Une fois le livre terminé, ma perplexité subsiste. Les librairies présentées sont intéressantes aujourd'hui mais comparé au potentiel de GWT 2, elles paraissent bien fades.

  • Smart GWT étant un wrapper de code JS, on perd des avantages de GWT (comme le debug pas à pas, la prévention contre les fuites mémoires, ...)
  • GXT quand à elle est une librairie full GWT mais tous ceux qui ont regardé son code vous diront qu'elle est loin déjà d'avoir intégré toute la puissance de GWT 1.0 (deferred binding). On a donc hâte qu'elle soit réécrite en tirant toutes les spécificités supplémentaires introduites par GWT 2.0.
  • Gears est aujourd'hui abandonnée au profit d'une solution plus standard du W3C.
  • Quand aux autres plus particulières, on a qu'un souhait : que leur intégration future à GWT se fasse le plus tôt possible.

Le chapitre "Les services RPC" ressemble pour l'essentiel à ce qu'on trouve ailleurs. Certes, l'auteur parle de deRPC, la nouvelle version du RPC, du mode hybride compatible RPC 1.X et RPC 2.X, de bonnes pratiques et du contournement de la règle SOP (Exemple du proxying) mais il m'a un peu laissé sur ma faim. J'aurai aimé dans ce chapitre une section "sous le capot" telle qu'on les trouve dans d'autres chapitres. J'aurai également aimé qu'il détaille la connexion d'un client RPC à un serveur non RPC.

2) Des chapitres qui détaillent des aspects de GWT comme aucun ouvrage ne l'a fait jusqu'à présent.

Le chapitre "L'intégration de code Javascript" est passionnant. En suivant la problématique, l'approche historique et les débats de l'équipe de développement GWT, on a l'impression d'être avec eux dans les coulisses.

Le chapitre "La création de composants personnalisés" est assez étoffée. On y apprend surtout pourquoi Javascript a des fuites mémoires et comment GWT s'y prend pour les éviter. A conseiller aux développeurs Javascript !!!

Le chapitre "L'intégration J2EE" fournit des pistes à ceux qui doivent s'interfacer avec du Spring et des EJB. Certains reprocheront que la liaison avec leur librairie préférée n'est pas abordée mais vu la richesse de J2EE, le choix de l'auteur se limitant aux deux principales est pertinent.

Les chapitres "La liaison différee" et "Sous le capot de GWT" détaillent les mécanismes utilisés par GWT pour générer du code multi navigateur et optimisé. Très intéressant !!!

Le chapitre "L'internationalisation" est très complet. Je note particulièrement la question des formes plurielles et des outils pour en écrire le moins possible (Feignant ? Non, productif !).

Dans le chapitre "Les design Pattern GWT", il est question à la fois des patterns MVC, MVP pour séparer les responsabilités et de bonnes pratiques concernant l'historique, les traitements longs et la sécurité. Cette dernière étant détaillée (injection sql, XSS, CSRF, authentification), elle pourrait peut être faire l'objet d'un chapitre séparé ?

3) Et "must have", des chapitres complètements inédits sur la version 2.0 qui est sortie en même temps que l'ouvrage.

Le chapitre "Les modèles de placement CSS" intéressera tous ceux qui ont galéré pour faire la mise en page de leur application GWT. La nouvelle solution est beaucoup plus propre et est donc à essayer d'urgence !

Le chapitre "Le chargement à la demande" décrit la nouvelle fonctionnalité qui permet de partitionner le code javascript généré. Sur le papier, elle semble intéressante mais reste à voir en pratique si elle n'apporte pas davantage de complexité. Mais bon, l'ami Sami vous aura prévenu !

Le chapitre "La gestion des ressources" répond également à une problématique d'optimisation des temps de chargements. On y apprend comment mettre en cache tout types de ressources et même comment faire de l'injection de styles CSS (Il faut dire que l'extension du mécanisme ImageBundle a permis d'introduire des directives dans les fichier CSS)

Le chapitre "L'environnement de tests" présente les styles de test introduits dans la nouvelle version. A se demander comment on faisait avant ?

Le chapitre "La création d'interface avec UIBinder" sera utile à tous ceux qui préfèrent coder leur vues en XML.

Comme je vous le disais dans ma critique du livre d'Olivier Gérardin, les francophones ont dû attendre plus de 3 ans les livres en français sur GWT mais une fois de plus, cela valait le coup d'attendre. Le hasard faisant bien les choses, je suis ravi de l'ordre de parution puisque après le premier livre en français sur GWT (plus didactique), les développeurs pourront continuer avec celui-ci (plus technique), le premier livre mondial sur GWT 2.0.




 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:23
Programmation GWT 2 : Développer des applications RIA et Ajax avec Google Web Toolkit: Amazon.fr: Sami Jaber: Livres@@AMEPARAM@@http://ecx.images-amazon.com/images/I/51oU0cKXfDL.@@AMEPARAM@@51oU0cKXfDL

23/01/2009

Citation Envoyé par benwit Voir le message
Je viens de le terminer !

Si vous voulez savoir ce que j'en pense, venez lire ma critique .

Si vous avez des questions à me poser ou des commentaires à faire sur mes remarques, n'hésitez pas à venir en discuter ici.
04/12/2009


Le titre de l'ouvrage est désormais connu et les précommandes ouvertes notamment sur Amazon.

Et nous vous proposons également les grandes lignes du sommaire :
  • Introduction à GWT
  • L’environnement de développement
  • Les contrôles
  • Le modèle de placement CSS
  • Les bibliothèques tierces
  • L’intégration de code JavaScript
  • La création de composants personnalisés
  • Les services RPC
  • L’intégration J2EE
  • Le chargement à la demande
  • La liaison différée
  • La gestion des ressources
  • Sous le capot de GWT
  • L’internationalisation
  • L’environnement de tests
  • Les design patterns GWT
  • La création d’interfaces avec UIBinder
  • Le plug-in Eclipse pour GWT
Découvrez non seulement la table des matières complète ainsi que l'avant propos, mais également la couverture de l'ouvrage.
07/11/2009

Bonjour,

Il reste encore quelques mystères (titre, sommaire) sur ce livre à l'initiative de Sami Jaber qui sortira aux éditions Eyrolles, mais ce que l'on sait c'est qu'il fera près de 400 pages, qu'il couvrira GWT 2.0, et que sa sortie devrait intervenir en parallèle de la release finale de GWT 2.0.

Les informations seront relayées dans ce fil de discussion au fil de l'eau dès leur officialisation.

Cet ouvrage vous intrigue ? Pensez vous qu'il puisse vous être utile pour démarrer ou passer à GWT 2.0 ?

N'hésitez pas à poster vos commentaires à la suite, notamment pour ceux qui se pencheront sur le livre lors de sa sortie.
Avatar de nicorama nicorama - En attente de confirmation mail https://www.developpez.com
le 11/11/2009 à 9:37
Pour avoir discuter avec Sami au JUG de Toulouse, et pour avoir lu régulièrement son blog, je pense que le livre sera très bon.
GWT est une techno assez particulière, et l'achat d'un livre n'est quand même pas superflu !
Avatar de lunatix lunatix - Rédacteur https://www.developpez.com
le 11/11/2009 à 11:47
tres bonne idée, GWT 2 semble tres prometteur en reglant les défauts de la premiere version (rpc servlet, layouts en xml etc..)

c'est ou les précommandes ?
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éer des applications web interactives avec Google Web Toolkit versions 1.7 et 2.0: Amazon.fr: Olivier Gé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 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 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 Ajax pour Java

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

Ajax pour Java

L'art de la programmation XML et XMLHttpRequest

de
Public visé : Intermédiaire

Résumé de l'éditeur


Comment rendre ses applications web en Java plus dynamiques et réactives ? En mettant de l'Ajax dedans bien sûr ! Grâce aux fonctionnalités typiques d'Ajax, les applications web peuvent s'enrichir de listes de suggestions ou de glisser-déposer de fenêtres qui faciliteront l'accès aux données en temps réel. Ajax pour Java est un guide qui aidera les développeurs Java à se familiariser avec Ajax et les technologies qui s'y rattachent (Struts, Google Web Toolkit, JavaScript, XMLHttpRequest ou encore JSON). Il leur apprendra, par exemple, comment créer des applications s'appuyant sur JavaScript côté-client, lancer des requêtes depuis une servlet Java et en afficher les résultats sans devoir rafraîchir toute la page web, mettre en oeuvre une stratégie client/serveur à base de données brutes avec XML et JSON pour produire des ensembles de données complexes. Il développe entre autres les aspects suivants :
  • Le glisser-déposer avec les bibliothèques JavaScript Prototype, script.aculo.us
  • La création d'un nuage de tags ; La construction d'un champ de suggestions
  • L'intégration d'Ajax dans des applications JSP et JSF
  • L'utilisation de Struts dans Ajax avec DWR
  • L'exploitation de Google Web Toolkit pour compiler les applications écrites en Java en HTML et JavaScript
  • La mise en place de services au client avec GWT


À l'ère du Web 2.0, Ajax pour Java s'adresse aux développeurs Java souhaitant doper leurs applications en ligne avec Ajax en leur fournissant souplesse, interactivité et réactivité.

Édition : O'REILLY - 216 pages , 1re édition, 25 mai 2007

ISBN10 : 2841774619 - ISBN13 : 9782841774616

Commandez sur www.amazon.fr :

33.25 € TTC (prix éditeur 35.00 € TTC) livraison gratuite !
  • Installation de l'environnement logiciel
  • JavaScript pour Ajax
  • Un servlet Ajax simple
  • XML et JSON pour Ajax
  • Manipulation efficace des données
  • Bibliothèques et boîtes à outils Ajax
  • Etiquette Ajax
  • Ajax et Stuts
  • Ajax et JavaServer Faces
  • Google Web Toolkit
Critique du livre par la rédaction kmdkaci le 1er mai 2009
Vous ne vous êtes jamais demandé comment une application comme Google Maps est si réactive ? Ou comment certains sites vous suggèrent des informations en fonction de ce que vous êtes en train de saisir dans les champs des formulaires ? Si vous n'avez pas encore de réponse, vous trouverez des réponses dans le livre "Ajax on Java" de Steve Olson, traduit en français par Denis Priou.

Ce livre est destiné aux développeurs souhaitant réaliser des applications web dotées du concept Ajax. Le premier chapitre décrit les étapes nécessaires à l'installation de l'environnement Java, suivi d'un exemple d'interaction entre un client et un serveur via Ajax, dont on trouve la description coté client au chapitre 2 et l'utilisation côté serveur au chapitre 3. Même si on associe souvent XML à Ajax, l'auteur nous montre que cette structure de données n'est pas toujours nécessaire quand il s'agit d'une simple application ou quand il n'y a qu'une donnée à échanger entre le serveur et le client à un instant donné. En revanche si l'application nécessite des transferts de données nombreux et complexes, recourir à une structure comme XML ou JSON est primordial. C'est ce qui est décrit au chapitre 4. Dans ce dernier, l'auteur présente différentes API de parsing XML, notamment JDOM, DOM4J et SAX. Il y décrit aussi la façon de recevoir les données et surtout comment JavaScript exploite le code XML. Dans le même chapitre l'auteur présente une "alternative" à XML. Il s'agit de JSON, un moyen simple et moins gourmand en ressources, mais qui présente aussi l'avantage de pouvoir effectuer des analyses avec la fonction eval() de JavaScript.

Au chapitre 5, l'auteur décrit les méthodes qui permettent d'atteindre des informations stockées dans une base de données et de les afficher intuitivement grâce à Ajax. Chaque jour qui passe apporte son lot de nouvelles applications web. Pour accélérer les développements, de nombreuses librairies ont vu le jour pour aider les développeurs à créer des sites web utilisant Ajax.

Le chapitre 6 présente ces différentes boîtes à outils, entre autres Dojo Toolkit, Rico Toolkit et DWR (Direct WebRemoting) lesquelles offrent de nombreuses fonctionnalités très utiles. A la fin du chapitre, un exemple de Glisser-Déposer a été détaillé avec la librairie Scriptaculous et Prototype. Cet exemple complet décrit la création d'un panier pour un site e-Commerce.

Si vous êtes amené à réécrire plusieurs fois le même code pour Ajax, sachez que le chapitre 7 vous explique comment développer des fonctionnalités personnelles que vous allez réemployer dans vos applications en créant vos propres étiquettes et utiliser dans les pages JSP.

Le chapitre 8 et 9 présentent les techniques t'intégration d'Ajax dans des applications développées avec les Framework Struts et JSF (Java Server Faces). Le chapitre 10 est un tutoriel présentant l'outil GWT (Google Web Toolkit).

Cet ouvrage est destiné aux développeurs web en Java. Les cours sont présentés d'une manière progressive. Toutefois, les développeurs familiarisés avec les Servlets, JavaScript, HTML et l'analyse syntaxique sous XML n'auront pas de mal à suivre les exemples et les codes sources décrits dans ce livre. Grâce à Ajax vos applications deviendront plus intuitives et réactives. L'auteur l'a dit : "Développeurs Swing, soyez prévenus : Ajax hausse le ton et le niveau de jeu !"




 Poster une réponse Signaler un problème

Avatar de Ricky81 Ricky81 - Expert éminent sénior https://www.developpez.com
le 20/05/2009 à 9:58
Bonjour,

Kamel Kaci a publié une critique de Ajax pour Java traduction de "Ajax on Java"

Petits extraits :

Cet ouvrage est destiné aux développeurs web en Java. Les cours sont présentés d'une manière progressive.
L'auteur l'a dit : "Développeurs Swing, soyez prévenus : Ajax hausse le ton et le niveau de jeu !"
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 Développement JEE 5 avec Eclipse Europa

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

Développement JEE 5 avec Eclipse Europa

de
Public visé : Débutant

Résumé de l'éditeur

Résolument pratique, cet ouvrage montre comment utiliser de manière cohérente et efficace les différents outils de la suite Eclipse Europa, combinés à des frameworks tels que JBoss Seam, pour couvrir l'ensemble du cycle de développement d'une application Java EE 5 et tirer parti des innovations de la spécification EJB 3.

L'ouvrage met l'accent sur la conception du modèle de données avec Data Tools, le développement JSF avec Web Tools et Seam, le nouveau standard EJB 3.0, le mapping objet-relationnel avec Java Persistence API et le framework Dali, l'approche de développement piloté par le modèle avec EclipseUML et AndroMDA, les fonctionnalités avancées du framework Seam et le déploiement sur le serveur JBoss.

Cette approche est illustrée au travers de l'étude de cas WebStock, application e-commerce construite au fil de l'ouvrage et dont le code source est disponible sur www.editions-eyrolles.com. Le lecteur acquerra ainsi une parfaite maîtrise des outils et une solide méthodologie de développement reposant sur un ensemble de "best practices" en matière de conception d'applications EJB 3.

Édition : Eyrolles - 377 pages , 1re édition, 4 octobre 2006

ISBN10 : 2212120613 - ISBN13 : 9782212120615

Commandez sur www.amazon.fr :

42.75 € TTC (prix éditeur 45.00 € TTC) livraison gratuite !
  • Partie 1 : La plate-forme de développement Europa
    • Nouveauté d'Europa
    • Support du client riche avec Eclipse RCP
    • Support du développement en équipe sous Eclipse avec CVS
    • Profiling de code avec le projet TPTP
  • Partie 2 : Développement Web avec le projet Eclipse Web Tools
    • Le projet WTP ( Web Tools Platform )
    • Conception du modèle de données avec le projet DTP
    • Développement Web avec l'outillage Web Tools et les patterns
    • Développement Web avec le framework JBoss Seam
  • Partie 3 : Développement EJB 3 avec Eclipse et les Web Tools
    • Les fondamentaux EJB 3
    • L'API JPA et la gestion des entités
    • Mapping JPA avec Dali
    • Mise en oeuvre de l'application webstock
    • Configuration EJB3 avancée avec Seam
  • Partie 4 : Annexes
    • Annexe A : Procédure d'installation
    • Annexe B : Annotations Seam

Critique du livre par la rédaction yolepro le 1er septembre 2009
Depuis maintenant plusieurs années (je n'ose pas compter) que je développe sous Eclipse, j'ai toujours eu des difficultés à comprendre le fonctionnement de ces différents modules, leurs couvertures et leurs interactions. Dans ce contexte ce livre me semblait convenir et je n'ai pas été déçu. J'ai toujours eu l'habitude d'utiliser Eclipse en anglais et si la plupart des impressions d'écran sont en anglais, certaines demeurent "étrangement" en français. On sent tout de même qu'un effort particulier a été fait sur ce point. Ce livre est vraiment idéal pour celui qui veut connaître les différentes briques logicielles qui composent Eclipse Europa avec un niveau de détail la plupart du temps suffisant (idéal pour des experts techniques ou des responsables techniques).

Le chapitre RPC détaille un exemple simple d'implémentation d'une application RCP. Ce chapitre est très intéressant mais je suis resté un peu frustré de ne pas pouvoir faire un test directement avec les corrigés car les sources ne sont pas disponibles sur le site Eyrolles.

Le chapitre sur la gestion de configuration avec CVS ou SVN est par contre presque trop détaillé et l'on aurait pu se passer de l'installation de Tortoise, mais cela montre un côté que l'on a moins l'habitude de voir : l'installation d'un serveur CVS et SVN. Cette étape fait souvent perdre du temps dans le démarrage amont d'un projet. Le chapitre sur le profiling montre un outil relativement inconnu qui peut être très important pour limiter les risques de fuite mémoire sur un projet. Il couvre de manière générale le spectre des outils intégrés dans TPTP. Ces modules sont relativement poussés et pourraient permettre l'économie de licence d'outils onéreux tel que JProbe.

La présentation des sous-projets JST et WST nous explique de manière exhaustive les composants qu'ils contiennent. Cela reste superficiel bien entendu (il faudrait presque un livre pour chaque module) mais j'aurais bien aimé avoir quelques précisions sur le fonctionnement des modules web services, monitor TCP (quelques lignes, voir un paragraphe aurait suffi). De plus le fait de découper par incubateur (JST d'un côté et WST de l'autre) fait que l'on retrouve les modules pêle-mêles ce qui nuit un peu à la lisibilité. La partie Data Tools Platform reste assez superficielle mais couvre les points indispensables à connaître. Par contre, tout le déroulement du chapitre parle d'Apache Derby alors que les scripts fournis ainsi que les exemples des chapitres suivants utilisent tous Mysql 5. Du coup, impossible d'intégrer les scripts à la base Derby.

Cette partie fait malheureusement sombrer le lecteur que je suis dans une impuissance dûe au fait qu'il m'est impossible d'intégrer les projets des chapitres suivants. Du coup, lire les exemples d'implémentation sans pouvoir les tester réellement est vraiment frustrant. Le format et la distance dans les explications est très bien trouvé de mon point de vue, mais cela aurait dû être appuyé par des projets téléchargeables "impeccables" et une démarche pour suivre sur ces projets. Les chapitres suivants sont bien entendu intéressants même si la partie Seam est à mon sens en trop car non intégrée dans la plate forme standard Europa.

Il est évident que des outils comme Eclipse évoluent très rapidement (depuis Europa sont sortis Ganymede et Galileo) et les supports papiers ne sont donc pas forcément les plus adaptés. Il y manque d'ailleurs le projet Mylyn (arrivé depuis Galileo) concernant les aspects de gestion des tâches et automatisations des process. Mais ce livre montre les principales fonctionnalités d'Eclipse ce qui est déjà conséquent. De plus cet outil devenant le centre des processus de développement il est actuellement indispensable de connaître les domaines techniques qu'il couvre et comment les utiliser. En attendant une version Galileo du bouquin, il reste donc la référence en son genre.
Critique du livre par la rédaction Hikage le 1er septembre 2008
Eclipse étant de plus en plus utilisé par les entreprises, nous sommes tous un jour confrontés à celui-ci. Et si vous désirez maîtriser rapidement l'IDE, ce livre pourrait être une solution.

Le livre va présenter les différents modules et plugins disponibles pour vous aider dans le développement Java allant du module WTP pour le développement Web, au plugin TPTP pour le profiling de code ou le projet Dali pour le support JPA.
Pour chacun des modules, l'installation sera décrite si elle est nécessaire et l'utilisation du module sera expliquée clairement. Le tout est accompagné de nombreuses copies d'écran.

Un rappel général des différentes technologies JEE est fait comme c'est le cas pour JSF ou les EJB par exemple. Mais même si le titre du livre spécifie JEE, celui-ci ne s'y arrête pas rigoureusement en présentant JBoss Seam (un projet basé sur JSF), la programmation de client riche ou encore la conception MDA avec EclipseUML et AndroMDA.

Bref, ce livre est très bien fait et permet de vite prendre en main les différents plugins nécessaires au développement de projet Java.




 Poster une réponse Signaler un problème

Avatar de Ricky81 Ricky81 - Expert éminent sénior https://www.developpez.com
le 26/09/2009 à 10:16
Bonjour,

Nous avons déjà 2 critiques pour cet ouvrage.

[ame="http://www.amazon.fr/Développement-JEE-avec-Eclipse-Europa/dp/2212120613/wwwdeveloppec-21"]Développement JEE 5 avec Eclipse Europa: Amazon.fr: Karim Djaafar: Livres[/ame]

Y-a-t-il d'autres avis ?
Avatar de kmdkaci kmdkaci - Membre éprouvé https://www.developpez.com
le 29/09/2009 à 14:59
Bonjour à tous,
J'ai acheté le livre, je le trouve bien et surtout structuré. C'est un moyen simple et efficace pour comprendre l'environnement Eclipse avec les differents framworks. J'ai aussi apprecié l'explication de la 3eme partie, celle liée aux EJB.

 
couverture du livre Les Cahiers du programmeur Java EE 5

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

Les Cahiers du programmeur Java EE 5

de
Public visé : Intermédiaire

Résumé de l'éditeur

Ce cahier détaille la conception d'un site de commerce électronique avec UML et Java EE 5. Inspirée du Java Petstore, l'étude de cas se construit au fil des chapitres en appliquant les spécifications Java EE 5 : EJB 3.0, JPA 1.0, Servlet 2.5, JSP 2.1, JSF 1.2, Web Services 1.2, JAXB 2.0, JAX-WS 2.0, JavaMail 1.4, JMS 1.1. L'application est déployée dans le serveur GlassFish et utilise la base de données Derby.

Cet ouvrage s'adresse aux architectes et développeurs confirmés qui veulent découvrir les nouveautés de Java EE 5 ou migrer leurs applications J2EE 1.4 existantes. Il montre comment s'imbriquent les différentes API de Java EE 5 dans une application internet-intranet.

Édition : Eyrolles - 329 pages , 1re édition, 1er mai 2009

ISBN10 : 2212120389 - ISBN13 : 9782212120387

Commandez sur www.amazon.fr :

34.02 € TTC (prix éditeur 36.00 € TTC) livraison gratuite !
  • Présentation de l'étude de cas
  • L'architecture de l'application
  • Outils et installation
  • Objets persistants
  • Traitements métier
  • Exécution de l'application
  • Interface web
  • Gestion du panier électronique
  • Conserver l'état dans l'application
  • Echanges
  • Traitements asynchrones
  • Annexes
    • Spécifications EE5
    • Tâches ANT
    • Sigles et acronymes
    • EJB2


Critique du livre par la rédaction afrikha le 1er janvier 2008
Ce livre est une réussite dans la mesure où il atteint les objectifs qu'il s'était fixé, à savoir faire découvrir Java EE 5 aux architectes et développeurs confirmés. L'ouvrage s'articule autour de la réalisation d'un site de commerce électronique ce qui a pour avantage d'éclairer à chaque chapitre les concepts théoriques vus précédemment, et permet de mesurer d'une manière précise les apports de Java EE 5 dans la pratique, sans pour autant rentrer dans les détails de chaque spécification abordée. Pour cela l'auteur a pris soin de mettre des références fort pertinentes.

La progression du livre est très pédagogique ce qui est un tour de force compte tenu de l'étendue du sujet : l'auteur parvient à expliquer au fur et à mesure différents concepts et leur imbrication sans sauter les étapes.

Autre point positif, le site de l'auteur est doté d'un forum et permet ainsi de discuter de tel ou tel aspect du livre.

Si je devais relever des points négatifs, je dirais que la présence systèmatique du code des annotations peut paraître inutile compte tenu d'une certaine redondance, mais bon ça reste anécdotique.

Pour conclure, c'est un livre très abouti, à commander donc et à recommander.
Critique du livre par la rédaction Yann D'Isanto le 1er août 2007
Bien que des notions élémentaires de la plateforme Java EE soient suffisantes pour aborder ce livre, il requiert toutefois d'avoir de solides connaissances de la plateforme Java SE ainsi que de bons acquis en UML et XML.

Cet ouvrage tient toutes ses promesses. Il réussit le tour de force d'aborder un nombre impressionant d'APIs de la plateforme Java EE de façon claire et concise. Celles-ci ne sont donc pas abordées dans leur intégralité (un livre ne suffirait pas) mais elles le sont suffisamment pour commencer à savoir s'en servir et nous donner l'envie d'aller plus loin. Ces APIs font toutes partie des spécifications constituant Java EE 5 (EJB3, JPA, JSP, JSF, JSTL, JMS, JAX-WS, JAXB, JavaMail, ...). Pour les personnes voulant approfondir ces notions, l'auteur a eu la très bonne idée de donner, tout au long de son ouvrage, des références sur les sujets qu'il aborde.

Le livre est construit autour du développement d'une application web complète (de type site marchand). C'est cette approche qui permet de couvrir de façon concrète le large panel d'APIs abordées.

Autre point intéressant, la première partie est consacrée à la conception de l'application où l'auteur partage son expérience et son savoir faire en expliquant ses choix (attitude qu'il adopte tout au long du livre).

Agréable à lire et au contenu d'une grande qualité, cet ouvrage m'apparaît être un indispensable pour tout développeur Java EE désireux de connaître la plateforme Java EE 5.

Vous trouverez également sur le site de l'auteur les sources complètes du livre ainsi qu'un espace de discussion autour du livre et du code de l'application.


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 Java

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

Java

Plus rapide, plus léger

de
Public visé : Expert

Résumé de l'éditeur

Les développeurs Java ont à maintenir des applications de plus en plus complexes. La majeure partie de leur temps ne consiste plus à résoudre des problèmes mais à écrire en code qui corresponde à leurs frameworks. On est alors en droit de se demander si la complexité et la lourdeur sont intrinsèques à Java. Cet ouvrage vise a vous démontrer que non. S'enfermer dans des solutions complexes, des bibliothèques et des frameworks à croissance exponentielle et une quantité excessive de code n'ont pour seule issue que l'impossibilité de maintenir le logiciel développé. Il est effectivement possible de faire évoluer votre code Java de manière à le rendre plus simple et plus flexible. Les auteurs de Java, plus rapide, plus léger, donnent ici des réponses aux programmeurs Java qui s'interrogent face à la complexité croissante de Java et qui veulent travailler autrement. Autour de cinq principes clés, ils démontrent comment construire simplement des applications, comment découpler son code et choisir des technologies adaptées. Deux frameworks libres, Spring et Hihernate, appliquent ces cinq principes que sont la simplicité, ne faire qu'une seule chose à fois, mais bien, la recherche de la transparence, la possibilité de faire évoluer son code et le choix judicieux des technologies selon le projet à mener. Ils proposent ainsi une application web d'entreprise en illustration de ces principes de développement. Le but affirmé de cet ouvrage est bel et bien d'écrire du code Java plus rapide, plus léger et plus propre.

Édition : O'REILLY - 250 pages , 1re édition, 1er novembre 2004

ISBN10 : 2841773124 - ISBN13 : 9782841773121

Commandez sur www.amazon.fr :

33.25 € TTC (prix éditeur 35.00 € TTC) livraison gratuite !
[list][*]L'inévitable indigestion
  • Eviter l'inévitable ?
  • Options
  • Cinq principes pour combattre l'indigestion
  • Conclusion
[*]Faire simple
  • Les valeurs de la simplicité
  • Processus et simplicité
  • Avoir un filet de sécurité
  • Conclusion
[*]Ne faire qu'une seule chose à la fois, mais bien
  • Comprendre le problème
  • Décomposer le problème
  • Construire une architecture en couches
  • Revoir la conception pour réduire le couplage
  • Conclusion
[*]Prôner la transparence
  • Bénéfices de la transparence
  • Qui commande ?
  • Alternatives à la transparence
  • Réflexion
  • Injecter du code
  • Générer du code
  • Toujours plus loin
  • Conclusion
[*]Nous sommes le reflet de ce que nous mangeons
  • Marteaux en or
  • Comprendre le schéma global
  • Considérer les besoins techniques
  • Conclusion
[*]Permettre les extensions
  • Bases de l'extension
  • Outils pour l'extension
  • Modèles de plug-in
  • Qui est le client ?
  • Conclusion
[*]Hibernate
[list][*]La vérité est ailleurs[*]Qu'est-ce qu'Hibernate ?[*]Utiliser le modèle de persistance[*]Evaluer Hibernate[*]Conclusion
[list][*]Spring
  • Qu'est-ce que Spring ?
  • Pet Store: un contre exemple
  • Le modèle de domaine
  • Intégrer la persistance
  • Présentation
  • Conclusion
[*]Robot de recherche simple
  • Principes d'un robot de recherche ?
  • Analyse des besoins
  • Préparer le développement
  • Conception
  • Service de configuration
  • Service d'exploration et d'indexation
  • Service de recherche
  • Interface en mode console
  • Interface service web
  • Poursuivre le développement du robot de recherche
[*]Evolutions de l'application JPetStore
  • La fonctionnalité de recherche existante
  • Remplacer le contrôleur
  • L'interface utilisateur (JSP)
  • Configurer le service d'indexation
  • Utiliser le service de configuration
  • Intégrer Hibernate
  • Conclusion
[*]L'avenir
  • Technologie
  • Processus
  • Les défis
  • Conclusion
[*]Bibliographie[*]Index
[list]
Critique du livre par la rédaction GrandFather le 1er novembre 2006
Cet ouvrage débute par le constat alarmant que la technologie Java est arrivée à une croisée des chemins, et que les frameworks et outils employés en entreprise ont atteint une taille critique et une complexité telles qu'elles mettent en péril les évolutions et les investissements. Beaucoup trop de développeurs cèdent encore à la fascination du "marteau en or", et cet ouvrage se propose de leur montrer la voie du pragmatisme et de l'efficience. Pour cela, les auteurs mèlent considérations techniques concrètes liées au codage et réflexions portées sur le design des applications, tout en ne négligeant pas les aspects psychologiques qui ont un impact sur la conception et le déroulement des projets, tout cela constituant un panorama complet, à ma connaissance inédit, de l'activité du développeur Java en entreprise. A toutes les étapes de la construction de l'application, les auteurs mettent en garde contre la tentation d'introduire de la lourdeur et de la sophistication là où ce n'est pas nécessaire, et proposent des alternatives plus légères et plus "agiles".

La lecture de ce livre a pour effet bénéfique de décomplexer le développeur rebuté par la complexité des conteneurs d'EJB et autres frameworks d'entreprise "indigestes". Pour les problématiques - majoritaires - pour lesquelles les mécanismes sophistiqués mis en oeuvre dans ces frameworks ne sont pas une nécessité vitale ou n'apportent pas de plus-value, cet ouvrage conseille l'emploi de frameworks plus légers, plus simples et plus spécialisés, tels que Spring & Hibernate, et l'illustre par une étude de cas. Les dernières évolutions de la plateforme entreprise de Sun, J2EE 5, qui montrent un réel effort en direction de la simplicité, laissent à penser que les auteurs ont vu juste et visé là où cela faisait mal... D'autres préconisations, tel que le développement dirigé par les tests, sont elles en passe d'entrer dans les moeurs, et la lecture des arguments en sa faveur développés dans ce livre devrait achever de convaincre les réticents.

L'intérêt que représente ce petit livre atypique pour le développeur Java professionnel est inversement proportionnel à son nombre de pages. J'ai particulièrement apprécié le portrait qui est fait du développeur soumis quotidiennement à des tiraillements entre volonté de bien faire et volonté demieux faire, et dans lequel nous nous reconnaissons tous. Ce livre, plutôt destiné aux développeurs expérimentés, sera le compagnon idéal de vos autres ouvrages d'ingénierie logicielle, afin de ne jamais perdre de vue la plus grande vertu à laquelle doivent aspirer tous les développeurs : la simplicité.


couverture du livre Eclipse et JBoss

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

Eclipse et JBoss

de
Public visé : Expert

Résumé de l'éditeur

Développement d'applications J2EE professionnelles, de la conception au déploiement.

Édition : Eyrolles - 629 pages , 1re édition, 1er mars 2005

ISBN10 : 2212114060 - ISBN13 : 9782212114065

Commandez sur www.amazon.fr :

42.75 € TTC (prix éditeur 45.00 € TTC) livraison gratuite !
  • Développement et déploiement J2EE avec Eclipse et JBoss
  • L'étude de cas WebStock
  • Développement Web avec MyEclipse
  • Développement EJB avec JBoss, MyEclipse et XDoclet
  • Aspects avancés de JBoss
Critique du livre par la rédaction el_toro le 1er juin 2005
C'est un livre sur le développement J2EE avec Eclipse. L'intérêt de l'ouvrage est de présenter les très nombreux outils à interfacer avec Eclipse qui ne se suffit plus à lui-même. Qu'il s'agisse du déploiement avec Ant, des tests unitaires avec JUnit, de l'analyse des performances avec JUnitPerf, de la génération de fichiers de configuration ou de code avec XDoclet, de la gestion collaborative de sources avec CVS, de la génération de code à partir de diagrammes UML avec EclipseUML... nombreux sont les outils qui permettent d'accélerer et de rationnaliser le développement d'applications J2EE. L'auteur nous présente avec simplicité les multiples outils ainsi que les méthodes (design pattern) à disposition des développeurs pour un travail de qualité, réutilisable et maintenable.


couverture du livre Struts

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

Struts

Les bonnes pratiques pour des développements web réussis

de
Public visé : Expert

Résumé de l'éditeur

Ce livre s'adresse aux développeur et programmeurs d'applications déjà expérimentés en Java et qui ont besoin de maîtriser Struts rapidement et efficacement.
Le framework Jakarta Struts est devenu un standard Open Source confirmé : sa performance, son indépendance par rapport à des systèmes propriétaires et son efficacité des coûts sont des avantages convaincants.
Résolument concret et pratique, cet ouvrage rassemble des conseils, une multitudes d'exercices, des résumés et tout un savoir-faire tiré de l'expérience professionnelle des deux auteurs.
Ils exposent les méthodes les plus efficaces, les interfaces les plus conviviales, les coûts les moins élevés, le chemin le plus court, en un mot ce que les Anglo-saxons appellent les "Best Practices".

- La première partie passe en revue les phases de développement avec Struts 1.2, JSTL 1.1, Servlet 1.4, JSP 2.0, Tomcat 5, Eclipse 3 et PostgreSQL.
- La seconde apprend comment construire une infrastructure applicative solide et performante et comment tirer des avantages de la réutilisation de code.
- La troisième partie explique comment concevoir une interface utilisateur sûre, et comment sécuriser l'application.

Édition : Dunod - 219 pages , 1re édition, 1er février 2005

ISBN10 : 2100486357 - ISBN13 : 9782100486359

Commandez sur www.amazon.fr :

28.41 € TTC (prix éditeur 29.00 € TTC) livraison gratuite !
  • Démarrer le projet
  • Spécifications des exigences
  • Créer un accès à la base de données
  • Travailler avec des actions simples
  • Travailler avec des JSP et View
  • Travailler avec des Beans simples
  • Astuces sur le processus de développement
  • Créer l'accès aux données
  • Des Beans réutilisables
  • Actions et événements réutilisables
  • Autres actions de traitement des formulaires
  • Validation
  • Contenu dynamique de site
  • Sécurité
  • Formulaires complexes et notation par points
  • Eléments déroulants et super-type
  • Concevoir l'interface utilisateur
  • Gestion de la performance
  • Future sécurité de l'application
Critique du livre par la rédaction Xoux le 1er septembre 2005
Cet ouvrage se destine à des développeurs, experts techniques ou architectes, disposant de bases concernant Struts et étant à la recherche de bonnes pratiques.
Les pistes de réflexions suggérées par les auteurs sont nombreuses, dispersées tout au long d'un ouvrage qui manque de cohérence d'ensemble et qui s'éloigne par moment de Struts. Ainsi, le lecteur y trouvera une multitude de conseils pour ses développements Web en Java, mais ne devra pas se reposer sur cet ouvrage pour apprendre à utiliser Struts.

Malgré une certaine désorganisation, les sujets abordés par les auteurs sont intéressants mais par moment assez peu explorés en profondeur. Charge au lecteur d'aller plus loin en partant à la recherche de lectures complémentaires sur les sujets qui auront retenu son attention.
Agrémenté de quelques chapitres plutôt orientés "Gestion de projet", le propos de cet ouvrage repose entièrement sur la suite de développement Jasic (éditée par les sociétés respectives des auteurs) qui rassemble un certain nombre d'outils/framework tels que Struts ou encore iBatis.

On regrettera néanmoins l'absence de certaines thématiques comme les traitements côté serveur, Struts-Layout, les bibliothèques de tags bean et logic, ou encore davantage d'éléments concernant les Tiles. Le lecteur appréciera l'abondance d'illustrations par le code, code dont le style n'est malheureusement pas très agréable à la lecture.

En conclusion, ce livre, véritable mine d'informations et de conseils, malgré une organisation une peu fouillie, vous sera de bon conseil pour approndir l'utilisation de Struts ou de manière générale la construction d'applications Web basées autour de Struts ou un framework équivalent.
Par contre, il ne vous formera pas à Struts, et un minimum de connaissances sur ce framework semble nécessaire pour bien aborder le contenu du livre.

Retrouvez la critique complète ici.


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 Services Web avec J2EE et .NET : Conception et implémentations

Note 4.5 drapeau
Détails du livre
Sommaire
Critiques (2)
0 commentaire
 
 

Services Web avec J2EE et .NET : Conception et implémentations

de
Public visé : Débutant

Résumé de l'éditeur

Pour faire interagir de manière fiable, souple, sécurisée et transactionnelle, des applications hétérogènes au sein d'architectures orientées services, il faut intégrer les notions de contrat, de processus et de conversation métier, mais aussi maîtriser les environnements d'exécution en évitant les dérives propriétaires qui réduisent l'interopérabilité.

Une référence pour les développeurs accompagnée d'études de cas.
Cet ouvrage avant tout destiné aux développeurs et aux architectes explique la mise en oeuvre d'architectures réparties sur des plates-formes hétérogènes et mixtes, aussi bien côté serveur (J2EE, .NET) que sur le poste de travail (Internet Explorer, Mozilla, Flash, Microsoft Excel XP...), en mettant l'accent sur la description des processus métier avec BPEL.
Les techniques d'infrastructure ayant trait à la sécurité, à la fiabilité et aux transactions telles que WS-Security, WS-Transaction, WS-Coordination, sont présentées en détail, non sans un rappel approfondi des normes fondatrices (SOAP 1.1 et 1.2, WSDL et UDDI), de leurs dernières implémentations et des recommandations d'interopérabilité WS-I.

À qui s'adresse cet ouvrage ?
  • Aux développeurs d'applications, en particulier à ceux qui utilisent les environnements J2EE et .NET.
  • Aux architectes des systèmes d'information, tentés par les architectures orientées services (AOS).
  • Aux décideurs, consultants, chefs de projets et spécialistes de l'intégration, qui ont besoin d'étendre leur capacité d'intervention vers l'urbanisation et l'ouverture du SI de l'entreprise.
  • Aux étudiants des écoles d'ingénieurs et universitaires, qui recherchent une référence sur l'architecture orientée services et les technologies de services Web.

Édition : Eyrolles - 1055 pages , 1re édition, 11 novembre 2003

ISBN10 : 2212110677 - ISBN13 : 9782212110678

Commandez sur www.amazon.fr :

52.25 € TTC (prix éditeur 55.00 € TTC) livraison gratuite !
L'architecture orientée services
Technologies des services Web
Les plates-formes opérationnelles
L'infrastructure des services Web
Etudes de cas
Critique du livre par la rédaction Eric REBOISSON le 10 avril 2005
Voilà un gros ouvrage (plus de 1000 pages) traitant des Services Web : une première partie définit les concepts autour des Services Web, une seconde plus technique couvre les technologies et spécifications, et le livre s'achève avec l'utilisation des Services Web sur les plateformes Java et .Net.
Le livre "Services Web avec J2EE et .Net" est très complet pour comprendre les nombreux intervenants des Services Web, on y trouvera une explication à de nombreux acronymes satellites (SOAP, WSDL, UDDI...la liste est longue), comme un dictionnaire en somme, c'est d'ailleurs je pense son optique d'utilisation première. La majeure partie de ce livre est donc théorique, le reste laisse place aux cas pratiques J2EE et .Net, avec des exemples que j'ai trouvé légers pour ces deux plateformes, donc à vos claviers pour allez plus loin.
La mise en page est claire, de nombreux schémas et échantillons de codes viennent agrémenter la théorie dispensée. Donc, un livre bien utile pour se rappeller l'utilisation et la mise en oeuvre de Service Web, mais également un bon point de départ pour comprendre la technologie. Je le conseille finalement à ceux qui débutent dans les Web Services, aux décideurs pour acquérir une vue d'ensemble tout en gardant à l'idée qu'à posteriori une exploration technique sera nécessaire.
Bonne lecture !
Critique du livre par la rédaction Thomas Lebrun le 22 mai 2008
Si vous souhaitez tout savoir des Web Services, alors ce livre est pour vous !
Très complet, il vous permettra d'apprendre tout d'abord les bases, puis vous vous tournerez ensuite vers des notions plus complexes.
L'étude de cas est un vrai régal: en effet, dans beaucoup de livres, on vous explique ce que vous devez faire, mais il arrive très souvent que cela manque... d'exemples. Cette étude comble cette lacune et on ne peut que l'apprécier.
Bref, encore un livre que ne je peux que conseiller !




 Poster une réponse Signaler un problème

Avatar de forum forum - Robot Forum https://www.developpez.com
le 15/07/2014 à 21:31
Services Web avec J2EE et .NET : Conception et implémentations
Pour faire interagir de manière fiable, souple, sécurisée et transactionnelle, des applications hétérogènes au sein d'architectures orientées services, il faut intégrer les notions de contrat, de processus et de conversation métier, mais aussi maîtriser les environnements d'exécution en évitant les dérives propriétaires qui réduisent l'interopérabilité.

Une référence pour les développeurs accompagnée d'études de cas.
Cet ouvrage avant tout destiné aux développeurs et aux architectes explique la mise en oeuvre d'architectures réparties sur des plates-formes hétérogènes et mixtes, aussi bien côté serveur (J2EE, .NET) que sur le poste de travail (Internet Explorer, Mozilla, Flash, Microsoft Excel XP...), en mettant l'accent sur la description des processus métier avec BPEL.
Les techniques d'infrastructure ayant trait à la sécurité, à la fiabilité et aux transactions telles que WS-Security, WS-Transaction, WS-Coordination, sont présentées en détail, non sans un rappel approfondi des normes fondatrices (SOAP 1.1 et 1.2, WSDL et UDDI), de leurs dernières implémentations et des recommandations d'interopérabilité WS-I.

À qui s'adresse cet ouvrage ?
  • Aux développeurs d'applications, en particulier à ceux qui utilisent les environnements J2EE et .NET.
  • Aux architectes des systèmes d'information, tentés par les architectures orientées services (AOS).
  • Aux décideurs, consultants, chefs de projets et spécialistes de l'intégration, qui ont besoin d'étendre leur capacité d'intervention vers l'urbanisation et l'ouverture du SI de l'entreprise.
  • Aux étudiants des écoles d'ingénieurs et universitaires, qui recherchent une référence sur l'architecture orientée services et les technologies de services Web.


[Lire la suite]




 
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.