Les livres Java Web pour les Expérimentés

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

  1. 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
  2. Programmation GWT 2 - Développer des applications RIA et Ajax avec Google Web Toolkit
  3. Struts 2 - Le framework de développement d'applications Java EE
  4. Java SOA Cookbook
  5. Seam in action
  6. Les Cahiers du programmeur Java EE 5
  7. Développement Java sous STRUTS : Version 1.2
  8. Google Web Toolkit - GWT Java AJAX Programming
  9. Sun Certified Web Component Developer Study Companion - J2EE 1.4 (exams 310-081 and 310-082)
  10. Java - Plus rapide, plus léger
  11. Eclipse et JBoss
  12. Struts - Les bonnes pratiques pour des développements web réussis
  13. Services Web avec J2EE et .NET : Conception et implémentations
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 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 Java SOA Cookbook

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

Java SOA Cookbook

de
Public visé : Intermédiaire

Résumé de l'éditeur

Java SOA Cookbook offers practical solutions and advice to programmers charged with implementing a service-oriented architecture (SOA) in their organization. Instead of providing another conceptual, high-level view of SOA, this cookbook shows you how to make SOA work. It's full of Java and XML code you can insert directly into your applications and recipes you can apply right away.

The book focuses primarily on the use of free and open source Java Web Services technologies -- including Java SE 6 and Java EE 5 tools -- but you'll find tips for using commercially available tools as well.

Java SOA Cookbook will help you:

  • Construct XML vocabularies and data models appropriate to SOA applications
  • Build real-world web services using the latest Java standards, including JAX-WS 2.1 and JAX-RS 1.0 for RESTful web services
  • Integrate applications from popular service providers using SOAP, POX, and Atom
  • Create service orchestrations with complete coverage of the WS-BPEL (Business Process Execution Language) 2.0 standard
  • Improve the reliability of SOAP-based services with specifications such as WS-Reliable Messaging
  • Deal with governance, interoperability, and quality-of-service issues

The recipes in Java SOA Cookbook will equip you with the knowledge you need to approach SOA as an integration challenge, not an obstacle.

Édition : O'Reilly - 740 pages , 1re édition, 1er mars 2009

ISBN10 : 0596520727 - ISBN13 : 9780596520724

Commandez sur www.amazon.fr :

36.79 € TTC (prix éditeur 39.82 € TTC) livraison gratuite !
[list][*]Part 1: SOA Fundamentals
  • Chapter 1. Introduction to SOA
  • Chapter 2. XML Schema and the SOA Data Model
  • Chapter 3. Working with XML and Java
[*]Part 2: Web Services
  • Chapter 4. Getting Started
  • Chapter 5. Web Services with SAAJ
  • Chapter 6. Creating Web Service Applications with JAX-WS
  • Chapter 7. Providing SOAP-Based Web Services
  • Chapter 8. RESTful Web Services
[*]Part 3: Business Processes
  • Chapter 9. Service Orchestrations with BPEL
  • Chapter 10. Advanced Orchestrations with BPEL
  • Chapter 11. SOA Governance
[*]Part 4: Interoperability and Quality of Service
  • Chapter 12. Web Service Interoperability
  • Chapter 13. Quality of Service
  • Chapter 14. Enterprise Service Bus

[list]
Critique du livre par la rédaction Eric REBOISSON le 1er janvier 2010


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

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

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

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

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

Voilà donc un livre que j'ai apprécié, par sa structure efficace, la richesse et la qualité de son contenu. Et comme en cuisine, vous utiliserez ce livre comme un ouvrage de référence quand des problèmes précis seront à résoudre, une lecture linéaire est, je pense, trop ennuyante.
Critique du livre par la rédaction Hikage le 1er août 2009
Français

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

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

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

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

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

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

English

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

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

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

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

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

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




 Poster une réponse Signaler un problème

Avatar de Ricky81 Ricky81 - Expert éminent sénior https://www.developpez.com
le 08/08/2009 à 15:39
Bonjour,

Le terme SOA est très en vogue ces dernières années, et les concepts se déclinent de manière exhaustive en Java.

Il existe un ouvrage édité par O'Reilly UK intitulé Java SOA Cookbook qui se propose d'illustrer la SOA par l'intermédiaire de petites recettes pratiques.

Voici ce qu'en pense le responsable bénévole Spring :

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

(...)

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

Certains ont eu l'occasion de feuilleter ce livre ?
Avatar de elitost elitost - Expert éminent https://www.developpez.com
le 08/01/2010 à 23:01
Eh bien, j'ai pu lire ce livre et en rédiger une critique pour Developpez.

C'est un très bon livre sur la SOA, on y trouvera la trousse à outils nécessaire pour résoudre ses problèmes et répondre aux questions sur le sujet.

Il y a énormément de sujets abordés (plusieurs dizaines), le développeurs comme le concepteur SOA y trouvera forcemment son bonheur.

Et vous ? vous en avez pensé quoi ?

 
couverture du livre Seam in action

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

Seam in action

de
Public visé : Expert

Édition : Manning - 590 pages , 1re édition, 1er septembre 2009

ISBN10 : 1933988401 - ISBN13 : 9781933988405

Commandez sur www.amazon.fr :

34.82 € TTC (prix éditeur 44.99 € TTC) livraison gratuite !
Part 1 Teeing off with Seam
  • 1 Seam unifies Java EE
  • 2 Putting seam-gen to work

Part 2 Seam fundamentals
  • 3 The Seam life cycle
  • 4 Components and contexts
  • 5 The Seam component descriptor
  • 6 Absolute inversion of control

Part 3 Seam's state management
  • 7 The conversation: Seam's unit of work
  • 8 Understanding Java persistence
  • 9 Seam-managed persistence and transactions
  • 10 Rapid Seam development

Part 4 Sinking the business requirements
  • 11 Securing Seam applications
  • 12 Ajax and JavaScript remoting
  • 13 File, rich rendering, and email support
Critique du livre par la rédaction longbeach le 1er janvier 2009
Seam veut dire suture en anglais. Mais depuis 3 ans, ce mot revêt une autre signification pour les développeurs puisqu'il désigne aussi un framework. C'est un framework assez récent, la version 1.0.0 Beta 1 date de septembre 2005, dont le project leader est Gavin King (l'un des créateurs d'Hibernate), qui intègre JSF et les EJB 3, et c'est donc avec beaucoup d'intérêt et de curiosité que j'ai lu ce livre. L'auteur, Dan Allen, sait de quoi il parle puisqu'il est un committer sur le projet. On apprend qu'à l'origine le terme Seam a été choisi pour désigner l'effort d'intégration entre JSF et les EJB 3. Les applications JBoss Seam peuvent tourner sur Websphere, Weblogic, Tomcat. Le livre se veut pratique puisqu'il propose de développer une application de golf (Open 18) pour illustrer les fonctionnalités de Seam. Le livre est divisé en 4 parties.

Dans la 1ère partie (chapitres 1, 2), l'outil seam-gen est détaillé et utilisé dès le départ pour la mise en place de l'environnement de développement, à partir d'une base de données Hypersonic H2.

Dans la 2ème partie (chapitres 3, 4, 5, 6), l'auteur explique ce que Seam apporte à JSF, en corrigeant certaines « lourdeurs », tel qu'un fichier XML trop verbeux (faces-config.xml), en supprimant les tags <managed-bean> du fichier. On peut grâce à Seam se passer de définir les backed beans dans un fichier XML. Le cycle de vie JSF avec Seam est décrit également pour expliquer les avantages de Seam. Le chapitre 4 traite des components, les annotations concernées (@Name, @Scope ...), le cycle de vie des components, etc. Dans le chapitre 5 les tags du fichier de configuration components.xml (une alternative aux annotations) sont largement détaillés. Le chapitre 6 traite des interceptors et de la notion de bijection (= injection + outjection, avec les annotations @In, @Out) en introduisant le nouveau terme outjection qui désigne la possibilité de mettre une propriété de component dans une variable de contexte pour être ensuite utilisée dans un autre component, une vue JSF ... Avec la bijection, les valeurs sont injectées depuis les variables de contexte quand le component est invoqué et réinjectées vers les variables de contexte. Une distinction nette est faite entre injection statique (assignation d'une variable quand le component est instancié) et injection dynamique (chaque fois qu'une méthode d'un component est invoquée).

Dans la 3ème partie (chapitres 7, 8, 9, 10), un chapitre entier (chapitre 7) est dédié à l'état Conversation, un des 2 états/contextes introduits par Seam (l'autre état étant business process, qui est plus long que la session), en plus des 4 états classiques que sont Request, Page, Session, Application. Cet état permet de lier des requêtes individuelles. Les 6 états classés par portée croissante sont donc : Request (event), Page, Conversation, Session, Business Process, Application. La notion de conversation, les page flows et les annotations concernées (@Begin, @Conversational, @End etc) sont systématiquement et largement expliquées avec des extraits de code s'articulant autour de l'application Open 18. Le chapitre 8 est un rappel nécessaire sur JPA et Hibernate. J'ai particulièrement apprécié le rappel sur l'extended persistence context et les différences entre ces 2 APIs car c'est bien expliqué. Le chapitre suivant aborde la gestion de la persistence et les transactions avec Seam, notamment dans la conversation, et est largement illustré par des extraits de code. Le chapitre 10 présente le Seam Application Framework au travers d'un exercice.

Dans la 4ème partie (chapitres 11, 12, 13), on apprend que Seam s'appuie sur JAAS pour l'authentication (chapitre 11). Un exemple avec une page de login JSF est utilisé. Une distinction est faite entre les authorisations basées sur des rôles et les authorisations basées sur des règles. Le moteur de règles Drools (qui tire son nom du terme "Dynamic rules") est présenté et utilisé pour créer des règles. Un exemple rapide d'utilisation du component org.jboss.seam.captcha pour l'affichage d'un CAPTCHA dans une page web est expliqué. Le chapitre 12 met l'accent sur AJAX et les solutions existantes qui tournent autour (Ajax4jsf, ICEfaces, GWT ...) Enfin, le chapitre 13 présente divers components Seam tel que <s:fileUpload> pour uploader des fichiers à partir d'un form JSF, <s:graphicImage> pour le rendu dynamique d'images , des UI components pour la génération de PDF à travers des templates de Facelets, mais aussi le module Seam de génération de graphique basé sur JFreeChart, l'envoi de mail avec un component mail Seam etc

Ce que j'ai aimé dans ce livre : Le ton de l'auteur. On a l'impression d'assister à une présentation en live de Seam, l'auteur passe beaucoup de temps à introduire les choses, à peser le pour et le contre des solutions existantes et ensuite à expliquer comment Seam peut être une solution possible. Le thème du golf, omniprésent et instructif ;-)

Ce que j'ai moins aimé dans ce livre : La prise en compte d'une version antérieure de JBoss AS : 4.2 au lieu de 5 (Java EE 5)

Le code source du livre est bien entendu disponible sur le site du livre, ainsi que deux chapitres "bonus" format PDF concernant l'intégration avec Spring d'une part et la gestion du business process (jBPM) d'autre part : http://www.manning.com/dallen/

Le site de l'auteur : http://www.mojavelinux.com/ Un errata est disponible à l'adresse http://www.manning.com/dallen/excerpt_errata.html

Enfin, le code source du livre est aussi disponible sur : http://code.google.com/p/seaminaction/

English version :

A seam is a joining of 2 things, like 2 fabrics for example. But for 3 years now, it has had another meaning for developers since it also refers to a framework. It is a rather new framework, the 1.0.0 Beta version was released in September 2005, the project leader was Gavin King (one of the creators of Hibernate), it uses JSF and EJB 3, and so it is with some big interest and curiosity that i read this book. The author, Dan Allen, knows what he is talking about since he is a committer on the project. We learn that the term Seam was chosen to refer to the work put on to facilitate the collaboration between JSF and EJB 3. JBoss Seam applications may run on Websphere, Weblogic, Tomcat. The book has a practical approach since it is based on an application centered on the game of golf (Open 18), to illustrate the features of Seam. The book is divided into 4 parts.

In the 1st part (chapters 1, 2), the seam-gen tool is explained and used from the beginning to set up the development environment, using a Hypersonic H2 database.

In the 2nd part (chapters 3, 4, 5, 6), the author explains what Seam brings to JSF, correcting some defects, such as a verbose XML file (faces-config.xml), by removing the <managed-bean> tags from the file. With Seam it is possible to define the backed beans in an XML file. The life cycle of JSF with Seam is also detailed to explain the advantages of Seam. Chapter 4 introduces the components, its related annotations (@Name, @Scope ...), the life cycle of components, etc. In chapter 5, the tags of the configuration file components.xml (the alternative to annotations) are explained in details. Chapter 6 is about interceptors and the concept of bijection (= injection + outjection, with annotations @In, @Out) by introducing the new term outjection which refers to the possibility of injecting the property of a component into a context variable, which can be re-used inside another component, a JSF view ... With bijection, the values are injected from context variables when the component is called and injected again into the context variables. A clear distinction is made between static injection (the value is injected when the component instance is created) and dynamic injection (the value is injected when a method on the component is executed).

In the 3rd part (chapters 7, 8, 9, 10), an entire chapter (chapter 7) is dedicated to the Conversation scope, one of the 2 scopes/contexts introduced by Seam (the other scope being business process, which is longer than the session), as an addition to the 4 classic scopes which are Request, Page, Session, Application. This scope ties together individual requests. So the 6 scopes ordered by ascending scope are : Request (event), Page, Conversation, Session, Business Process, Application. The term of conversation, page flows and related annotations (@Begin, @Conversational, @End, etc) are systematically and largely explained with code snippets around the Open 18 application. Chapter 8 is a necessary reminder of JPA and Hibernate. I have particularly liked the quick presentation on extended persistence context and the differences between these 2 APIs because it is well explained. The next chapter is about the persistence and the transactions with Seam, in particular within the conversation, and is largely illustrated with code snippets. Chapter 10 explains the Seam Application Framework with an exercise.

In the 4th part (chapters 11, 12, 13), we learn that Seam relies on JAAS for authentication (chapter 11). A sample with a JSF login page form is used. A clear distinction is made between role-based authorizations and rule-based authorisations. The rules engine Drools (the name Drools is derived from the term "dynamic rules") is explained and used to create the rules. A quick sample of use of the org.jboss.seam.captcha component to display CAPTCHA inside a web page is explained. AJAX and existing solutions (Ajax4jsf, ICEfaces, GWT ...) are empasized in chapter 12. Finally, chapter 13 introduces a few Seam components such as <s:fileUpload> to upload files from a JSF form, <s:graphicImage> for the dynamic rendering of images, UI components to generate PDF files using facelets templates, but also the Seam module for graphic generation based on JFreeChart, composing email with a Seam component mail etc

What I liked about this book : The author's tone. It makes you feel like you are attending a live presentation on Seam, the author spends a lot of time introducing things, weighs the pros and the cons of existing solutions and then explains how Seam can be a possible solution. I also liked the golf theme, omnipresent, and instructive ;-)

What I liked the least in this book : The referring to an older version of JBoss AS : 4.2 instead of 5 (Java EE 5)

The source code of the book is of course available on the book's website, along with 2 extra chapters in PDF format regarding the integration with Spring and the use of business process (jBPM) : http://www.manning.com/dallen/

The author's website : http://www.mojavelinux.com/ An errata is also available at http://www.manning.com/dallen/excerpt_errata.html

Finally, the code source of the book is also available at : http://code.google.com/p/seaminaction/


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 Google Web Toolkit

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

Google Web Toolkit

GWT Java AJAX Programming

de
Public visé : Expert

Résumé de l'éditeur

This book is for Java developers who want to create Ajax interfaces using the Google Web Toolkit (GWT). It focuses on useful, practical tasks from the first chapter. The book is aimed at programmers who want to use GWT to create interfaces for their professional web applications. It concentrates on the serious side of Ajax: creating powerful, productive applications for browser platforms. GWT Ajax Programming shows you how to create reliable user interfaces that enhance the user experience.

GWT is an open source Java software development framework that makes writing AJAX applications like Google Maps and Gmail easy for developers who don't speak browser quirks as a second language. Writing dynamic web applications today is a tedious and error-prone process; you spend 90% of your time working around subtle incompatibilities between web browsers and platforms, and JavaScript's lack of modularity makes sharing, testing, and reusing AJAX components difficult and fragile. GWT lets you avoid many of these headaches while offering your users the same dynamic, standards-compliant experience. You write your front end in the Java programming language, and the GWT compiler converts your Java classes to browser-compliant JavaScript and HTML.

Plan your ECM installation, implement it, and customize it. Among the many topics covered are:

Set up an elegant GWT development environment in Eclipse
Create, test, debug and deploy GWT applications
Develop custom widgets - examples include a calendar and weather forecast widget
Internationalize your GWT applications
Create complex interfaces using grids, moveable elements, and more
Integrate GWT with Rico, Moo.fx and Script.aculo.us to create even more attractive UIs using JSNI

Each chapter covers a series of practical tasks, showing how to achieve a particular useful result - and then learn how it works so that you can apply your knowledge to your own unique situation. Readers will need experience writing non-trivial applications using Java. Experience with developing web interfaces is useful, but knowledge of JavaScript and DHTML is not required... GWT takes care of that!

Édition : Packt Publishing - 238 pages , 1re édition, 1er février 2007

ISBN10 : 1847191002 - ISBN13 : 9781847191007

Commandez sur www.amazon.fr :

35.54 € TTC (prix éditeur 35.99 € TTC) livraison gratuite !
  • Preface
  • Chapter 1: Getting Started
  • Chapter 2: Creating a New GWT Application
  • Chapter 3: Creating Services
  • Chapter 4: Interactive Forms
  • Chapter 5: Responsive Complex Interfaces
  • Chapter 6: Browser Effects with JSNI and JavaScript Libraries
  • Chapter 7: Custom Widgets
  • Chapter 8: Unit Tests
  • Chapter 9: I18N and XML
  • Chapter 10: Deployment
  • Appendix A: Running the Samples
  • Index
Critique du livre par la rédaction moritan le 1er mai 2007
Il s'agit d'un très bon livre d'introduction à GWT.
Il est bien écrit et didactique.
Je dois avouer que la structure des chapitres m'a d'abord déconcerté, chacun de ces chapitres est scindé en quatre parties:

  • Présentation
  • "Time for action"
  • "What's just happened"
  • "There's more / summary"


Le fait de commencer par réaliser le code puis ensuite de donner l'explication du code réalisé, peut surprendre mais finalement cela permet de ne pas réserver ce livre à un public restreint. Pour le débutant, le fait que le code soit clairement séparé des explications permet de se concentrer sur les faits importants et de ne pas se disperser entre le code et les explications.
Pour un lecteur expérimenté, cela permet de retrouver rapidement l'information recherchée ou de passer rapidement sur les notions qu'il maitrise.
La section "There's more /summary" est très intéressante, elle permet de voir les petits plus existants, et de recentrer les notions déjà vu.

La qualité du code donné, ainsi que les méthodes de réalisation fournies sont de très bon niveau.

Pourquoi ne pas mettre 5 étoiles ?
C'est un très bon livre d'introduction et d'aide mémoire, mais il n'est pas totalement complet.
Il manque pour moi trois notions pour qu'il soit complet.
D'abord un peu d'information sur les conventions de nommage, nottament pour les styles CSS.
Ensuite, l'utilisation du protocole JSON n'est pas abordé, ce protocole peut-être utile pour permettre de mélanger un application GWT avec un autre langage PHP par exemple.
Enfin, un exemple d'utilisation du framework GWT, avec un autre framework de type Struts, pour l'intégration avec des applications existantes.


couverture du livre Sun Certified Web Component Developer Study Companion

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

Sun Certified Web Component Developer Study Companion

J2EE 1.4 (exams 310-081 and 310-082)

de
Public visé : Expert

Résumé de l'éditeur

This book is a study guide for any candidate preparing for the new J2EE 1.4 version of the Sun Certified Web Component Developer exam (310-081 and upgrade 310-082). It contains the theory behind why the Web container operates as it does, and important notes, hints and tips on the types of ?trick' questions to look for in the exam. By combining logical and easy-to-follow discussions with clear visual aids and diagrams, you will learn how the container works, and, by the end of the book, you'll be wondering why servlets, JSPs and tag libraries seemed so complicated before. By combining the theory taught in this book with practical experience, you will not only succeed in passing the exam, but will do so confident that you are able to solve problems and draw-up solutions ?on the job'.

Reference Material

Have you ever found that you couldn't quite remember the names of the XML elements or attributes in the Deployment Descriptor or Tag Library Descriptor, or perhaps you've had problems recalling custom tag life cycles? Not a problem! Helpful visual diagrams show ?at a glance' the important schemas, without having to resort to knowing the XML Schema or DTD languages, as used in the specifications.

Who is this book suitable for?

This guide is not intended as a beginner's book. It assumes prior, although basic, knowledge of J2EE, the Web container and the Extensible Mark-up Language (XML) core syntax. However, the thorough explanations presented in this book give excellent grounding in the subject, and a well-versed beginner or a quick-learner might be able to pick up sufficient knowledge of the Web container to actually pass the exam (no guarantees)! In addition, particular attention is devoted to the subjects of the Expression Language and custom tag libraries, both of which are new or have been significantly updated in the 1.4 version of the J2EE platform. No knowledge of either of these more difficult topics is assumed.

Additional Chapters

The two additional chapters present a summary of all the new features available in Java EE 5.0, including the platform's change of name! These are suitable for anyone already working confidently with J2EE 1.4.

Édition : Garner Press - 640 pages , 1re édition, 1er juillet 2006

ISBN10 : 0955160316 - ISBN13 : 9780955160318

Commandez sur www.amazon.fr :

29.99 € TTC (prix éditeur 31.06 € TTC) livraison gratuite !
J2EE Environment
  • Networks and HTTP
  • J2EE Architecture

Servlets
  • Servlet Basics
  • Servlet Contexts
  • Requests and Responses
  • Wrappers and Request Dispatching
  • Filters
  • Session Management
  • Application Deployment

JavaServer Pages
  • JSP Basics
  • JSP Documents
  • Expression Language
  • Standard Actions and JavaBeans
  • Tag Libraries and the JSTL
  • Custom Tags
  • Tag Files
  • Tag Deployment

Further Topics
  • Security
  • J2EE Patterns

Java EE 5
  • Servlet 2.5 and JSP 2.1 Changes
  • Unified Expression Language (EL 2.1)

APPENDICES
  • Exam Objectives
  • Mock Exam Subscription

Critique du livre par la rédaction vbrabant le 1er mai 2007
J'ai eu un coup de coeur pour ce livre concernant la certification SCWCD J2EE 1.4 (310-081).
Je pense que Charles Lyons a réussi quelque chose de magnifique avec ce livre.

J'ai beaucoup aimé son approche, très équilibrée, pour vous expliquer les choses. Il ne va pas vous expliquer le protocole HTTP dans tous les détails comme si vous deviez être un expert réseau, ni vous l'expliquer comme si vous aviez vécu dans le désert jusqu'à présent. Mais il va vous l'expliquer simplement, mettant l'accent sur les choses à retenir pour l'examen.
Les questions que l'on retrouve dans le livre (il y en a plus de 300) vous donnent une bonne idée de ce qui vous attends à l'examen.

Mais il y a également des bonus :

Ainsi, en plus du livre, vous avez également un "mock exam" en ligne, vous permettant de vous entraîner encore un peu plus.
Les deux derniers chapitre du livre vous expliquent également les modifications introduites avec Java EE 5 dans ce qui est Servlet 2.5, JSP 2.1, et EL 2.1.

Attention que ce n'est qu'un "Study Companion" pour ce qui est de la certification. Il n'est pas là pour remplacer les livres qui vous apprennent tout de A à Z. Il est là pour réviser quelque peu la matière et vous rafraîchir la mémoire sur les points importants pour l'examen.

Bien que ce livre tranche tout à fait, si on le compare avec l'approche choisie pas les auteurs de la série Head First de chez Oreilly, il a tout de même un style propre à lui qui le rend différent des autres livres que l'ont lit généralement sur les certifications.

Il m'a vraiment beaucoup plus.

Je lui donne 5 étoiles, car je pense qu'il le mérite vraiment. Et j'espère que vous partagerez également cet avis.


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 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]